_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q12200 | AddFlag | train | func (f VerifyFlag) AddFlag(fset *pflag.FlagSet) (interface{}, error) {
switch f.Type {
case StringFlag:
return fset.String(f.Name, "", f.Description), nil
case BoolFlag:
return fset.Bool(f.Name, false, f.Description), nil
default:
return nil, errors.Errorf("unrecognized flag type: %v", f.Type)
}
} | go | {
"resource": ""
} |
q12201 | ConfigVersion | train | func ConfigVersion(in []byte) (string, error) {
var cfgWithVersion ConfigWithVersion
if err := yaml.Unmarshal(in, &cfgWithVersion); err != nil {
return "", errors.Wrapf(err, "failed to unmarshal YAML")
}
return cfgWithVersion.Version, nil
} | go | {
"resource": ""
} |
q12202 | Move | train | func Move(src, dst string) error {
if err := verifyDstPathSafe(dst); err != nil {
return errors.Wrapf(err, "cannot move 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
} | go | {
"resource": ""
} |
q12203 | CopyDir | train | func CopyDir(src, dst string) error {
if err := verifyDstPathSafe(dst); err != nil {
return errors.Wrapf(err, "cannot copy directory to path %s", dst)
}
srcInfo, err := os.Stat(src)
if err != nil {
return errors.Wrapf(err, "failed to stat source directory %s", src)
}
if err := os.Mkdir(dst, srcInfo.Mode());... | go | {
"resource": ""
} |
q12204 | SyncDirAdditive | train | func SyncDirAdditive(src, dst string) error {
srcInfos, err := ioutil.ReadDir(src)
if err != nil {
return errors.Wrapf(err, "failed to open %s", src)
}
for _, srcInfo := range srcInfos {
srcPath := path.Join(src, srcInfo.Name())
dstPath := path.Join(dst, srcInfo.Name())
if dstInfo, err := os.Stat(dstPath)... | go | {
"resource": ""
} |
q12205 | verifyDstPathSafe | train | func verifyDstPathSafe(dst string) error {
if _, err := os.Stat(dst); !os.IsNotExist(err) {
return errors.Wrapf(err, "destination path %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)
}
r... | go | {
"resource": ""
} |
q12206 | Download | train | func Download(pkgSrc PkgSrc, dstFilePath string, w io.Writer) (rErr error) {
wantChecksum := pkgSrc.Checksum()
if info, err := os.Stat(dstFilePath); err == nil {
if info.IsDir() {
return errors.Errorf("destination path %s already exists and is a directory", dstFilePath)
}
if wantChecksum != "" {
// if fil... | go | {
"resource": ""
} |
q12207 | ListProjectPaths | train | func ListProjectPaths(projectDir string, include, exclude matcher.Matcher) ([]string, error) {
wd, err := os.Getwd()
if err != nil {
return nil, errors.Wrapf(err, "failed to determine working directory")
}
if !filepath.IsAbs(projectDir) {
projectDir = path.Join(wd, projectDir)
}
relPathPrefix, err := filepath... | go | {
"resource": ""
} |
q12208 | AllPaths | train | func AllPaths(dir string) (map[string]bool, error) {
m := make(map[string]bool)
return m, allPaths(m, nil, dir)
} | go | {
"resource": ""
} |
q12209 | pluginTGZContentHash | train | func pluginTGZContentHash(tgzContentReader io.Reader) (string, error) {
hasher := sha256.New()
if err := CopySingleFileTGZContent(hasher, tgzContentReader); err != nil {
return "", err
}
return hex.EncodeToString(hasher.Sum(nil)), nil
} | go | {
"resource": ""
} |
q12210 | ProjectDir | train | func (g GlobalConfig) ProjectDir() (string, error) {
if g.Wrapper == "" {
return "", errors.Errorf("wrapper must be specified to determine project directory")
}
return path.Dir(g.Wrapper), nil
} | go | {
"resource": ""
} |
q12211 | getIndex | train | func (h *HyperLogLogPlus) getIndex(k uint32) uint32 {
if k&1 == 1 {
return eb32(k, 32, 32-h.p)
}
return eb32(k, pPrime+1, pPrime-h.p+1)
} | go | {
"resource": ""
} |
q12212 | mergeSparse | train | func (h *HyperLogLogPlus) mergeSparse() {
keys := make(sortableSlice, 0, len(h.tmpSet))
for k := range h.tmpSet {
keys = append(keys, k)
}
sort.Sort(keys)
newList := newCompressedList(int(h.m))
for iter, i := h.sparseList.Iter(), 0; iter.HasNext() || i < len(keys); {
if !iter.HasNext() {
newList.Append(ke... | go | {
"resource": ""
} |
q12213 | NewPlus | train | func NewPlus(precision uint8) (*HyperLogLogPlus, error) {
if precision > 18 || precision < 4 {
return nil, errors.New("precision must be between 4 and 18")
}
h := &HyperLogLogPlus{}
h.p = precision
h.m = 1 << precision
h.sparse = true
h.tmpSet = set{}
h.sparseList = newCompressedList(int(h.m))
return h, nil... | go | {
"resource": ""
} |
q12214 | Clear | train | func (h *HyperLogLogPlus) Clear() {
h.sparse = true
h.tmpSet = set{}
h.sparseList = newCompressedList(int(h.m))
h.reg = nil
} | go | {
"resource": ""
} |
q12215 | toNormal | train | func (h *HyperLogLogPlus) toNormal() {
h.reg = make([]uint8, h.m)
for iter := h.sparseList.Iter(); iter.HasNext(); {
i, r := h.decodeHash(iter.Next())
if h.reg[i] < r {
h.reg[i] = r
}
}
h.sparse = false
h.tmpSet = nil
h.sparseList = nil
} | go | {
"resource": ""
} |
q12216 | Add | train | func (h *HyperLogLogPlus) Add(item Hash64) {
x := item.Sum64()
if h.sparse {
h.tmpSet.Add(h.encodeHash(x))
h.maybeMerge()
} else {
i := eb64(x, 64, 64-h.p) // {x63,...,x64-p}
w := x<<h.p | 1<<(h.p-1) // {x63-p,...,x0}
zeroBits := clz64(w) + 1
if zeroBits > h.reg[i] {
h.reg[i] = zeroBits
}
}
} | go | {
"resource": ""
} |
q12217 | Merge | train | func (h *HyperLogLogPlus) Merge(other *HyperLogLogPlus) error {
if h.p != other.p {
return errors.New("precisions must be equal")
}
if h.sparse && other.sparse {
for k := range other.tmpSet {
h.tmpSet.Add(k)
}
for iter := other.sparseList.Iter(); iter.HasNext(); {
h.tmpSet.Add(iter.Next())
}
h.may... | go | {
"resource": ""
} |
q12218 | maybeMerge | train | func (h *HyperLogLogPlus) maybeMerge() {
if uint32(len(h.tmpSet))*100 > h.m {
h.mergeSparse()
}
} | go | {
"resource": ""
} |
q12219 | estimateBias | train | func (h *HyperLogLogPlus) estimateBias(est float64) float64 {
estTable, biasTable := rawEstimateData[h.p-4], biasData[h.p-4]
if estTable[0] > est {
return biasTable[0]
}
lastEstimate := estTable[len(estTable)-1]
if lastEstimate < est {
return biasTable[len(biasTable)-1]
}
var i int
for i = 0; i < len(est... | go | {
"resource": ""
} |
q12220 | GobEncode | train | func (h *HyperLogLogPlus) GobEncode() ([]byte, error) {
buf := bytes.Buffer{}
enc := gob.NewEncoder(&buf)
if err := enc.Encode(h.reg); err != nil {
return nil, err
}
if err := enc.Encode(h.m); err != nil {
return nil, err
}
if err := enc.Encode(h.p); err != nil {
return nil, err
}
if err := enc.Encode(h.... | go | {
"resource": ""
} |
q12221 | GobDecode | train | func (h *HyperLogLogPlus) GobDecode(b []byte) error {
dec := gob.NewDecoder(bytes.NewBuffer(b))
if err := dec.Decode(&h.reg); err != nil {
return err
}
if err := dec.Decode(&h.m); err != nil {
return err
}
if err := dec.Decode(&h.p); err != nil {
return err
}
if err := dec.Decode(&h.sparse); err != nil {
... | go | {
"resource": ""
} |
q12222 | eb32 | train | func eb32(bits uint32, hi uint8, lo uint8) uint32 {
m := uint32(((1 << (hi - lo)) - 1) << lo)
return (bits & m) >> lo
} | go | {
"resource": ""
} |
q12223 | eb64 | train | func eb64(bits uint64, hi uint8, lo uint8) uint64 {
m := uint64(((1 << (hi - lo)) - 1) << lo)
return (bits & m) >> lo
} | go | {
"resource": ""
} |
q12224 | New | train | func New(precision uint8) (*HyperLogLog, error) {
if precision > 16 || precision < 4 {
return nil, errors.New("precision must be between 4 and 16")
}
h := &HyperLogLog{}
h.p = precision
h.m = 1 << precision
h.reg = make([]uint8, h.m)
return h, nil
} | go | {
"resource": ""
} |
q12225 | Add | train | func (h *HyperLogLog) Add(item Hash32) {
x := item.Sum32()
i := eb32(x, 32, 32-h.p) // {x31,...,x32-p}
w := x<<h.p | 1<<(h.p-1) // {x32-p,...,x0}
zeroBits := clz32(w) + 1
if zeroBits > h.reg[i] {
h.reg[i] = zeroBits
}
} | go | {
"resource": ""
} |
q12226 | Merge | train | func (h *HyperLogLog) Merge(other *HyperLogLog) error {
if h.p != other.p {
return errors.New("precisions must be equal")
}
for i, v := range other.reg {
if v > h.reg[i] {
h.reg[i] = v
}
}
return nil
} | go | {
"resource": ""
} |
q12227 | GobEncode | train | func (h *HyperLogLog) GobEncode() ([]byte, error) {
buf := bytes.Buffer{}
enc := gob.NewEncoder(&buf)
if err := enc.Encode(h.reg); err != nil {
return nil, err
}
if err := enc.Encode(h.m); err != nil {
return nil, err
}
if err := enc.Encode(h.p); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q12228 | GobDecode | train | func (h *HyperLogLog) GobDecode(b []byte) error {
dec := gob.NewDecoder(bytes.NewBuffer(b))
if err := dec.Decode(&h.reg); err != nil {
return err
}
if err := dec.Decode(&h.m); err != nil {
return err
}
if err := dec.Decode(&h.p); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q12229 | String | train | func (i Hash) String() string {
start := uint32(i >> 8)
n := uint32(i & 0xff)
if start+n > uint32(len(_Hash_text)) {
return ""
}
return _Hash_text[start : start+n]
} | go | {
"resource": ""
} |
q12230 | ToHash | train | func ToHash(s []byte) Hash {
if len(s) == 0 || len(s) > _Hash_maxLen {
return 0
}
h := uint32(_Hash_hash0)
for i := 0; i < len(s); i++ {
h ^= uint32(s[i])
h *= 16777619
}
if i := _Hash_table[h&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)... | go | {
"resource": ""
} |
q12231 | NewStreamLexerSize | train | func NewStreamLexerSize(r io.Reader, size int) *StreamLexer {
// if reader has the bytes in memory already, use that instead
if buffer, ok := r.(interface {
Bytes() []byte
}); ok {
return &StreamLexer{
err: io.EOF,
buf: buffer.Bytes(),
}
}
return &StreamLexer{
r: r,
buf: make([]byte, 0, size),
}... | go | {
"resource": ""
} |
q12232 | Err | train | func (z *StreamLexer) Err() error {
if z.err == io.EOF && z.pos < len(z.buf) {
return nil
}
return z.err
} | go | {
"resource": ""
} |
q12233 | Shift | train | func (z *StreamLexer) Shift() []byte {
if z.pos > len(z.buf) { // make sure we peeked at least as much as we shift
z.read(z.pos - 1)
}
b := z.buf[z.start:z.pos]
z.start = z.pos
return b
} | go | {
"resource": ""
} |
q12234 | ShiftLen | train | func (z *StreamLexer) ShiftLen() int {
n := z.start - z.prevStart
z.prevStart = z.start
return n
} | go | {
"resource": ""
} |
q12235 | NewLexer | train | func NewLexer(r io.Reader) *Lexer {
var b []byte
if r != nil {
if buffer, ok := r.(interface {
Bytes() []byte
}); ok {
b = buffer.Bytes()
} else {
var err error
b, err = ioutil.ReadAll(r)
if err != nil {
return &Lexer{
buf: []byte{0},
err: err,
}
}
}
}
return NewLexerByte... | go | {
"resource": ""
} |
q12236 | NewLexerBytes | train | func NewLexerBytes(b []byte) *Lexer {
z := &Lexer{
buf: b,
}
n := len(b)
if n == 0 {
z.buf = nullBuffer
} else if b[n-1] != 0 {
// Append NULL to buffer, but try 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... | go | {
"resource": ""
} |
q12237 | Restore | train | func (z *Lexer) Restore() {
if z.restore != nil {
z.restore()
z.restore = nil
}
} | go | {
"resource": ""
} |
q12238 | Peek | train | func (z *Lexer) Peek(pos int) byte {
pos += z.pos
return z.buf[pos]
} | go | {
"resource": ""
} |
q12239 | Shift | train | func (z *Lexer) Shift() []byte {
b := z.buf[z.start:z.pos]
z.start = z.pos
return b
} | go | {
"resource": ""
} |
q12240 | Dimension | train | func Dimension(b []byte) (int, int) {
num := Number(b)
if num == 0 || num == len(b) {
return num, 0
} else if b[num] == '%' {
return num, 1
} else if 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') {... | go | {
"resource": ""
} |
q12241 | Mediatype | train | func Mediatype(b []byte) ([]byte, map[string]string) {
i := 0
for i < len(b) && b[i] == ' ' {
i++
}
b = b[i:]
n := len(b)
mimetype := b
var params map[string]string
for i := 3; i < n; i++ { // mimetype is at least three characters long
if b[i] == ';' || b[i] == ' ' {
mimetype = b[:i]
if b[i] == ' ' {
... | go | {
"resource": ""
} |
q12242 | DataURI | train | func DataURI(dataURI []byte) ([]byte, []byte, error) {
if len(dataURI) > 5 && bytes.Equal(dataURI[:5], []byte("data:")) {
dataURI = dataURI[5:]
inBase64 := false
var mediatype []byte
i := 0
for j := 0; j < len(dataURI); j++ {
c := dataURI[j]
if c == '=' || c == ';' || c == ',' {
if c != '=' && byte... | go | {
"resource": ""
} |
q12243 | NewParser | train | func NewParser(r io.Reader, isInline bool) *Parser {
l := NewLexer(r)
p := &Parser{
l: l,
state: make([]State, 0, 4),
}
if isInline {
p.state = append(p.state, (*Parser).parseDeclarationList)
} else {
p.state = append(p.state, (*Parser).parseStylesheet)
}
return p
} | go | {
"resource": ""
} |
q12244 | Err | train | func (p *Parser) Err() error {
if p.err != nil {
return p.err
}
return p.l.Err()
} | go | {
"resource": ""
} |
q12245 | Write | train | func (w *Writer) Write(b []byte) (int, error) {
n := len(b)
end := len(w.buf)
if end+n > cap(w.buf) {
buf := make([]byte, end, 2*cap(w.buf)+n)
copy(buf, w.buf)
w.buf = buf
}
w.buf = w.buf[:end+n]
return copy(w.buf[end:], b), nil
} | go | {
"resource": ""
} |
q12246 | IsIdent | train | func IsIdent(b []byte) bool {
l := NewLexer(buffer.NewReader(b))
l.consumeIdentToken()
l.r.Restore()
return l.r.Pos() == len(b)
} | go | {
"resource": ""
} |
q12247 | IsURLUnquoted | train | func IsURLUnquoted(b []byte) bool {
l := NewLexer(buffer.NewReader(b))
l.consumeUnquotedURL()
l.r.Restore()
return l.r.Pos() == len(b)
} | go | {
"resource": ""
} |
q12248 | EscapeAttrVal | train | func EscapeAttrVal(buf *[]byte, b []byte) []byte {
singles := 0
doubles := 0
for i, c := range b {
if c == '&' {
if quote, n := parse.QuoteEntity(b[i:]); n > 0 {
if quote == '"' {
doubles++
} else {
singles++
}
}
} else if c == '"' {
doubles++
} else if c == '\'' {
singles++
... | go | {
"resource": ""
} |
q12249 | EscapeCDATAVal | train | func EscapeCDATAVal(buf *[]byte, b []byte) ([]byte, bool) {
n := 0
for _, c := range b {
if c == '<' || c == '&' {
if c == '<' {
n += 3 // <
} else {
n += 4 // &
}
if n > len("<![CDATA[]]>") {
return b, false
}
}
}
if len(b)+n > cap(*buf) {
*buf = make([]byte, 0, len(b)+n)
}... | go | {
"resource": ""
} |
q12250 | Copy | train | func Copy(src []byte) (dst []byte) {
dst = make([]byte, len(src))
copy(dst, src)
return
} | go | {
"resource": ""
} |
q12251 | ToLower | train | func ToLower(src []byte) []byte {
for i, c := range src {
if c >= 'A' && c <= 'Z' {
src[i] = c + ('a' - 'A')
}
}
return src
} | go | {
"resource": ""
} |
q12252 | IsAllWhitespace | train | func IsAllWhitespace(b []byte) bool {
for _, c := range b {
if !IsWhitespace(c) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q12253 | TrimWhitespace | train | func TrimWhitespace(b []byte) []byte {
n := len(b)
start := n
for i := 0; i < n; i++ {
if !IsWhitespace(b[i]) {
start = i
break
}
}
end := n
for i := n - 1; i >= start; i-- {
if !IsWhitespace(b[i]) {
end = i + 1
break
}
}
return b[start:end]
} | go | {
"resource": ""
} |
q12254 | AppendPrice | train | func AppendPrice(b []byte, price int64, dec bool, milSeparator byte, decSeparator byte) []byte {
if price < 0 {
if price == -9223372036854775808 {
x := []byte("92 233 720 368 547 758 08")
x[2] = milSeparator
x[6] = milSeparator
x[10] = milSeparator
x[14] = milSeparator
x[18] = milSeparator
x[22]... | go | {
"resource": ""
} |
q12255 | Err | train | func (l *Lexer) Err() error {
if l.err != nil {
return l.err
}
return l.r.Err()
} | go | {
"resource": ""
} |
q12256 | shiftXml | train | func (l *Lexer) shiftXml(rawTag Hash) []byte {
inQuote := false
for {
c := l.r.Peek(0)
if c == '"' {
inQuote = !inQuote
l.r.Move(1)
} else if c == '<' && !inQuote && l.r.Peek(1) == '/' {
mark := l.r.Pos()
l.r.Move(2)
for {
if c = l.r.Peek(0); !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') {
... | go | {
"resource": ""
} |
q12257 | Position | train | func Position(r io.Reader, offset int) (line, col int, context string) {
l := buffer.NewLexer(r)
line = 1
for {
c := l.Peek(0)
if c == 0 && l.Err() != nil || offset == l.Pos() {
col = l.Pos() + 1
context = positionContext(l, line, col)
return
}
nNewline := 0
if c == '\n' {
nNewline = 1
} el... | go | {
"resource": ""
} |
q12258 | Read | train | func (r *Reader) Read(b []byte) (n int, err error) {
if len(b) == 0 {
return 0, nil
}
if r.pos >= len(r.buf) {
return 0, io.EOF
}
n = copy(b, r.buf[r.pos:])
r.pos += n
return
} | go | {
"resource": ""
} |
q12259 | ParseInt | train | func ParseInt(b []byte) (int64, int) {
i := 0
neg := false
if len(b) > 0 && (b[0] == '+' || b[0] == '-') {
neg = b[0] == '-'
i++
}
n := uint64(0)
for i < len(b) {
c := b[i]
if n > math.MaxUint64/10 {
return 0, 0
} else if c >= '0' && c <= '9' {
n *= 10
n += uint64(c - '0')
} else {
break
... | go | {
"resource": ""
} |
q12260 | ParseFloat | train | func ParseFloat(b []byte) (float64, int) {
i := 0
neg := false
if i < len(b) && (b[i] == '+' || b[i] == '-') {
neg = b[i] == '-'
i++
}
dot := -1
trunk := -1
n := uint64(0)
for ; i < len(b); i++ {
c := b[i]
if c >= '0' && c <= '9' {
if trunk == -1 {
if n > math.MaxUint64/10 {
trunk = i
}... | go | {
"resource": ""
} |
q12261 | NewError | train | func NewError(msg string, r io.Reader, offset int) *Error {
return &Error{
Message: msg,
r: r,
Offset: offset,
}
} | go | {
"resource": ""
} |
q12262 | NewErrorLexer | train | func NewErrorLexer(msg string, l *buffer.Lexer) *Error {
r := buffer.NewReader(l.Bytes())
offset := l.Offset()
return NewError(msg, r, offset)
} | go | {
"resource": ""
} |
q12263 | Position | train | func (e *Error) Position() (int, int, string) {
if e.line == 0 {
e.line, e.column, e.context = Position(e.r, e.Offset)
}
return e.line, e.column, e.context
} | go | {
"resource": ""
} |
q12264 | Error | train | func (e *Error) Error() string {
line, column, context := e.Position()
return fmt.Sprintf("parse error:%d:%d: %s\n%s", line, column, e.Message, context)
} | go | {
"resource": ""
} |
q12265 | consumeBracket | train | func (l *Lexer) consumeBracket() TokenType {
switch l.r.Peek(0) {
case '(':
l.r.Move(1)
return LeftParenthesisToken
case ')':
l.r.Move(1)
return RightParenthesisToken
case '[':
l.r.Move(1)
return LeftBracketToken
case ']':
l.r.Move(1)
return RightBracketToken
case '{':
l.r.Move(1)
return LeftB... | go | {
"resource": ""
} |
q12266 | consumeNumeric | train | func (l *Lexer) consumeNumeric() TokenType {
if l.consumeNumberToken() {
if l.consumeByte('%') {
return PercentageToken
} else if l.consumeIdentToken() {
return DimensionToken
}
return NumberToken
}
return ErrorToken
} | go | {
"resource": ""
} |
q12267 | consumeString | train | func (l *Lexer) consumeString() TokenType {
// assume to be on " or '
delim := l.r.Peek(0)
l.r.Move(1)
for {
c := l.r.Peek(0)
if c == 0 && l.r.Err() != nil {
break
} else if c == '\n' || c == '\r' || c == '\f' {
l.r.Move(1)
return BadStringToken
} else if c == delim {
l.r.Move(1)
break
} el... | go | {
"resource": ""
} |
q12268 | consumeRemnantsBadURL | train | func (l *Lexer) consumeRemnantsBadURL() {
for {
if l.consumeByte(')') || l.r.Err() != nil {
break
} else if !l.consumeEscape() {
l.r.Move(1)
}
}
} | go | {
"resource": ""
} |
q12269 | consumeIdentlike | train | func (l *Lexer) consumeIdentlike() TokenType {
if l.consumeIdentToken() {
if l.r.Peek(0) != '(' {
return IdentToken
} else if !parse.EqualFold(bytes.Replace(l.r.Lexeme(), []byte{'\\'}, nil, -1), []byte{'u', 'r', 'l'}) {
l.r.Move(1)
return FunctionToken
}
l.r.Move(1)
// consume url
for l.consumeWh... | go | {
"resource": ""
} |
q12270 | String | train | func (state State) String() string {
switch state {
case ValueState:
return "Value"
case ObjectKeyState:
return "ObjectKey"
case ObjectValueState:
return "ObjectValue"
case ArrayState:
return "Array"
}
return "Invalid(" + strconv.Itoa(int(state)) + ")"
} | go | {
"resource": ""
} |
q12271 | NewParser | train | func NewParser(r io.Reader) *Parser {
return &Parser{
r: buffer.NewLexer(r),
state: []State{ValueState},
}
} | go | {
"resource": ""
} |
q12272 | Err | train | func (p *Parser) Err() error {
if p.err != nil {
return p.err
}
return p.r.Err()
} | go | {
"resource": ""
} |
q12273 | EscapeAttrVal | train | func EscapeAttrVal(buf *[]byte, orig, b []byte, isXML bool) []byte {
singles := 0
doubles := 0
unquoted := true
entities := false
for i, c := range b {
if charTable[c] {
if c == '&' {
entities = true
if quote, n := parse.QuoteEntity(b[i:]); n > 0 {
if quote == '"' {
unquoted = false
d... | go | {
"resource": ""
} |
q12274 | NewKeymap | train | func NewKeymap(config map[string]string, actions map[string][]string) Keymap {
return Keymap{
Config: config,
Action: actions,
seq: keyseq.New(),
}
} | go | {
"resource": ""
} |
q12275 | LookupAction | train | func (km Keymap) LookupAction(ev termbox.Event) Action {
modifier := keyseq.ModNone
if (ev.Mod & termbox.ModAlt) != 0 {
modifier = keyseq.ModAlt
}
key := keyseq.Key{
Modifier: modifier,
Key: ev.Key,
Ch: ev.Ch,
}
action, err := km.seq.AcceptKey(key)
switch err {
case nil:
// Found an actio... | go | {
"resource": ""
} |
q12276 | ApplyKeybinding | train | func (km *Keymap) ApplyKeybinding() error {
k := km.seq
k.Clear()
// Copy the map
kb := map[string]Action{}
for s, a := range defaultKeyBinding {
kb[s] = a
}
// munge the map using config
for s, as := range km.Config {
if as == "-" {
delete(kb, s)
continue
}
v, err := km.resolveActionName(as, 0... | go | {
"resource": ""
} |
q12277 | LineAt | train | func (flb FilteredBuffer) LineAt(i int) (line.Line, error) {
if i >= len(flb.selection) {
return nil, errors.Errorf("specified index %d is out of range", len(flb.selection))
}
return flb.src.LineAt(flb.selection[i])
} | go | {
"resource": ""
} |
q12278 | EventToString | train | func EventToString(ev termbox.Event) (string, error) {
s := ""
if ev.Key == 0 {
s = string([]rune{ev.Ch})
} else {
var ok bool
s, ok = keyToString[ev.Key]
if !ok {
return "", errors.Errorf("no such key %#v", ev)
}
// Special case for ArrowUp/Down/Left/Right
switch s {
case "ArrowUp":
s = "^"
... | go | {
"resource": ""
} |
q12279 | NewExternalCmd | train | func NewExternalCmd(name string, cmd string, args []string, threshold int, idgen line.IDGenerator, enableSep bool) *ExternalCmd {
if len(args) == 0 {
args = []string{"$QUERY"}
}
if threshold <= 0 {
threshold = DefaultCustomFilterBufferThreshold
}
return &ExternalCmd{
args: args,
cmd: ... | go | {
"resource": ""
} |
q12280 | New | train | func New(bufsiz int) *Hub {
return &Hub{
isSync: false,
queryCh: make(chan Payload, bufsiz),
drawCh: make(chan Payload, bufsiz),
statusMsgCh: make(chan Payload, bufsiz),
pagingCh: make(chan Payload, bufsiz),
}
} | go | {
"resource": ""
} |
q12281 | send | train | func send(ch chan Payload, r *payload, needReply bool) {
if needReply {
r.done = make(chan struct{})
defer func() { <-r.done }()
}
ch <- r
} | go | {
"resource": ""
} |
q12282 | SendQuery | train | func (h *Hub) SendQuery(q string) {
send(h.QueryCh(), NewPayload(q), h.isSync)
} | go | {
"resource": ""
} |
q12283 | SendDraw | train | func (h *Hub) SendDraw(options interface{}) {
pdebug.Printf("START Hub.SendDraw %v", options)
defer pdebug.Printf("END Hub.SendDraw %v", options)
send(h.DrawCh(), NewPayload(options), h.isSync)
} | go | {
"resource": ""
} |
q12284 | SendStatusMsgAndClear | train | func (h *Hub) SendStatusMsgAndClear(q string, clearDelay time.Duration) {
msg := newStatusMsgReq(q, clearDelay)
send(h.StatusMsgCh(), NewPayload(msg), h.isSync)
} | go | {
"resource": ""
} |
q12285 | SendPaging | train | func (h *Hub) SendPaging(x interface{}) {
send(h.PagingCh(), NewPayload(x), h.isSync)
} | go | {
"resource": ""
} |
q12286 | Flush | train | func (t *Termbox) Flush() error {
t.mutex.Lock()
defer t.mutex.Unlock()
return errors.Wrap(termbox.Flush(), "failed to flush termbox")
} | go | {
"resource": ""
} |
q12287 | PollEvent | train | func (t *Termbox) PollEvent(ctx context.Context) chan termbox.Event {
// XXX termbox.PollEvent() can get stuck on unexpected signal
// handling cases. We still would like to wait until the user
// (termbox) has some event for us to process, but we don't
// want to allow termbox to control/block our input loop.
//
... | go | {
"resource": ""
} |
q12288 | SetCell | train | func (t *Termbox) SetCell(x, y int, ch rune, fg, bg termbox.Attribute) {
t.mutex.Lock()
defer t.mutex.Unlock()
termbox.SetCell(x, y, ch, fg, bg)
} | go | {
"resource": ""
} |
q12289 | Size | train | func (t *Termbox) Size() (int, int) {
t.mutex.Lock()
defer t.mutex.Unlock()
return termbox.Size()
} | go | {
"resource": ""
} |
q12290 | Runes | train | func (q *Query) Runes() <-chan rune {
q.mutex.Lock()
defer q.mutex.Unlock()
c := make(chan rune, len(q.query))
go func() {
defer close(c)
q.mutex.Lock()
defer q.mutex.Unlock()
for _, r := range q.query {
c <- r
}
}()
return c
} | go | {
"resource": ""
} |
q12291 | Execute | train | func (a ActionFunc) Execute(ctx context.Context, state *Peco, e termbox.Event) {
a(ctx, state, e)
} | go | {
"resource": ""
} |
q12292 | Register | train | func (a ActionFunc) Register(name string, defaultKeys ...termbox.Key) {
nameToActions["peco."+name] = a
for _, k := range defaultKeys {
a.registerKeySequence(keyseq.KeyList{keyseq.NewKeyFromKey(k)})
}
} | go | {
"resource": ""
} |
q12293 | RegisterKeySequence | train | func (a ActionFunc) RegisterKeySequence(name string, k keyseq.KeyList) {
nameToActions["peco."+name] = a
a.registerKeySequence(k)
} | go | {
"resource": ""
} |
q12294 | doAcceptChar | train | func doAcceptChar(ctx context.Context, state *Peco, e termbox.Event) {
if e.Key == termbox.KeySpace {
e.Ch = ' '
}
ch := e.Ch
if ch <= 0 {
return
}
if state.SingleKeyJumpMode() {
doSingleKeyJump(ctx, state, e)
return
}
q := state.Query()
c := state.Caret()
q.InsertAt(ch, c.Pos())
c.Move(1)
h :=... | go | {
"resource": ""
} |
q12295 | IsEndMark | train | func IsEndMark(err error) bool {
if em, ok := errors.Cause(err).(EndMarker); ok {
return em.EndMark()
}
return false
} | go | {
"resource": ""
} |
q12296 | Send | train | func (oc ChanOutput) Send(v interface{}) (err error) {
if oc == nil {
return errors.New("nil channel")
}
// We allow ourselves a 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
} | go | {
"resource": ""
} |
q12297 | SendEndMark | train | func (oc ChanOutput) SendEndMark(s string) error {
return errors.Wrap(oc.Send(errors.Wrap(EndMark{}, s)), "failed to send end mark")
} | go | {
"resource": ""
} |
q12298 | SetSource | train | func (p *Pipeline) SetSource(s Source) {
p.mutex.Lock()
defer p.mutex.Unlock()
p.src = s
} | go | {
"resource": ""
} |
q12299 | Add | train | func (p *Pipeline) Add(n Acceptor) {
p.mutex.Lock()
defer p.mutex.Unlock()
p.nodes = append(p.nodes, n)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.