id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c12200 | fset.Bool(f.Name, false, f.Description), nil
default:
return nil, errors.Errorf("unrecognized flag type: %v", f.Type)
}
} | |
c12201 | errors.Wrapf(err, "failed to unmarshal YAML")
}
return cfgWithVersion.Version, nil
} | |
c12202 | directory to path %s", dst)
}
if err := os.Rename(src, dst); err != nil {
return errors.Wrapf(err, "failed to rename %s to %s", src, dst)
}
return nil
} | |
c12203 | for _, f := range files {
srcPath := path.Join(src, f.Name())
dstPath := path.Join(dst, f.Name())
if f.IsDir() {
err = CopyDir(srcPath, dstPath)
} else {
err = CopyFile(srcPath, dstPath)
}
if err != nil {
return errors.Wrapf(err, "failed to copy %s to %s", srcPath, dstPath)
}
}
return nil
} | |
c12204 | err = CopyDir(srcPath, dstPath)
} else {
err = CopyFile(srcPath, dstPath)
}
if err != nil {
return errors.Wrapf(err, "failed to copy %s to %s", srcPath, dstPath)
}
} else if err != nil {
return errors.Wrapf(err, "failed to stat %s", dstPath)
} else if srcInfo.IsDir() && dstInfo.IsDir() {
... | |
c12205 | %s already exists", dst)
}
if _, err := os.Stat(path.Dir(dst)); os.IsNotExist(err) {
return errors.Wrapf(err, "parent directory of destination path %s does not exist", dst)
}
return nil
} | |
c12206 | file %s", dstFilePath)
}
defer func() {
if err := dstFile.Close(); err != nil && rErr == nil {
rErr = errors.Wrapf(err, "failed to close file %s in defer", dstFilePath)
}
}()
h := sha256.New()
mw := io.MultiWriter(h, dstFile)
_, _ = fmt.Fprintf(w, "Getting package from %v...\n", pkgSrc.Path())
if err :... | |
c12207 | }
relPathPrefix, err := filepath.Rel(wd, projectDir)
if err != nil {
return nil, errors.Wrapf(err, "failed to determine relative path")
}
files, err := matcher.ListFiles(projectDir, include, exclude)
if err != nil {
return nil, err
}
if relPathPrefix != "" {
for i, file := range files {
files[i] = pat... | |
c12208 | make(map[string]bool)
return m, allPaths(m, nil, dir)
} | |
c12209 | if err := CopySingleFileTGZContent(hasher, tgzContentReader); err != nil {
return "", err
}
return hex.EncodeToString(hasher.Sum(nil)), nil
} | |
c12210 | specified to determine project directory")
}
return path.Dir(g.Wrapper), nil
} | |
c12211 | 32-h.p)
}
return eb32(k, pPrime+1, pPrime-h.p+1)
} | |
c12212 |
x1, x2 := iter.Peek(), keys[i]
if x1 == x2 {
newList.Append(iter.Next())
i++
} else if x1 > x2 {
newList.Append(x2)
i++
} else {
newList.Append(iter.Next())
}
}
h.sparseList = newList
h.tmpSet = set{}
if uint32(h.sparseList.Len()) > h.m {
h.toNormal()
}
} | |
c12213 | h.m = 1 << precision
h.sparse = true
h.tmpSet = set{}
h.sparseList = newCompressedList(int(h.m))
return h, nil
} | |
c12214 |
h.tmpSet = set{}
h.sparseList = newCompressedList(int(h.m))
h.reg = nil
} | |
c12215 |
i, r := h.decodeHash(iter.Next())
if h.reg[i] < r {
h.reg[i] = r
}
}
h.sparse = false
h.tmpSet = nil
h.sparseList = nil
} | |
c12216 | | 1<<(h.p-1) // {x63-p,...,x0}
zeroBits := clz64(w) + 1
if zeroBits > h.reg[i] {
h.reg[i] = zeroBits
}
}
} | |
c12217 |
return nil
}
if h.sparse {
h.mergeSparseAndToNormal()
}
if other.sparse {
for k := range other.tmpSet {
i, r := other.decodeHash(k)
if r > h.reg[i] {
h.reg[i] = r
}
}
for iter := other.sparseList.Iter(); iter.HasNext(); {
i, r := other.decodeHash(iter.Next())
if r > h.reg[i] {
h... | |
c12218 |
if uint32(len(h.tmpSet))*100 > h.m {
h.mergeSparse()
}
} | |
c12219 | for i = 0; i < len(estTable) && estTable[i] < est; i++ {
}
e1, b1 := estTable[i-1], biasTable[i-1]
e2, b2 := estTable[i], biasTable[i]
c := (est - e1) / (e2 - e1)
return b1*(1-c) + b2*c
} | |
c12220 | return nil, err
}
if err := enc.Encode(h.sparseList.Count); err != nil {
return nil, err
}
if err := enc.Encode(h.sparseList.b); err != nil {
return nil, err
}
if err := enc.Encode(h.sparseList.last); err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | |
c12221 | h.sparseList = newCompressedList(int(h.m))
if err := dec.Decode(&h.sparseList.Count); err != nil {
return err
}
if err := dec.Decode(&h.sparseList.b); err != nil {
return err
}
if err := dec.Decode(&h.sparseList.last); err != nil {
return err
}
}
return nil
} | |
c12222 | - 1) << lo)
return (bits & m) >> lo
} | |
c12223 | - 1) << lo)
return (bits & m) >> lo
} | |
c12224 | be between 4 and 16")
}
h := &HyperLogLog{}
h.p = precision
h.m = 1 << precision
h.reg = make([]uint8, h.m)
return h, nil
} | |
c12225 |
zeroBits := clz32(w) + 1
if zeroBits > h.reg[i] {
h.reg[i] = zeroBits
}
} | |
c12226 | v := range other.reg {
if v > h.reg[i] {
h.reg[i] = v
}
}
return nil
} | |
c12227 | nil {
return nil, err
}
if err := enc.Encode(h.p); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c12228 | {
return err
}
if err := dec.Decode(&h.p); err != nil {
return err
}
return nil
} | |
c12229 | return ""
}
return _Hash_text[start : start+n]
} | |
c12230 | }
}
return i
}
NEXT:
if i := _Hash_table[(h>>16)&uint32(len(_Hash_table)-1)]; int(i&0xff) == len(s) {
t := _Hash_text[i>>8 : i>>8+i&0xff]
for i := 0; i < len(s); i++ {
if t[i] != s[i] {
return 0
}
}
return i
}
return 0
} | |
c12231 | err: io.EOF,
buf: buffer.Bytes(),
}
}
return &StreamLexer{
r: r,
buf: make([]byte, 0, size),
}
} | |
c12232 | < len(z.buf) {
return nil
}
return z.err
} | |
c12233 | z.read(z.pos - 1)
}
b := z.buf[z.start:z.pos]
z.start = z.pos
return b
} | |
c12234 |
z.prevStart = z.start
return n
} | |
c12235 | buffer.Bytes()
} else {
var err error
b, err = ioutil.ReadAll(r)
if err != nil {
return &Lexer{
buf: []byte{0},
err: err,
}
}
}
}
return NewLexerBytes(b)
} | |
c12236 | to avoid reallocation
if cap(b) > n {
// Overwrite next byte but restore when done
b = b[:n+1]
c := b[n]
b[n] = 0
z.buf = b
z.restore = func() {
b[n] = c
}
} else {
z.buf = append(b, 0)
}
}
return z
} | |
c12237 | z.restore()
z.restore = nil
}
} | |
c12238 | += z.pos
return z.buf[pos]
} | |
c12239 | := z.buf[z.start:z.pos]
z.start = z.pos
return b
} | |
c12240 | b[num] >= 'a' && b[num] <= 'z' || b[num] >= 'A' && b[num] <= 'Z' {
i := num + 1
for i < len(b) && (b[i] >= 'a' && b[i] <= 'z' || b[i] >= 'A' && b[i] <= 'Z') {
i++
}
return num, i - num
}
return num, 0
} | |
c12241 | }
params = map[string]string{}
s := string(b)
PARAM:
i++
for i < n && s[i] == ' ' {
i++
}
start := i
for i < n && s[i] != '=' && s[i] != ';' && s[i] != ' ' {
i++
}
key := s[start:i]
for i < n && s[i] == ' ' {
i++
}
if i < n && s[i] == '=' {
i++
for i < n && s[i... | |
c12242 | = []byte("text/plain")
}
data := dataURI[j+1:]
if inBase64 {
decoded := make([]byte, base64.StdEncoding.DecodedLen(len(data)))
n, err := base64.StdEncoding.Decode(decoded, data)
if err != nil {
return nil, nil, err
}
data = decoded[:n]
} else if unescaped, err :... | |
c12243 |
p.state = append(p.state, (*Parser).parseDeclarationList)
} else {
p.state = append(p.state, (*Parser).parseStylesheet)
}
return p
} | |
c12244 | p.err != nil {
return p.err
}
return p.l.Err()
} | |
c12245 | copy(buf, w.buf)
w.buf = buf
}
w.buf = w.buf[:end+n]
return copy(w.buf[end:], b), nil
} | |
c12246 |
l.consumeIdentToken()
l.r.Restore()
return l.r.Pos() == len(b)
} | |
c12247 |
l.consumeUnquotedURL()
l.r.Restore()
return l.r.Pos() == len(b)
} | |
c12248 | {
if c == '&' {
if entityQuote, n := parse.QuoteEntity(b[i:]); n > 0 {
j += copy(t[j:], b[start:i])
if entityQuote != quote {
t[j] = entityQuote
j++
} else {
j += copy(t[j:], escapedQuote)
}
start = i + n
}
} else if c == quote {
j += copy(t[j:], b[start:i])
j += copy... | |
c12249 | == '<' {
j += copy(t[j:], b[start:i])
j += copy(t[j:], ltEntityBytes)
start = i + 1
} else if c == '&' {
j += copy(t[j:], b[start:i])
j += copy(t[j:], ampEntityBytes)
start = i + 1
}
}
j += copy(t[j:], b[start:])
return t[:j], true
} | |
c12250 | len(src))
copy(dst, src)
return
} | |
c12251 |
if c >= 'A' && c <= 'Z' {
src[i] = c + ('a' - 'A')
}
}
return src
} | |
c12252 | return false
}
}
return true
} | |
c12253 | start = i
break
}
}
end := n
for i := n - 1; i >= start; i-- {
if !IsWhitespace(b[i]) {
end = i + 1
break
}
}
return b[start:end]
} | |
c12254 | if i+n > cap(b) {
b = append(b, make([]byte, n)...)
} else {
b = b[:i+n]
}
// print fractional-part
i += n - 1
if dec {
for j := 0; j < 2; j++ {
c := byte(price%10) + '0'
price /= 10
b[i] = c
i--
}
b[i] = decSeparator
i--
} else {
price /= 100
}
if price == 0 {
b[i] = '0'
return... | |
c12255 | return l.err
}
return l.r.Err()
} | |
c12256 | if l.r.Err() == nil {
l.err = parse.NewErrorLexer("unexpected null character", l.r)
}
return l.r.Shift()
} else {
l.r.Move(1)
}
}
for {
c := l.r.Peek(0)
if c == '>' {
l.r.Move(1)
break
} else if c == 0 {
if l.r.Err() == nil {
l.err = parse.NewErrorLexer("unexpected null charact... | |
c12257 | }
} else {
l.Move(1)
}
if nNewline > 0 {
if offset < l.Pos()+nNewline {
// move onto offset position, let next iteration handle it
l.Move(offset - l.Pos())
continue
}
l.Move(nNewline)
line++
offset -= l.Pos()
l.Skip()
}
}
} | |
c12258 | {
return 0, io.EOF
}
n = copy(b, r.buf[r.pos:])
r.pos += n
return
} | |
c12259 | } else {
break
}
i++
}
if !neg && n > uint64(math.MaxInt64) || n > uint64(math.MaxInt64)+1 {
return 0, 0
} else if neg {
return -int64(n), i
}
return int64(n), i
} | |
c12260 | expExp = e
i += expLen
}
}
exp := expExp - mantExp
// copied from strconv/atof.go
if exp == 0 {
return f, i
} else if exp > 0 && exp <= 15+22 { // int * 10^k
// If exponent is big but number of digits is not,
// can move a few zeros into the integer part.
if exp > 22 {
f *= float64pow10[exp-22]
... | |
c12261 | {
return &Error{
Message: msg,
r: r,
Offset: offset,
}
} | |
c12262 | := l.Offset()
return NewError(msg, r, offset)
} | |
c12263 |
e.line, e.column, e.context = Position(e.r, e.Offset)
}
return e.line, e.column, e.context
} | |
c12264 |
return fmt.Sprintf("parse error:%d:%d: %s\n%s", line, column, e.Message, context)
} | |
c12265 | return RightBracketToken
case '{':
l.r.Move(1)
return LeftBraceToken
case '}':
l.r.Move(1)
return RightBraceToken
}
return ErrorToken
} | |
c12266 |
return PercentageToken
} else if l.consumeIdentToken() {
return DimensionToken
}
return NumberToken
}
return ErrorToken
} | |
c12267 | break
} else if c == '\\' {
if !l.consumeEscape() {
l.r.Move(1)
l.consumeNewline()
}
} else {
l.r.Move(1)
}
}
return StringToken
} | |
c12268 |
} else if !l.consumeEscape() {
l.r.Move(1)
}
}
} | |
c12269 | } else if !l.consumeUnquotedURL() && !l.consumeWhitespace() { // if unquoted URL fails due to encountering whitespace, continue
l.consumeRemnantsBadURL()
return BadURLToken
}
for l.consumeWhitespace() {
}
if !l.consumeByte(')') && l.r.Err() != io.EOF {
l.consumeRemnantsBadURL()
return BadURLToken
... | |
c12270 | return "ObjectValue"
case ArrayState:
return "Array"
}
return "Invalid(" + strconv.Itoa(int(state)) + ")"
} | |
c12271 |
r: buffer.NewLexer(r),
state: []State{ValueState},
}
} | |
c12272 | p.err != nil {
return p.err
}
return p.r.Err()
} | |
c12273 |
escapedQuote = singleQuoteEntityBytes
}
if n > cap(*buf) {
*buf = make([]byte, 0, n) // maximum size, not actual size
}
t := (*buf)[:n] // maximum size, not actual size
t[0] = quote
j := 1
start := 0
for i, c := range b {
if c == '&' {
if entityQuote, n := parse.QuoteEntity(b[i:]); n > 0 {
j += co... | |
c12274 |
Action: actions,
seq: keyseq.New(),
}
} | |
c12275 |
if pdebug.Enabled {
pdebug.Printf("Keymap.Handler: Fetched action")
}
return wrapClearSequence(action.(Action))
case keyseq.ErrInSequence:
if pdebug.Enabled {
pdebug.Printf("Keymap.Handler: Waiting for more commands...")
}
return wrapRememberSequence(ActionFunc(doNothing))
default:
if pdebug.Enab... | |
c12276 | name %s", as)
}
kb[s] = v
}
// now compile using kb
// there's no need to do this, but we sort keys here just to make
// debugging easier
keys := make([]string, 0, len(kb))
for s := range kb {
keys = append(keys, s)
}
sort.Strings(keys)
for _, s := range keys {
a := kb[s]
list, err := keyseq.ToKey... | |
c12277 | out of range", len(flb.selection))
}
return flb.src.LineAt(flb.selection[i])
} | |
c12278 | s = "v"
case "ArrowLeft":
s = "<"
case "ArrowRight":
s = ">"
}
}
if ev.Mod&termbox.ModAlt == 1 {
return "M-" + s, nil
}
return s, nil
} | |
c12279 | cmd,
enableSep: enableSep,
idgen: idgen,
name: name,
outCh: pipeline.ChanOutput(make(chan interface{})),
thresholdBufsiz: threshold,
}
} | |
c12280 |
drawCh: make(chan Payload, bufsiz),
statusMsgCh: make(chan Payload, bufsiz),
pagingCh: make(chan Payload, bufsiz),
}
} | |
c12281 | needReply {
r.done = make(chan struct{})
defer func() { <-r.done }()
}
ch <- r
} | |
c12282 | {
send(h.QueryCh(), NewPayload(q), h.isSync)
} | |
c12283 | %v", options)
defer pdebug.Printf("END Hub.SendDraw %v", options)
send(h.DrawCh(), NewPayload(options), h.isSync)
} | |
c12284 | {
msg := newStatusMsgReq(q, clearDelay)
send(h.StatusMsgCh(), NewPayload(msg), h.isSync)
} | |
c12285 | {
send(h.PagingCh(), NewPayload(x), h.isSync)
} | |
c12286 | t.mutex.Unlock()
return errors.Wrap(termbox.Flush(), "failed to flush termbox")
} | |
c12287 | }
t.Close()
}
}
}()
go func() {
defer func() { recover() }()
defer func() { close(evCh) }()
for {
ev := termbox.PollEvent()
if ev.Type != termbox.EventInterrupt {
evCh <- ev
continue
}
select {
case <-ctx.Done():
return
case replyCh := <-t.resumeCh:
t.Init()
... | |
c12288 | defer t.mutex.Unlock()
termbox.SetCell(x, y, ch, fg, bg)
} | |
c12289 | t.mutex.Unlock()
return termbox.Size()
} | |
c12290 |
go func() {
defer close(c)
q.mutex.Lock()
defer q.mutex.Unlock()
for _, r := range q.query {
c <- r
}
}()
return c
} | |
c12291 | state *Peco, e termbox.Event) {
a(ctx, state, e)
} | |
c12292 | {
a.registerKeySequence(keyseq.KeyList{keyseq.NewKeyFromKey(k)})
}
} | |
c12293 | keyseq.KeyList) {
nameToActions["peco."+name] = a
a.registerKeySequence(k)
} | |
c12294 | := state.Caret()
q.InsertAt(ch, c.Pos())
c.Move(1)
h := state.Hub()
h.SendDrawPrompt() // Update prompt before running query
state.ExecQuery()
} | |
c12295 | return em.EndMark()
}
return false
} | |
c12296 | timeout of 1 second.
t := time.NewTimer(time.Second)
defer t.Stop()
select {
case oc <- v:
case <-t.C:
return errors.New("failed to send (not listening)")
}
return nil
} | |
c12297 | errors.Wrap(oc.Send(errors.Wrap(EndMark{}, s)), "failed to send end mark")
} | |
c12298 | defer p.mutex.Unlock()
p.src = s
} | |
c12299 |
defer p.mutex.Unlock()
p.nodes = append(p.nodes, n)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.