id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c9600 | return nErr.HTTPError()
}
return false
} | |
c9601 | return nErr.NetworkError()
}
return false
} | |
c9602 | return nErr.ServiceNotFoundError()
}
return false
} | |
c9603 | {
case TimeoutError:
return errType.Timeout()
default:
return false
}
} | |
c9604 | kvErr.StatusCode() == int(gocbcore.StatusAuthError)
}
return false
} | |
c9605 | cause.(KeyValueError); ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusNoBucket)
}
return false
} | |
c9606 | ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusAccessError)
}
return false
} | |
c9607 | {
case ConfigurationError:
return errType.ConfigurationError()
default:
return false
}
} | |
c9608 | cause.(KeyValueError); ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusSubDocPathNotFound)
}
return false
} | |
c9609 | {
case DurabilityError:
return errType.DurabilityError()
default:
return false
}
} | |
c9610 | {
case NoResultsError:
return errType.NoResultsError()
default:
return false
}
} | |
c9611 | := r.streamResult.NextBytes()
if err != nil {
r.err = err
return nil
}
return raw
} | |
c9612 | opentracing.Tag{Key: "couchbase.service", Value: "cbas"}, opentracing.ChildOf(opts.ParentSpanContext))
}
defer span.Finish()
provider, err := c.getHTTPProvider()
if err != nil {
return nil, err
}
return c.analyticsQuery(ctx, span.Context(), statement, opts, provider)
} | |
c9613 | return events.APIGatewayProxyResponse{}, err
}
w := NewResponse()
h.ServeHTTP(w, r)
return w.End(), nil
})
return nil
} | |
c9614 | context.WithValue(ctx, requestContextKey, e.RequestContext)
} | |
c9615 | ok := ctx.Value(requestContextKey).(events.APIGatewayProxyRequestContext)
return c, ok
} | |
c9616 | w.header == nil {
w.header = make(http.Header)
}
return w.header
} | |
c9617 |
w.WriteHeader(http.StatusOK)
}
return w.buf.Write(b)
} | |
c9618 | v := range w.Header() {
if len(v) > 0 {
h[k] = v[len(v)-1]
}
}
w.out.Headers = h
w.wroteHeader = true
} | |
c9619 | {
w.out.Body = w.buf.String()
}
// notify end
w.closeNotifyCh <- true
return w.out
} | |
c9620 |
case h.Get("Content-Encoding") == "gzip":
return true
default:
return false
}
} | |
c9621 | return true
case "application/json":
return true
case "application/xml":
return true
default:
return false
}
} | |
c9622 | err != nil {
return nil, errors.Wrap(err, "creating request")
}
// remote addr
req.RemoteAddr = e.RequestContext.Identity.SourceIP
// header fields
for k, v := range e.Headers {
req.Header.Set(k, v)
}
// content-length
if req.Header.Get("Content-Length") == "" && body != "" {
req.Header.Set("Content-L... | |
c9623 | return 8*pw.Offset + 8*int64(pw.cntBuf) + int64(pw.numBits)
} | |
c9624 | |= uint64(v) << pw.numBits
pw.numBits += nb
} | |
c9625 | {
return 0, err
}
}
cnt, err = pw.wr.Write(buf)
pw.Offset += int64(cnt)
return cnt, err
} | |
c9626 |
pw.bufBits |= uint64(v) << pw.numBits
pw.numBits += nb
return true
} | |
c9627 |
pw.bufBits |= uint64(v) << pw.numBits
pw.numBits += nb
} | |
c9628 |
pw.bufBits |= uint64(chunk>>countBits) << pw.numBits
pw.numBits += nb
return true
} | |
c9629 | uint(chunk & countMask)
pw.bufBits |= uint64(chunk>>countBits) << pw.numBits
pw.numBits += nb
} | |
c9630 | pw.PushBits(); err != nil {
return pw.Offset, err
}
cnt, err := pw.wr.Write(pw.buf[:pw.cntBuf])
pw.cntBuf -= cnt
pw.Offset += int64(cnt)
return pw.Offset, err
} | |
c9631 | the architecture supports it.
binary.LittleEndian.PutUint64(pw.buf[pw.cntBuf:], u)
nb := pw.numBits / 8 // Number of bytes to copy from bit buffer
pw.cntBuf += int(nb)
pw.bufBits >>= 8 * nb
pw.numBits -= 8 * nb
return 8 * nb, nil
} | |
c9632 | for _, m := range ms {
r, err1 := filepath.Rel(p, m)
fi, err2 := os.Stat(m)
if err1 == nil && err2 == nil && !fi.IsDir() {
fs = append(fs, file{Abs: m, Rel: r})
}
}
}
}
return fs
} | |
c9633 | cerr.Code = replaceCode
}
err = errorf(cerr.Code, "%s", cerr.Msg)
}
return err
} | |
c9634 | x |= uint32(reverseLUT[byte(v>>16)]) << 8
x |= uint32(reverseLUT[byte(v>>24)]) << 0
return x
} | |
c9635 | new(Reader)
mr.Reset(rd)
return mr
} | |
c9636 | } else {
// Use pre-allocated prefix.Reader to wrap input Reader.
mr.rd = &mr.br
mr.rd.Init(rd, false)
}
return
} | |
c9637 | mr.err = io.EOF
break
}
mr.err = mr.decodeBlock()
if mr.err != nil {
break
}
}
mr.OutputOffset += int64(rdCnt)
return rdCnt, mr.err
} | |
c9638 | io.EOF {
return mr.err
}
mr.FinalMode = mr.final
mr.err = errClosed
mr.rd = nil // Release reference to underlying Reader
return nil
} | |
c9639 | contextP2LUT[base+i] = contextLUT1[byte(i)]
case contextSigned:
contextP1LUT[base+i] = contextLUT2[byte(i)] << 3
contextP2LUT[base+i] = contextLUT2[byte(i)]
default:
panic("unknown context mode")
}
}
}
} | |
c9640 |
return contextP1LUT[base+uint(p1)] | contextP2LUT[base+uint(p2)]
} | |
c9641 | {
if dd.full {
return dd.size
}
return dd.wrPos
} | |
c9642 | size > dd.size {
size = dd.size
}
hist := make([]byte, size)
copy(hist, dd.hist)
dd.hist = hist
}
}
return toRead
} | |
c9643 | return dd.hist[dd.wrPos-1], dd.hist[len(dd.hist)-1]
} else {
return dd.hist[len(dd.hist)-1], dd.hist[len(dd.hist)-2]
}
} | |
c9644 |
paths = defaultPaths()
globs = []string{"*.txt", "*.bin"}
levels = []int{1, 6, 9}
sizes = []int{1e4, 1e5, 1e6}
} | |
c9645 | re := regexp.MustCompile("\\.0*e\\+0*")
return re.ReplaceAllString(s, "e")
default:
s := unitconv.FormatPrefix(float64(n), unitconv.Base1024, 2)
return strings.Replace(s, ".00", "", -1)
}
} | |
c9646 | int(pr.fedBits-pr.numBits)
offset = 8*pr.Offset + int64(discardBits)
}
return offset
} | |
c9647 | >>= 8
pr.numBits -= 8
}
return cnt, nil
}
if _, err := pr.Flush(); err != nil {
return 0, err
}
cnt, err = pr.rd.Read(buf)
pr.Offset += int64(cnt)
return cnt, err
} | |
c9648 | {
rc := rcs[pr.ReadSymbol(pd)]
return uint(rc.Base) + pr.ReadBits(uint(rc.Len))
} | |
c9649 | uint(pr.bufBits & uint64(1<<nb-1))
pr.bufBits >>= nb
pr.numBits -= nb
return val
} | |
c9650 | linkIdx := chunk >> countBits
chunk = pd.links[linkIdx][uint32(pr.bufBits>>pd.chunkBits)&pd.linkMask]
nb = uint(chunk & countMask)
}
if nb <= pr.numBits {
pr.bufBits >>= nb
pr.numBits -= nb
return uint(chunk >> countBits)
}
}
} | |
c9651 |
// Discard some bytes to update read offset.
var err error
nd := (pr.discardBits + 7) / 8 // Round up to nearest byte
nd, err = pr.bufRd.Discard(nd)
pr.discardBits -= nd * 8 // -7..0
pr.Offset += int64(nd)
// These are invalid after Discard.
pr.bufPeek = nil
return pr.Offset, err
} | |
c9652 |
}
i += 2
} else {
if i+2 < len(word) {
word[i+2] ^= 5
}
i += 3
}
if once {
return
}
}
} | |
c9653 | err != nil {
b.Fatalf("unexpected error: %v", err)
}
if err != nil {
b.Fatalf("unexpected error: %v", err)
}
b.SetBytes(int64(len(input)))
}
})
} | |
c9654 | b.StartTimer()
for i := 0; i < b.N; i++ {
rd := dec(bufio.NewReader(bytes.NewBuffer(input)))
cnt, err := io.Copy(ioutil.Discard, rd)
if err := rd.Close(); err != nil {
b.Fatalf("unexpected error: %v", err)
}
if err != nil {
b.Fatalf("unexpected error: %v", err)
}
b.SetBytes(cnt)
}
})
... | |
c9655 | allocUint32s(pe.chunks, numChunks)
pe.chunkMask = uint32(numChunks - 1)
for i := range pe.chunks {
pe.chunks[i] = 0 // Logic below relies on zero value as uninitialized
}
// Insert each symbol, checking that there are no conflicts.
for _, c := range codes {
if pe.chunks[c.Sym&pe.chunkMask] > 0 {
// Collis... | |
c9656 |
pos := int(r.Size()) - r.Len()
decompressMeta(data[:pos])
return b, true
} | |
c9657 | r := bytes.NewReader(data)
for r.Len() > 0 {
zr := flate.NewReader(r)
b, err := ioutil.ReadAll(zr)
if err != nil {
panic(err)
}
if len(b) > 0 {
panic("non-zero meta-encoded block")
}
if err := zr.Close(); err != nil {
panic(err)
}
}
} | |
c9658 | 1 << uint(dictBitSizes[i])
dictOffsets[i] = dictOffsets[i-1] + (i-1)*dictSizes[i-1]
}
} | |
c9659 | uint32(minBase), Len: uint32(nb)})
minBase += 1 << nb
}
return rc
} | |
c9660 |
if len(codes) != 1 {
return codes
}
return append(codes, prefix.PrefixCode{Sym: uint32(maxSyms), Len: 1})
} | |
c9661 | x |= uint32(ReverseLUT[byte(v>>16)]) << 8
x |= uint32(ReverseLUT[byte(v>>24)]) << 0
return x
} | |
c9662 | return ReverseUint32(v << (32 - n))
} | |
c9663 | 40
x |= uint64(ReverseLUT[byte(v>>24)]) << 32
x |= uint64(ReverseLUT[byte(v>>32)]) << 24
x |= uint64(ReverseLUT[byte(v>>40)]) << 16
x |= uint64(ReverseLUT[byte(v>>48)]) << 8
x |= uint64(ReverseLUT[byte(v>>56)]) << 0
return x
} | |
c9664 | return ReverseUint64(v << (64 - n))
} | |
c9665 | 0; i-- {
magic = (magic << 8) | uint32(data[i])
if magic&magicMask == magicVals {
return i
}
}
return -1
} | |
c9666 | int(oneBitsLUT[b])
zeros = 8 - ones
return
} | |
c9667 | (*Reader, error) {
xr := new(Reader)
err := xr.Reset(rs)
return xr, err
} | |
c9668 | {
return xr.err
}
if !xr.idx.AppendRecord(footSize, 0, footerType) {
xr.err = errCorrupted
return xr.err
}
// Setup initial chunk reader.
_, xr.err = xr.Seek(0, io.SeekStart)
return xr.err
} | |
c9669 | raw sizes match.
if xr.chk.typ != footerType {
xr.chk.csize += int64(len(endBlock)) // Side of effect of using chunkReader
}
if xr.chk.csize != xr.zr.InputOffset || xr.chk.rsize != xr.zr.OutputOffset {
xr.err = errCorrupted
break
}
// Seek to next chunk.
if _, xr.err = xr.Seek(xr.offset,... | |
c9670 | xr.ri = xr.idx.Search(pos)
prev, curr = xr.idx.GetRecords(xr.ri)
}
xr.ri++
if xr.ri > len(xr.idx.Records) {
xr.ri = len(xr.idx.Records)
}
// Setup a chunk reader at the given position.
xr.chk = chunk{
csize: curr.CompOffset - prev.CompOffset,
rsize: curr.RawOffset - prev.RawOffset,
typ: curr.Type,
... | |
c9671 |
}
if xr.err != nil && xr.err != io.EOF {
return xr.err
}
xr.err = errClosed
return nil
} | |
c9672 | err != nil {
return err
}
backSize, compSize = idx.BackSize, idx.LastRecord().CompOffset
}
if pos != 0 {
return errCorrupted
}
// Compact all indexes into one.
for i := len(xr.idxs) - 1; i >= 0; i-- {
idx := xr.idxs[i]
if !xr.idx.AppendIndex(&idx) {
return errCorrupted
}
if !xr.idx.AppendReco... | |
c9673 |
if xr.bw.Len() != 4 || binary.LittleEndian.Uint32(xr.bw.Bytes()) != crc {
return errCorrupted
}
if xr.mr.FinalMode != meta.FinalMeta {
return errCorrupted
}
if xr.mr.InputOffset != idx.IndexSize {
return errCorrupted
}
// Convert individual index sizes to be absolute offsets.
for _, chk := range xr.chun... | |
c9674 |
return 0, 0, err
}
// Parse the footer.
bufRaw := xr.bw.Bytes()
if len(bufRaw) < 3 || !bytes.Equal(bufRaw[:3], magic[:]) {
return 0, 0, errCorrupted // Magic value mismatch
}
backSizeU64, cnt := binary.Uvarint(bufRaw[3:])
if cnt <= 0 {
return 0, 0, errCorrupted // Integer overflow for VLI
}
if len(bufR... | |
c9675 | typ,
}
if rec.CompOffset < lastRec.CompOffset || rec.RawOffset < lastRec.RawOffset {
return false // Overflow detected
}
idx.Records = append(idx.Records, rec)
return true
} | |
c9676 | idx.Records = idx.Records[:len(idx.Records)-i] // Ensure atomic append
return false
}
preRec = rec
}
return true
} | |
c9677 | if i >= 0 && i < len(recs) {
curr = recs[i]
} else {
curr = prev
curr.Type = unknownType
}
return prev, curr
} | |
c9678 | = idx.Records[len(idx.Records)-1]
}
return rec
} | |
c9679 | {
r.buf, r.pos = r.buf[off:], pos
} else {
r.buf, r.pos = nil, pos
}
} | |
c9680 | int64(cnt), compSize: int64(cw2)})
cw2 = 0
zw2.Reset(&cw2)
if err == io.ErrUnexpectedEOF {
break
}
if err != nil {
log.Fatal(err)
}
}
// Flush the streamed compressor and record the compressed size.
if err := zw1.Flush(); err != nil {
log.Fatal(err)
}
strmRec.compSize = int64(cw1)
return st... | |
c9681 | log.Fatal(err)
}
if err := w.Close(); err != nil {
log.Fatal(err)
}
return buf.Bytes()
} | |
c9682 | nil {
log.Fatal(err)
}
if err := mw.Close(); err != nil {
log.Fatal(err)
}
return buf.Bytes()
} | |
c9683 | conf.IndexSize > 0:
nidx = conf.IndexSize
}
}
zw, err := newFlateWriter(wr, lvl)
if err != nil {
return nil, err
}
xw := &Writer{wr: wr, zw: zw, nchk: nchk, nidx: nidx}
xw.Reset(wr)
return xw, nil
} | |
c9684 | xw.zw.Reset(wr)
}
if xw.nchk == 0 {
xw.nchk = DefaultChunkSize
}
if xw.nidx == 0 {
xw.nidx = DefaultIndexSize
}
xw.idx.Reset()
return nil
} | |
c9685 | current chunk.
offset := xw.zw.OutputOffset
n, xw.err = xw.zw.Write(buf[:remain])
xw.OutputOffset += xw.zw.OutputOffset - offset
buf = buf[n:]
cnt += n
}
xw.InputOffset += int64(cnt)
return cnt, xw.err
} | |
c9686 | if err := xw.Flush(FlushFull); err != nil {
return err
}
}
xw.err = xw.encodeIndex(&xw.idx)
backSize := xw.idx.IndexSize
xw.idx.Reset()
xw.idx.BackSize = backSize
return xw.err
default:
return errorf(errors.Invalid, "invalid flush mode: %d", mode)
}
} | |
c9687 | || len(xw.idx.Records) > 0 {
xw.err = xw.Flush(FlushIndex)
if xw.err != nil {
return xw.err
}
}
// Encode the footer.
err := xw.encodeFooter(xw.idx.BackSize)
if err != nil {
xw.err = err
} else {
xw.err = errClosed
}
return err
} | |
c9688 | preRec = rec
}
if errVLI != nil {
return errWrap(errVLI)
}
binary.LittleEndian.PutUint32(xw.scratch[:], crc)
if _, err := xw.mw.Write(xw.scratch[:4]); err != nil {
return errWrap(err)
}
if err := xw.mw.Close(); err != nil {
return errWrap(err)
}
index.IndexSize = xw.mw.OutputOffset // Record the encode... | |
c9689 | return errWrap(err)
}
if err := xw.mw.Close(); err != nil {
return errWrap(err)
}
if xw.mw.NumBlocks != 1 {
return errorf(errors.Internal, "footer was not a single block")
}
return nil
} | |
c9690 | new(Writer)
mw.Reset(wr)
return mw
} | |
c9691 | wr: wr,
bw: mw.bw,
bb: mw.bb,
cnts: mw.cnts,
}
return
} | |
c9692 |
if mw.err != nil {
break
}
skipEncode:
mw.buf0s += zeros
mw.buf1s += ones
mw.buf[mw.bufCnt] = b
mw.bufCnt++
wrCnt++
}
mw.InputOffset += int64(wrCnt)
return wrCnt, mw.err
} | |
c9693 | else {
mw.err = errClosed
}
mw.wr = nil // Release reference to underlying Writer
return err
} | |
c9694 | = internal.ReverseLUT[b]
}
cval = crc32.Update(cval, crc32.IEEETable, c.buf[:n])
buf = buf[n:]
}
c.val = internal.ReverseUint32(cval)
} | |
c9695 | // Fixed prefix block (RFC section 3.2.6).
zr.litTree, zr.distTree = &decLit, &decDist
zr.step = (*Reader).readBlock
case 2:
// Dynamic prefix block (RFC section 3.2.7).
zr.litTree, zr.distTree = &zr.pd1, &zr.pd2
zr.rd.ReadPrefixCodes(zr.litTree, zr.distTree)
zr.step = (*Reader).readBlock
default:
// ... | |
c9696 | zr.toRead = zr.dict.ReadFlush()
zr.step = (*Reader).readRawData // We need to continue this work
return
}
zr.finishBlock()
} | |
c9697 |
rec := lenRanges[litSym-257]
extra, ok := zr.rd.TryReadBits(uint(rec.Len))
if !ok {
extra = zr.rd.ReadBits(uint(rec.Len))
}
zr.cpyLen = int(rec.Base) + int(extra)
// Read the distance symbol.
distSym, ok := zr.rd.TryReadSymbol(zr.distTree)
if !ok {
distSym = zr.rd.ReadSymbol(zr.distTre... | |
c9698 |
zr.err = io.EOF
}
zr.step = (*Reader).readBlockHeader
} | |
c9699 | / 8 // Round up to nearest byte
nd, _ = br.bufRd.Discard(nd)
br.discardBits -= nd * 8 // -7..0
br.offset += int64(nd)
// These are invalid after Discard.
br.bufPeek = nil
return br.offset
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.