_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q9600 | IsHTTPError | train | func IsHTTPError(err error) bool {
cause := errors.Cause(err)
if nErr, ok := cause.(HTTPError); ok {
return nErr.HTTPError()
}
return false
} | go | {
"resource": ""
} |
q9601 | IsNetworkError | train | func IsNetworkError(err error) bool {
cause := errors.Cause(err)
if nErr, ok := cause.(NetworkError); ok {
return nErr.NetworkError()
}
return false
} | go | {
"resource": ""
} |
q9602 | IsServiceNotFoundError | train | func IsServiceNotFoundError(err error) bool {
cause := errors.Cause(err)
if nErr, ok := cause.(ServiceNotFoundError); ok {
return nErr.ServiceNotFoundError()
}
return false
} | go | {
"resource": ""
} |
q9603 | IsTimeoutError | train | func IsTimeoutError(err error) bool {
switch errType := errors.Cause(err).(type) {
case TimeoutError:
return errType.Timeout()
default:
return false
}
} | go | {
"resource": ""
} |
q9604 | IsAuthenticationError | train | func IsAuthenticationError(err error) bool {
cause := errors.Cause(err)
if kvErr, ok := cause.(KeyValueError); ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusAuthError)
}
return false
} | go | {
"resource": ""
} |
q9605 | IsBucketMissingError | train | func IsBucketMissingError(err error) bool {
cause := errors.Cause(err)
if kvErr, ok := cause.(KeyValueError); ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusNoBucket)
}
return false
} | go | {
"resource": ""
} |
q9606 | IsAccessError | train | func IsAccessError(err error) bool {
cause := errors.Cause(err)
if kvErr, ok := cause.(KeyValueError); ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusAccessError)
}
return false
} | go | {
"resource": ""
} |
q9607 | IsConfigurationError | train | func IsConfigurationError(err error) bool {
switch errType := errors.Cause(err).(type) {
case ConfigurationError:
return errType.ConfigurationError()
default:
return false
}
} | go | {
"resource": ""
} |
q9608 | IsSubdocPathNotFoundError | train | func IsSubdocPathNotFoundError(err error) bool {
cause := errors.Cause(err)
if kvErr, ok := cause.(KeyValueError); ok && kvErr.KVError() {
return kvErr.StatusCode() == int(gocbcore.StatusSubDocPathNotFound)
}
return false
} | go | {
"resource": ""
} |
q9609 | IsDurabilityError | train | func IsDurabilityError(err error) bool {
switch errType := errors.Cause(err).(type) {
case DurabilityError:
return errType.DurabilityError()
default:
return false
}
} | go | {
"resource": ""
} |
q9610 | IsNoResultsError | train | func IsNoResultsError(err error) bool {
switch errType := errors.Cause(err).(type) {
case NoResultsError:
return errType.NoResultsError()
default:
return false
}
} | go | {
"resource": ""
} |
q9611 | NextBytes | train | func (r *AnalyticsResults) NextBytes() []byte {
if r.streamResult.Closed() {
return nil
}
raw, err := r.streamResult.NextBytes()
if err != nil {
r.err = err
return nil
}
return raw
} | go | {
"resource": ""
} |
q9612 | AnalyticsQuery | train | func (c *Cluster) AnalyticsQuery(statement string, opts *AnalyticsQueryOptions) (*AnalyticsResults, error) {
if opts == nil {
opts = &AnalyticsQueryOptions{}
}
ctx := opts.Context
if ctx == nil {
ctx = context.Background()
}
var span opentracing.Span
if opts.ParentSpanContext == nil {
span = opentracing.G... | go | {
"resource": ""
} |
q9613 | ListenAndServe | train | func ListenAndServe(addr string, h http.Handler) error {
if h == nil {
h = http.DefaultServeMux
}
lambda.Start(func(ctx context.Context, e events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
r, err := NewRequest(ctx, e)
if err != nil {
return events.APIGatewayProxyResponse{}, err
}
... | go | {
"resource": ""
} |
q9614 | newContext | train | func newContext(ctx context.Context, e events.APIGatewayProxyRequest) context.Context {
return context.WithValue(ctx, requestContextKey, e.RequestContext)
} | go | {
"resource": ""
} |
q9615 | RequestContext | train | func RequestContext(ctx context.Context) (events.APIGatewayProxyRequestContext, bool) {
c, ok := ctx.Value(requestContextKey).(events.APIGatewayProxyRequestContext)
return c, ok
} | go | {
"resource": ""
} |
q9616 | Header | train | func (w *ResponseWriter) Header() http.Header {
if w.header == nil {
w.header = make(http.Header)
}
return w.header
} | go | {
"resource": ""
} |
q9617 | Write | train | func (w *ResponseWriter) Write(b []byte) (int, error) {
if !w.wroteHeader {
w.WriteHeader(http.StatusOK)
}
return w.buf.Write(b)
} | go | {
"resource": ""
} |
q9618 | WriteHeader | train | func (w *ResponseWriter) WriteHeader(status int) {
if w.wroteHeader {
return
}
if w.Header().Get("Content-Type") == "" {
w.Header().Set("Content-Type", "text/plain; charset=utf8")
}
w.out.StatusCode = status
h := make(map[string]string)
for k, v := range w.Header() {
if len(v) > 0 {
h[k] = v[len(v)-... | go | {
"resource": ""
} |
q9619 | End | train | func (w *ResponseWriter) End() events.APIGatewayProxyResponse {
w.out.IsBase64Encoded = isBinary(w.header)
if w.out.IsBase64Encoded {
w.out.Body = base64.StdEncoding.EncodeToString(w.buf.Bytes())
} else {
w.out.Body = w.buf.String()
}
// notify end
w.closeNotifyCh <- true
return w.out
} | go | {
"resource": ""
} |
q9620 | isBinary | train | func isBinary(h http.Header) bool {
switch {
case !isTextMime(h.Get("Content-Type")):
return true
case h.Get("Content-Encoding") == "gzip":
return true
default:
return false
}
} | go | {
"resource": ""
} |
q9621 | isTextMime | train | func isTextMime(kind string) bool {
mt, _, err := mime.ParseMediaType(kind)
if err != nil {
return false
}
if strings.HasPrefix(mt, "text/") {
return true
}
switch mt {
case "image/svg+xml":
return true
case "application/json":
return true
case "application/xml":
return true
default:
return fals... | go | {
"resource": ""
} |
q9622 | NewRequest | train | func NewRequest(ctx context.Context, e events.APIGatewayProxyRequest) (*http.Request, error) {
// path
u, err := url.Parse(e.Path)
if err != nil {
return nil, errors.Wrap(err, "parsing path")
}
// querystring
q := u.Query()
for k, v := range e.QueryStringParameters {
q.Set(k, v)
}
u.RawQuery = q.Encode()
... | go | {
"resource": ""
} |
q9623 | BitsWritten | train | func (pw *Writer) BitsWritten() int64 {
return 8*pw.Offset + 8*int64(pw.cntBuf) + int64(pw.numBits)
} | go | {
"resource": ""
} |
q9624 | WritePads | train | func (pw *Writer) WritePads(v uint) {
nb := -pw.numBits & 7
pw.bufBits |= uint64(v) << pw.numBits
pw.numBits += nb
} | go | {
"resource": ""
} |
q9625 | Write | train | func (pw *Writer) Write(buf []byte) (cnt int, err error) {
if pw.numBits > 0 || pw.cntBuf > 0 {
if pw.numBits%8 != 0 {
return 0, errorf(errors.Invalid, "non-aligned bit buffer")
}
if _, err := pw.Flush(); err != nil {
return 0, err
}
}
cnt, err = pw.wr.Write(buf)
pw.Offset += int64(cnt)
return cnt, e... | go | {
"resource": ""
} |
q9626 | TryWriteBits | train | func (pw *Writer) TryWriteBits(v, nb uint) bool {
if 64-pw.numBits < nb {
return false
}
pw.bufBits |= uint64(v) << pw.numBits
pw.numBits += nb
return true
} | go | {
"resource": ""
} |
q9627 | WriteBits | train | func (pw *Writer) WriteBits(v, nb uint) {
if _, err := pw.PushBits(); err != nil {
errors.Panic(err)
}
pw.bufBits |= uint64(v) << pw.numBits
pw.numBits += nb
} | go | {
"resource": ""
} |
q9628 | TryWriteSymbol | train | func (pw *Writer) TryWriteSymbol(sym uint, pe *Encoder) bool {
chunk := pe.chunks[uint32(sym)&pe.chunkMask]
nb := uint(chunk & countMask)
if 64-pw.numBits < nb {
return false
}
pw.bufBits |= uint64(chunk>>countBits) << pw.numBits
pw.numBits += nb
return true
} | go | {
"resource": ""
} |
q9629 | WriteSymbol | train | func (pw *Writer) WriteSymbol(sym uint, pe *Encoder) {
if _, err := pw.PushBits(); err != nil {
errors.Panic(err)
}
chunk := pe.chunks[uint32(sym)&pe.chunkMask]
nb := uint(chunk & countMask)
pw.bufBits |= uint64(chunk>>countBits) << pw.numBits
pw.numBits += nb
} | go | {
"resource": ""
} |
q9630 | Flush | train | func (pw *Writer) Flush() (int64, error) {
if pw.numBits < 8 && pw.cntBuf == 0 {
return pw.Offset, nil
}
if _, err := 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
} | go | {
"resource": ""
} |
q9631 | PushBits | train | func (pw *Writer) PushBits() (uint, error) {
if pw.cntBuf >= len(pw.buf)-8 {
cnt, err := pw.wr.Write(pw.buf[:pw.cntBuf])
pw.cntBuf -= cnt
pw.Offset += int64(cnt)
if err != nil {
return 0, err
}
}
u := pw.bufBits
if pw.bigEndian {
// Swap all the bits within each byte.
u = (u&0xaaaaaaaaaaaaaaaa)>>1... | go | {
"resource": ""
} |
q9632 | getFiles | train | func getFiles(paths []string, globs []string) []file {
var fs []file
for _, p := range paths {
for _, g := range globs {
ms, _ := filepath.Glob(filepath.Join(p, g))
for _, m := range ms {
r, err1 := filepath.Rel(p, m)
fi, err2 := os.Stat(m)
if err1 == nil && err2 == nil && !fi.IsDir() {
fs = ... | go | {
"resource": ""
} |
q9633 | errWrap | train | func errWrap(err error, replaceCode int) error {
if cerr, ok := err.(errors.Error); ok {
if errors.IsInvalid(cerr) {
cerr.Code = replaceCode
}
err = errorf(cerr.Code, "%s", cerr.Msg)
}
return err
} | go | {
"resource": ""
} |
q9634 | reverseUint32 | train | func reverseUint32(v uint32) (x uint32) {
x |= uint32(reverseLUT[byte(v>>0)]) << 24
x |= uint32(reverseLUT[byte(v>>8)]) << 16
x |= uint32(reverseLUT[byte(v>>16)]) << 8
x |= uint32(reverseLUT[byte(v>>24)]) << 0
return x
} | go | {
"resource": ""
} |
q9635 | NewReader | train | func NewReader(rd io.Reader) *Reader {
mr := new(Reader)
mr.Reset(rd)
return mr
} | go | {
"resource": ""
} |
q9636 | Reset | train | func (mr *Reader) Reset(rd io.Reader) {
*mr = Reader{
br: mr.br,
bw: mr.bw,
bb: mr.bb,
}
if br, ok := rd.(*prefix.Reader); ok {
// Use input Reader directly as a prefix.Reader.
mr.rd = br
} else {
// Use pre-allocated prefix.Reader to wrap input Reader.
mr.rd = &mr.br
mr.rd.Init(rd, false)
}
retur... | go | {
"resource": ""
} |
q9637 | Read | train | func (mr *Reader) Read(buf []byte) (int, error) {
if mr.err != nil {
return 0, mr.err
}
var rdCnt int
for len(buf) > 0 {
if len(mr.buf) > 0 {
cpCnt := copy(buf, mr.buf)
mr.buf = mr.buf[cpCnt:]
rdCnt += cpCnt
break
}
if mr.final != FinalNil {
mr.FinalMode = mr.final
mr.err = io.EOF
bre... | go | {
"resource": ""
} |
q9638 | Close | train | func (mr *Reader) Close() error {
if mr.err == errClosed {
return nil
}
if mr.err != nil && mr.err != io.EOF {
return mr.err
}
mr.FinalMode = mr.final
mr.err = errClosed
mr.rd = nil // Release reference to underlying Reader
return nil
} | go | {
"resource": ""
} |
q9639 | initContextLUTs | train | func initContextLUTs() {
for i := 0; i < 256; i++ {
for m := 0; m < numContextModes; m++ {
base := m << 8
// Operations performed here are specified in RFC section 7.1.
switch m {
case contextLSB6:
contextP1LUT[base+i] = byte(i) & 0x3f
contextP2LUT[base+i] = 0
case contextMSB6:
contextP1L... | go | {
"resource": ""
} |
q9640 | getLitContextID | train | func getLitContextID(p1, p2 byte, mode uint8) uint8 {
base := uint(mode) << 8
return contextP1LUT[base+uint(p1)] | contextP2LUT[base+uint(p2)]
} | go | {
"resource": ""
} |
q9641 | HistSize | train | func (dd *dictDecoder) HistSize() int {
if dd.full {
return dd.size
}
return dd.wrPos
} | go | {
"resource": ""
} |
q9642 | ReadFlush | train | func (dd *dictDecoder) ReadFlush() []byte {
toRead := dd.hist[dd.rdPos:dd.wrPos]
dd.rdPos = dd.wrPos
if dd.wrPos == len(dd.hist) {
if len(dd.hist) == dd.size {
dd.wrPos, dd.rdPos = 0, 0
dd.full = true
} else {
// Allocate a larger history buffer.
size := cap(dd.hist) * growFactor
if size > dd.size... | go | {
"resource": ""
} |
q9643 | LastBytes | train | func (dd *dictDecoder) LastBytes() (p1, p2 byte) {
if dd.wrPos > 1 {
return dd.hist[dd.wrPos-1], dd.hist[dd.wrPos-2]
} else if dd.wrPos > 0 {
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]
}
} | go | {
"resource": ""
} |
q9644 | setDefaults | train | func setDefaults() {
formats = defaultFormats()
tests = defaultTests()
codecs = defaultCodecs()
paths = defaultPaths()
globs = []string{"*.txt", "*.bin"}
levels = []int{1, 6, 9}
sizes = []int{1e4, 1e5, 1e6}
} | go | {
"resource": ""
} |
q9645 | intName | train | func intName(n int64) string {
switch n {
case 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12:
s := fmt.Sprintf("%e", float64(n))
re := regexp.MustCompile("\\.0*e\\+0*")
return re.ReplaceAllString(s, "e")
default:
s := unitconv.FormatPrefix(float64(n), unitconv.Base1024, 2)
return strings.Replace(s, "... | go | {
"resource": ""
} |
q9646 | BitsRead | train | func (pr *Reader) BitsRead() int64 {
offset := 8*pr.Offset - int64(pr.numBits)
if pr.bufRd != nil {
discardBits := pr.discardBits + int(pr.fedBits-pr.numBits)
offset = 8*pr.Offset + int64(discardBits)
}
return offset
} | go | {
"resource": ""
} |
q9647 | Read | train | func (pr *Reader) Read(buf []byte) (cnt int, err error) {
if pr.numBits > 0 {
if pr.numBits%8 != 0 {
return 0, errorf(errors.Invalid, "non-aligned bit buffer")
}
for cnt = 0; len(buf) > cnt && pr.numBits > 0; cnt++ {
if pr.bigEndian {
buf[cnt] = internal.ReverseLUT[byte(pr.bufBits)]
} else {
buf... | go | {
"resource": ""
} |
q9648 | ReadOffset | train | func (pr *Reader) ReadOffset(pd *Decoder, rcs RangeCodes) uint {
rc := rcs[pr.ReadSymbol(pd)]
return uint(rc.Base) + pr.ReadBits(uint(rc.Len))
} | go | {
"resource": ""
} |
q9649 | ReadBits | train | func (pr *Reader) ReadBits(nb uint) uint {
if err := pr.PullBits(nb); err != nil {
errors.Panic(err)
}
val := uint(pr.bufBits & uint64(1<<nb-1))
pr.bufBits >>= nb
pr.numBits -= nb
return val
} | go | {
"resource": ""
} |
q9650 | ReadSymbol | train | func (pr *Reader) ReadSymbol(pd *Decoder) uint {
if len(pd.chunks) == 0 {
panicf(errors.Invalid, "decode with empty prefix tree")
}
nb := uint(pd.MinBits)
for {
if err := pr.PullBits(nb); err != nil {
errors.Panic(err)
}
chunk := pd.chunks[uint32(pr.bufBits)&pd.chunkMask]
nb = uint(chunk & countMask)
... | go | {
"resource": ""
} |
q9651 | Flush | train | func (pr *Reader) Flush() (int64, error) {
if pr.bufRd == nil {
return pr.Offset, nil
}
// Update the number of total bits to discard.
pr.discardBits += int(pr.fedBits - pr.numBits)
pr.fedBits = pr.numBits
// Discard some bytes to update read offset.
var err error
nd := (pr.discardBits + 7) / 8 // Round up ... | go | {
"resource": ""
} |
q9652 | transformUppercase | train | func transformUppercase(word []byte, once bool) {
for i := 0; i < len(word); {
c := word[i]
if c < 192 {
if c >= 97 && c <= 122 {
word[i] ^= 32
}
i += 1
} else if c < 224 {
if i+1 < len(word) {
word[i+1] ^= 32
}
i += 2
} else {
if i+2 < len(word) {
word[i+2] ^= 5
}
i += 3... | go | {
"resource": ""
} |
q9653 | BenchmarkEncoder | train | func BenchmarkEncoder(input []byte, enc Encoder, lvl int) testing.BenchmarkResult {
return testing.Benchmark(func(b *testing.B) {
b.StopTimer()
if enc == nil {
b.Fatalf("unexpected error: nil Encoder")
}
runtime.GC()
b.StartTimer()
for i := 0; i < b.N; i++ {
wr := enc(ioutil.Discard, lvl)
_, err :... | go | {
"resource": ""
} |
q9654 | BenchmarkDecoder | train | func BenchmarkDecoder(input []byte, dec Decoder) testing.BenchmarkResult {
return testing.Benchmark(func(b *testing.B) {
b.StopTimer()
if dec == nil {
b.Fatalf("unexpected error: nil Decoder")
}
runtime.GC()
b.StartTimer()
for i := 0; i < b.N; i++ {
rd := dec(bufio.NewReader(bytes.NewBuffer(input)))
... | go | {
"resource": ""
} |
q9655 | Init | train | func (pe *Encoder) Init(codes PrefixCodes) {
// Handle special case trees.
if len(codes) <= 1 {
switch {
case len(codes) == 0: // Empty tree (should error if used later)
*pe = Encoder{chunks: pe.chunks[:0], NumSyms: 0}
case len(codes) == 1 && codes[0].Len == 0: // Single code tree (bit-length of zero)
pe.... | go | {
"resource": ""
} |
q9656 | decodeMeta | train | func decodeMeta(data []byte) ([]byte, bool) {
r := bytes.NewReader(data)
mr := xflate.NewMetaReader(r)
b, err := ioutil.ReadAll(mr)
if err != nil {
return nil, false
}
pos := int(r.Size()) - r.Len()
decompressMeta(data[:pos])
return b, true
} | go | {
"resource": ""
} |
q9657 | decompressMeta | train | func decompressMeta(data []byte) {
// Make a copy and append DEFLATE terminator block.
data = append([]byte(nil), data...)
data = append(data, []byte{0x01, 0x00, 0x00, 0xff, 0xff}...)
r := bytes.NewReader(data)
for r.Len() > 0 {
zr := flate.NewReader(r)
b, err := ioutil.ReadAll(zr)
if err != nil {
panic(... | go | {
"resource": ""
} |
q9658 | initDictLUTs | train | func initDictLUTs() {
// Sweep from minDictLen to maxDictLen, inclusive.
for i := minDictLen; i <= maxDictLen; i++ {
dictSizes[i] = 1 << uint(dictBitSizes[i])
dictOffsets[i] = dictOffsets[i-1] + (i-1)*dictSizes[i-1]
}
} | go | {
"resource": ""
} |
q9659 | MakeRangeCodes | train | func MakeRangeCodes(minBase uint, bits []uint) (rc RangeCodes) {
for _, nb := range bits {
rc = append(rc, RangeCode{Base: uint32(minBase), Len: uint32(nb)})
minBase += 1 << nb
}
return rc
} | go | {
"resource": ""
} |
q9660 | handleDegenerateCodes | train | func handleDegenerateCodes(codes prefix.PrefixCodes, maxSyms uint) prefix.PrefixCodes {
if len(codes) != 1 {
return codes
}
return append(codes, prefix.PrefixCode{Sym: uint32(maxSyms), Len: 1})
} | go | {
"resource": ""
} |
q9661 | ReverseUint32 | train | func ReverseUint32(v uint32) (x uint32) {
x |= uint32(ReverseLUT[byte(v>>0)]) << 24
x |= uint32(ReverseLUT[byte(v>>8)]) << 16
x |= uint32(ReverseLUT[byte(v>>16)]) << 8
x |= uint32(ReverseLUT[byte(v>>24)]) << 0
return x
} | go | {
"resource": ""
} |
q9662 | ReverseUint32N | train | func ReverseUint32N(v uint32, n uint) (x uint32) {
return ReverseUint32(v << (32 - n))
} | go | {
"resource": ""
} |
q9663 | ReverseUint64 | train | func ReverseUint64(v uint64) (x uint64) {
x |= uint64(ReverseLUT[byte(v>>0)]) << 56
x |= uint64(ReverseLUT[byte(v>>8)]) << 48
x |= uint64(ReverseLUT[byte(v>>16)]) << 40
x |= uint64(ReverseLUT[byte(v>>24)]) << 32
x |= uint64(ReverseLUT[byte(v>>32)]) << 24
x |= uint64(ReverseLUT[byte(v>>40)]) << 16
x |= uint64(Rev... | go | {
"resource": ""
} |
q9664 | ReverseUint64N | train | func ReverseUint64N(v uint64, n uint) (x uint64) {
return ReverseUint64(v << (64 - n))
} | go | {
"resource": ""
} |
q9665 | ReverseSearch | train | func ReverseSearch(data []byte) int {
var magic uint32
for i := len(data) - 1; i >= 0; i-- {
magic = (magic << 8) | uint32(data[i])
if magic&magicMask == magicVals {
return i
}
}
return -1
} | go | {
"resource": ""
} |
q9666 | numBits | train | func numBits(b byte) (zeros, ones int) {
ones = int(oneBitsLUT[b])
zeros = 8 - ones
return
} | go | {
"resource": ""
} |
q9667 | NewReader | train | func NewReader(rs io.ReadSeeker, conf *ReaderConfig) (*Reader, error) {
xr := new(Reader)
err := xr.Reset(rs)
return xr, err
} | go | {
"resource": ""
} |
q9668 | Reset | train | func (xr *Reader) Reset(rs io.ReadSeeker) error {
*xr = Reader{
rd: rs,
mr: xr.mr,
zr: xr.zr,
idx: xr.idx,
br: xr.br,
bw: xr.bw,
idxs: xr.idxs,
chunks: xr.chunks,
}
if xr.zr == nil {
xr.zr, _ = newFlateReader(nil)
}
xr.idx.Reset()
// Read entire index.
var backSize, footSize int6... | go | {
"resource": ""
} |
q9669 | Read | train | func (xr *Reader) Read(buf []byte) (int, error) {
if xr.err != nil {
return 0, xr.err
}
// Discard some data to reach the expected raw offset.
if xr.discard > 0 {
var n int64
xr.lr = io.LimitedReader{R: xr.zr, N: xr.discard}
n, xr.err = io.Copy(ioutil.Discard, &xr.lr)
if xr.err != nil {
return 0, xr.e... | go | {
"resource": ""
} |
q9670 | Seek | train | func (xr *Reader) Seek(offset int64, whence int) (int64, error) {
if xr.err != nil && xr.err != io.EOF {
return 0, xr.err
}
// Determine which position to seek to.
var pos int64
end := xr.idx.LastRecord().RawOffset
switch whence {
case io.SeekStart:
pos = offset
case io.SeekCurrent:
pos = xr.offset + off... | go | {
"resource": ""
} |
q9671 | Close | train | func (xr *Reader) Close() error {
if xr.err == errClosed {
return nil
}
if xr.err != nil && xr.err != io.EOF {
return xr.err
}
xr.err = errClosed
return nil
} | go | {
"resource": ""
} |
q9672 | decodeIndexes | train | func (xr *Reader) decodeIndexes(backSize int64) error {
pos, err := xr.rd.Seek(0, io.SeekCurrent)
if err != nil {
return err
}
// Read all indexes.
var compSize int64
xr.idxs = xr.idxs[:0]
for {
// Seek backwards past index and compressed blocks.
newPos := pos - (backSize + compSize)
if newPos < 0 || ne... | go | {
"resource": ""
} |
q9673 | decodeIndex | train | func (xr *Reader) decodeIndex(idx *index) error {
// Helper function to read VLIs.
var errVLI error
readVLI := func() int64 {
x, n := binary.Uvarint(xr.bw.Bytes())
if n <= 0 || x > math.MaxInt64 {
errVLI = errCorrupted
return 0
}
xr.bw.Next(n)
return int64(x)
}
// Read the index and restore the un... | go | {
"resource": ""
} |
q9674 | decodeFooter | train | func (xr *Reader) decodeFooter() (backSize, footSize int64, err error) {
// Read the last few bytes of the stream.
end, err := xr.rd.Seek(0, io.SeekEnd)
if err != nil {
return 0, 0, err
}
if end > meta.MaxEncBytes {
end = meta.MaxEncBytes
}
if _, err := xr.rd.Seek(-end, io.SeekEnd); err != nil {
return 0, ... | go | {
"resource": ""
} |
q9675 | AppendRecord | train | func (idx *index) AppendRecord(compSize, rawSize int64, typ int) bool {
if rawSize < 0 || compSize < 0 {
return false // Invalid size
}
lastRec := idx.LastRecord()
rec := record{
CompOffset: lastRec.CompOffset + compSize,
RawOffset: lastRec.RawOffset + rawSize,
Type: typ,
}
if rec.CompOffset < las... | go | {
"resource": ""
} |
q9676 | AppendIndex | train | func (idx *index) AppendIndex(other *index) bool {
var preRec record
for i, rec := range other.Records {
csize, rsize := rec.CompOffset-preRec.CompOffset, rec.RawOffset-preRec.RawOffset
if !idx.AppendRecord(csize, rsize, rec.Type) {
idx.Records = idx.Records[:len(idx.Records)-i] // Ensure atomic append
retu... | go | {
"resource": ""
} |
q9677 | GetRecords | train | func (idx *index) GetRecords(i int) (prev, curr record) {
recs := idx.Records
if i > len(recs) {
i = len(recs)
}
if i-1 >= 0 && i-1 < len(recs) {
prev = recs[i-1]
}
if i >= 0 && i < len(recs) {
curr = recs[i]
} else {
curr = prev
curr.Type = unknownType
}
return prev, curr
} | go | {
"resource": ""
} |
q9678 | LastRecord | train | func (idx *index) LastRecord() record {
var rec record
if len(idx.Records) > 0 {
rec = idx.Records[len(idx.Records)-1]
}
return rec
} | go | {
"resource": ""
} |
q9679 | update | train | func (r *stringReader) update() {
pos, _ := r.Seek(0, io.SeekCurrent)
if off := pos - r.pos; off >= 0 && off < int64(len(r.buf)) {
r.buf, r.pos = r.buf[off:], pos
} else {
r.buf, r.pos = nil, pos
}
} | go | {
"resource": ""
} |
q9680 | computeRecords | train | func computeRecords(r io.Reader, lvl, chnkSize int) (strmRec indexRecord, chnkRecs []indexRecord) {
var cw1, cw2 countWriter
zw1, _ := flate.NewWriter(&cw1, lvl) // Streamed compressor
zw2, _ := flate.NewWriter(&cw2, lvl) // Chunked compressor
buf := make([]byte, chnkSize)
for {
// Read a full chunks worth of da... | go | {
"resource": ""
} |
q9681 | compress | train | func compress(b []byte, lvl int) []byte {
var buf bytes.Buffer
w, err := flate.NewWriter(&buf, lvl)
if err != nil {
log.Fatal(err)
}
if _, err := io.Copy(w, bytes.NewReader(b)); err != nil {
log.Fatal(err)
}
if err := w.Close(); err != nil {
log.Fatal(err)
}
return buf.Bytes()
} | go | {
"resource": ""
} |
q9682 | encode | train | func encode(b []byte) []byte {
var buf bytes.Buffer
mw := meta.NewWriter(&buf)
mw.FinalMode = meta.FinalMeta
if _, err := io.Copy(mw, bytes.NewReader(b)); err != nil {
log.Fatal(err)
}
if err := mw.Close(); err != nil {
log.Fatal(err)
}
return buf.Bytes()
} | go | {
"resource": ""
} |
q9683 | NewWriter | train | func NewWriter(wr io.Writer, conf *WriterConfig) (*Writer, error) {
var lvl int
var nchk, nidx int64
if conf != nil {
lvl = conf.Level
switch {
case conf.ChunkSize < 0:
return nil, errorf(errors.Invalid, "invalid chunk size: %d", conf.ChunkSize)
case conf.ChunkSize > 0:
nchk = conf.ChunkSize
}
swit... | go | {
"resource": ""
} |
q9684 | Reset | train | func (xw *Writer) Reset(wr io.Writer) error {
*xw = Writer{
wr: wr,
mw: xw.mw,
zw: xw.zw,
nchk: xw.nchk,
nidx: xw.nidx,
idx: xw.idx,
}
if xw.zw == nil {
xw.zw, _ = newFlateWriter(wr, DefaultCompression)
} else {
xw.zw.Reset(wr)
}
if xw.nchk == 0 {
xw.nchk = DefaultChunkSize
}
if xw.nidx... | go | {
"resource": ""
} |
q9685 | Write | train | func (xw *Writer) Write(buf []byte) (int, error) {
if xw.err != nil {
return 0, xw.err
}
var n, cnt int
for len(buf) > 0 && xw.err == nil {
// Flush chunk if necessary.
remain := xw.nchk - xw.zw.InputOffset
if remain <= 0 {
xw.err = xw.Flush(FlushFull)
continue
}
if remain > int64(len(buf)) {
... | go | {
"resource": ""
} |
q9686 | Flush | train | func (xw *Writer) Flush(mode FlushMode) error {
if xw.err != nil {
return xw.err
}
switch mode {
case FlushSync:
offset := xw.zw.OutputOffset
xw.err = xw.zw.Flush()
xw.OutputOffset += xw.zw.OutputOffset - offset
return xw.err
case FlushFull:
if xw.err = xw.Flush(FlushSync); xw.err != nil {
return x... | go | {
"resource": ""
} |
q9687 | Close | train | func (xw *Writer) Close() error {
if xw.err == errClosed {
return nil
}
if xw.err != nil {
return xw.err
}
// Flush final index.
if xw.zw.OutputOffset+xw.zw.InputOffset > 0 || len(xw.idx.Records) > 0 {
xw.err = xw.Flush(FlushIndex)
if xw.err != nil {
return xw.err
}
}
// Encode the footer.
err :... | go | {
"resource": ""
} |
q9688 | encodeIndex | train | func (xw *Writer) encodeIndex(index *index) error {
// Helper function to write VLIs.
var crc uint32
var errVLI error
writeVLI := func(x int64) {
b := xw.scratch[:binary.PutUvarint(xw.scratch[:], uint64(x))]
crc = crc32.Update(crc, crc32.MakeTable(crc32.IEEE), b)
if _, err := xw.mw.Write(b); err != nil {
e... | go | {
"resource": ""
} |
q9689 | encodeFooter | train | func (xw *Writer) encodeFooter(backSize int64) error {
var n int
n += copy(xw.scratch[n:], magic[:])
n += binary.PutUvarint(xw.scratch[n:], uint64(backSize))
xw.mw.Reset(xw.wr)
defer func() { xw.OutputOffset += xw.mw.OutputOffset }()
xw.mw.FinalMode = meta.FinalStream
if _, err := xw.mw.Write(xw.scratch[:n]); e... | go | {
"resource": ""
} |
q9690 | NewWriter | train | func NewWriter(wr io.Writer) *Writer {
mw := new(Writer)
mw.Reset(wr)
return mw
} | go | {
"resource": ""
} |
q9691 | Reset | train | func (mw *Writer) Reset(wr io.Writer) {
*mw = Writer{
wr: wr,
bw: mw.bw,
bb: mw.bb,
cnts: mw.cnts,
}
return
} | go | {
"resource": ""
} |
q9692 | Write | train | func (mw *Writer) Write(buf []byte) (int, error) {
if mw.err != nil {
return 0, mw.err
}
var wrCnt int
for _, b := range buf {
zeros, ones := numBits(b)
// If possible, avoid flushing to maintain high efficiency.
if ensured := mw.bufCnt < EnsureRawBytes; ensured {
goto skipEncode
}
if huffLen, _ :=... | go | {
"resource": ""
} |
q9693 | Close | train | func (mw *Writer) Close() error {
if mw.err == errClosed {
return nil
}
if mw.err != nil {
return mw.err
}
err := mw.encodeBlock(mw.FinalMode)
if err != nil {
mw.err = err
} else {
mw.err = errClosed
}
mw.wr = nil // Release reference to underlying Writer
return err
} | go | {
"resource": ""
} |
q9694 | update | train | func (c *crc) update(buf []byte) {
cval := internal.ReverseUint32(c.val)
for len(buf) > 0 {
n := len(buf)
if n > len(c.buf) {
n = len(c.buf)
}
for i, b := range buf[:n] {
c.buf[i] = internal.ReverseLUT[b]
}
cval = crc32.Update(cval, crc32.IEEETable, c.buf[:n])
buf = buf[n:]
}
c.val = internal.Re... | go | {
"resource": ""
} |
q9695 | readBlockHeader | train | func (zr *Reader) readBlockHeader() {
zr.last = zr.rd.ReadBits(1) == 1
switch zr.rd.ReadBits(2) {
case 0:
// Raw block (RFC section 3.2.4).
zr.rd.ReadPads()
n := uint16(zr.rd.ReadBits(16))
nn := uint16(zr.rd.ReadBits(16))
if n^nn != 0xffff {
panicf(errors.Corrupted, "raw block size mismatch")
}
zr.... | go | {
"resource": ""
} |
q9696 | readRawData | train | func (zr *Reader) readRawData() {
buf := zr.dict.WriteSlice()
if len(buf) > zr.blkLen {
buf = buf[:zr.blkLen]
}
cnt, err := zr.rd.Read(buf)
zr.blkLen -= cnt
zr.dict.WriteMark(cnt)
if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
errors.Panic(err)
}
if zr.blkLen > 0 {
zr.toRead = zr... | go | {
"resource": ""
} |
q9697 | readBlock | train | func (zr *Reader) readBlock() {
const (
stateInit = iota // Zero value must be stateInit
stateDict
)
switch zr.stepState {
case stateInit:
goto readLiteral
case stateDict:
goto copyDistance
}
readLiteral:
// Read literal and/or (length, distance) according to RFC section 3.2.3.
{
if zr.dict.AvailSiz... | go | {
"resource": ""
} |
q9698 | finishBlock | train | func (zr *Reader) finishBlock() {
if zr.last {
zr.rd.ReadPads()
zr.err = io.EOF
}
zr.step = (*Reader).readBlockHeader
} | go | {
"resource": ""
} |
q9699 | FlushOffset | train | func (br *bitReader) FlushOffset() int64 {
if br.bufRd == nil {
return br.offset
}
// Update the number of total bits to discard.
br.discardBits += int(br.fedBits - br.numBits)
br.fedBits = br.numBits
// Discard some bytes to update read offset.
nd := (br.discardBits + 7) / 8 // Round up to nearest byte
nd,... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.