id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
152,100 | Robpol86/logrus-custom-formatter | formatter.go | Format | func (f *CustomFormatter) Format(entry *logrus.Entry) ([]byte, error) {
// Call handlers.
values := make([]interface{}, len(f.Handlers))
for i, handler := range f.Handlers {
value, err := handler(entry, f)
if err != nil {
return nil, err
}
values[i] = value
}
// Parse template and return.
parsed := f.Sprintf(values...)
return bytes.NewBufferString(parsed).Bytes(), nil
} | go | func (f *CustomFormatter) Format(entry *logrus.Entry) ([]byte, error) {
// Call handlers.
values := make([]interface{}, len(f.Handlers))
for i, handler := range f.Handlers {
value, err := handler(entry, f)
if err != nil {
return nil, err
}
values[i] = value
}
// Parse template and return.
parsed := f.Sprintf(values...)
return bytes.NewBufferString(parsed).Bytes(), nil
} | [
"func",
"(",
"f",
"*",
"CustomFormatter",
")",
"Format",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Call handlers.",
"values",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"... | // Format is called by logrus and returns the formatted string. | [
"Format",
"is",
"called",
"by",
"logrus",
"and",
"returns",
"the",
"formatted",
"string",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/formatter.go#L62-L76 |
152,101 | Robpol86/logrus-custom-formatter | handlers.go | Contains | func (a Attributes) Contains(attr string) bool {
_, ok := a[attr]
return ok
} | go | func (a Attributes) Contains(attr string) bool {
_, ok := a[attr]
return ok
} | [
"func",
"(",
"a",
"Attributes",
")",
"Contains",
"(",
"attr",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"a",
"[",
"attr",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // Contains returns true if attr is present. | [
"Contains",
"returns",
"true",
"if",
"attr",
"is",
"present",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/handlers.go#L33-L36 |
152,102 | Robpol86/logrus-custom-formatter | handlers.go | HandlerAscTime | func HandlerAscTime(entry *logrus.Entry, formatter *CustomFormatter) (interface{}, error) {
return entry.Time.Format(formatter.TimestampFormat), nil
} | go | func HandlerAscTime(entry *logrus.Entry, formatter *CustomFormatter) (interface{}, error) {
return entry.Time.Format(formatter.TimestampFormat), nil
} | [
"func",
"HandlerAscTime",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
",",
"formatter",
"*",
"CustomFormatter",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"entry",
".",
"Time",
".",
"Format",
"(",
"formatter",
".",
"TimestampFormat",... | // HandlerAscTime returns the formatted timestamp of the entry. | [
"HandlerAscTime",
"returns",
"the",
"formatted",
"timestamp",
"of",
"the",
"entry",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/handlers.go#L39-L41 |
152,103 | Robpol86/logrus-custom-formatter | handlers.go | HandlerName | func HandlerName(entry *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
if value, ok := entry.Data["name"]; ok {
return value.(string), nil
}
return "", nil
} | go | func HandlerName(entry *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
if value, ok := entry.Data["name"]; ok {
return value.(string), nil
}
return "", nil
} | [
"func",
"HandlerName",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
",",
"_",
"*",
"CustomFormatter",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"value",
",",
"ok",
":=",
"entry",
".",
"Data",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{... | // HandlerName returns the name field value set by the user in entry.Data. | [
"HandlerName",
"returns",
"the",
"name",
"field",
"value",
"set",
"by",
"the",
"user",
"in",
"entry",
".",
"Data",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/handlers.go#L84-L89 |
152,104 | Robpol86/logrus-custom-formatter | handlers.go | HandlerMessage | func HandlerMessage(entry *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
return entry.Message, nil
} | go | func HandlerMessage(entry *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
return entry.Message, nil
} | [
"func",
"HandlerMessage",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
",",
"_",
"*",
"CustomFormatter",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"entry",
".",
"Message",
",",
"nil",
"\n",
"}"
] | // HandlerMessage returns the unformatted log message in the entry. | [
"HandlerMessage",
"returns",
"the",
"unformatted",
"log",
"message",
"in",
"the",
"entry",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/handlers.go#L92-L94 |
152,105 | Robpol86/logrus-custom-formatter | handlers.go | HandlerProcess | func HandlerProcess(_ *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
return os.Getpid(), nil
} | go | func HandlerProcess(_ *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
return os.Getpid(), nil
} | [
"func",
"HandlerProcess",
"(",
"_",
"*",
"logrus",
".",
"Entry",
",",
"_",
"*",
"CustomFormatter",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"os",
".",
"Getpid",
"(",
")",
",",
"nil",
"\n",
"}"
] | // HandlerProcess returns the current process' PID. | [
"HandlerProcess",
"returns",
"the",
"current",
"process",
"PID",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/handlers.go#L97-L99 |
152,106 | Robpol86/logrus-custom-formatter | handlers.go | HandlerRelativeCreated | func HandlerRelativeCreated(_ *logrus.Entry, formatter *CustomFormatter) (interface{}, error) {
return int(time.Since(formatter.startTime) / time.Second), nil
} | go | func HandlerRelativeCreated(_ *logrus.Entry, formatter *CustomFormatter) (interface{}, error) {
return int(time.Since(formatter.startTime) / time.Second), nil
} | [
"func",
"HandlerRelativeCreated",
"(",
"_",
"*",
"logrus",
".",
"Entry",
",",
"formatter",
"*",
"CustomFormatter",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"int",
"(",
"time",
".",
"Since",
"(",
"formatter",
".",
"startTime",
")... | // HandlerRelativeCreated returns the number of seconds since program start time. | [
"HandlerRelativeCreated",
"returns",
"the",
"number",
"of",
"seconds",
"since",
"program",
"start",
"time",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/handlers.go#L102-L104 |
152,107 | Robpol86/logrus-custom-formatter | colors_windows.go | windowsNativeANSI | func windowsNativeANSI(stderr bool, setMode bool, sc sysCaller) (enabled bool, err error) {
// Check if ANSI is supported by means of ANSICON or ConEmu first.
isAnsicon := (os.Getenv("ANSICON") != "" && os.Getenv("ANSICON_VER") != "")
isConEmu := os.Getenv("ConEmuANSI") == "ON"
if isAnsicon || isConEmu {
return true, nil
}
if sc == nil {
if stderr {
sc = &sysCall{nStdHandle: syscall.STD_ERROR_HANDLE}
} else {
sc = &sysCall{nStdHandle: syscall.STD_OUTPUT_HANDLE}
}
}
// Get win32 handle.
if err = sc.getStdHandle(); err != nil {
return
}
// Get console mode.
var dwMode uint32
if err = sc.getConsoleMode(&dwMode); err != nil {
return
}
enabled = dwMode&EnableVirtualTerminalProcessing != 0
if enabled || !setMode {
return
}
// Try to enable the feature.
dwMode |= EnableVirtualTerminalProcessing
if r1, err := sc.setConsoleMode(uintptr(dwMode)); r1 == 0 {
return false, err
}
return true, nil
} | go | func windowsNativeANSI(stderr bool, setMode bool, sc sysCaller) (enabled bool, err error) {
// Check if ANSI is supported by means of ANSICON or ConEmu first.
isAnsicon := (os.Getenv("ANSICON") != "" && os.Getenv("ANSICON_VER") != "")
isConEmu := os.Getenv("ConEmuANSI") == "ON"
if isAnsicon || isConEmu {
return true, nil
}
if sc == nil {
if stderr {
sc = &sysCall{nStdHandle: syscall.STD_ERROR_HANDLE}
} else {
sc = &sysCall{nStdHandle: syscall.STD_OUTPUT_HANDLE}
}
}
// Get win32 handle.
if err = sc.getStdHandle(); err != nil {
return
}
// Get console mode.
var dwMode uint32
if err = sc.getConsoleMode(&dwMode); err != nil {
return
}
enabled = dwMode&EnableVirtualTerminalProcessing != 0
if enabled || !setMode {
return
}
// Try to enable the feature.
dwMode |= EnableVirtualTerminalProcessing
if r1, err := sc.setConsoleMode(uintptr(dwMode)); r1 == 0 {
return false, err
}
return true, nil
} | [
"func",
"windowsNativeANSI",
"(",
"stderr",
"bool",
",",
"setMode",
"bool",
",",
"sc",
"sysCaller",
")",
"(",
"enabled",
"bool",
",",
"err",
"error",
")",
"{",
"// Check if ANSI is supported by means of ANSICON or ConEmu first.",
"isAnsicon",
":=",
"(",
"os",
".",
... | // Does this console window have ENABLE_VIRTUAL_TERMINAL_PROCESSING enabled? Optionally try to enable if not. | [
"Does",
"this",
"console",
"window",
"have",
"ENABLE_VIRTUAL_TERMINAL_PROCESSING",
"enabled?",
"Optionally",
"try",
"to",
"enable",
"if",
"not",
"."
] | ba99911cd0e4ade6bf41bf080e923bde0ed46b98 | https://github.com/Robpol86/logrus-custom-formatter/blob/ba99911cd0e4ade6bf41bf080e923bde0ed46b98/colors_windows.go#L38-L75 |
152,108 | sbunce/bson | bson.go | JSON | func (this BSON) JSON() (string, error) {
m, err := this.Map()
if err != nil {
return "", err
}
j, err := json.Marshal(m)
if err != nil {
return "", err
}
return string(j), nil
} | go | func (this BSON) JSON() (string, error) {
m, err := this.Map()
if err != nil {
return "", err
}
j, err := json.Marshal(m)
if err != nil {
return "", err
}
return string(j), nil
} | [
"func",
"(",
"this",
"BSON",
")",
"JSON",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"m",
",",
"err",
":=",
"this",
".",
"Map",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"j",
","... | // JSON transcodes the BSON document to JSON. | [
"JSON",
"transcodes",
"the",
"BSON",
"document",
"to",
"JSON",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L52-L62 |
152,109 | sbunce/bson | bson.go | Encode | func (this Map) Encode() (BSON, error) {
b, err := encodeMap("", this)
if err != nil {
return nil, err
}
return b, nil
} | go | func (this Map) Encode() (BSON, error) {
b, err := encodeMap("", this)
if err != nil {
return nil, err
}
return b, nil
} | [
"func",
"(",
"this",
"Map",
")",
"Encode",
"(",
")",
"(",
"BSON",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"encodeMap",
"(",
"\"",
"\"",
",",
"this",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n"... | // Encode Map to BSON. | [
"Encode",
"Map",
"to",
"BSON",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L87-L93 |
152,110 | sbunce/bson | bson.go | MustEncode | func (this Map) MustEncode() BSON {
b, err := encodeMap("", this)
if err != nil {
panic(err)
}
return b
} | go | func (this Map) MustEncode() BSON {
b, err := encodeMap("", this)
if err != nil {
panic(err)
}
return b
} | [
"func",
"(",
"this",
"Map",
")",
"MustEncode",
"(",
")",
"BSON",
"{",
"b",
",",
"err",
":=",
"encodeMap",
"(",
"\"",
"\"",
",",
"this",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"b",
"\n",
... | // MustEncode panics if Map cannot be encoded to BSON. | [
"MustEncode",
"panics",
"if",
"Map",
"cannot",
"be",
"encoded",
"to",
"BSON",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L96-L102 |
152,111 | sbunce/bson | bson.go | print | func print(v interface{}) string {
switch vt := v.(type) {
case Map:
return vt.String()
case Slice:
return vt.String()
case BSON:
return fmt.Sprintf("BSON(%v)", vt)
case Float:
return fmt.Sprintf("Float(%v)", vt)
case String:
return fmt.Sprintf("String(%v)", vt)
case Array:
wr := bytes.NewBuffer(nil)
fmt.Fprint(wr, "Array([")
for i, vtv := range vt {
fmt.Fprint(wr, print(vtv))
if i != len(vt)-1 {
fmt.Fprint(wr, " ")
}
}
fmt.Fprintf(wr, "])")
return wr.String()
case Binary:
return fmt.Sprintf("Binary(%v)", vt)
case Undefined:
return "Undefined()"
case ObjectId:
return fmt.Sprintf("ObjectId(%v)", vt)
case Bool:
return fmt.Sprintf("Bool(%v)", vt)
case UTCDateTime:
return fmt.Sprintf("UTCDateTime(%v)", time.Unix(0, int64(vt)*1000*1000))
case Null:
return "Null()"
case Regexp:
return fmt.Sprintf("Regexp(Pattern(%v) Options(%v))", vt.Pattern, vt.Options)
case DBPointer:
return fmt.Sprintf("DBPointer(Name(%v) ObjectId(%v))", vt.Name, vt.ObjectId)
case Javascript:
return fmt.Sprintf("Javascript(%v)", vt)
case Symbol:
return fmt.Sprintf("Symbol(%v)", vt)
case JavascriptScope:
return fmt.Sprintf("JavascriptScope(Javascript(%v) Scope(%v))", vt.Javascript, vt.Scope)
case Int32:
return fmt.Sprintf("Int32(%v)", vt)
case Timestamp:
return fmt.Sprintf("Timestamp(%v)", vt)
case Int64:
return fmt.Sprintf("Int64(%v)", vt)
case MinKey:
return "MinKey()"
case MaxKey:
return "MaxKey()"
}
return fmt.Sprint(v)
} | go | func print(v interface{}) string {
switch vt := v.(type) {
case Map:
return vt.String()
case Slice:
return vt.String()
case BSON:
return fmt.Sprintf("BSON(%v)", vt)
case Float:
return fmt.Sprintf("Float(%v)", vt)
case String:
return fmt.Sprintf("String(%v)", vt)
case Array:
wr := bytes.NewBuffer(nil)
fmt.Fprint(wr, "Array([")
for i, vtv := range vt {
fmt.Fprint(wr, print(vtv))
if i != len(vt)-1 {
fmt.Fprint(wr, " ")
}
}
fmt.Fprintf(wr, "])")
return wr.String()
case Binary:
return fmt.Sprintf("Binary(%v)", vt)
case Undefined:
return "Undefined()"
case ObjectId:
return fmt.Sprintf("ObjectId(%v)", vt)
case Bool:
return fmt.Sprintf("Bool(%v)", vt)
case UTCDateTime:
return fmt.Sprintf("UTCDateTime(%v)", time.Unix(0, int64(vt)*1000*1000))
case Null:
return "Null()"
case Regexp:
return fmt.Sprintf("Regexp(Pattern(%v) Options(%v))", vt.Pattern, vt.Options)
case DBPointer:
return fmt.Sprintf("DBPointer(Name(%v) ObjectId(%v))", vt.Name, vt.ObjectId)
case Javascript:
return fmt.Sprintf("Javascript(%v)", vt)
case Symbol:
return fmt.Sprintf("Symbol(%v)", vt)
case JavascriptScope:
return fmt.Sprintf("JavascriptScope(Javascript(%v) Scope(%v))", vt.Javascript, vt.Scope)
case Int32:
return fmt.Sprintf("Int32(%v)", vt)
case Timestamp:
return fmt.Sprintf("Timestamp(%v)", vt)
case Int64:
return fmt.Sprintf("Int64(%v)", vt)
case MinKey:
return "MinKey()"
case MaxKey:
return "MaxKey()"
}
return fmt.Sprint(v)
} | [
"func",
"print",
"(",
"v",
"interface",
"{",
"}",
")",
"string",
"{",
"switch",
"vt",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"Map",
":",
"return",
"vt",
".",
"String",
"(",
")",
"\n",
"case",
"Slice",
":",
"return",
"vt",
".",
"String",
... | // print pretty-prints BSON value. | [
"print",
"pretty",
"-",
"prints",
"BSON",
"value",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L105-L162 |
152,112 | sbunce/bson | bson.go | String | func (this Map) String() string {
wr := bytes.NewBuffer(nil)
fmt.Fprint(wr, "Map[")
for k, v := range this {
fmt.Fprintf(wr, "%v: %v", k, print(v))
}
fmt.Fprintf(wr, "]")
return wr.String()
} | go | func (this Map) String() string {
wr := bytes.NewBuffer(nil)
fmt.Fprint(wr, "Map[")
for k, v := range this {
fmt.Fprintf(wr, "%v: %v", k, print(v))
}
fmt.Fprintf(wr, "]")
return wr.String()
} | [
"func",
"(",
"this",
"Map",
")",
"String",
"(",
")",
"string",
"{",
"wr",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"fmt",
".",
"Fprint",
"(",
"wr",
",",
"\"",
"\"",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"this",
"{",
"... | // String pretty prints the Map with BSON types. | [
"String",
"pretty",
"prints",
"the",
"Map",
"with",
"BSON",
"types",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L165-L173 |
152,113 | sbunce/bson | bson.go | Encode | func (this Slice) Encode() (BSON, error) {
b, err := encodeSlice("", this)
if err != nil {
return nil, err
}
return b, nil
} | go | func (this Slice) Encode() (BSON, error) {
b, err := encodeSlice("", this)
if err != nil {
return nil, err
}
return b, nil
} | [
"func",
"(",
"this",
"Slice",
")",
"Encode",
"(",
")",
"(",
"BSON",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"encodeSlice",
"(",
"\"",
"\"",
",",
"this",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
... | // Encode Slice to BSON. | [
"Encode",
"Slice",
"to",
"BSON",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L176-L182 |
152,114 | sbunce/bson | bson.go | MustEncode | func (this Slice) MustEncode() BSON {
b, err := encodeSlice("", this)
if err != nil {
panic(err)
}
return b
} | go | func (this Slice) MustEncode() BSON {
b, err := encodeSlice("", this)
if err != nil {
panic(err)
}
return b
} | [
"func",
"(",
"this",
"Slice",
")",
"MustEncode",
"(",
")",
"BSON",
"{",
"b",
",",
"err",
":=",
"encodeSlice",
"(",
"\"",
"\"",
",",
"this",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"b",
"\n"... | // MustEncode panics if Slice cannot be encoded to BSON. | [
"MustEncode",
"panics",
"if",
"Slice",
"cannot",
"be",
"encoded",
"to",
"BSON",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L185-L191 |
152,115 | sbunce/bson | bson.go | String | func (this Slice) String() string {
wr := bytes.NewBuffer(nil)
fmt.Fprint(wr, "Slice[")
for i, v := range this {
fmt.Fprintf(wr, "%v: %v", v.Key, print(v.Val))
if i != len(this)-1 {
fmt.Fprint(wr, " ")
}
}
fmt.Fprintf(wr, "]")
return wr.String()
} | go | func (this Slice) String() string {
wr := bytes.NewBuffer(nil)
fmt.Fprint(wr, "Slice[")
for i, v := range this {
fmt.Fprintf(wr, "%v: %v", v.Key, print(v.Val))
if i != len(this)-1 {
fmt.Fprint(wr, " ")
}
}
fmt.Fprintf(wr, "]")
return wr.String()
} | [
"func",
"(",
"this",
"Slice",
")",
"String",
"(",
")",
"string",
"{",
"wr",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"fmt",
".",
"Fprint",
"(",
"wr",
",",
"\"",
"\"",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"this",
"{",
... | // String pretty prints the Slice with BSON types. | [
"String",
"pretty",
"prints",
"the",
"Slice",
"with",
"BSON",
"types",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/bson.go#L194-L205 |
152,116 | davecheney/xattr | xattr_linux.go | stripUserPrefix | func stripUserPrefix(s []string) []string {
for i, a := range s {
if strings.HasPrefix(a, userPrefix) {
s[i] = a[5:]
}
}
return s
} | go | func stripUserPrefix(s []string) []string {
for i, a := range s {
if strings.HasPrefix(a, userPrefix) {
s[i] = a[5:]
}
}
return s
} | [
"func",
"stripUserPrefix",
"(",
"s",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"for",
"i",
",",
"a",
":=",
"range",
"s",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"a",
",",
"userPrefix",
")",
"{",
"s",
"[",
"i",
"]",
"=",
"a",
"[",
... | // Strip off "user." prefixes from attribute names. | [
"Strip",
"off",
"user",
".",
"prefixes",
"from",
"attribute",
"names",
"."
] | dc6dbbe49f0b0bfcc98dedef66662d93462a720c | https://github.com/davecheney/xattr/blob/dc6dbbe49f0b0bfcc98dedef66662d93462a720c/xattr_linux.go#L68-L75 |
152,117 | sbl/ner | ner.go | Tokenize | func Tokenize(text string) []string {
cs := C.CString(text)
defer C.free(unsafe.Pointer(cs))
ctokens := C.mitie_tokenize(cs)
defer C.mitie_free(unsafe.Pointer(ctokens))
i := 0
// a hack since mitie arrays are NULL terminated.
p := (*[1 << 30]*C.char)(unsafe.Pointer(ctokens))
tokens := make([]string, 0, 20)
for p[i] != nil {
tokens = append(tokens, C.GoString(p[i]))
i++
}
return tokens
} | go | func Tokenize(text string) []string {
cs := C.CString(text)
defer C.free(unsafe.Pointer(cs))
ctokens := C.mitie_tokenize(cs)
defer C.mitie_free(unsafe.Pointer(ctokens))
i := 0
// a hack since mitie arrays are NULL terminated.
p := (*[1 << 30]*C.char)(unsafe.Pointer(ctokens))
tokens := make([]string, 0, 20)
for p[i] != nil {
tokens = append(tokens, C.GoString(p[i]))
i++
}
return tokens
} | [
"func",
"Tokenize",
"(",
"text",
"string",
")",
"[",
"]",
"string",
"{",
"cs",
":=",
"C",
".",
"CString",
"(",
"text",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cs",
")",
")",
"\n",
"ctokens",
":=",
"C",
".",
"m... | // Tokenize returns a slice that contains a tokenized copy of the input text. | [
"Tokenize",
"returns",
"a",
"slice",
"that",
"contains",
"a",
"tokenized",
"copy",
"of",
"the",
"input",
"text",
"."
] | 036eccba91a21b3a23d2f112c49f992a2fb8ac44 | https://github.com/sbl/ner/blob/036eccba91a21b3a23d2f112c49f992a2fb8ac44/ner.go#L42-L56 |
152,118 | sbl/ner | ner.go | NewExtractor | func NewExtractor(path string) (*Extractor, error) {
model := C.CString(path)
defer C.free(unsafe.Pointer(model))
ner := C.mitie_load_named_entity_extractor(model)
if ner == nil {
return nil, ErrCantOpen
}
return &Extractor{
ner: ner,
}, nil
} | go | func NewExtractor(path string) (*Extractor, error) {
model := C.CString(path)
defer C.free(unsafe.Pointer(model))
ner := C.mitie_load_named_entity_extractor(model)
if ner == nil {
return nil, ErrCantOpen
}
return &Extractor{
ner: ner,
}, nil
} | [
"func",
"NewExtractor",
"(",
"path",
"string",
")",
"(",
"*",
"Extractor",
",",
"error",
")",
"{",
"model",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"model",
")",
")",
"\n",
... | // NewExtractor returns an Extractor given the path to a language model. | [
"NewExtractor",
"returns",
"an",
"Extractor",
"given",
"the",
"path",
"to",
"a",
"language",
"model",
"."
] | 036eccba91a21b3a23d2f112c49f992a2fb8ac44 | https://github.com/sbl/ner/blob/036eccba91a21b3a23d2f112c49f992a2fb8ac44/ner.go#L79-L90 |
152,119 | sbl/ner | ner.go | Extract | func (ext *Extractor) Extract(tokens []string) ([]Entity, error) {
ctokens := C.ner_arr_make(C.int(len(tokens)) + 1) // NULL termination
defer C.ner_arr_free(ctokens, C.int(len(tokens))+1)
for i, t := range tokens {
cs := C.CString(t) // released by ner_arr_free
C.ner_arr_set(ctokens, cs, C.int(i))
}
dets := C.mitie_extract_entities(ext.ner, ctokens)
defer C.mitie_free(unsafe.Pointer(dets))
if dets == nil {
return nil, ErrMemory
}
n := int(C.mitie_ner_get_num_detections(dets))
entities := make([]Entity, n, n)
for i := 0; i < n; i++ {
pos := int(C.mitie_ner_get_detection_position(dets, C.ulong(i)))
len := int(C.mitie_ner_get_detection_length(dets, C.ulong(i)))
entities[i] = Entity{
Tag: int(C.mitie_ner_get_detection_tag(dets, C.ulong(i))),
Score: float64(C.mitie_ner_get_detection_score(dets, C.ulong(i))),
Name: strings.Join(tokens[pos:pos+len], " "),
Range: Range{pos, pos + len},
}
}
return entities, nil
} | go | func (ext *Extractor) Extract(tokens []string) ([]Entity, error) {
ctokens := C.ner_arr_make(C.int(len(tokens)) + 1) // NULL termination
defer C.ner_arr_free(ctokens, C.int(len(tokens))+1)
for i, t := range tokens {
cs := C.CString(t) // released by ner_arr_free
C.ner_arr_set(ctokens, cs, C.int(i))
}
dets := C.mitie_extract_entities(ext.ner, ctokens)
defer C.mitie_free(unsafe.Pointer(dets))
if dets == nil {
return nil, ErrMemory
}
n := int(C.mitie_ner_get_num_detections(dets))
entities := make([]Entity, n, n)
for i := 0; i < n; i++ {
pos := int(C.mitie_ner_get_detection_position(dets, C.ulong(i)))
len := int(C.mitie_ner_get_detection_length(dets, C.ulong(i)))
entities[i] = Entity{
Tag: int(C.mitie_ner_get_detection_tag(dets, C.ulong(i))),
Score: float64(C.mitie_ner_get_detection_score(dets, C.ulong(i))),
Name: strings.Join(tokens[pos:pos+len], " "),
Range: Range{pos, pos + len},
}
}
return entities, nil
} | [
"func",
"(",
"ext",
"*",
"Extractor",
")",
"Extract",
"(",
"tokens",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"Entity",
",",
"error",
")",
"{",
"ctokens",
":=",
"C",
".",
"ner_arr_make",
"(",
"C",
".",
"int",
"(",
"len",
"(",
"tokens",
")",
")",
... | // Extract runs the extractor and returns a slice of Entities found in the
// given tokens. | [
"Extract",
"runs",
"the",
"extractor",
"and",
"returns",
"a",
"slice",
"of",
"Entities",
"found",
"in",
"the",
"given",
"tokens",
"."
] | 036eccba91a21b3a23d2f112c49f992a2fb8ac44 | https://github.com/sbl/ner/blob/036eccba91a21b3a23d2f112c49f992a2fb8ac44/ner.go#L114-L143 |
152,120 | sbunce/bson | misc.go | catpath | func catpath(path, name string) string {
if path == "" {
return name
}
return strings.Join([]string{path, name}, ".")
} | go | func catpath(path, name string) string {
if path == "" {
return name
}
return strings.Join([]string{path, name}, ".")
} | [
"func",
"catpath",
"(",
"path",
",",
"name",
"string",
")",
"string",
"{",
"if",
"path",
"==",
"\"",
"\"",
"{",
"return",
"name",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"[",
"]",
"string",
"{",
"path",
",",
"name",
"}",
",",
"\""... | // catpath concatenates a name on to a document path. This is used to keep track
// of where we are in a document for the purpose of generating descriptive
// errors. | [
"catpath",
"concatenates",
"a",
"name",
"on",
"to",
"a",
"document",
"path",
".",
"This",
"is",
"used",
"to",
"keep",
"track",
"of",
"where",
"we",
"are",
"in",
"a",
"document",
"for",
"the",
"purpose",
"of",
"generating",
"descriptive",
"errors",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/misc.go#L24-L29 |
152,121 | davecheney/xattr | xattr_darwin.go | Getxattr | func Getxattr(path, name string) ([]byte, error) {
// find size.
size, err := getxattr(path, name, nil, 0, 0, 0)
if err != nil {
return nil, &XAttrError{"getxattr", path, name, err}
}
buf := make([]byte, size)
// Read into buffer of that size.
read, err := getxattr(path, name, &buf[0], size, 0, 0)
if err != nil {
return nil, &XAttrError{"getxattr", path, name, err}
}
return buf[:read], nil
} | go | func Getxattr(path, name string) ([]byte, error) {
// find size.
size, err := getxattr(path, name, nil, 0, 0, 0)
if err != nil {
return nil, &XAttrError{"getxattr", path, name, err}
}
buf := make([]byte, size)
// Read into buffer of that size.
read, err := getxattr(path, name, &buf[0], size, 0, 0)
if err != nil {
return nil, &XAttrError{"getxattr", path, name, err}
}
return buf[:read], nil
} | [
"func",
"Getxattr",
"(",
"path",
",",
"name",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// find size.",
"size",
",",
"err",
":=",
"getxattr",
"(",
"path",
",",
"name",
",",
"nil",
",",
"0",
",",
"0",
",",
"0",
")",
"\n",
"i... | // Retrieve extended attribute data associated with path. | [
"Retrieve",
"extended",
"attribute",
"data",
"associated",
"with",
"path",
"."
] | dc6dbbe49f0b0bfcc98dedef66662d93462a720c | https://github.com/davecheney/xattr/blob/dc6dbbe49f0b0bfcc98dedef66662d93462a720c/xattr_darwin.go#L4-L17 |
152,122 | davecheney/xattr | xattr_darwin.go | Listxattr | func Listxattr(path string) ([]string, error) {
// find size.
size, err := listxattr(path, nil, 0, 0)
if err != nil {
return nil, &XAttrError{"listxattr", path, "", err}
}
buf := make([]byte, size)
// Read into buffer of that size.
read, err := listxattr(path, &buf[0], size, 0)
if err != nil {
return nil, &XAttrError{"listxattr", path, "", err}
}
return nullTermToStrings(buf[:read]), nil
} | go | func Listxattr(path string) ([]string, error) {
// find size.
size, err := listxattr(path, nil, 0, 0)
if err != nil {
return nil, &XAttrError{"listxattr", path, "", err}
}
buf := make([]byte, size)
// Read into buffer of that size.
read, err := listxattr(path, &buf[0], size, 0)
if err != nil {
return nil, &XAttrError{"listxattr", path, "", err}
}
return nullTermToStrings(buf[:read]), nil
} | [
"func",
"Listxattr",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"// find size.",
"size",
",",
"err",
":=",
"listxattr",
"(",
"path",
",",
"nil",
",",
"0",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"retu... | // Retrieves a list of names of extended attributes associated with the
// given path in the file system. | [
"Retrieves",
"a",
"list",
"of",
"names",
"of",
"extended",
"attributes",
"associated",
"with",
"the",
"given",
"path",
"in",
"the",
"file",
"system",
"."
] | dc6dbbe49f0b0bfcc98dedef66662d93462a720c | https://github.com/davecheney/xattr/blob/dc6dbbe49f0b0bfcc98dedef66662d93462a720c/xattr_darwin.go#L21-L34 |
152,123 | sbunce/bson | encode.go | encodeMap | func encodeMap(path string, m Map) ([]byte, error) {
buf := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(buf, binary.LittleEndian, uint32(0)); err != nil {
return nil, err
}
// Encode.
for name, v := range m {
if err := encodeVal(buf, catpath(path, name), name, v); err != nil {
return nil, err
}
}
// End of BSON null byte.
if err := buf.WriteByte(0x00); err != nil {
return nil, err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(buf.Bytes(), uint32(buf.Len()))
return buf.Bytes(), nil
} | go | func encodeMap(path string, m Map) ([]byte, error) {
buf := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(buf, binary.LittleEndian, uint32(0)); err != nil {
return nil, err
}
// Encode.
for name, v := range m {
if err := encodeVal(buf, catpath(path, name), name, v); err != nil {
return nil, err
}
}
// End of BSON null byte.
if err := buf.WriteByte(0x00); err != nil {
return nil, err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(buf.Bytes(), uint32(buf.Len()))
return buf.Bytes(), nil
} | [
"func",
"encodeMap",
"(",
"path",
"string",
",",
"m",
"Map",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
")",
")",
"\n\n",
"// This will be replaced by the ... | // encodeMap encodes a BSON document. The path keeps track of where in the Map
// we are for error reporting purposes. | [
"encodeMap",
"encodes",
"a",
"BSON",
"document",
".",
"The",
"path",
"keeps",
"track",
"of",
"where",
"in",
"the",
"Map",
"we",
"are",
"for",
"error",
"reporting",
"purposes",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L19-L43 |
152,124 | sbunce/bson | encode.go | encodeSlice | func encodeSlice(path string, s Slice) ([]byte, error) {
buf := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(buf, binary.LittleEndian, uint32(0)); err != nil {
return nil, err
}
// Encode.
for _, pair := range s {
if err := encodeVal(buf, catpath(path, pair.Key), pair.Key, pair.Val);
err != nil {
return nil, err
}
}
// End of BSON null byte.
if err := buf.WriteByte(0x00); err != nil {
return nil, err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(buf.Bytes(), uint32(buf.Len()))
return buf.Bytes(), nil
} | go | func encodeSlice(path string, s Slice) ([]byte, error) {
buf := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(buf, binary.LittleEndian, uint32(0)); err != nil {
return nil, err
}
// Encode.
for _, pair := range s {
if err := encodeVal(buf, catpath(path, pair.Key), pair.Key, pair.Val);
err != nil {
return nil, err
}
}
// End of BSON null byte.
if err := buf.WriteByte(0x00); err != nil {
return nil, err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(buf.Bytes(), uint32(buf.Len()))
return buf.Bytes(), nil
} | [
"func",
"encodeSlice",
"(",
"path",
"string",
",",
"s",
"Slice",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
")",
")",
"\n\n",
"// This will be replaced by ... | // encodeSlice encodes a BSON document. The path keeps track of where in the
// Slice we are for error reporting purposes. | [
"encodeSlice",
"encodes",
"a",
"BSON",
"document",
".",
"The",
"path",
"keeps",
"track",
"of",
"where",
"in",
"the",
"Slice",
"we",
"are",
"for",
"error",
"reporting",
"purposes",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L47-L73 |
152,125 | sbunce/bson | encode.go | MustEncodeStruct | func MustEncodeStruct(src interface{}) BSON {
b, err := encodeStruct("", src)
if err != nil {
panic(err)
}
return b
} | go | func MustEncodeStruct(src interface{}) BSON {
b, err := encodeStruct("", src)
if err != nil {
panic(err)
}
return b
} | [
"func",
"MustEncodeStruct",
"(",
"src",
"interface",
"{",
"}",
")",
"BSON",
"{",
"b",
",",
"err",
":=",
"encodeStruct",
"(",
"\"",
"\"",
",",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"b... | // MustEncodeStruct encodes a struct to BSON. Panics upon error. | [
"MustEncodeStruct",
"encodes",
"a",
"struct",
"to",
"BSON",
".",
"Panics",
"upon",
"error",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L81-L87 |
152,126 | sbunce/bson | encode.go | encodeStruct | func encodeStruct(path string, src interface{}) ([]byte, error) {
rv := indirect(reflect.ValueOf(src))
if rv.Kind() != reflect.Struct {
return nil, fmt.Errorf("%v, expected struct.", path)
}
buf := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(buf, binary.LittleEndian, uint32(0)); err != nil {
return nil, err
}
// Encode.
for i := 0; i < rv.NumField(); i++ {
sv := rv.Type().Field(i)
if sv.PkgPath != "" {
// Unexported field.
continue
}
name := sv.Name
fv := rv.Field(i)
fv = indirect(rv.Field(i))
if tag := sv.Tag.Get("bson"); tag != "" {
tok := strings.Split(tag, ",")
if tok[0] == "-" {
// Ignore field.
continue
}
if tok[0] != "" {
// Renamed field.
name = tok[0]
}
if len(tok) == 2 && tok[1] == "omitempty" && isEmptyValue(fv) {
// Empty field, omitempty true.
continue
}
}
if err := encodeVal(buf, catpath(path, name), name, fv.Interface());
err != nil {
return nil, err
}
}
// End of BSON null byte.
if err := buf.WriteByte(0x00); err != nil {
return nil, err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(buf.Bytes(), uint32(buf.Len()))
return buf.Bytes(), nil
} | go | func encodeStruct(path string, src interface{}) ([]byte, error) {
rv := indirect(reflect.ValueOf(src))
if rv.Kind() != reflect.Struct {
return nil, fmt.Errorf("%v, expected struct.", path)
}
buf := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(buf, binary.LittleEndian, uint32(0)); err != nil {
return nil, err
}
// Encode.
for i := 0; i < rv.NumField(); i++ {
sv := rv.Type().Field(i)
if sv.PkgPath != "" {
// Unexported field.
continue
}
name := sv.Name
fv := rv.Field(i)
fv = indirect(rv.Field(i))
if tag := sv.Tag.Get("bson"); tag != "" {
tok := strings.Split(tag, ",")
if tok[0] == "-" {
// Ignore field.
continue
}
if tok[0] != "" {
// Renamed field.
name = tok[0]
}
if len(tok) == 2 && tok[1] == "omitempty" && isEmptyValue(fv) {
// Empty field, omitempty true.
continue
}
}
if err := encodeVal(buf, catpath(path, name), name, fv.Interface());
err != nil {
return nil, err
}
}
// End of BSON null byte.
if err := buf.WriteByte(0x00); err != nil {
return nil, err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(buf.Bytes(), uint32(buf.Len()))
return buf.Bytes(), nil
} | [
"func",
"encodeStruct",
"(",
"path",
"string",
",",
"src",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"rv",
":=",
"indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"src",
")",
")",
"\n",
"if",
"rv",
".",
"Kind",
"("... | // encodeStruct encodes a BSON document. The path keeps track of where in the
// struct we are for error reporting purposes. | [
"encodeStruct",
"encodes",
"a",
"BSON",
"document",
".",
"The",
"path",
"keeps",
"track",
"of",
"where",
"in",
"the",
"struct",
"we",
"are",
"for",
"error",
"reporting",
"purposes",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L91-L144 |
152,127 | sbunce/bson | encode.go | encodeArray | func encodeArray(buf *bytes.Buffer, path, name string, val Array) error {
// Array is encoded as a document with incrementing numeric keys.
if len(val) == 0 {
return nil
}
// type
if err := buf.WriteByte(_ARRAY); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// Create array doc.
tmp := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(tmp, binary.LittleEndian, uint32(0)); err != nil {
return err
}
for i := 0; i < len(val); i++ {
name := strconv.Itoa(i)
var newpath string
if path == "" {
newpath = name
} else {
newpath = strings.Join([]string{path, name}, ".")
}
if err := encodeVal(tmp, newpath, name, val[i]); err != nil {
return err
}
}
// End of BSON null byte.
if err := tmp.WriteByte(0x00); err != nil {
return err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(tmp.Bytes(), uint32(tmp.Len()))
buf.Write(tmp.Bytes())
return nil
} | go | func encodeArray(buf *bytes.Buffer, path, name string, val Array) error {
// Array is encoded as a document with incrementing numeric keys.
if len(val) == 0 {
return nil
}
// type
if err := buf.WriteByte(_ARRAY); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// Create array doc.
tmp := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of the doc later.
if err := binary.Write(tmp, binary.LittleEndian, uint32(0)); err != nil {
return err
}
for i := 0; i < len(val); i++ {
name := strconv.Itoa(i)
var newpath string
if path == "" {
newpath = name
} else {
newpath = strings.Join([]string{path, name}, ".")
}
if err := encodeVal(tmp, newpath, name, val[i]); err != nil {
return err
}
}
// End of BSON null byte.
if err := tmp.WriteByte(0x00); err != nil {
return err
}
// Write size of document at start of BSON.
binary.LittleEndian.PutUint32(tmp.Bytes(), uint32(tmp.Len()))
buf.Write(tmp.Bytes())
return nil
} | [
"func",
"encodeArray",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"path",
",",
"name",
"string",
",",
"val",
"Array",
")",
"error",
"{",
"// Array is encoded as a document with incrementing numeric keys.",
"if",
"len",
"(",
"val",
")",
"==",
"0",
"{",
"retu... | // encodeArray encodes a BSON Array. | [
"encodeArray",
"encodes",
"a",
"BSON",
"Array",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L250-L296 |
152,128 | sbunce/bson | encode.go | encodeBinary | func encodeBinary(buf *bytes.Buffer, name string, val Binary) error {
// type
if err := buf.WriteByte(_BINARY_DATA); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if err := binary.Write(buf, binary.LittleEndian, uint32(len(val)));
err != nil {
return err
}
// Always use binary/generic subtype.
if err := buf.WriteByte(0x00); err != nil {
return err
}
if _, err := buf.Write(val); err != nil {
return err
}
return nil
} | go | func encodeBinary(buf *bytes.Buffer, name string, val Binary) error {
// type
if err := buf.WriteByte(_BINARY_DATA); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if err := binary.Write(buf, binary.LittleEndian, uint32(len(val)));
err != nil {
return err
}
// Always use binary/generic subtype.
if err := buf.WriteByte(0x00); err != nil {
return err
}
if _, err := buf.Write(val); err != nil {
return err
}
return nil
} | [
"func",
"encodeBinary",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Binary",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_BINARY_DATA",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
... | // encodeBinary encodes BSON Binary. | [
"encodeBinary",
"encodes",
"BSON",
"Binary",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L299-L326 |
152,129 | sbunce/bson | encode.go | encodeBool | func encodeBool(buf *bytes.Buffer, name string, val Bool) error {
// type
if err := buf.WriteByte(_BOOLEAN); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if val {
if err := buf.WriteByte(0x01); err != nil {
return err
}
} else {
if err := buf.WriteByte(0x00); err != nil {
return err
}
}
return nil
} | go | func encodeBool(buf *bytes.Buffer, name string, val Bool) error {
// type
if err := buf.WriteByte(_BOOLEAN); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if val {
if err := buf.WriteByte(0x01); err != nil {
return err
}
} else {
if err := buf.WriteByte(0x00); err != nil {
return err
}
}
return nil
} | [
"func",
"encodeBool",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Bool",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_BOOLEAN",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
... | // encodeBool encodes BSON Bool. | [
"encodeBool",
"encodes",
"BSON",
"Bool",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L329-L352 |
152,130 | sbunce/bson | encode.go | encodeDBPointer | func encodeDBPointer(buf *bytes.Buffer, path, name string,
val DBPointer) error {
if len(val.ObjectId) != 12 {
return fmt.Errorf("%v, DBPointer must be 12 bytes.", path)
}
// type
if err := buf.WriteByte(_DBPOINTER); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// Name
if err := writeString(buf, val.Name); err != nil {
return err
}
// ObjectId
if _, err := buf.Write(val.ObjectId); err != nil {
return err
}
return nil
} | go | func encodeDBPointer(buf *bytes.Buffer, path, name string,
val DBPointer) error {
if len(val.ObjectId) != 12 {
return fmt.Errorf("%v, DBPointer must be 12 bytes.", path)
}
// type
if err := buf.WriteByte(_DBPOINTER); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// Name
if err := writeString(buf, val.Name); err != nil {
return err
}
// ObjectId
if _, err := buf.Write(val.ObjectId); err != nil {
return err
}
return nil
} | [
"func",
"encodeDBPointer",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"path",
",",
"name",
"string",
",",
"val",
"DBPointer",
")",
"error",
"{",
"if",
"len",
"(",
"val",
".",
"ObjectId",
")",
"!=",
"12",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
... | // encodeDBPointer encodes BSON DBPointer. | [
"encodeDBPointer",
"encodes",
"BSON",
"DBPointer",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L355-L383 |
152,131 | sbunce/bson | encode.go | encodeEmbeddedDocument | func encodeEmbeddedDocument(buf *bytes.Buffer, path, name string,
val Doc) error {
// type
if err := buf.WriteByte(_EMBEDDED_DOCUMENT); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if a, ok := val.(Map); ok {
b, err := encodeMap(catpath(path, name), a)
if err != nil {
return err
}
if _, err := buf.Write(b); err != nil {
return err
}
} else if a, ok := val.(Slice); ok {
b, err := encodeSlice(catpath(path, name), a)
if err != nil {
return err
}
if _, err := buf.Write(b); err != nil {
return err
}
} else {
panic("Programmer mistake, failed to handle Doc type.")
}
return nil
} | go | func encodeEmbeddedDocument(buf *bytes.Buffer, path, name string,
val Doc) error {
// type
if err := buf.WriteByte(_EMBEDDED_DOCUMENT); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if a, ok := val.(Map); ok {
b, err := encodeMap(catpath(path, name), a)
if err != nil {
return err
}
if _, err := buf.Write(b); err != nil {
return err
}
} else if a, ok := val.(Slice); ok {
b, err := encodeSlice(catpath(path, name), a)
if err != nil {
return err
}
if _, err := buf.Write(b); err != nil {
return err
}
} else {
panic("Programmer mistake, failed to handle Doc type.")
}
return nil
} | [
"func",
"encodeEmbeddedDocument",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"path",
",",
"name",
"string",
",",
"val",
"Doc",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_EMBEDDED_DOCUMENT",
")",
";",
"err",
"!=",
... | // encodeEmbeddedDocument encodes embedded BSON document. | [
"encodeEmbeddedDocument",
"encodes",
"embedded",
"BSON",
"document",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L386-L421 |
152,132 | sbunce/bson | encode.go | encodeFloat | func encodeFloat(buf *bytes.Buffer, name string, val Float) error {
// type
if err := buf.WriteByte(_FLOATING_POINT); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
u := math.Float64bits(float64(val))
b := make([]byte, 8)
b[7] = byte(u >> 56)
b[6] = byte(u >> 48)
b[5] = byte(u >> 40)
b[4] = byte(u >> 32)
b[3] = byte(u >> 24)
b[2] = byte(u >> 16)
b[1] = byte(u >> 8)
b[0] = byte(u)
if _, err := buf.Write(b); err != nil {
return err
}
return nil
} | go | func encodeFloat(buf *bytes.Buffer, name string, val Float) error {
// type
if err := buf.WriteByte(_FLOATING_POINT); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
u := math.Float64bits(float64(val))
b := make([]byte, 8)
b[7] = byte(u >> 56)
b[6] = byte(u >> 48)
b[5] = byte(u >> 40)
b[4] = byte(u >> 32)
b[3] = byte(u >> 24)
b[2] = byte(u >> 16)
b[1] = byte(u >> 8)
b[0] = byte(u)
if _, err := buf.Write(b); err != nil {
return err
}
return nil
} | [
"func",
"encodeFloat",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Float",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_FLOATING_POINT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
... | // encodeFloat encodes BSON Float. | [
"encodeFloat",
"encodes",
"BSON",
"Float",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L424-L451 |
152,133 | sbunce/bson | encode.go | encodeInt32 | func encodeInt32(buf *bytes.Buffer, name string, val Int32) error {
// type
if err := buf.WriteByte(_32BIT_INTEGER); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return binary.Write(buf, binary.LittleEndian, val)
} | go | func encodeInt32(buf *bytes.Buffer, name string, val Int32) error {
// type
if err := buf.WriteByte(_32BIT_INTEGER); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return binary.Write(buf, binary.LittleEndian, val)
} | [
"func",
"encodeInt32",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Int32",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_32BIT_INTEGER",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
... | // encodeInt32 encodes BSON Int32. | [
"encodeInt32",
"encodes",
"BSON",
"Int32",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L454-L467 |
152,134 | sbunce/bson | encode.go | encodeInt64 | func encodeInt64(buf *bytes.Buffer, name string, val Int64) error {
// type
buf.WriteByte(_64BIT_INTEGER)
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
binary.Write(buf, binary.LittleEndian, val)
return nil
} | go | func encodeInt64(buf *bytes.Buffer, name string, val Int64) error {
// type
buf.WriteByte(_64BIT_INTEGER)
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
binary.Write(buf, binary.LittleEndian, val)
return nil
} | [
"func",
"encodeInt64",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Int64",
")",
"error",
"{",
"// type",
"buf",
".",
"WriteByte",
"(",
"_64BIT_INTEGER",
")",
"\n\n",
"// name",
"if",
"err",
":=",
"writeCstring",
"(",
"buf... | // encodeInt64 encodes BSON Int64. | [
"encodeInt64",
"encodes",
"BSON",
"Int64",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L470-L482 |
152,135 | sbunce/bson | encode.go | encodeJavascript | func encodeJavascript(buf *bytes.Buffer, name string, val Javascript) error {
// type
if err := buf.WriteByte(_JAVASCRIPT); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return writeString(buf, string(val))
} | go | func encodeJavascript(buf *bytes.Buffer, name string, val Javascript) error {
// type
if err := buf.WriteByte(_JAVASCRIPT); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return writeString(buf, string(val))
} | [
"func",
"encodeJavascript",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Javascript",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_JAVASCRIPT",
")",
";",
"err",
"!=",
"nil",
"{",
"retu... | // encodeJavascript encodes BSON Javascript. | [
"encodeJavascript",
"encodes",
"BSON",
"Javascript",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L485-L498 |
152,136 | sbunce/bson | encode.go | encodeJavascriptScope | func encodeJavascriptScope(buf *bytes.Buffer, path, name string,
val JavascriptScope) error {
// type
if err := buf.WriteByte(_JAVASCRIPT_SCOPE); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// Start code_w_s.
tmp := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of code_w_s.
if err := binary.Write(tmp, binary.LittleEndian, uint32(0)); err != nil {
return err
}
// Write Javascript.
if err := writeString(tmp, val.Javascript); err != nil {
return err
}
// Write scope.
b, err := encodeMap(catpath(path, name), val.Scope)
if err != nil {
return err
}
if _, err := tmp.Write(b); err != nil {
return err
}
// Write size of document at start of code_w_s.
binary.LittleEndian.PutUint32(tmp.Bytes(), uint32(tmp.Len()))
buf.Write(tmp.Bytes())
return nil
} | go | func encodeJavascriptScope(buf *bytes.Buffer, path, name string,
val JavascriptScope) error {
// type
if err := buf.WriteByte(_JAVASCRIPT_SCOPE); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// Start code_w_s.
tmp := bytes.NewBuffer(make([]byte, 0))
// This will be replaced by the size of code_w_s.
if err := binary.Write(tmp, binary.LittleEndian, uint32(0)); err != nil {
return err
}
// Write Javascript.
if err := writeString(tmp, val.Javascript); err != nil {
return err
}
// Write scope.
b, err := encodeMap(catpath(path, name), val.Scope)
if err != nil {
return err
}
if _, err := tmp.Write(b); err != nil {
return err
}
// Write size of document at start of code_w_s.
binary.LittleEndian.PutUint32(tmp.Bytes(), uint32(tmp.Len()))
buf.Write(tmp.Bytes())
return nil
} | [
"func",
"encodeJavascriptScope",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"path",
",",
"name",
"string",
",",
"val",
"JavascriptScope",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_JAVASCRIPT_SCOPE",
")",
";",
"err"... | // encodeJavascriptScope encodes BSON JavascriptScope. | [
"encodeJavascriptScope",
"encodes",
"BSON",
"JavascriptScope",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L501-L541 |
152,137 | sbunce/bson | encode.go | encodeMaxKey | func encodeMaxKey(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_MAX_KEY); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | go | func encodeMaxKey(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_MAX_KEY); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | [
"func",
"encodeMaxKey",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_MAX_KEY",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
... | // encodeMaxKey encodes BSON MaxKey. | [
"encodeMaxKey",
"encodes",
"BSON",
"MaxKey",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L544-L552 |
152,138 | sbunce/bson | encode.go | encodeMinKey | func encodeMinKey(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_MIN_KEY); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | go | func encodeMinKey(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_MIN_KEY); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | [
"func",
"encodeMinKey",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_MIN_KEY",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
... | // encodeMinKey encodes BSON MinKey. | [
"encodeMinKey",
"encodes",
"BSON",
"MinKey",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L555-L563 |
152,139 | sbunce/bson | encode.go | encodeNull | func encodeNull(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_NULL_VALUE); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | go | func encodeNull(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_NULL_VALUE); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | [
"func",
"encodeNull",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_NULL_VALUE",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",... | // encodeNull encodes BSON Null. | [
"encodeNull",
"encodes",
"BSON",
"Null",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L566-L574 |
152,140 | sbunce/bson | encode.go | encodeObjectId | func encodeObjectId(buf *bytes.Buffer, path, name string, val ObjectId) error {
if len(val) != 12 {
return fmt.Errorf("%v, ObjectId must be 12 bytes.", path)
}
// type
if err := buf.WriteByte(_OBJECT_ID); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if _, err := buf.Write(val); err != nil {
return err
}
return nil
} | go | func encodeObjectId(buf *bytes.Buffer, path, name string, val ObjectId) error {
if len(val) != 12 {
return fmt.Errorf("%v, ObjectId must be 12 bytes.", path)
}
// type
if err := buf.WriteByte(_OBJECT_ID); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
if _, err := buf.Write(val); err != nil {
return err
}
return nil
} | [
"func",
"encodeObjectId",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"path",
",",
"name",
"string",
",",
"val",
"ObjectId",
")",
"error",
"{",
"if",
"len",
"(",
"val",
")",
"!=",
"12",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
... | // encodeObjectId encodes BSON ObjectId. | [
"encodeObjectId",
"encodes",
"BSON",
"ObjectId",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L577-L598 |
152,141 | sbunce/bson | encode.go | encodeRegexp | func encodeRegexp(buf *bytes.Buffer, name string, val Regexp) error {
// type
if err := buf.WriteByte(_REGEXP); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// regex
if err := writeCstring(buf, val.Pattern); err != nil {
return err
}
// options
return writeCstring(buf, val.Options)
} | go | func encodeRegexp(buf *bytes.Buffer, name string, val Regexp) error {
// type
if err := buf.WriteByte(_REGEXP); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// regex
if err := writeCstring(buf, val.Pattern); err != nil {
return err
}
// options
return writeCstring(buf, val.Options)
} | [
"func",
"encodeRegexp",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Regexp",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_REGEXP",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err"... | // encodeRegexp encodes BSON Regexp. | [
"encodeRegexp",
"encodes",
"BSON",
"Regexp",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L601-L619 |
152,142 | sbunce/bson | encode.go | encodeString | func encodeString(buf *bytes.Buffer, name string, val String) error {
// type
if err := buf.WriteByte(_STRING); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return writeString(buf, string(val))
} | go | func encodeString(buf *bytes.Buffer, name string, val String) error {
// type
if err := buf.WriteByte(_STRING); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return writeString(buf, string(val))
} | [
"func",
"encodeString",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"String",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_STRING",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err"... | // encodeString encodes BSON String. | [
"encodeString",
"encodes",
"BSON",
"String",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L622-L635 |
152,143 | sbunce/bson | encode.go | encodeSymbol | func encodeSymbol(buf *bytes.Buffer, name string, val Symbol) error {
// type
if err := buf.WriteByte(_SYMBOL); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return writeString(buf, string(val))
} | go | func encodeSymbol(buf *bytes.Buffer, name string, val Symbol) error {
// type
if err := buf.WriteByte(_SYMBOL); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return writeString(buf, string(val))
} | [
"func",
"encodeSymbol",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Symbol",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_SYMBOL",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err"... | // encodeSymbol encodes BSON Symbol. | [
"encodeSymbol",
"encodes",
"BSON",
"Symbol",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L638-L651 |
152,144 | sbunce/bson | encode.go | encodeTimestamp | func encodeTimestamp(buf *bytes.Buffer, name string, val Timestamp) error {
// type
if err := buf.WriteByte(_TIMESTAMP); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return binary.Write(buf, binary.LittleEndian, uint64(val))
} | go | func encodeTimestamp(buf *bytes.Buffer, name string, val Timestamp) error {
// type
if err := buf.WriteByte(_TIMESTAMP); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return binary.Write(buf, binary.LittleEndian, uint64(val))
} | [
"func",
"encodeTimestamp",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"Timestamp",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_TIMESTAMP",
")",
";",
"err",
"!=",
"nil",
"{",
"return"... | // encodeTimestamp encodes BSON Timestamp. | [
"encodeTimestamp",
"encodes",
"BSON",
"Timestamp",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L654-L667 |
152,145 | sbunce/bson | encode.go | encodeUndefined | func encodeUndefined(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_UNDEFINED); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | go | func encodeUndefined(buf *bytes.Buffer, name string) error {
// type
if err := buf.WriteByte(_UNDEFINED); err != nil {
return err
}
// name
return writeCstring(buf, name)
} | [
"func",
"encodeUndefined",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_UNDEFINED",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n... | // encodeUndefined encodes BSON undefined. | [
"encodeUndefined",
"encodes",
"BSON",
"undefined",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L670-L678 |
152,146 | sbunce/bson | encode.go | encodeUTCDateTime | func encodeUTCDateTime(buf *bytes.Buffer, name string, val UTCDateTime) error {
// type
if err := buf.WriteByte(_UTC_DATETIME); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return binary.Write(buf, binary.LittleEndian, val)
} | go | func encodeUTCDateTime(buf *bytes.Buffer, name string, val UTCDateTime) error {
// type
if err := buf.WriteByte(_UTC_DATETIME); err != nil {
return err
}
// name
if err := writeCstring(buf, name); err != nil {
return err
}
// value
return binary.Write(buf, binary.LittleEndian, val)
} | [
"func",
"encodeUTCDateTime",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"name",
"string",
",",
"val",
"UTCDateTime",
")",
"error",
"{",
"// type",
"if",
"err",
":=",
"buf",
".",
"WriteByte",
"(",
"_UTC_DATETIME",
")",
";",
"err",
"!=",
"nil",
"{",
"... | // encodeUTCDateTime encodes UTCDateTime. | [
"encodeUTCDateTime",
"encodes",
"UTCDateTime",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L681-L694 |
152,147 | sbunce/bson | encode.go | writeCstring | func writeCstring(buf *bytes.Buffer, s string) error {
if _, err := buf.WriteString(s); err != nil {
return err
}
return buf.WriteByte(0x00)
} | go | func writeCstring(buf *bytes.Buffer, s string) error {
if _, err := buf.WriteString(s); err != nil {
return err
}
return buf.WriteByte(0x00)
} | [
"func",
"writeCstring",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"s",
"string",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"buf",
".",
"WriteString",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return... | // writeCstring writes BSON cstring. This is not a BSON element. | [
"writeCstring",
"writes",
"BSON",
"cstring",
".",
"This",
"is",
"not",
"a",
"BSON",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L718-L723 |
152,148 | sbunce/bson | encode.go | writeString | func writeString(buf *bytes.Buffer, s string) error {
if err := binary.Write(buf, binary.LittleEndian, uint32(len(s)+1)); err != nil {
return err
}
if _, err := buf.WriteString(s); err != nil {
return err
}
return buf.WriteByte(0x00)
} | go | func writeString(buf *bytes.Buffer, s string) error {
if err := binary.Write(buf, binary.LittleEndian, uint32(len(s)+1)); err != nil {
return err
}
if _, err := buf.WriteString(s); err != nil {
return err
}
return buf.WriteByte(0x00)
} | [
"func",
"writeString",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"s",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"binary",
".",
"Write",
"(",
"buf",
",",
"binary",
".",
"LittleEndian",
",",
"uint32",
"(",
"len",
"(",
"s",
")",
"+",
"1",
... | // writeString writes a BSON string. This is not a BSON element. | [
"writeString",
"writes",
"a",
"BSON",
"string",
".",
"This",
"is",
"not",
"a",
"BSON",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/encode.go#L726-L734 |
152,149 | sbunce/bson | decode.go | ReadOne | func ReadOne(rd io.Reader) (BSON, error) {
// Read length of document.
docLen, err := readInt32(rd)
if err != nil {
return nil, err
}
// Sanity check length.
if docLen > maxDocLen {
return nil, errors.New("Doc exceeded maximum size.")
}
// Read the document.
buf := make([]byte, int(docLen))
binary.LittleEndian.PutUint32(buf, uint32(docLen))
if _, err := io.ReadFull(rd, buf[4:]); err != nil {
return nil, err
}
return buf, nil
} | go | func ReadOne(rd io.Reader) (BSON, error) {
// Read length of document.
docLen, err := readInt32(rd)
if err != nil {
return nil, err
}
// Sanity check length.
if docLen > maxDocLen {
return nil, errors.New("Doc exceeded maximum size.")
}
// Read the document.
buf := make([]byte, int(docLen))
binary.LittleEndian.PutUint32(buf, uint32(docLen))
if _, err := io.ReadFull(rd, buf[4:]); err != nil {
return nil, err
}
return buf, nil
} | [
"func",
"ReadOne",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"BSON",
",",
"error",
")",
"{",
"// Read length of document.",
"docLen",
",",
"err",
":=",
"readInt32",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n... | // ReadOne BSON document. | [
"ReadOne",
"BSON",
"document",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L21-L41 |
152,150 | sbunce/bson | decode.go | ReadMap | func ReadMap(rd io.Reader) (m Map, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeMap(rd, "", true)
} | go | func ReadMap(rd io.Reader) (m Map, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeMap(rd, "", true)
} | [
"func",
"ReadMap",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"m",
"Map",
",",
"err",
"error",
")",
"{",
"// Just in case of programming mistake. Not intentionally used.",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",... | // ReadMap reads one Map. | [
"ReadMap",
"reads",
"one",
"Map",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L44-L53 |
152,151 | sbunce/bson | decode.go | ReadMapNoNest | func ReadMapNoNest(rd io.Reader) (m Map, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeMap(rd, "", false)
} | go | func ReadMapNoNest(rd io.Reader) (m Map, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeMap(rd, "", false)
} | [
"func",
"ReadMapNoNest",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"m",
"Map",
",",
"err",
"error",
")",
"{",
"// Just in case of programming mistake. Not intentionally used.",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
... | // ReadMapNoNest reads one Map, but doesn't decode nested documents. | [
"ReadMapNoNest",
"reads",
"one",
"Map",
"but",
"doesn",
"t",
"decode",
"nested",
"documents",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L56-L65 |
152,152 | sbunce/bson | decode.go | ReadSlice | func ReadSlice(rd io.Reader) (s Slice, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeSlice(rd, "", true)
} | go | func ReadSlice(rd io.Reader) (s Slice, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeSlice(rd, "", true)
} | [
"func",
"ReadSlice",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"s",
"Slice",
",",
"err",
"error",
")",
"{",
"// Just in case of programming mistake. Not intentionally used.",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"... | // ReadSlice reads one Slice, but doesn't decode nested documents. | [
"ReadSlice",
"reads",
"one",
"Slice",
"but",
"doesn",
"t",
"decode",
"nested",
"documents",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L68-L77 |
152,153 | sbunce/bson | decode.go | ReadSliceNoNest | func ReadSliceNoNest(rd io.Reader) (s Slice, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeSlice(rd, "", false)
} | go | func ReadSliceNoNest(rd io.Reader) (s Slice, err error) {
// Just in case of programming mistake. Not intentionally used.
defer func() {
if r := recover(); r != nil {
err = errors.New(fmt.Sprint(r))
}
}()
return decodeSlice(rd, "", false)
} | [
"func",
"ReadSliceNoNest",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"s",
"Slice",
",",
"err",
"error",
")",
"{",
"// Just in case of programming mistake. Not intentionally used.",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r... | // ReadSliceNoNest reads one Slice, but doesn't decode nested documents. | [
"ReadSliceNoNest",
"reads",
"one",
"Slice",
"but",
"doesn",
"t",
"decode",
"nested",
"documents",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L80-L89 |
152,154 | sbunce/bson | decode.go | decodeArray | func decodeArray(rd *bufio.Reader, path string) (string, Array, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
doc, err := decodeMap(rd, path, true)
if err != nil {
return "", nil, err
}
// BSON index names may not be ordered. Sort.
ns := make([]string, 0, len(doc))
for name, _ := range doc {
ns = append(ns, name)
}
sort.Strings(ns)
// Build slice.
slice := reflect.MakeSlice(reflect.TypeOf(Array{}), 0, len(ns))
for _, name := range ns {
slice = reflect.Append(slice, reflect.ValueOf(doc[name]))
}
return name, slice.Interface().(Array), nil
} | go | func decodeArray(rd *bufio.Reader, path string) (string, Array, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
doc, err := decodeMap(rd, path, true)
if err != nil {
return "", nil, err
}
// BSON index names may not be ordered. Sort.
ns := make([]string, 0, len(doc))
for name, _ := range doc {
ns = append(ns, name)
}
sort.Strings(ns)
// Build slice.
slice := reflect.MakeSlice(reflect.TypeOf(Array{}), 0, len(ns))
for _, name := range ns {
slice = reflect.Append(slice, reflect.ValueOf(doc[name]))
}
return name, slice.Interface().(Array), nil
} | [
"func",
"decodeArray",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
",",
"path",
"string",
")",
"(",
"string",
",",
"Array",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",... | // decodeArray decodes a BSON Array element. | [
"decodeArray",
"decodes",
"a",
"BSON",
"Array",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L424-L450 |
152,155 | sbunce/bson | decode.go | decodeBinary | func decodeBinary(rd *bufio.Reader) (string, Binary, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
dataLen, err := readInt32(rd)
if err != nil {
return "", nil, err
}
// discard subtype
_, err = rd.ReadByte()
if err != nil {
return "", nil, err
}
b := make([]byte, dataLen)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", nil, err
}
return name, Binary(b), nil
} | go | func decodeBinary(rd *bufio.Reader) (string, Binary, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
dataLen, err := readInt32(rd)
if err != nil {
return "", nil, err
}
// discard subtype
_, err = rd.ReadByte()
if err != nil {
return "", nil, err
}
b := make([]byte, dataLen)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", nil, err
}
return name, Binary(b), nil
} | [
"func",
"decodeBinary",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Binary",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // decodeBinary decodes BSON Binary element. | [
"decodeBinary",
"decodes",
"BSON",
"Binary",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L453-L477 |
152,156 | sbunce/bson | decode.go | decodeBool | func decodeBool(rd *bufio.Reader) (string, Bool, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", false, err
}
// value
b, err := rd.ReadByte()
if err != nil {
return "", false, err
}
return name, Bool(b == 0x01), nil
} | go | func decodeBool(rd *bufio.Reader) (string, Bool, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", false, err
}
// value
b, err := rd.ReadByte()
if err != nil {
return "", false, err
}
return name, Bool(b == 0x01), nil
} | [
"func",
"decodeBool",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Bool",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // decodeBool decodes BSON Bool element. | [
"decodeBool",
"decodes",
"BSON",
"Bool",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L480-L493 |
152,157 | sbunce/bson | decode.go | decodeDBPointer | func decodeDBPointer(rd *bufio.Reader) (string, DBPointer, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", DBPointer{}, err
}
// value
Name, err := readString(rd)
if err != nil {
return "", DBPointer{}, err
}
b := make([]byte, 12)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", DBPointer{}, err
}
return name, DBPointer{Name: Name, ObjectId: ObjectId(b)}, nil
} | go | func decodeDBPointer(rd *bufio.Reader) (string, DBPointer, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", DBPointer{}, err
}
// value
Name, err := readString(rd)
if err != nil {
return "", DBPointer{}, err
}
b := make([]byte, 12)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", DBPointer{}, err
}
return name, DBPointer{Name: Name, ObjectId: ObjectId(b)}, nil
} | [
"func",
"decodeDBPointer",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"DBPointer",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
... | // decodeDBPointer decodes BSON DBPointer. | [
"decodeDBPointer",
"decodes",
"BSON",
"DBPointer",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L496-L514 |
152,158 | sbunce/bson | decode.go | decodeFloat | func decodeFloat(rd *bufio.Reader) (string, Float, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Float(0), err
}
// value
b := make([]byte, 8)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", Float(0), err
}
var u uint64
u += uint64(b[7]) << 56
u += uint64(b[6]) << 48
u += uint64(b[5]) << 40
u += uint64(b[4]) << 32
u += uint64(b[3]) << 24
u += uint64(b[2]) << 16
u += uint64(b[1]) << 8
u += uint64(b[0])
return name, Float(math.Float64frombits(u)), nil
} | go | func decodeFloat(rd *bufio.Reader) (string, Float, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Float(0), err
}
// value
b := make([]byte, 8)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", Float(0), err
}
var u uint64
u += uint64(b[7]) << 56
u += uint64(b[6]) << 48
u += uint64(b[5]) << 40
u += uint64(b[4]) << 32
u += uint64(b[3]) << 24
u += uint64(b[2]) << 16
u += uint64(b[1]) << 8
u += uint64(b[0])
return name, Float(math.Float64frombits(u)), nil
} | [
"func",
"decodeFloat",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Float",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // decodeFloat decodes BSON Float element. | [
"decodeFloat",
"decodes",
"BSON",
"Float",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L517-L540 |
152,159 | sbunce/bson | decode.go | decodeInt32 | func decodeInt32(rd *bufio.Reader) (string, Int32, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i32, err := readInt32(rd)
if err != nil {
return "", 0, err
}
return name, Int32(i32), nil
} | go | func decodeInt32(rd *bufio.Reader) (string, Int32, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i32, err := readInt32(rd)
if err != nil {
return "", 0, err
}
return name, Int32(i32), nil
} | [
"func",
"decodeInt32",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Int32",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // decodeInt32 decodes BSON Int32 element. | [
"decodeInt32",
"decodes",
"BSON",
"Int32",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L543-L556 |
152,160 | sbunce/bson | decode.go | decodeInt64 | func decodeInt64(rd *bufio.Reader) (string, Int64, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i64, err := readInt64(rd)
if err != nil {
return "", 0, err
}
return name, Int64(i64), nil
} | go | func decodeInt64(rd *bufio.Reader) (string, Int64, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i64, err := readInt64(rd)
if err != nil {
return "", 0, err
}
return name, Int64(i64), nil
} | [
"func",
"decodeInt64",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Int64",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // decodeInt64 decodes BSON Int64 element. | [
"decodeInt64",
"decodes",
"BSON",
"Int64",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L559-L572 |
152,161 | sbunce/bson | decode.go | decodeJavascript | func decodeJavascript(rd *bufio.Reader) (string, Javascript, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", "", err
}
// value
s, err := readString(rd)
if err != nil {
return "", "", err
}
return name, Javascript(s), nil
} | go | func decodeJavascript(rd *bufio.Reader) (string, Javascript, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", "", err
}
// value
s, err := readString(rd)
if err != nil {
return "", "", err
}
return name, Javascript(s), nil
} | [
"func",
"decodeJavascript",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Javascript",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\""... | // decodeJavascript decodes BSON Javascript element. | [
"decodeJavascript",
"decodes",
"BSON",
"Javascript",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L575-L588 |
152,162 | sbunce/bson | decode.go | decodeJavascriptScope | func decodeJavascriptScope(rd *bufio.Reader, path string) (string, JavascriptScope, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", JavascriptScope{}, err
}
// value
_, err = readInt32(rd)
if err != nil {
return "", JavascriptScope{}, err
}
js, err := readString(rd)
if err != nil {
return "", JavascriptScope{}, err
}
m, err := decodeMap(rd, "", true)
if err != nil {
return "", JavascriptScope{}, err
}
return name, JavascriptScope{Javascript: js, Scope: m}, nil
} | go | func decodeJavascriptScope(rd *bufio.Reader, path string) (string, JavascriptScope, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", JavascriptScope{}, err
}
// value
_, err = readInt32(rd)
if err != nil {
return "", JavascriptScope{}, err
}
js, err := readString(rd)
if err != nil {
return "", JavascriptScope{}, err
}
m, err := decodeMap(rd, "", true)
if err != nil {
return "", JavascriptScope{}, err
}
return name, JavascriptScope{Javascript: js, Scope: m}, nil
} | [
"func",
"decodeJavascriptScope",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
",",
"path",
"string",
")",
"(",
"string",
",",
"JavascriptScope",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"... | // decodeJavascriptScope decodes BSON JavascriptScope element. | [
"decodeJavascriptScope",
"decodes",
"BSON",
"JavascriptScope",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L591-L612 |
152,163 | sbunce/bson | decode.go | decodeMaxKey | func decodeMaxKey(rd *bufio.Reader) (string, MaxKey, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", MaxKey{}, err
}
return name, MaxKey{}, nil
} | go | func decodeMaxKey(rd *bufio.Reader) (string, MaxKey, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", MaxKey{}, err
}
return name, MaxKey{}, nil
} | [
"func",
"decodeMaxKey",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"MaxKey",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // decodeMaxKey decodes BSON MaxKey element. | [
"decodeMaxKey",
"decodes",
"BSON",
"MaxKey",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L615-L622 |
152,164 | sbunce/bson | decode.go | decodeMinKey | func decodeMinKey(rd *bufio.Reader) (string, MinKey, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", MinKey{}, err
}
return name, MinKey{}, nil
} | go | func decodeMinKey(rd *bufio.Reader) (string, MinKey, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", MinKey{}, err
}
return name, MinKey{}, nil
} | [
"func",
"decodeMinKey",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"MinKey",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // decodeMinKey decodes BSON JavascriptMinKey element. | [
"decodeMinKey",
"decodes",
"BSON",
"JavascriptMinKey",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L625-L632 |
152,165 | sbunce/bson | decode.go | decodeNull | func decodeNull(rd *bufio.Reader) (string, Null, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Null{}, err
}
return name, Null{}, nil
} | go | func decodeNull(rd *bufio.Reader) (string, Null, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Null{}, err
}
return name, Null{}, nil
} | [
"func",
"decodeNull",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Null",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // decodeNull decodes BSON Null element. | [
"decodeNull",
"decodes",
"BSON",
"Null",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L635-L642 |
152,166 | sbunce/bson | decode.go | decodeObjectId | func decodeObjectId(rd *bufio.Reader) (string, ObjectId, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
b := make([]byte, 12)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", nil, err
}
return name, ObjectId(b), nil
} | go | func decodeObjectId(rd *bufio.Reader) (string, ObjectId, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
b := make([]byte, 12)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", nil, err
}
return name, ObjectId(b), nil
} | [
"func",
"decodeObjectId",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"ObjectId",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
... | // decodeObjectId decodes BSON ObjectId element. | [
"decodeObjectId",
"decodes",
"BSON",
"ObjectId",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L645-L659 |
152,167 | sbunce/bson | decode.go | decodeRegexp | func decodeRegexp(rd *bufio.Reader) (string, Regexp, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Regexp{}, err
}
// pattern
pattern, err := readCstring(rd)
if err != nil {
return "", Regexp{}, err
}
// options
options, err := readCstring(rd)
if err != nil {
return "", Regexp{}, err
}
return name, Regexp{Pattern: pattern, Options: options}, nil
} | go | func decodeRegexp(rd *bufio.Reader) (string, Regexp, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Regexp{}, err
}
// pattern
pattern, err := readCstring(rd)
if err != nil {
return "", Regexp{}, err
}
// options
options, err := readCstring(rd)
if err != nil {
return "", Regexp{}, err
}
return name, Regexp{Pattern: pattern, Options: options}, nil
} | [
"func",
"decodeRegexp",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Regexp",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // decodeRegexp decodes BSON Regexp element. | [
"decodeRegexp",
"decodes",
"BSON",
"Regexp",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L662-L681 |
152,168 | sbunce/bson | decode.go | decodeString | func decodeString(rd *bufio.Reader) (string, String, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", "", err
}
// value
s, err := readString(rd)
if err != nil {
return "", "", err
}
return name, String(s), nil
} | go | func decodeString(rd *bufio.Reader) (string, String, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", "", err
}
// value
s, err := readString(rd)
if err != nil {
return "", "", err
}
return name, String(s), nil
} | [
"func",
"decodeString",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"String",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // decodeString decodes BSON String element. | [
"decodeString",
"decodes",
"BSON",
"String",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L684-L697 |
152,169 | sbunce/bson | decode.go | decodeSymbol | func decodeSymbol(rd *bufio.Reader) (string, Symbol, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", "", err
}
// value
s, err := readString(rd)
if err != nil {
return "", "", err
}
return name, Symbol(s), nil
} | go | func decodeSymbol(rd *bufio.Reader) (string, Symbol, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", "", err
}
// value
s, err := readString(rd)
if err != nil {
return "", "", err
}
return name, Symbol(s), nil
} | [
"func",
"decodeSymbol",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Symbol",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // decodeSymbol decodes BSON Symbol element. | [
"decodeSymbol",
"decodes",
"BSON",
"Symbol",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L700-L713 |
152,170 | sbunce/bson | decode.go | decodeTimestamp | func decodeTimestamp(rd *bufio.Reader) (string, Timestamp, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i64, err := readInt64(rd)
if err != nil {
return "", 0, err
}
return name, Timestamp(i64), nil
} | go | func decodeTimestamp(rd *bufio.Reader) (string, Timestamp, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i64, err := readInt64(rd)
if err != nil {
return "", 0, err
}
return name, Timestamp(i64), nil
} | [
"func",
"decodeTimestamp",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Timestamp",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
... | // decodeTimestamp decodes BSON Timestamp element. | [
"decodeTimestamp",
"decodes",
"BSON",
"Timestamp",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L716-L729 |
152,171 | sbunce/bson | decode.go | decodeUndefined | func decodeUndefined(rd *bufio.Reader) (string, Undefined, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Undefined{}, err
}
return name, Undefined{}, nil
} | go | func decodeUndefined(rd *bufio.Reader) (string, Undefined, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", Undefined{}, err
}
return name, Undefined{}, nil
} | [
"func",
"decodeUndefined",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"Undefined",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
... | // decodeUndefined decodes BSON Undefined element. | [
"decodeUndefined",
"decodes",
"BSON",
"Undefined",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L732-L739 |
152,172 | sbunce/bson | decode.go | decodeUTCDateTime | func decodeUTCDateTime(rd *bufio.Reader) (string, UTCDateTime, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i64, err := readInt64(rd)
if err != nil {
return "", 0, err
}
return name, UTCDateTime(i64), nil
} | go | func decodeUTCDateTime(rd *bufio.Reader) (string, UTCDateTime, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", 0, err
}
// value
i64, err := readInt64(rd)
if err != nil {
return "", 0, err
}
return name, UTCDateTime(i64), nil
} | [
"func",
"decodeUTCDateTime",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"UTCDateTime",
",",
"error",
")",
"{",
"// name",
"name",
",",
"err",
":=",
"readCstring",
"(",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\... | // decodeUTCDateTime decodes BSON UTCDateTime element. | [
"decodeUTCDateTime",
"decodes",
"BSON",
"UTCDateTime",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L742-L755 |
152,173 | sbunce/bson | decode.go | readCstring | func readCstring(rd *bufio.Reader) (string, error) {
s, err := rd.ReadString(0x00)
if err != nil {
return "", err
}
return s[:len(s)-1], nil
} | go | func readCstring(rd *bufio.Reader) (string, error) {
s, err := rd.ReadString(0x00)
if err != nil {
return "", err
}
return s[:len(s)-1], nil
} | [
"func",
"readCstring",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"rd",
".",
"ReadString",
"(",
"0x00",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
... | // readCString reads one BSON C string. This is not a BSON element. | [
"readCString",
"reads",
"one",
"BSON",
"C",
"string",
".",
"This",
"is",
"not",
"a",
"BSON",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L758-L764 |
152,174 | sbunce/bson | decode.go | readInt32 | func readInt32(rd io.Reader) (int32, error) {
var i int32
if err := binary.Read(rd, binary.LittleEndian, &i); err != nil {
return 0, err
}
return i, nil
} | go | func readInt32(rd io.Reader) (int32, error) {
var i int32
if err := binary.Read(rd, binary.LittleEndian, &i); err != nil {
return 0, err
}
return i, nil
} | [
"func",
"readInt32",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"int32",
",",
"error",
")",
"{",
"var",
"i",
"int32",
"\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"rd",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"i",
")",
";",
"err",
... | // readBSONInt32 reads one int32. This is not a BSON element. | [
"readBSONInt32",
"reads",
"one",
"int32",
".",
"This",
"is",
"not",
"a",
"BSON",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L767-L773 |
152,175 | sbunce/bson | decode.go | readInt64 | func readInt64(rd io.Reader) (int64, error) {
var i int64
if err := binary.Read(rd, binary.LittleEndian, &i); err != nil {
return 0, err
}
return i, nil
} | go | func readInt64(rd io.Reader) (int64, error) {
var i int64
if err := binary.Read(rd, binary.LittleEndian, &i); err != nil {
return 0, err
}
return i, nil
} | [
"func",
"readInt64",
"(",
"rd",
"io",
".",
"Reader",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"i",
"int64",
"\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"rd",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"i",
")",
";",
"err",
... | // readInt64 reads one int64. This is not a BSON element. | [
"readInt64",
"reads",
"one",
"int64",
".",
"This",
"is",
"not",
"a",
"BSON",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L776-L782 |
152,176 | sbunce/bson | decode.go | readString | func readString(rd *bufio.Reader) (string, error) {
// Read string length.
var sLen int32
if err := binary.Read(rd, binary.LittleEndian, &sLen); err != nil {
return "", err
}
if sLen == 0 {
return "", nil
}
// Read string.
b := make([]byte, sLen)
if _, err := io.ReadFull(rd, b); err != nil {
return "", err
}
return string(b[:len(b)-1]), nil
} | go | func readString(rd *bufio.Reader) (string, error) {
// Read string length.
var sLen int32
if err := binary.Read(rd, binary.LittleEndian, &sLen); err != nil {
return "", err
}
if sLen == 0 {
return "", nil
}
// Read string.
b := make([]byte, sLen)
if _, err := io.ReadFull(rd, b); err != nil {
return "", err
}
return string(b[:len(b)-1]), nil
} | [
"func",
"readString",
"(",
"rd",
"*",
"bufio",
".",
"Reader",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Read string length.",
"var",
"sLen",
"int32",
"\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"rd",
",",
"binary",
".",
"LittleEndian",
"... | // readString reads one string. This is not a BSON element. | [
"readString",
"reads",
"one",
"string",
".",
"This",
"is",
"not",
"a",
"BSON",
"element",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/decode.go#L785-L801 |
152,177 | japm/goScript | eval.go | Prepare | func (e *Expr) Prepare(expr string) error {
//call Golang pareexpr function
exp, err := parser.ParseExpr(expr)
if err != nil {
return err
}
//resolve constants to its values
//to avoid unnecesary conversions
exp = resolveConstants(exp).(ast.Expr)
if err != nil {
return err
}
e.expr = exp
return err
} | go | func (e *Expr) Prepare(expr string) error {
//call Golang pareexpr function
exp, err := parser.ParseExpr(expr)
if err != nil {
return err
}
//resolve constants to its values
//to avoid unnecesary conversions
exp = resolveConstants(exp).(ast.Expr)
if err != nil {
return err
}
e.expr = exp
return err
} | [
"func",
"(",
"e",
"*",
"Expr",
")",
"Prepare",
"(",
"expr",
"string",
")",
"error",
"{",
"//call Golang pareexpr function",
"exp",
",",
"err",
":=",
"parser",
".",
"ParseExpr",
"(",
"expr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n... | // Prepare sentence for evaluation and reuse | [
"Prepare",
"sentence",
"for",
"evaluation",
"and",
"reuse"
] | caab90145b05376536bbab332312f4812123e197 | https://github.com/japm/goScript/blob/caab90145b05376536bbab332312f4812123e197/eval.go#L103-L119 |
152,178 | japm/goScript | eval.go | Eval | func (e *Expr) Eval(context interface{}) (val interface{}, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Eval paniked. %s", r)
}
}()
//create context for evaluation
ctxt := createContext(context)
//evaluate the prepared sentence
val, err = eval(e.expr, ctxt)
return val, err
} | go | func (e *Expr) Eval(context interface{}) (val interface{}, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Eval paniked. %s", r)
}
}()
//create context for evaluation
ctxt := createContext(context)
//evaluate the prepared sentence
val, err = eval(e.expr, ctxt)
return val, err
} | [
"func",
"(",
"e",
"*",
"Expr",
")",
"Eval",
"(",
"context",
"interface",
"{",
"}",
")",
"(",
"val",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"n... | // Eval a prepared sentence | [
"Eval",
"a",
"prepared",
"sentence"
] | caab90145b05376536bbab332312f4812123e197 | https://github.com/japm/goScript/blob/caab90145b05376536bbab332312f4812123e197/eval.go#L122-L137 |
152,179 | japm/goScript | eval.go | EvalNoRecover | func (e *Expr) EvalNoRecover(context interface{}) (interface{}, error) {
//create context for evaluation
ctxt := createContext(context)
//evaluate the prepared sentence
return eval(e.expr, ctxt)
} | go | func (e *Expr) EvalNoRecover(context interface{}) (interface{}, error) {
//create context for evaluation
ctxt := createContext(context)
//evaluate the prepared sentence
return eval(e.expr, ctxt)
} | [
"func",
"(",
"e",
"*",
"Expr",
")",
"EvalNoRecover",
"(",
"context",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"//create context for evaluation",
"ctxt",
":=",
"createContext",
"(",
"context",
")",
"\n\n",
"//evaluate th... | //EvalNoRecover without recover on defer | [
"EvalNoRecover",
"without",
"recover",
"on",
"defer"
] | caab90145b05376536bbab332312f4812123e197 | https://github.com/japm/goScript/blob/caab90145b05376536bbab332312f4812123e197/eval.go#L140-L147 |
152,180 | japm/goScript | eval.go | Eval | func Eval(expr string, context interface{}) (val interface{}, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Eval paniked. %s", r)
}
}()
exp, err := parser.ParseExpr(expr)
if err != nil {
return nilInterf, err
}
ctxt := createContext(context)
val, err = eval(exp, ctxt)
return val, err
} | go | func Eval(expr string, context interface{}) (val interface{}, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Eval paniked. %s", r)
}
}()
exp, err := parser.ParseExpr(expr)
if err != nil {
return nilInterf, err
}
ctxt := createContext(context)
val, err = eval(exp, ctxt)
return val, err
} | [
"func",
"Eval",
"(",
"expr",
"string",
",",
"context",
"interface",
"{",
"}",
")",
"(",
"val",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{... | //Eval expression within a context | [
"Eval",
"expression",
"within",
"a",
"context"
] | caab90145b05376536bbab332312f4812123e197 | https://github.com/japm/goScript/blob/caab90145b05376536bbab332312f4812123e197/eval.go#L160-L177 |
152,181 | japm/goScript | eval.go | createContext | func createContext(context interface{}) Context {
var ctxt Context
switch context.(type) {
case *map[string]interface{}:
ctxt = mapContext{*(context.(*map[string]interface{}))}
case map[string]interface{}:
ctxt = mapContext{(context.(map[string]interface{}))}
case reflect.Value:
rval := context.(reflect.Value)
if rval.Kind() == reflect.Ptr {
rval = rval.Elem()
}
ctxt = reflectContext{rval}
case *reflect.Value:
rval := *(context.(*reflect.Value))
if rval.Kind() == reflect.Ptr {
rval = rval.Elem()
}
ctxt = reflectContext{rval}
default:
var ok bool
if context == nil {
ctxt = nilContext{}
} else {
//A custom context can be used, resolve it
ctxt, ok = context.(Context)
if !ok {
//Not a custom context, default to a reflect context
rval := reflect.ValueOf(context)
if rval.Kind() == reflect.Ptr {
rval = rval.Elem()
}
ctxt = reflectContext{rval}
}
}
}
return ctxt
} | go | func createContext(context interface{}) Context {
var ctxt Context
switch context.(type) {
case *map[string]interface{}:
ctxt = mapContext{*(context.(*map[string]interface{}))}
case map[string]interface{}:
ctxt = mapContext{(context.(map[string]interface{}))}
case reflect.Value:
rval := context.(reflect.Value)
if rval.Kind() == reflect.Ptr {
rval = rval.Elem()
}
ctxt = reflectContext{rval}
case *reflect.Value:
rval := *(context.(*reflect.Value))
if rval.Kind() == reflect.Ptr {
rval = rval.Elem()
}
ctxt = reflectContext{rval}
default:
var ok bool
if context == nil {
ctxt = nilContext{}
} else {
//A custom context can be used, resolve it
ctxt, ok = context.(Context)
if !ok {
//Not a custom context, default to a reflect context
rval := reflect.ValueOf(context)
if rval.Kind() == reflect.Ptr {
rval = rval.Elem()
}
ctxt = reflectContext{rval}
}
}
}
return ctxt
} | [
"func",
"createContext",
"(",
"context",
"interface",
"{",
"}",
")",
"Context",
"{",
"var",
"ctxt",
"Context",
"\n",
"switch",
"context",
".",
"(",
"type",
")",
"{",
"case",
"*",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"ctxt",
"=",
"ma... | //Creates the apropiate execution identificaion resolver
//It creates one of the especialized context or
//can resolve a custom context provided by the user | [
"Creates",
"the",
"apropiate",
"execution",
"identificaion",
"resolver",
"It",
"creates",
"one",
"of",
"the",
"especialized",
"context",
"or",
"can",
"resolve",
"a",
"custom",
"context",
"provided",
"by",
"the",
"user"
] | caab90145b05376536bbab332312f4812123e197 | https://github.com/japm/goScript/blob/caab90145b05376536bbab332312f4812123e197/eval.go#L199-L237 |
152,182 | sbunce/bson | reach.go | Reach | func (this Slice) Reach(dst interface{}, dot ...string) (bool, error) {
if dst == nil {
return false, errors.New("dst must not be nil.")
}
src := reach(this, dot...)
if src == nil {
return false, nil
}
return assign(dst, src)
} | go | func (this Slice) Reach(dst interface{}, dot ...string) (bool, error) {
if dst == nil {
return false, errors.New("dst must not be nil.")
}
src := reach(this, dot...)
if src == nil {
return false, nil
}
return assign(dst, src)
} | [
"func",
"(",
"this",
"Slice",
")",
"Reach",
"(",
"dst",
"interface",
"{",
"}",
",",
"dot",
"...",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"dst",
"==",
"nil",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
... | // Same as map reach. | [
"Same",
"as",
"map",
"reach",
"."
] | 2aa5ebe749b24e053f742541fe8242e80f40c4a0 | https://github.com/sbunce/bson/blob/2aa5ebe749b24e053f742541fe8242e80f40c4a0/reach.go#L45-L54 |
152,183 | rancher/host-api | app/common/error.go | CheckError | func CheckError(err error, level int) {
if err != nil {
var stack [4096]byte
runtime.Stack(stack[:], false)
log.Printf("%q\n%s\n", err, stack[:])
switch level {
case 0:
glog.Infoln("%q\n%s\n", err)
case 1:
glog.Warningln("%q\n%s\n", err)
case 2:
glog.Errorln("%q\n%s\n", err)
case 3:
glog.Fatalln("%q\n%s\n", err)
}
glog.Flush()
}
} | go | func CheckError(err error, level int) {
if err != nil {
var stack [4096]byte
runtime.Stack(stack[:], false)
log.Printf("%q\n%s\n", err, stack[:])
switch level {
case 0:
glog.Infoln("%q\n%s\n", err)
case 1:
glog.Warningln("%q\n%s\n", err)
case 2:
glog.Errorln("%q\n%s\n", err)
case 3:
glog.Fatalln("%q\n%s\n", err)
}
glog.Flush()
}
} | [
"func",
"CheckError",
"(",
"err",
"error",
",",
"level",
"int",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"var",
"stack",
"[",
"4096",
"]",
"byte",
"\n",
"runtime",
".",
"Stack",
"(",
"stack",
"[",
":",
"]",
",",
"false",
")",
"\n",
"log",
".",
... | // 0 = info
// 1 = warning
// 2 = error - should be most common
// 3 = fatal | [
"0",
"=",
"info",
"1",
"=",
"warning",
"2",
"=",
"error",
"-",
"should",
"be",
"most",
"common",
"3",
"=",
"fatal"
] | d56f3d0283c4910e9cc62d9123419f6caa2f9429 | https://github.com/rancher/host-api/blob/d56f3d0283c4910e9cc62d9123419f6caa2f9429/app/common/error.go#L14-L33 |
152,184 | marksamman/bencode | encoder.go | Encode | func Encode(v interface{}) []byte {
encoder := encoder{}
encoder.writeInterfaceType(v)
return encoder.Bytes()
} | go | func Encode(v interface{}) []byte {
encoder := encoder{}
encoder.writeInterfaceType(v)
return encoder.Bytes()
} | [
"func",
"Encode",
"(",
"v",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"encoder",
":=",
"encoder",
"{",
"}",
"\n",
"encoder",
".",
"writeInterfaceType",
"(",
"v",
")",
"\n",
"return",
"encoder",
".",
"Bytes",
"(",
")",
"\n",
"}"
] | // Encode takes a bencode supported data type and
// returns a bencode byte array representation | [
"Encode",
"takes",
"a",
"bencode",
"supported",
"data",
"type",
"and",
"returns",
"a",
"bencode",
"byte",
"array",
"representation"
] | dc84f26e086e81e5025e4db80274a96a5698df79 | https://github.com/marksamman/bencode/blob/dc84f26e086e81e5025e4db80274a96a5698df79/encoder.go#L97-L101 |
152,185 | otiai10/marmoset | router.go | Apply | func (router *Router) Apply(filters ...Filterable) error {
router.filters = filters
return nil
} | go | func (router *Router) Apply(filters ...Filterable) error {
router.filters = filters
return nil
} | [
"func",
"(",
"router",
"*",
"Router",
")",
"Apply",
"(",
"filters",
"...",
"Filterable",
")",
"error",
"{",
"router",
".",
"filters",
"=",
"filters",
"\n",
"return",
"nil",
"\n",
"}"
] | // Apply applies Filters | [
"Apply",
"applies",
"Filters"
] | 2adcf18928cbc73d640249eed0ac8e49ce4bdcb8 | https://github.com/otiai10/marmoset/blob/2adcf18928cbc73d640249eed0ac8e49ce4bdcb8/router.go#L218-L221 |
152,186 | guotie/gogb2312 | gb2312.go | nearbyutf8 | func nearbyutf8(buf []byte, tlen int, plen int) string {
if tlen <= plen {
return tohex(buf) + string(buf)
}
start := tlen - plen
if buf[start] < byte(0x7f) || buf[start] > byte(0xe0) {
return tohex(buf[start:]) + string(buf[start:])
}
start = start - 1
if buf[start] < byte(0x7f) || buf[start] > byte(0xe0) {
return tohex(buf[start:]) + string(buf[start:])
}
if start < 1 {
return ""
}
start = start - 1
if buf[start] < byte(0x7f) || buf[start] > byte(0xe0) {
return tohex(buf[start:]) + string(buf[start:])
}
return ""
} | go | func nearbyutf8(buf []byte, tlen int, plen int) string {
if tlen <= plen {
return tohex(buf) + string(buf)
}
start := tlen - plen
if buf[start] < byte(0x7f) || buf[start] > byte(0xe0) {
return tohex(buf[start:]) + string(buf[start:])
}
start = start - 1
if buf[start] < byte(0x7f) || buf[start] > byte(0xe0) {
return tohex(buf[start:]) + string(buf[start:])
}
if start < 1 {
return ""
}
start = start - 1
if buf[start] < byte(0x7f) || buf[start] > byte(0xe0) {
return tohex(buf[start:]) + string(buf[start:])
}
return ""
} | [
"func",
"nearbyutf8",
"(",
"buf",
"[",
"]",
"byte",
",",
"tlen",
"int",
",",
"plen",
"int",
")",
"string",
"{",
"if",
"tlen",
"<=",
"plen",
"{",
"return",
"tohex",
"(",
"buf",
")",
"+",
"string",
"(",
"buf",
")",
"\n",
"}",
"\n\n",
"start",
":=",... | // get a slice of utf-8 string, from tlen-plen, to tlen | [
"get",
"a",
"slice",
"of",
"utf",
"-",
"8",
"string",
"from",
"tlen",
"-",
"plen",
"to",
"tlen"
] | a052a05f3e7eee704c1da5c5498a5e5718a97b1f | https://github.com/guotie/gogb2312/blob/a052a05f3e7eee704c1da5c5498a5e5718a97b1f/gb2312.go#L71-L92 |
152,187 | guotie/gogb2312 | gb2312.go | isutf8 | func isutf8(buf []byte, blen int) int {
if blen <= 2 {
return 0
}
// invalid utf-8 code
if buf[0] == byte(0xc0) || buf[0] == byte(0xc1) ||
buf[0] == byte(0xfe) || buf[0] == byte(0xff) {
return 0
}
var (
i int = 3
maxlen int = 6
)
if blen < 6 {
maxlen = blen
}
for ; i < maxlen; i++ {
fb := utf8FirstByte[i]
mk := utf8FirstMask[i]
if buf[0]&mk == fb {
res := true
for j := 1; j <= i-1; j++ {
b := buf[j]
if b == byte(0xc0) || b == byte(0xc1) ||
b == byte(0xfe) || b == byte(0xff) {
return 0
}
if b&byte(0xc0) != 0x80 {
res = false
break
}
}
if res {
return i
}
}
}
return 0
} | go | func isutf8(buf []byte, blen int) int {
if blen <= 2 {
return 0
}
// invalid utf-8 code
if buf[0] == byte(0xc0) || buf[0] == byte(0xc1) ||
buf[0] == byte(0xfe) || buf[0] == byte(0xff) {
return 0
}
var (
i int = 3
maxlen int = 6
)
if blen < 6 {
maxlen = blen
}
for ; i < maxlen; i++ {
fb := utf8FirstByte[i]
mk := utf8FirstMask[i]
if buf[0]&mk == fb {
res := true
for j := 1; j <= i-1; j++ {
b := buf[j]
if b == byte(0xc0) || b == byte(0xc1) ||
b == byte(0xfe) || b == byte(0xff) {
return 0
}
if b&byte(0xc0) != 0x80 {
res = false
break
}
}
if res {
return i
}
}
}
return 0
} | [
"func",
"isutf8",
"(",
"buf",
"[",
"]",
"byte",
",",
"blen",
"int",
")",
"int",
"{",
"if",
"blen",
"<=",
"2",
"{",
"return",
"0",
"\n",
"}",
"\n",
"// invalid utf-8 code",
"if",
"buf",
"[",
"0",
"]",
"==",
"byte",
"(",
"0xc0",
")",
"||",
"buf",
... | // check if the first N byte of buf is utf-8 | [
"check",
"if",
"the",
"first",
"N",
"byte",
"of",
"buf",
"is",
"utf",
"-",
"8"
] | a052a05f3e7eee704c1da5c5498a5e5718a97b1f | https://github.com/guotie/gogb2312/blob/a052a05f3e7eee704c1da5c5498a5e5718a97b1f/gb2312.go#L219-L258 |
152,188 | marksamman/bencode | decoder.go | Decode | func Decode(reader io.Reader) (map[string]interface{}, error) {
decoder := decoder{*bufio.NewReader(reader)}
if firstByte, err := decoder.ReadByte(); err != nil {
return make(map[string]interface{}), nil
} else if firstByte != 'd' {
return nil, errors.New("bencode data must begin with a dictionary")
}
return decoder.readDictionary()
} | go | func Decode(reader io.Reader) (map[string]interface{}, error) {
decoder := decoder{*bufio.NewReader(reader)}
if firstByte, err := decoder.ReadByte(); err != nil {
return make(map[string]interface{}), nil
} else if firstByte != 'd' {
return nil, errors.New("bencode data must begin with a dictionary")
}
return decoder.readDictionary()
} | [
"func",
"Decode",
"(",
"reader",
"io",
".",
"Reader",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"decoder",
":=",
"decoder",
"{",
"*",
"bufio",
".",
"NewReader",
"(",
"reader",
")",
"}",
"\n",
"if",
"firstBy... | // Decode takes an io.Reader and parses it as bencode,
// on failure, err will be a non-nil value | [
"Decode",
"takes",
"an",
"io",
".",
"Reader",
"and",
"parses",
"it",
"as",
"bencode",
"on",
"failure",
"err",
"will",
"be",
"a",
"non",
"-",
"nil",
"value"
] | dc84f26e086e81e5025e4db80274a96a5698df79 | https://github.com/marksamman/bencode/blob/dc84f26e086e81e5025e4db80274a96a5698df79/decoder.go#L151-L159 |
152,189 | fabiorphp/kongo | service.go | create | func (s *ServicesService) create(ctx context.Context, svc *Service, groupName string) (*Service, *http.Response, error) {
resource, _ := url.Parse(servicesResourcePath)
opts := &sheriff.Options{Groups: []string{groupName}}
body, err := sheriff.Marshal(opts, svc)
if err != nil {
return nil, nil, err
}
req, err := s.client.NewRequest(ctx, http.MethodPost, resource, body)
if err != nil {
return nil, nil, err
}
root := new(Service)
res, err := s.client.Do(req, root)
if err != nil {
return nil, res, err
}
return root, res, nil
} | go | func (s *ServicesService) create(ctx context.Context, svc *Service, groupName string) (*Service, *http.Response, error) {
resource, _ := url.Parse(servicesResourcePath)
opts := &sheriff.Options{Groups: []string{groupName}}
body, err := sheriff.Marshal(opts, svc)
if err != nil {
return nil, nil, err
}
req, err := s.client.NewRequest(ctx, http.MethodPost, resource, body)
if err != nil {
return nil, nil, err
}
root := new(Service)
res, err := s.client.Do(req, root)
if err != nil {
return nil, res, err
}
return root, res, nil
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"create",
"(",
"ctx",
"context",
".",
"Context",
",",
"svc",
"*",
"Service",
",",
"groupName",
"string",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"resource",
"... | // create creates a new service | [
"create",
"creates",
"a",
"new",
"service"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L127-L152 |
152,190 | fabiorphp/kongo | service.go | CreateWithContext | func (s *ServicesService) CreateWithContext(ctx context.Context, svc *Service) (*Service, *http.Response, error) {
return s.create(ctx, svc, "create")
} | go | func (s *ServicesService) CreateWithContext(ctx context.Context, svc *Service) (*Service, *http.Response, error) {
return s.create(ctx, svc, "create")
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"CreateWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"svc",
"*",
"Service",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"s",
".",
"create",
... | // CreateWithContext creates a new service | [
"CreateWithContext",
"creates",
"a",
"new",
"service"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L155-L157 |
152,191 | fabiorphp/kongo | service.go | Create | func (s *ServicesService) Create(svc *Service) (*Service, *http.Response, error) {
return s.CreateWithContext(context.TODO(), svc)
} | go | func (s *ServicesService) Create(svc *Service) (*Service, *http.Response, error) {
return s.CreateWithContext(context.TODO(), svc)
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"Create",
"(",
"svc",
"*",
"Service",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"s",
".",
"CreateWithContext",
"(",
"context",
".",
"TODO",
"(",
")",
... | // Create creates a new service | [
"Create",
"creates",
"a",
"new",
"service"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L160-L162 |
152,192 | fabiorphp/kongo | service.go | CreateByURL | func (s *ServicesService) CreateByURL(svc *Service) (*Service, *http.Response, error) {
return s.CreateByURLWithContext(context.TODO(), svc)
} | go | func (s *ServicesService) CreateByURL(svc *Service) (*Service, *http.Response, error) {
return s.CreateByURLWithContext(context.TODO(), svc)
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"CreateByURL",
"(",
"svc",
"*",
"Service",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"s",
".",
"CreateByURLWithContext",
"(",
"context",
".",
"TODO",
"(... | // CreateByURL creates a new service by URL | [
"CreateByURL",
"creates",
"a",
"new",
"service",
"by",
"URL"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L170-L172 |
152,193 | fabiorphp/kongo | service.go | DeleteWithContext | func (s *ServicesService) DeleteWithContext(ctx context.Context, idOrName string) (*http.Response, error) {
resource, _ := url.Parse(servicesResourcePath)
resource.Path = path.Join(resource.Path, idOrName)
req, err := s.client.NewRequest(ctx, http.MethodDelete, resource, nil)
if err != nil {
return nil, err
}
res, err := s.client.Do(req, nil)
if err != nil {
return res, err
}
return res, nil
} | go | func (s *ServicesService) DeleteWithContext(ctx context.Context, idOrName string) (*http.Response, error) {
resource, _ := url.Parse(servicesResourcePath)
resource.Path = path.Join(resource.Path, idOrName)
req, err := s.client.NewRequest(ctx, http.MethodDelete, resource, nil)
if err != nil {
return nil, err
}
res, err := s.client.Do(req, nil)
if err != nil {
return res, err
}
return res, nil
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"DeleteWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"idOrName",
"string",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"resource",
",",
"_",
":=",
"url",
".",
"Parse",
"(",
... | // DeleteWithContext retrieves registred service by ID or Name | [
"DeleteWithContext",
"retrieves",
"registred",
"service",
"by",
"ID",
"or",
"Name"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L175-L192 |
152,194 | fabiorphp/kongo | service.go | Delete | func (s *ServicesService) Delete(idOrName string) (*http.Response, error) {
return s.DeleteWithContext(context.TODO(), idOrName)
} | go | func (s *ServicesService) Delete(idOrName string) (*http.Response, error) {
return s.DeleteWithContext(context.TODO(), idOrName)
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"Delete",
"(",
"idOrName",
"string",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"s",
".",
"DeleteWithContext",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"idOrName",
")",
... | // Delete retrieves registred service by ID or Name | [
"Delete",
"retrieves",
"registred",
"service",
"by",
"ID",
"or",
"Name"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L195-L197 |
152,195 | fabiorphp/kongo | service.go | GetWithContext | func (s *ServicesService) GetWithContext(ctx context.Context, idOrName string) (*Service, *http.Response, error) {
resource, _ := url.Parse(servicesResourcePath)
resource.Path = path.Join(resource.Path, idOrName)
req, err := s.client.NewRequest(ctx, http.MethodGet, resource, nil)
if err != nil {
return nil, nil, err
}
svc := new(Service)
res, err := s.client.Do(req, svc)
if err != nil {
return nil, res, err
}
return svc, res, nil
} | go | func (s *ServicesService) GetWithContext(ctx context.Context, idOrName string) (*Service, *http.Response, error) {
resource, _ := url.Parse(servicesResourcePath)
resource.Path = path.Join(resource.Path, idOrName)
req, err := s.client.NewRequest(ctx, http.MethodGet, resource, nil)
if err != nil {
return nil, nil, err
}
svc := new(Service)
res, err := s.client.Do(req, svc)
if err != nil {
return nil, res, err
}
return svc, res, nil
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"GetWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"idOrName",
"string",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"resource",
",",
"_",
":=",
"url",
... | // GetWithContext retrieves registred service by ID or Name | [
"GetWithContext",
"retrieves",
"registred",
"service",
"by",
"ID",
"or",
"Name"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L200-L219 |
152,196 | fabiorphp/kongo | service.go | Get | func (s *ServicesService) Get(idOrName string) (*Service, *http.Response, error) {
return s.GetWithContext(context.TODO(), idOrName)
} | go | func (s *ServicesService) Get(idOrName string) (*Service, *http.Response, error) {
return s.GetWithContext(context.TODO(), idOrName)
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"Get",
"(",
"idOrName",
"string",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"s",
".",
"GetWithContext",
"(",
"context",
".",
"TODO",
"(",
")",
",",
... | // Get retrieves registred service by ID or Name | [
"Get",
"retrieves",
"registred",
"service",
"by",
"ID",
"or",
"Name"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L222-L224 |
152,197 | fabiorphp/kongo | service.go | ListWithContext | func (s *ServicesService) ListWithContext(ctx context.Context, options *ListServicesOptions) ([]*Service, *http.Response, error) {
opts, _ := query.Values(options)
resource, _ := url.Parse(servicesResourcePath)
resource.RawQuery = opts.Encode()
req, err := s.client.NewRequest(ctx, http.MethodGet, resource, nil)
if err != nil {
return nil, nil, err
}
root := new(ServicesRoot)
res, err := s.client.Do(req, root)
if err != nil {
return nil, res, err
}
return root.Services, res, nil
} | go | func (s *ServicesService) ListWithContext(ctx context.Context, options *ListServicesOptions) ([]*Service, *http.Response, error) {
opts, _ := query.Values(options)
resource, _ := url.Parse(servicesResourcePath)
resource.RawQuery = opts.Encode()
req, err := s.client.NewRequest(ctx, http.MethodGet, resource, nil)
if err != nil {
return nil, nil, err
}
root := new(ServicesRoot)
res, err := s.client.Do(req, root)
if err != nil {
return nil, res, err
}
return root.Services, res, nil
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"ListWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"options",
"*",
"ListServicesOptions",
")",
"(",
"[",
"]",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"opts",
... | // ListWithContext retrieves a list of registred services | [
"ListWithContext",
"retrieves",
"a",
"list",
"of",
"registred",
"services"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L227-L247 |
152,198 | fabiorphp/kongo | service.go | List | func (s *ServicesService) List(options *ListServicesOptions) ([]*Service, *http.Response, error) {
return s.ListWithContext(context.TODO(), options)
} | go | func (s *ServicesService) List(options *ListServicesOptions) ([]*Service, *http.Response, error) {
return s.ListWithContext(context.TODO(), options)
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"List",
"(",
"options",
"*",
"ListServicesOptions",
")",
"(",
"[",
"]",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"s",
".",
"ListWithContext",
"(",
"context",
"."... | // List retrieves a list of registred services | [
"List",
"retrieves",
"a",
"list",
"of",
"registred",
"services"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L250-L252 |
152,199 | fabiorphp/kongo | service.go | UpdateWithContext | func (s *ServicesService) UpdateWithContext(ctx context.Context, idOrName string, svc *Service) (*Service, *http.Response, error) {
return s.update(ctx, idOrName, svc, "update")
} | go | func (s *ServicesService) UpdateWithContext(ctx context.Context, idOrName string, svc *Service) (*Service, *http.Response, error) {
return s.update(ctx, idOrName, svc, "update")
} | [
"func",
"(",
"s",
"*",
"ServicesService",
")",
"UpdateWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"idOrName",
"string",
",",
"svc",
"*",
"Service",
")",
"(",
"*",
"Service",
",",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"retu... | // UpdateWithContext updates a service | [
"UpdateWithContext",
"updates",
"a",
"service"
] | 4b98febd8f13378979c33e392de0a78adc06e336 | https://github.com/fabiorphp/kongo/blob/4b98febd8f13378979c33e392de0a78adc06e336/service.go#L284-L286 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.