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 listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
16,000 | hjson/hjson-go | encode.go | DefaultOptions | func DefaultOptions() EncoderOptions {
opt := EncoderOptions{}
opt.Eol = "\n"
opt.BracesSameLine = false
opt.EmitRootBraces = true
opt.QuoteAlways = false
opt.IndentBy = " "
opt.AllowMinusZero = false
opt.UnknownAsNull = false
return opt
} | go | func DefaultOptions() EncoderOptions {
opt := EncoderOptions{}
opt.Eol = "\n"
opt.BracesSameLine = false
opt.EmitRootBraces = true
opt.QuoteAlways = false
opt.IndentBy = " "
opt.AllowMinusZero = false
opt.UnknownAsNull = false
return opt
} | [
"func",
"DefaultOptions",
"(",
")",
"EncoderOptions",
"{",
"opt",
":=",
"EncoderOptions",
"{",
"}",
"\n",
"opt",
".",
"Eol",
"=",
"\"",
"\\n",
"\"",
"\n",
"opt",
".",
"BracesSameLine",
"=",
"false",
"\n",
"opt",
".",
"EmitRootBraces",
"=",
"true",
"\n",
... | // DefaultOptions returns the default encoding options. | [
"DefaultOptions",
"returns",
"the",
"default",
"encoding",
"options",
"."
] | 9147687966d9f3424e938ac93f70fbeae23f1321 | https://github.com/hjson/hjson-go/blob/9147687966d9f3424e938ac93f70fbeae23f1321/encode.go#L36-L46 |
16,001 | hjson/hjson-go | decode.go | Unmarshal | func Unmarshal(data []byte, v interface{}) (err error) {
var value interface{}
parser := &hjsonParser{data, 0, ' '}
parser.resetAt()
value, err = parser.rootValue()
if err != nil {
return err
}
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return errors.New("non-pointer " + reflect.TypeOf(v).String())
}
for rv.Kind() == reflect.Ptr {
rv = rv.Elem()
}
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
rv.Set(reflect.ValueOf(value))
return err
} | go | func Unmarshal(data []byte, v interface{}) (err error) {
var value interface{}
parser := &hjsonParser{data, 0, ' '}
parser.resetAt()
value, err = parser.rootValue()
if err != nil {
return err
}
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return errors.New("non-pointer " + reflect.TypeOf(v).String())
}
for rv.Kind() == reflect.Ptr {
rv = rv.Elem()
}
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
rv.Set(reflect.ValueOf(value))
return err
} | [
"func",
"Unmarshal",
"(",
"data",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"var",
"value",
"interface",
"{",
"}",
"\n",
"parser",
":=",
"&",
"hjsonParser",
"{",
"data",
",",
"0",
",",
"' '",
"}",
"\n"... | // Unmarshal parses the Hjson-encoded data and stores the result
// in the value pointed to by v.
//
// Unmarshal uses the inverse of the encodings that
// Marshal uses, allocating maps, slices, and pointers as necessary.
// | [
"Unmarshal",
"parses",
"the",
"Hjson",
"-",
"encoded",
"data",
"and",
"stores",
"the",
"result",
"in",
"the",
"value",
"pointed",
"to",
"by",
"v",
".",
"Unmarshal",
"uses",
"the",
"inverse",
"of",
"the",
"encodings",
"that",
"Marshal",
"uses",
"allocating",
... | 9147687966d9f3424e938ac93f70fbeae23f1321 | https://github.com/hjson/hjson-go/blob/9147687966d9f3424e938ac93f70fbeae23f1321/decode.go#L458-L481 |
16,002 | kylelemons/godebug | pretty/public.go | Sprint | func (cfg *Config) Sprint(vals ...interface{}) string {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.String()
} | go | func (cfg *Config) Sprint(vals ...interface{}) string {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.String()
} | [
"func",
"(",
"cfg",
"*",
"Config",
")",
"Sprint",
"(",
"vals",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"cfg",
".",
"fprint",
"(",
"buf",
",",
"vals",
"...",
")",
"\n",
"return"... | // Sprint returns a string representation of the given value according to cfg. | [
"Sprint",
"returns",
"a",
"string",
"representation",
"of",
"the",
"given",
"value",
"according",
"to",
"cfg",
"."
] | 009bb93e63da0d3607040fbc75007ff3e635a5a5 | https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L118-L122 |
16,003 | kylelemons/godebug | pretty/public.go | Fprint | func Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
return DefaultConfig.Fprint(w, vals...)
} | go | func Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
return DefaultConfig.Fprint(w, vals...)
} | [
"func",
"Fprint",
"(",
"w",
"io",
".",
"Writer",
",",
"vals",
"...",
"interface",
"{",
"}",
")",
"(",
"n",
"int64",
",",
"err",
"error",
")",
"{",
"return",
"DefaultConfig",
".",
"Fprint",
"(",
"w",
",",
"vals",
"...",
")",
"\n",
"}"
] | // Fprint writes the representation of the given value to the writer according to the DefaultConfig. | [
"Fprint",
"writes",
"the",
"representation",
"of",
"the",
"given",
"value",
"to",
"the",
"writer",
"according",
"to",
"the",
"DefaultConfig",
"."
] | 009bb93e63da0d3607040fbc75007ff3e635a5a5 | https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L125-L127 |
16,004 | kylelemons/godebug | pretty/public.go | Fprint | func (cfg *Config) Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.WriteTo(w)
} | go | func (cfg *Config) Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.WriteTo(w)
} | [
"func",
"(",
"cfg",
"*",
"Config",
")",
"Fprint",
"(",
"w",
"io",
".",
"Writer",
",",
"vals",
"...",
"interface",
"{",
"}",
")",
"(",
"n",
"int64",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"cfg"... | // Fprint writes the representation of the given value to the writer according to the cfg. | [
"Fprint",
"writes",
"the",
"representation",
"of",
"the",
"given",
"value",
"to",
"the",
"writer",
"according",
"to",
"the",
"cfg",
"."
] | 009bb93e63da0d3607040fbc75007ff3e635a5a5 | https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L130-L134 |
16,005 | kylelemons/godebug | pretty/public.go | Compare | func (cfg *Config) Compare(a, b interface{}) string {
diffCfg := *cfg
diffCfg.Diffable = true
return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
} | go | func (cfg *Config) Compare(a, b interface{}) string {
diffCfg := *cfg
diffCfg.Diffable = true
return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
} | [
"func",
"(",
"cfg",
"*",
"Config",
")",
"Compare",
"(",
"a",
",",
"b",
"interface",
"{",
"}",
")",
"string",
"{",
"diffCfg",
":=",
"*",
"cfg",
"\n",
"diffCfg",
".",
"Diffable",
"=",
"true",
"\n",
"return",
"diff",
".",
"Diff",
"(",
"cfg",
".",
"S... | // Compare returns a string containing a line-by-line unified diff of the
// values in got and want according to the cfg. | [
"Compare",
"returns",
"a",
"string",
"containing",
"a",
"line",
"-",
"by",
"-",
"line",
"unified",
"diff",
"of",
"the",
"values",
"in",
"got",
"and",
"want",
"according",
"to",
"the",
"cfg",
"."
] | 009bb93e63da0d3607040fbc75007ff3e635a5a5 | https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/pretty/public.go#L149-L153 |
16,006 | kylelemons/godebug | diff/diff.go | Diff | func Diff(A, B string) string {
aLines := strings.Split(A, "\n")
bLines := strings.Split(B, "\n")
chunks := DiffChunks(aLines, bLines)
buf := new(bytes.Buffer)
for _, c := range chunks {
for _, line := range c.Added {
fmt.Fprintf(buf, "+%s\n", line)
}
for _, line := range c.Deleted {
fmt.Fprintf(buf, "-%s\n", line)
}
for _, line := range c.Equal {
fmt.Fprintf(buf, " %s\n", line)
}
}
return strings.TrimRight(buf.String(), "\n")
} | go | func Diff(A, B string) string {
aLines := strings.Split(A, "\n")
bLines := strings.Split(B, "\n")
chunks := DiffChunks(aLines, bLines)
buf := new(bytes.Buffer)
for _, c := range chunks {
for _, line := range c.Added {
fmt.Fprintf(buf, "+%s\n", line)
}
for _, line := range c.Deleted {
fmt.Fprintf(buf, "-%s\n", line)
}
for _, line := range c.Equal {
fmt.Fprintf(buf, " %s\n", line)
}
}
return strings.TrimRight(buf.String(), "\n")
} | [
"func",
"Diff",
"(",
"A",
",",
"B",
"string",
")",
"string",
"{",
"aLines",
":=",
"strings",
".",
"Split",
"(",
"A",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"bLines",
":=",
"strings",
".",
"Split",
"(",
"B",
",",
"\"",
"\\n",
"\"",
")",
"\n\n",
"chu... | // Diff returns a string containing a line-by-line unified diff of the linewise
// changes required to make A into B. Each line is prefixed with '+', '-', or
// ' ' to indicate if it should be added, removed, or is correct respectively. | [
"Diff",
"returns",
"a",
"string",
"containing",
"a",
"line",
"-",
"by",
"-",
"line",
"unified",
"diff",
"of",
"the",
"linewise",
"changes",
"required",
"to",
"make",
"A",
"into",
"B",
".",
"Each",
"line",
"is",
"prefixed",
"with",
"+",
"-",
"or",
"to",... | 009bb93e63da0d3607040fbc75007ff3e635a5a5 | https://github.com/kylelemons/godebug/blob/009bb93e63da0d3607040fbc75007ff3e635a5a5/diff/diff.go#L41-L60 |
16,007 | pivotal-cf/brokerapi | domain/apiresponses/failure_responses.go | ValidatedStatusCode | func (f *FailureResponse) ValidatedStatusCode(logger lager.Logger) int {
if f.statusCode < 400 || 600 <= f.statusCode {
if logger != nil {
logger.Error("validating-status-code", fmt.Errorf("Invalid failure http response code: 600, expected 4xx or 5xx, returning internal server error: 500."))
}
return http.StatusInternalServerError
}
return f.statusCode
} | go | func (f *FailureResponse) ValidatedStatusCode(logger lager.Logger) int {
if f.statusCode < 400 || 600 <= f.statusCode {
if logger != nil {
logger.Error("validating-status-code", fmt.Errorf("Invalid failure http response code: 600, expected 4xx or 5xx, returning internal server error: 500."))
}
return http.StatusInternalServerError
}
return f.statusCode
} | [
"func",
"(",
"f",
"*",
"FailureResponse",
")",
"ValidatedStatusCode",
"(",
"logger",
"lager",
".",
"Logger",
")",
"int",
"{",
"if",
"f",
".",
"statusCode",
"<",
"400",
"||",
"600",
"<=",
"f",
".",
"statusCode",
"{",
"if",
"logger",
"!=",
"nil",
"{",
... | // ValidatedStatusCode returns the HTTP response status code. If the code is not 4xx
// or 5xx, an InternalServerError will be returned instead. | [
"ValidatedStatusCode",
"returns",
"the",
"HTTP",
"response",
"status",
"code",
".",
"If",
"the",
"code",
"is",
"not",
"4xx",
"or",
"5xx",
"an",
"InternalServerError",
"will",
"be",
"returned",
"instead",
"."
] | 0689a56bf95377293e632db1ad1432b311ff3962 | https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L49-L57 |
16,008 | pivotal-cf/brokerapi | domain/apiresponses/failure_responses.go | AppendErrorMessage | func (f *FailureResponse) AppendErrorMessage(msg string) *FailureResponse {
return &FailureResponse{
error: errors.New(fmt.Sprintf("%s %s", f.Error(), msg)),
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | go | func (f *FailureResponse) AppendErrorMessage(msg string) *FailureResponse {
return &FailureResponse{
error: errors.New(fmt.Sprintf("%s %s", f.Error(), msg)),
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | [
"func",
"(",
"f",
"*",
"FailureResponse",
")",
"AppendErrorMessage",
"(",
"msg",
"string",
")",
"*",
"FailureResponse",
"{",
"return",
"&",
"FailureResponse",
"{",
"error",
":",
"errors",
".",
"New",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"f",... | // AppendErrorMessage returns an error with the message updated. All other properties are preserved. | [
"AppendErrorMessage",
"returns",
"an",
"error",
"with",
"the",
"message",
"updated",
".",
"All",
"other",
"properties",
"are",
"preserved",
"."
] | 0689a56bf95377293e632db1ad1432b311ff3962 | https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L65-L73 |
16,009 | pivotal-cf/brokerapi | domain/apiresponses/failure_responses.go | NewFailureResponseBuilder | func NewFailureResponseBuilder(err error, statusCode int, loggerAction string) *FailureResponseBuilder {
return &FailureResponseBuilder{
error: err,
statusCode: statusCode,
loggerAction: loggerAction,
emptyResponse: false,
}
} | go | func NewFailureResponseBuilder(err error, statusCode int, loggerAction string) *FailureResponseBuilder {
return &FailureResponseBuilder{
error: err,
statusCode: statusCode,
loggerAction: loggerAction,
emptyResponse: false,
}
} | [
"func",
"NewFailureResponseBuilder",
"(",
"err",
"error",
",",
"statusCode",
"int",
",",
"loggerAction",
"string",
")",
"*",
"FailureResponseBuilder",
"{",
"return",
"&",
"FailureResponseBuilder",
"{",
"error",
":",
"err",
",",
"statusCode",
":",
"statusCode",
","... | // NewFailureResponseBuilder returns a pointer to a newly instantiated FailureResponseBuilder
// Accepts required arguments to create a FailureResponse. | [
"NewFailureResponseBuilder",
"returns",
"a",
"pointer",
"to",
"a",
"newly",
"instantiated",
"FailureResponseBuilder",
"Accepts",
"required",
"arguments",
"to",
"create",
"a",
"FailureResponse",
"."
] | 0689a56bf95377293e632db1ad1432b311ff3962 | https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L86-L93 |
16,010 | pivotal-cf/brokerapi | domain/apiresponses/failure_responses.go | WithErrorKey | func (f *FailureResponseBuilder) WithErrorKey(errorKey string) *FailureResponseBuilder {
f.errorKey = errorKey
return f
} | go | func (f *FailureResponseBuilder) WithErrorKey(errorKey string) *FailureResponseBuilder {
f.errorKey = errorKey
return f
} | [
"func",
"(",
"f",
"*",
"FailureResponseBuilder",
")",
"WithErrorKey",
"(",
"errorKey",
"string",
")",
"*",
"FailureResponseBuilder",
"{",
"f",
".",
"errorKey",
"=",
"errorKey",
"\n",
"return",
"f",
"\n",
"}"
] | // WithErrorKey adds a custom ErrorKey which will be used in FailureResponse to add an `Error`
// field to the JSON HTTP response body | [
"WithErrorKey",
"adds",
"a",
"custom",
"ErrorKey",
"which",
"will",
"be",
"used",
"in",
"FailureResponse",
"to",
"add",
"an",
"Error",
"field",
"to",
"the",
"JSON",
"HTTP",
"response",
"body"
] | 0689a56bf95377293e632db1ad1432b311ff3962 | https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L97-L100 |
16,011 | pivotal-cf/brokerapi | domain/apiresponses/failure_responses.go | Build | func (f *FailureResponseBuilder) Build() *FailureResponse {
return &FailureResponse{
error: f.error,
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | go | func (f *FailureResponseBuilder) Build() *FailureResponse {
return &FailureResponse{
error: f.error,
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | [
"func",
"(",
"f",
"*",
"FailureResponseBuilder",
")",
"Build",
"(",
")",
"*",
"FailureResponse",
"{",
"return",
"&",
"FailureResponse",
"{",
"error",
":",
"f",
".",
"error",
",",
"statusCode",
":",
"f",
".",
"statusCode",
",",
"loggerAction",
":",
"f",
"... | // Build returns the generated FailureResponse built using previously configured variables. | [
"Build",
"returns",
"the",
"generated",
"FailureResponse",
"built",
"using",
"previously",
"configured",
"variables",
"."
] | 0689a56bf95377293e632db1ad1432b311ff3962 | https://github.com/pivotal-cf/brokerapi/blob/0689a56bf95377293e632db1ad1432b311ff3962/domain/apiresponses/failure_responses.go#L110-L118 |
16,012 | jonas747/dca | dca.go | DecodeFrame | func DecodeFrame(r io.Reader) (frame []byte, err error) {
var size int16
err = binary.Read(r, binary.LittleEndian, &size)
if err != nil {
return
}
if size < 0 {
return nil, ErrNegativeFrameSize
}
frame = make([]byte, size)
err = binary.Read(r, binary.LittleEndian, &frame)
return
} | go | func DecodeFrame(r io.Reader) (frame []byte, err error) {
var size int16
err = binary.Read(r, binary.LittleEndian, &size)
if err != nil {
return
}
if size < 0 {
return nil, ErrNegativeFrameSize
}
frame = make([]byte, size)
err = binary.Read(r, binary.LittleEndian, &frame)
return
} | [
"func",
"DecodeFrame",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"frame",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"size",
"int16",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"si... | // DecodeFrame decodes a dca frame from an io.Reader and returns the raw opus audio ready to be sent to discord | [
"DecodeFrame",
"decodes",
"a",
"dca",
"frame",
"from",
"an",
"io",
".",
"Reader",
"and",
"returns",
"the",
"raw",
"opus",
"audio",
"ready",
"to",
"be",
"sent",
"to",
"discord"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/dca.go#L54-L68 |
16,013 | jonas747/dca | decode.go | NewDecoder | func NewDecoder(r io.Reader) *Decoder {
decoder := &Decoder{
r: bufio.NewReader(r),
}
return decoder
} | go | func NewDecoder(r io.Reader) *Decoder {
decoder := &Decoder{
r: bufio.NewReader(r),
}
return decoder
} | [
"func",
"NewDecoder",
"(",
"r",
"io",
".",
"Reader",
")",
"*",
"Decoder",
"{",
"decoder",
":=",
"&",
"Decoder",
"{",
"r",
":",
"bufio",
".",
"NewReader",
"(",
"r",
")",
",",
"}",
"\n\n",
"return",
"decoder",
"\n",
"}"
] | // NewDecoder returns a new dca decoder | [
"NewDecoder",
"returns",
"a",
"new",
"dca",
"decoder"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L29-L35 |
16,014 | jonas747/dca | decode.go | ReadMetadata | func (d *Decoder) ReadMetadata() error {
if d.firstFrameProcessed {
return ErrNotFirstFrame
}
d.firstFrameProcessed = true
fingerprint, err := d.r.Peek(4)
if err != nil {
return err
}
if string(fingerprint[:3]) != "DCA" {
return ErrNotDCA
}
// We just peeked earlier, mark this portion as read
d.r.Discard(4)
// Read the format version
version, err := strconv.ParseInt(string(fingerprint[3:]), 10, 32)
if err != nil {
return err
}
d.FormatVersion = int(version)
// The length of the metadata
var metaLen int32
err = binary.Read(d.r, binary.LittleEndian, &metaLen)
if err != nil {
return err
}
// Read in the metadata itself
jsonBuf := make([]byte, metaLen)
err = binary.Read(d.r, binary.LittleEndian, &jsonBuf)
if err != nil {
return err
}
// And unmarshal it
var metadata *Metadata
err = json.Unmarshal(jsonBuf, &metadata)
d.Metadata = metadata
return err
} | go | func (d *Decoder) ReadMetadata() error {
if d.firstFrameProcessed {
return ErrNotFirstFrame
}
d.firstFrameProcessed = true
fingerprint, err := d.r.Peek(4)
if err != nil {
return err
}
if string(fingerprint[:3]) != "DCA" {
return ErrNotDCA
}
// We just peeked earlier, mark this portion as read
d.r.Discard(4)
// Read the format version
version, err := strconv.ParseInt(string(fingerprint[3:]), 10, 32)
if err != nil {
return err
}
d.FormatVersion = int(version)
// The length of the metadata
var metaLen int32
err = binary.Read(d.r, binary.LittleEndian, &metaLen)
if err != nil {
return err
}
// Read in the metadata itself
jsonBuf := make([]byte, metaLen)
err = binary.Read(d.r, binary.LittleEndian, &jsonBuf)
if err != nil {
return err
}
// And unmarshal it
var metadata *Metadata
err = json.Unmarshal(jsonBuf, &metadata)
d.Metadata = metadata
return err
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"ReadMetadata",
"(",
")",
"error",
"{",
"if",
"d",
".",
"firstFrameProcessed",
"{",
"return",
"ErrNotFirstFrame",
"\n",
"}",
"\n",
"d",
".",
"firstFrameProcessed",
"=",
"true",
"\n\n",
"fingerprint",
",",
"err",
":=",... | // ReadMetadata reads the first metadata frame
// OpusFrame will call this automatically if | [
"ReadMetadata",
"reads",
"the",
"first",
"metadata",
"frame",
"OpusFrame",
"will",
"call",
"this",
"automatically",
"if"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L39-L83 |
16,015 | jonas747/dca | decode.go | OpusFrame | func (d *Decoder) OpusFrame() (frame []byte, err error) {
if !d.firstFrameProcessed {
// Check to see if this contains metadata and read the metadata if so
magic, err := d.r.Peek(3)
if err != nil {
return nil, err
}
if string(magic) == "DCA" {
err = d.ReadMetadata()
if err != nil {
return nil, err
}
}
}
frame, err = DecodeFrame(d.r)
return
} | go | func (d *Decoder) OpusFrame() (frame []byte, err error) {
if !d.firstFrameProcessed {
// Check to see if this contains metadata and read the metadata if so
magic, err := d.r.Peek(3)
if err != nil {
return nil, err
}
if string(magic) == "DCA" {
err = d.ReadMetadata()
if err != nil {
return nil, err
}
}
}
frame, err = DecodeFrame(d.r)
return
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"OpusFrame",
"(",
")",
"(",
"frame",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"if",
"!",
"d",
".",
"firstFrameProcessed",
"{",
"// Check to see if this contains metadata and read the metadata if so",
"magic",
",",
... | // OpusFrame returns the next audio frame
// If this is the first frame it will also check for metadata in it | [
"OpusFrame",
"returns",
"the",
"next",
"audio",
"frame",
"If",
"this",
"is",
"the",
"first",
"frame",
"it",
"will",
"also",
"check",
"for",
"metadata",
"in",
"it"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L87-L105 |
16,016 | jonas747/dca | decode.go | FrameDuration | func (d *Decoder) FrameDuration() time.Duration {
if d.Metadata == nil {
return 20
}
// I don't understand nick, why does it have to be like this nick, please nick, im not having a good time nick.
// 960B = pcm framesize of 20ms 1 channel audio
return time.Duration(((d.Metadata.Opus.FrameSize/d.Metadata.Opus.Channels)/960)*20) * time.Millisecond
} | go | func (d *Decoder) FrameDuration() time.Duration {
if d.Metadata == nil {
return 20
}
// I don't understand nick, why does it have to be like this nick, please nick, im not having a good time nick.
// 960B = pcm framesize of 20ms 1 channel audio
return time.Duration(((d.Metadata.Opus.FrameSize/d.Metadata.Opus.Channels)/960)*20) * time.Millisecond
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"FrameDuration",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"d",
".",
"Metadata",
"==",
"nil",
"{",
"return",
"20",
"\n",
"}",
"\n\n",
"// I don't understand nick, why does it have to be like this nick, please nick, im not h... | // FrameDuration implements OpusReader, returnining the specified duration per frame | [
"FrameDuration",
"implements",
"OpusReader",
"returnining",
"the",
"specified",
"duration",
"per",
"frame"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/decode.go#L108-L116 |
16,017 | jonas747/dca | stream.go | PlaybackPosition | func (s *StreamingSession) PlaybackPosition() time.Duration {
s.Lock()
dur := time.Duration(s.framesSent) * s.source.FrameDuration()
s.Unlock()
return dur
} | go | func (s *StreamingSession) PlaybackPosition() time.Duration {
s.Lock()
dur := time.Duration(s.framesSent) * s.source.FrameDuration()
s.Unlock()
return dur
} | [
"func",
"(",
"s",
"*",
"StreamingSession",
")",
"PlaybackPosition",
"(",
")",
"time",
".",
"Duration",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"dur",
":=",
"time",
".",
"Duration",
"(",
"s",
".",
"framesSent",
")",
"*",
"s",
".",
"source",
".",
"Fra... | // PlaybackPosition returns the the duration of content we have transmitted so far | [
"PlaybackPosition",
"returns",
"the",
"the",
"duration",
"of",
"content",
"we",
"have",
"transmitted",
"so",
"far"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/stream.go#L160-L165 |
16,018 | jonas747/dca | stream.go | Finished | func (s *StreamingSession) Finished() (bool, error) {
s.Lock()
err := s.err
fin := s.finished
s.Unlock()
return fin, err
} | go | func (s *StreamingSession) Finished() (bool, error) {
s.Lock()
err := s.err
fin := s.finished
s.Unlock()
return fin, err
} | [
"func",
"(",
"s",
"*",
"StreamingSession",
")",
"Finished",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"err",
":=",
"s",
".",
"err",
"\n",
"fin",
":=",
"s",
".",
"finished",
"\n",
"s",
".",
"Unlock",
"(",
... | // Finished returns wether the stream finished or not, and any error that caused it to stop | [
"Finished",
"returns",
"wether",
"the",
"stream",
"finished",
"or",
"not",
"and",
"any",
"error",
"that",
"caused",
"it",
"to",
"stop"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/stream.go#L168-L175 |
16,019 | jonas747/dca | stream.go | Paused | func (s *StreamingSession) Paused() bool {
s.Lock()
p := s.paused
s.Unlock()
return p
} | go | func (s *StreamingSession) Paused() bool {
s.Lock()
p := s.paused
s.Unlock()
return p
} | [
"func",
"(",
"s",
"*",
"StreamingSession",
")",
"Paused",
"(",
")",
"bool",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"p",
":=",
"s",
".",
"paused",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
"\n",
"}"
] | // Paused returns wether the sream is paused or not | [
"Paused",
"returns",
"wether",
"the",
"sream",
"is",
"paused",
"or",
"not"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/stream.go#L178-L184 |
16,020 | jonas747/dca | encode.go | Validate | func (opts *EncodeOptions) Validate() error {
if opts.Volume < 0 || opts.Volume > 512 {
return errors.New("Out of bounds volume (0-512)")
}
if opts.FrameDuration != 20 && opts.FrameDuration != 40 && opts.FrameDuration != 60 {
return errors.New("Invalid FrameDuration")
}
if opts.PacketLoss < 0 || opts.PacketLoss > 100 {
return errors.New("Invalid packet loss percentage")
}
if opts.Application != AudioApplicationAudio && opts.Application != AudioApplicationVoip && opts.Application != AudioApplicationLowDelay {
return errors.New("Invalid audio application")
}
if opts.CompressionLevel < 0 || opts.CompressionLevel > 10 {
return errors.New("Compression level out of bounds (0-10)")
}
if opts.Threads < 0 {
return errors.New("Number of threads can't be less than 0")
}
return nil
} | go | func (opts *EncodeOptions) Validate() error {
if opts.Volume < 0 || opts.Volume > 512 {
return errors.New("Out of bounds volume (0-512)")
}
if opts.FrameDuration != 20 && opts.FrameDuration != 40 && opts.FrameDuration != 60 {
return errors.New("Invalid FrameDuration")
}
if opts.PacketLoss < 0 || opts.PacketLoss > 100 {
return errors.New("Invalid packet loss percentage")
}
if opts.Application != AudioApplicationAudio && opts.Application != AudioApplicationVoip && opts.Application != AudioApplicationLowDelay {
return errors.New("Invalid audio application")
}
if opts.CompressionLevel < 0 || opts.CompressionLevel > 10 {
return errors.New("Compression level out of bounds (0-10)")
}
if opts.Threads < 0 {
return errors.New("Number of threads can't be less than 0")
}
return nil
} | [
"func",
"(",
"opts",
"*",
"EncodeOptions",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"opts",
".",
"Volume",
"<",
"0",
"||",
"opts",
".",
"Volume",
">",
"512",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if"... | // Validate returns an error if the options are not correct | [
"Validate",
"returns",
"an",
"error",
"if",
"the",
"options",
"are",
"not",
"correct"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L65-L91 |
16,021 | jonas747/dca | encode.go | EncodeMem | func EncodeMem(r io.Reader, options *EncodeOptions) (session *EncodeSession, err error) {
err = options.Validate()
if err != nil {
return
}
session = &EncodeSession{
options: options,
pipeReader: r,
frameChannel: make(chan *Frame, options.BufferedFrames),
}
go session.run()
return
} | go | func EncodeMem(r io.Reader, options *EncodeOptions) (session *EncodeSession, err error) {
err = options.Validate()
if err != nil {
return
}
session = &EncodeSession{
options: options,
pipeReader: r,
frameChannel: make(chan *Frame, options.BufferedFrames),
}
go session.run()
return
} | [
"func",
"EncodeMem",
"(",
"r",
"io",
".",
"Reader",
",",
"options",
"*",
"EncodeOptions",
")",
"(",
"session",
"*",
"EncodeSession",
",",
"err",
"error",
")",
"{",
"err",
"=",
"options",
".",
"Validate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",... | // EncodedMem encodes data from memory | [
"EncodedMem",
"encodes",
"data",
"from",
"memory"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L143-L156 |
16,022 | jonas747/dca | encode.go | Stop | func (e *EncodeSession) Stop() error {
e.Lock()
defer e.Unlock()
if !e.running || e.process == nil {
return errors.New("Not running")
}
err := e.process.Kill()
return err
} | go | func (e *EncodeSession) Stop() error {
e.Lock()
defer e.Unlock()
if !e.running || e.process == nil {
return errors.New("Not running")
}
err := e.process.Kill()
return err
} | [
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"Stop",
"(",
")",
"error",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"e",
".",
"running",
"||",
"e",
".",
"process",
"==",
"nil",
"{",
"return",
... | // Stop stops the encoding session | [
"Stop",
"stops",
"the",
"encoding",
"session"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L541-L550 |
16,023 | jonas747/dca | encode.go | OpusFrame | func (e *EncodeSession) OpusFrame() (frame []byte, err error) {
f := <-e.frameChannel
if f == nil {
return nil, io.EOF
}
if f.metaData {
// Return the next one then...
return e.OpusFrame()
}
if len(f.data) < 2 {
return nil, ErrBadFrame
}
return f.data[2:], nil
} | go | func (e *EncodeSession) OpusFrame() (frame []byte, err error) {
f := <-e.frameChannel
if f == nil {
return nil, io.EOF
}
if f.metaData {
// Return the next one then...
return e.OpusFrame()
}
if len(f.data) < 2 {
return nil, ErrBadFrame
}
return f.data[2:], nil
} | [
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"OpusFrame",
"(",
")",
"(",
"frame",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"f",
":=",
"<-",
"e",
".",
"frameChannel",
"\n",
"if",
"f",
"==",
"nil",
"{",
"return",
"nil",
",",
"io",
".",
"E... | // OpusFrame implements OpusReader, returning the next opus frame | [
"OpusFrame",
"implements",
"OpusReader",
"returning",
"the",
"next",
"opus",
"frame"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L564-L580 |
16,024 | jonas747/dca | encode.go | Running | func (e *EncodeSession) Running() (running bool) {
e.Lock()
running = e.running
e.Unlock()
return
} | go | func (e *EncodeSession) Running() (running bool) {
e.Lock()
running = e.running
e.Unlock()
return
} | [
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"Running",
"(",
")",
"(",
"running",
"bool",
")",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"running",
"=",
"e",
".",
"running",
"\n",
"e",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] | // Running returns true if running | [
"Running",
"returns",
"true",
"if",
"running"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L583-L588 |
16,025 | jonas747/dca | encode.go | FrameDuration | func (e *EncodeSession) FrameDuration() time.Duration {
return time.Duration(e.options.FrameDuration) * time.Millisecond
} | go | func (e *EncodeSession) FrameDuration() time.Duration {
return time.Duration(e.options.FrameDuration) * time.Millisecond
} | [
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"FrameDuration",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Duration",
"(",
"e",
".",
"options",
".",
"FrameDuration",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"}"
] | // FrameDuration implements OpusReader, retruning the duratio of each frame | [
"FrameDuration",
"implements",
"OpusReader",
"retruning",
"the",
"duratio",
"of",
"each",
"frame"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L646-L648 |
16,026 | jonas747/dca | encode.go | Error | func (e *EncodeSession) Error() error {
e.Lock()
defer e.Unlock()
return e.err
} | go | func (e *EncodeSession) Error() error {
e.Lock()
defer e.Unlock()
return e.err
} | [
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"Error",
"(",
")",
"error",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"Unlock",
"(",
")",
"\n",
"return",
"e",
".",
"err",
"\n",
"}"
] | // Error returns any error that occured during the encoding process | [
"Error",
"returns",
"any",
"error",
"that",
"occured",
"during",
"the",
"encoding",
"process"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L651-L655 |
16,027 | jonas747/dca | encode.go | FFMPEGMessages | func (e *EncodeSession) FFMPEGMessages() string {
e.Lock()
output := e.ffmpegOutput
e.Unlock()
return output
} | go | func (e *EncodeSession) FFMPEGMessages() string {
e.Lock()
output := e.ffmpegOutput
e.Unlock()
return output
} | [
"func",
"(",
"e",
"*",
"EncodeSession",
")",
"FFMPEGMessages",
"(",
")",
"string",
"{",
"e",
".",
"Lock",
"(",
")",
"\n",
"output",
":=",
"e",
".",
"ffmpegOutput",
"\n",
"e",
".",
"Unlock",
"(",
")",
"\n",
"return",
"output",
"\n",
"}"
] | // FFMPEGMessages returns messages printed by ffmpeg to stderr, you can use this to see what ffmpeg is saying if your encoding fails | [
"FFMPEGMessages",
"returns",
"messages",
"printed",
"by",
"ffmpeg",
"to",
"stderr",
"you",
"can",
"use",
"this",
"to",
"see",
"what",
"ffmpeg",
"is",
"saying",
"if",
"your",
"encoding",
"fails"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/encode.go#L658-L663 |
16,028 | jonas747/dca | cmd/dca/main.go | init | func init() {
flag.StringVar(&InFile, "i", "pipe:0", "infile")
flag.IntVar(&Volume, "vol", 256, "change audio volume (256=normal)")
flag.IntVar(&Channels, "ac", 2, "audio channels")
flag.IntVar(&FrameRate, "ar", 48000, "audio sampling rate")
flag.IntVar(&FrameDuration, "as", 20, "audio frame duration can be 20, 40, or 60 (ms)")
flag.IntVar(&Bitrate, "ab", 128, "audio encoding bitrate in kb/s can be 8 - 128")
flag.IntVar(&Threads, "threads", 0, "number of threads to use, 0 for auto")
flag.BoolVar(&VBR, "vbr", true, "variable bitrate")
flag.BoolVar(&RawOutput, "raw", false, "Raw opus output (no metadata or magic bytes)")
flag.StringVar(&Application, "aa", "audio", "audio application can be voip, audio, or lowdelay")
flag.StringVar(&CoverFormat, "cf", "jpeg", "format the cover art will be encoded with")
flag.StringVar(&Comment, "com", "", "leave a comment in the metadata")
flag.BoolVar(&Quiet, "quiet", false, "disable stats output to stderr")
flag.Parse()
} | go | func init() {
flag.StringVar(&InFile, "i", "pipe:0", "infile")
flag.IntVar(&Volume, "vol", 256, "change audio volume (256=normal)")
flag.IntVar(&Channels, "ac", 2, "audio channels")
flag.IntVar(&FrameRate, "ar", 48000, "audio sampling rate")
flag.IntVar(&FrameDuration, "as", 20, "audio frame duration can be 20, 40, or 60 (ms)")
flag.IntVar(&Bitrate, "ab", 128, "audio encoding bitrate in kb/s can be 8 - 128")
flag.IntVar(&Threads, "threads", 0, "number of threads to use, 0 for auto")
flag.BoolVar(&VBR, "vbr", true, "variable bitrate")
flag.BoolVar(&RawOutput, "raw", false, "Raw opus output (no metadata or magic bytes)")
flag.StringVar(&Application, "aa", "audio", "audio application can be voip, audio, or lowdelay")
flag.StringVar(&CoverFormat, "cf", "jpeg", "format the cover art will be encoded with")
flag.StringVar(&Comment, "com", "", "leave a comment in the metadata")
flag.BoolVar(&Quiet, "quiet", false, "disable stats output to stderr")
flag.Parse()
} | [
"func",
"init",
"(",
")",
"{",
"flag",
".",
"StringVar",
"(",
"&",
"InFile",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"IntVar",
"(",
"&",
"Volume",
",",
"\"",
"\"",
",",
"256",
",",
"\"",
"\"",
")",
"\n",
"... | // init configures and parses the command line arguments | [
"init",
"configures",
"and",
"parses",
"the",
"command",
"line",
"arguments"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/cmd/dca/main.go#L59-L76 |
16,029 | jonas747/dca | cmd/dca/main.go | main | func main() {
//////////////////////////////////////////////////////////////////////////
// BLOCK : Basic setup and validation
//////////////////////////////////////////////////////////////////////////
// If only one argument provided assume it's a filename.
if len(os.Args) == 2 {
InFile = os.Args[1]
}
// If reading from a file, verify it exists.
if InFile != "pipe:0" {
if _, err := os.Stat(InFile); os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "warning: infile does not exist as a file on this system, will still continue on incase this is something else that ffmpeg accepts")
}
}
// If reading from pipe, make sure pipe is open
if InFile == "pipe:0" {
fi, err := os.Stdin.Stat()
if err != nil {
fmt.Println(err)
return
}
if (fi.Mode() & os.ModeCharDevice) == 0 {
} else {
fmt.Fprintln(os.Stderr, "error: stdin is not a pipe.")
flag.Usage()
return
}
}
if Bitrate < 1 || Bitrate > 512 {
Bitrate = 64 // Set to Discord default
}
//////////////////////////////////////////////////////////////////////////
// BLOCK : Start reader and writer workers
//////////////////////////////////////////////////////////////////////////
options := &dca.EncodeOptions{
Volume: Volume,
Channels: Channels,
FrameRate: FrameRate,
FrameDuration: FrameDuration,
Bitrate: Bitrate,
RawOutput: RawOutput,
Application: dca.AudioApplication(Application),
CoverFormat: CoverFormat,
VBR: VBR,
Comment: Comment,
Threads: Threads,
}
var session *dca.EncodeSession
var output = os.Stdout
if InFile == "pipe:0" {
session, err = dca.EncodeMem(os.Stdin, options)
} else {
session, err = dca.EncodeFile(InFile, options)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Failed creating an encoding session: ", err)
os.Exit(1)
}
if !Quiet {
go statusPrinter(session)
}
_, err := io.Copy(output, session)
if err != nil {
fmt.Fprintln(os.Stderr, "\nError writing:", err)
os.Exit(1)
} else if !Quiet {
fmt.Fprintf(os.Stderr, "\nFinished encoding\n")
fmt.Fprint(os.Stderr, "ffmpeg output\n\n", session.FFMPEGMessages())
}
} | go | func main() {
//////////////////////////////////////////////////////////////////////////
// BLOCK : Basic setup and validation
//////////////////////////////////////////////////////////////////////////
// If only one argument provided assume it's a filename.
if len(os.Args) == 2 {
InFile = os.Args[1]
}
// If reading from a file, verify it exists.
if InFile != "pipe:0" {
if _, err := os.Stat(InFile); os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "warning: infile does not exist as a file on this system, will still continue on incase this is something else that ffmpeg accepts")
}
}
// If reading from pipe, make sure pipe is open
if InFile == "pipe:0" {
fi, err := os.Stdin.Stat()
if err != nil {
fmt.Println(err)
return
}
if (fi.Mode() & os.ModeCharDevice) == 0 {
} else {
fmt.Fprintln(os.Stderr, "error: stdin is not a pipe.")
flag.Usage()
return
}
}
if Bitrate < 1 || Bitrate > 512 {
Bitrate = 64 // Set to Discord default
}
//////////////////////////////////////////////////////////////////////////
// BLOCK : Start reader and writer workers
//////////////////////////////////////////////////////////////////////////
options := &dca.EncodeOptions{
Volume: Volume,
Channels: Channels,
FrameRate: FrameRate,
FrameDuration: FrameDuration,
Bitrate: Bitrate,
RawOutput: RawOutput,
Application: dca.AudioApplication(Application),
CoverFormat: CoverFormat,
VBR: VBR,
Comment: Comment,
Threads: Threads,
}
var session *dca.EncodeSession
var output = os.Stdout
if InFile == "pipe:0" {
session, err = dca.EncodeMem(os.Stdin, options)
} else {
session, err = dca.EncodeFile(InFile, options)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Failed creating an encoding session: ", err)
os.Exit(1)
}
if !Quiet {
go statusPrinter(session)
}
_, err := io.Copy(output, session)
if err != nil {
fmt.Fprintln(os.Stderr, "\nError writing:", err)
os.Exit(1)
} else if !Quiet {
fmt.Fprintf(os.Stderr, "\nFinished encoding\n")
fmt.Fprint(os.Stderr, "ffmpeg output\n\n", session.FFMPEGMessages())
}
} | [
"func",
"main",
"(",
")",
"{",
"//////////////////////////////////////////////////////////////////////////",
"// BLOCK : Basic setup and validation",
"//////////////////////////////////////////////////////////////////////////",
"// If only one argument provided assume it's a filename.",
"if",
"l... | // very simple program that wraps ffmpeg and outputs raw opus data frames
// with a uint16 header for each frame with the frame length in bytes | [
"very",
"simple",
"program",
"that",
"wraps",
"ffmpeg",
"and",
"outputs",
"raw",
"opus",
"data",
"frames",
"with",
"a",
"uint16",
"header",
"for",
"each",
"frame",
"with",
"the",
"frame",
"length",
"in",
"bytes"
] | 10e959e9d3e808cd961308760de0c1c36285fed7 | https://github.com/jonas747/dca/blob/10e959e9d3e808cd961308760de0c1c36285fed7/cmd/dca/main.go#L80-L162 |
16,030 | aerokube/ggr | proxy.go | WithSuitableAuthentication | func WithSuitableAuthentication(authenticator *auth.BasicAuth, handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
if !guestAccessAllowed {
//All requests require authentication
requireBasicAuth(authenticator, handler)(w, r)
} else if _, _, basicAuthPresent := r.BasicAuth(); !basicAuthPresent {
//Run the handler as unauthenticated user
confLock.RLock()
_, ok := quota[guestUserName]
confLock.RUnlock()
if !ok {
reply(w, errMsg("Guest access is unavailable"), http.StatusUnauthorized)
} else {
handler(w, r)
}
} else {
//Run the handler using basic authentication
if fileExists(users) {
requireBasicAuth(authenticator, handler)(w, r)
} else {
handler(w, r)
}
}
}
} | go | func WithSuitableAuthentication(authenticator *auth.BasicAuth, handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
if !guestAccessAllowed {
//All requests require authentication
requireBasicAuth(authenticator, handler)(w, r)
} else if _, _, basicAuthPresent := r.BasicAuth(); !basicAuthPresent {
//Run the handler as unauthenticated user
confLock.RLock()
_, ok := quota[guestUserName]
confLock.RUnlock()
if !ok {
reply(w, errMsg("Guest access is unavailable"), http.StatusUnauthorized)
} else {
handler(w, r)
}
} else {
//Run the handler using basic authentication
if fileExists(users) {
requireBasicAuth(authenticator, handler)(w, r)
} else {
handler(w, r)
}
}
}
} | [
"func",
"WithSuitableAuthentication",
"(",
"authenticator",
"*",
"auth",
".",
"BasicAuth",
",",
"handler",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
")",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
... | //WithSuitableAuthentication handles basic authentication and guest quota processing | [
"WithSuitableAuthentication",
"handles",
"basic",
"authentication",
"and",
"guest",
"quota",
"processing"
] | 7fd402dceba08932f755f8ea29295e4826c025ee | https://github.com/aerokube/ggr/blob/7fd402dceba08932f755f8ea29295e4826c025ee/proxy.go#L589-L613 |
16,031 | nu7hatch/gouuid | uuid.go | Parse | func Parse(b []byte) (u *UUID, err error) {
if len(b) != 16 {
err = errors.New("Given slice is not valid UUID sequence")
return
}
u = new(UUID)
copy(u[:], b)
return
} | go | func Parse(b []byte) (u *UUID, err error) {
if len(b) != 16 {
err = errors.New("Given slice is not valid UUID sequence")
return
}
u = new(UUID)
copy(u[:], b)
return
} | [
"func",
"Parse",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"b",
")",
"!=",
"16",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
... | // Parse creates a UUID object from given bytes slice. | [
"Parse",
"creates",
"a",
"UUID",
"object",
"from",
"given",
"bytes",
"slice",
"."
] | 179d4d0c4d8d407a32af483c2354df1d2c91e6c3 | https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L73-L81 |
16,032 | nu7hatch/gouuid | uuid.go | NewV3 | func NewV3(ns *UUID, name []byte) (u *UUID, err error) {
if ns == nil {
err = errors.New("Invalid namespace UUID")
return
}
u = new(UUID)
// Set all bits to MD5 hash generated from namespace and name.
u.setBytesFromHash(md5.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(3)
return
} | go | func NewV3(ns *UUID, name []byte) (u *UUID, err error) {
if ns == nil {
err = errors.New("Invalid namespace UUID")
return
}
u = new(UUID)
// Set all bits to MD5 hash generated from namespace and name.
u.setBytesFromHash(md5.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(3)
return
} | [
"func",
"NewV3",
"(",
"ns",
"*",
"UUID",
",",
"name",
"[",
"]",
"byte",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"if",
"ns",
"==",
"nil",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"... | // Generate a UUID based on the MD5 hash of a namespace identifier
// and a name. | [
"Generate",
"a",
"UUID",
"based",
"on",
"the",
"MD5",
"hash",
"of",
"a",
"namespace",
"identifier",
"and",
"a",
"name",
"."
] | 179d4d0c4d8d407a32af483c2354df1d2c91e6c3 | https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L85-L96 |
16,033 | nu7hatch/gouuid | uuid.go | NewV4 | func NewV4() (u *UUID, err error) {
u = new(UUID)
// Set all bits to randomly (or pseudo-randomly) chosen values.
_, err = rand.Read(u[:])
if err != nil {
return
}
u.setVariant(ReservedRFC4122)
u.setVersion(4)
return
} | go | func NewV4() (u *UUID, err error) {
u = new(UUID)
// Set all bits to randomly (or pseudo-randomly) chosen values.
_, err = rand.Read(u[:])
if err != nil {
return
}
u.setVariant(ReservedRFC4122)
u.setVersion(4)
return
} | [
"func",
"NewV4",
"(",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"u",
"=",
"new",
"(",
"UUID",
")",
"\n",
"// Set all bits to randomly (or pseudo-randomly) chosen values.",
"_",
",",
"err",
"=",
"rand",
".",
"Read",
"(",
"u",
"[",
":",
... | // Generate a random UUID. | [
"Generate",
"a",
"random",
"UUID",
"."
] | 179d4d0c4d8d407a32af483c2354df1d2c91e6c3 | https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L99-L109 |
16,034 | nu7hatch/gouuid | uuid.go | NewV5 | func NewV5(ns *UUID, name []byte) (u *UUID, err error) {
u = new(UUID)
// Set all bits to truncated SHA1 hash generated from namespace
// and name.
u.setBytesFromHash(sha1.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(5)
return
} | go | func NewV5(ns *UUID, name []byte) (u *UUID, err error) {
u = new(UUID)
// Set all bits to truncated SHA1 hash generated from namespace
// and name.
u.setBytesFromHash(sha1.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(5)
return
} | [
"func",
"NewV5",
"(",
"ns",
"*",
"UUID",
",",
"name",
"[",
"]",
"byte",
")",
"(",
"u",
"*",
"UUID",
",",
"err",
"error",
")",
"{",
"u",
"=",
"new",
"(",
"UUID",
")",
"\n",
"// Set all bits to truncated SHA1 hash generated from namespace",
"// and name.",
"... | // Generate a UUID based on the SHA-1 hash of a namespace identifier
// and a name. | [
"Generate",
"a",
"UUID",
"based",
"on",
"the",
"SHA",
"-",
"1",
"hash",
"of",
"a",
"namespace",
"identifier",
"and",
"a",
"name",
"."
] | 179d4d0c4d8d407a32af483c2354df1d2c91e6c3 | https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L113-L121 |
16,035 | nu7hatch/gouuid | uuid.go | setBytesFromHash | func (u *UUID) setBytesFromHash(hash hash.Hash, ns, name []byte) {
hash.Write(ns[:])
hash.Write(name)
copy(u[:], hash.Sum([]byte{})[:16])
} | go | func (u *UUID) setBytesFromHash(hash hash.Hash, ns, name []byte) {
hash.Write(ns[:])
hash.Write(name)
copy(u[:], hash.Sum([]byte{})[:16])
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"setBytesFromHash",
"(",
"hash",
"hash",
".",
"Hash",
",",
"ns",
",",
"name",
"[",
"]",
"byte",
")",
"{",
"hash",
".",
"Write",
"(",
"ns",
"[",
":",
"]",
")",
"\n",
"hash",
".",
"Write",
"(",
"name",
")",
"... | // Generate a MD5 hash of a namespace and a name, and copy it to the
// UUID slice. | [
"Generate",
"a",
"MD5",
"hash",
"of",
"a",
"namespace",
"and",
"a",
"name",
"and",
"copy",
"it",
"to",
"the",
"UUID",
"slice",
"."
] | 179d4d0c4d8d407a32af483c2354df1d2c91e6c3 | https://github.com/nu7hatch/gouuid/blob/179d4d0c4d8d407a32af483c2354df1d2c91e6c3/uuid.go#L125-L129 |
16,036 | michaelklishin/rabbit-hole | vhosts.go | ListVhosts | func (c *Client) ListVhosts() (rec []VhostInfo, err error) {
req, err := newGETRequest(c, "vhosts")
if err != nil {
return []VhostInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []VhostInfo{}, err
}
return rec, nil
} | go | func (c *Client) ListVhosts() (rec []VhostInfo, err error) {
req, err := newGETRequest(c, "vhosts")
if err != nil {
return []VhostInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []VhostInfo{}, err
}
return rec, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListVhosts",
"(",
")",
"(",
"rec",
"[",
"]",
"VhostInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"retu... | // ListVhosts returns a list of virtual hosts. | [
"ListVhosts",
"returns",
"a",
"list",
"of",
"virtual",
"hosts",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/vhosts.go#L81-L92 |
16,037 | michaelklishin/rabbit-hole | vhosts.go | PutVhost | func (c *Client) PutVhost(vhostname string, settings VhostSettings) (res *http.Response, err error) {
body, err := json.Marshal(settings)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "vhosts/"+PathEscape(vhostname), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | go | func (c *Client) PutVhost(vhostname string, settings VhostSettings) (res *http.Response, err error) {
body, err := json.Marshal(settings)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "vhosts/"+PathEscape(vhostname), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PutVhost",
"(",
"vhostname",
"string",
",",
"settings",
"VhostSettings",
")",
"(",
"res",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"sett... | // Creates or updates a virtual host. | [
"Creates",
"or",
"updates",
"a",
"virtual",
"host",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/vhosts.go#L123-L140 |
16,038 | michaelklishin/rabbit-hole | client.go | NewTLSClient | func NewTLSClient(uri string, username string, password string, transport http.RoundTripper) (me *Client, err error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
me = &Client{
Endpoint: uri,
host: u.Host,
Username: username,
Password: password,
transport: transport,
}
return me, nil
} | go | func NewTLSClient(uri string, username string, password string, transport http.RoundTripper) (me *Client, err error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
me = &Client{
Endpoint: uri,
host: u.Host,
Username: username,
Password: password,
transport: transport,
}
return me, nil
} | [
"func",
"NewTLSClient",
"(",
"uri",
"string",
",",
"username",
"string",
",",
"password",
"string",
",",
"transport",
"http",
".",
"RoundTripper",
")",
"(",
"me",
"*",
"Client",
",",
"err",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",... | // Creates a client with a transport; it is up to the developer to make that layer secure. | [
"Creates",
"a",
"client",
"with",
"a",
"transport",
";",
"it",
"is",
"up",
"to",
"the",
"developer",
"to",
"make",
"that",
"layer",
"secure",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/client.go#L41-L56 |
16,039 | michaelklishin/rabbit-hole | permissions.go | ListPermissions | func (c *Client) ListPermissions() (rec []PermissionInfo, err error) {
req, err := newGETRequest(c, "permissions/")
if err != nil {
return []PermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []PermissionInfo{}, err
}
return rec, nil
} | go | func (c *Client) ListPermissions() (rec []PermissionInfo, err error) {
req, err := newGETRequest(c, "permissions/")
if err != nil {
return []PermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []PermissionInfo{}, err
}
return rec, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListPermissions",
"(",
")",
"(",
"rec",
"[",
"]",
"PermissionInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{... | // ListPermissions returns permissions for all users and virtual hosts. | [
"ListPermissions",
"returns",
"permissions",
"for",
"all",
"users",
"and",
"virtual",
"hosts",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/permissions.go#L29-L40 |
16,040 | michaelklishin/rabbit-hole | permissions.go | UpdatePermissionsIn | func (c *Client) UpdatePermissionsIn(vhost, username string, permissions Permissions) (res *http.Response, err error) {
body, err := json.Marshal(permissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | go | func (c *Client) UpdatePermissionsIn(vhost, username string, permissions Permissions) (res *http.Response, err error) {
body, err := json.Marshal(permissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdatePermissionsIn",
"(",
"vhost",
",",
"username",
"string",
",",
"permissions",
"Permissions",
")",
"(",
"res",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
"."... | // Updates permissions of user in virtual host. | [
"Updates",
"permissions",
"of",
"user",
"in",
"virtual",
"host",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/permissions.go#L89-L106 |
16,041 | michaelklishin/rabbit-hole | topic_permissions.go | ListTopicPermissions | func (c *Client) ListTopicPermissions() (rec []TopicPermissionInfo, err error) {
req, err := newGETRequest(c, "topic-permissions/")
if err != nil {
return []TopicPermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []TopicPermissionInfo{}, err
}
return rec, nil
} | go | func (c *Client) ListTopicPermissions() (rec []TopicPermissionInfo, err error) {
req, err := newGETRequest(c, "topic-permissions/")
if err != nil {
return []TopicPermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []TopicPermissionInfo{}, err
}
return rec, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListTopicPermissions",
"(",
")",
"(",
"rec",
"[",
"]",
"TopicPermissionInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"... | // ListTopicPermissions returns topic-permissions for all users and virtual hosts. | [
"ListTopicPermissions",
"returns",
"topic",
"-",
"permissions",
"for",
"all",
"users",
"and",
"virtual",
"hosts",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/topic_permissions.go#L28-L39 |
16,042 | michaelklishin/rabbit-hole | topic_permissions.go | UpdateTopicPermissionsIn | func (c *Client) UpdateTopicPermissionsIn(vhost, username string, TopicPermissions TopicPermissions) (res *http.Response, err error) {
body, err := json.Marshal(TopicPermissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "topic-permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | go | func (c *Client) UpdateTopicPermissionsIn(vhost, username string, TopicPermissions TopicPermissions) (res *http.Response, err error) {
body, err := json.Marshal(TopicPermissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "topic-permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateTopicPermissionsIn",
"(",
"vhost",
",",
"username",
"string",
",",
"TopicPermissions",
"TopicPermissions",
")",
"(",
"res",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
... | // Updates topic-permissions of user in virtual host. | [
"Updates",
"topic",
"-",
"permissions",
"of",
"user",
"in",
"virtual",
"host",
"."
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/topic_permissions.go#L88-L105 |
16,043 | michaelklishin/rabbit-hole | bindings.go | ListBindings | func (c *Client) ListBindings() (rec []BindingInfo, err error) {
req, err := newGETRequest(c, "bindings/")
if err != nil {
return []BindingInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []BindingInfo{}, err
}
return rec, nil
} | go | func (c *Client) ListBindings() (rec []BindingInfo, err error) {
req, err := newGETRequest(c, "bindings/")
if err != nil {
return []BindingInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []BindingInfo{}, err
}
return rec, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListBindings",
"(",
")",
"(",
"rec",
"[",
"]",
"BindingInfo",
",",
"err",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newGETRequest",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"... | // ListBindings returns all bindings | [
"ListBindings",
"returns",
"all",
"bindings"
] | cfa3c7b4e6be452ebc192d079f8303ea67ef92f4 | https://github.com/michaelklishin/rabbit-hole/blob/cfa3c7b4e6be452ebc192d079f8303ea67ef92f4/bindings.go#L53-L64 |
16,044 | johnnadratowski/golang-neo4j-bolt-driver | encoding/decoder.go | NewDecoder | func NewDecoder(r io.Reader) Decoder {
return Decoder{
r: r,
buf: &bytes.Buffer{},
}
} | go | func NewDecoder(r io.Reader) Decoder {
return Decoder{
r: r,
buf: &bytes.Buffer{},
}
} | [
"func",
"NewDecoder",
"(",
"r",
"io",
".",
"Reader",
")",
"Decoder",
"{",
"return",
"Decoder",
"{",
"r",
":",
"r",
",",
"buf",
":",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewDecoder Creates a new Decoder object | [
"NewDecoder",
"Creates",
"a",
"new",
"Decoder",
"object"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/decoder.go#L27-L32 |
16,045 | johnnadratowski/golang-neo4j-bolt-driver | encoding/decoder.go | read | func (d Decoder) read() (*bytes.Buffer, error) {
output := &bytes.Buffer{}
for {
lengthBytes := make([]byte, 2)
if numRead, err := io.ReadFull(d.r, lengthBytes); numRead != 2 {
return nil, errors.Wrap(err, "Couldn't read expected bytes for message length. Read: %d Expected: 2.", numRead)
}
// Chunk header contains length of current message
messageLen := binary.BigEndian.Uint16(lengthBytes)
if messageLen == 0 {
// If the length is 0, the chunk is done.
return output, nil
}
data, err := d.readData(messageLen)
if err != nil {
return output, errors.Wrap(err, "An error occurred reading message data")
}
numWritten, err := output.Write(data)
if numWritten < len(data) {
return output, errors.New("Didn't write full data on output. Expected: %d Wrote: %d", len(data), numWritten)
} else if err != nil {
return output, errors.Wrap(err, "Error writing data to output")
}
}
} | go | func (d Decoder) read() (*bytes.Buffer, error) {
output := &bytes.Buffer{}
for {
lengthBytes := make([]byte, 2)
if numRead, err := io.ReadFull(d.r, lengthBytes); numRead != 2 {
return nil, errors.Wrap(err, "Couldn't read expected bytes for message length. Read: %d Expected: 2.", numRead)
}
// Chunk header contains length of current message
messageLen := binary.BigEndian.Uint16(lengthBytes)
if messageLen == 0 {
// If the length is 0, the chunk is done.
return output, nil
}
data, err := d.readData(messageLen)
if err != nil {
return output, errors.Wrap(err, "An error occurred reading message data")
}
numWritten, err := output.Write(data)
if numWritten < len(data) {
return output, errors.New("Didn't write full data on output. Expected: %d Wrote: %d", len(data), numWritten)
} else if err != nil {
return output, errors.Wrap(err, "Error writing data to output")
}
}
} | [
"func",
"(",
"d",
"Decoder",
")",
"read",
"(",
")",
"(",
"*",
"bytes",
".",
"Buffer",
",",
"error",
")",
"{",
"output",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"for",
"{",
"lengthBytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",... | // Read out the object bytes to decode | [
"Read",
"out",
"the",
"object",
"bytes",
"to",
"decode"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/decoder.go#L40-L67 |
16,046 | johnnadratowski/golang-neo4j-bolt-driver | encoding/decoder.go | Decode | func (d Decoder) Decode() (interface{}, error) {
data, err := d.read()
if err != nil {
return nil, err
}
return d.decode(data)
} | go | func (d Decoder) Decode() (interface{}, error) {
data, err := d.read()
if err != nil {
return nil, err
}
return d.decode(data)
} | [
"func",
"(",
"d",
"Decoder",
")",
"Decode",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"d",
".",
"read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n... | // Decode decodes the stream to an object | [
"Decode",
"decodes",
"the",
"stream",
"to",
"an",
"object"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/decoder.go#L92-L99 |
16,047 | johnnadratowski/golang-neo4j-bolt-driver | errors/errors.go | New | func New(msg string, args ...interface{}) *Error {
return &Error{
msg: fmt.Sprintf(msg, args...),
stack: debug.Stack(),
level: 0,
}
} | go | func New(msg string, args ...interface{}) *Error {
return &Error{
msg: fmt.Sprintf(msg, args...),
stack: debug.Stack(),
level: 0,
}
} | [
"func",
"New",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"return",
"&",
"Error",
"{",
"msg",
":",
"fmt",
".",
"Sprintf",
"(",
"msg",
",",
"args",
"...",
")",
",",
"stack",
":",
"debug",
".",
"Stack",... | // New makes a new error | [
"New",
"makes",
"a",
"new",
"error"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/errors/errors.go#L18-L24 |
16,048 | johnnadratowski/golang-neo4j-bolt-driver | errors/errors.go | Wrap | func Wrap(err error, msg string, args ...interface{}) *Error {
if e, ok := err.(*Error); ok {
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: e,
}
}
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: err,
stack: debug.Stack(),
}
} | go | func Wrap(err error, msg string, args ...interface{}) *Error {
if e, ok := err.(*Error); ok {
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: e,
}
}
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: err,
stack: debug.Stack(),
}
} | [
"func",
"Wrap",
"(",
"err",
"error",
",",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"Error",
")",
";",
"ok",
"{",
"return",
"&",
"Error",
"{",
"msg",
... | // Wrap wraps an error with a new error | [
"Wrap",
"wraps",
"an",
"error",
"with",
"a",
"new",
"error"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/errors/errors.go#L27-L40 |
16,049 | johnnadratowski/golang-neo4j-bolt-driver | errors/errors.go | InnerMost | func (e *Error) InnerMost() error {
if e.wrapped == nil {
return e
}
if inner, ok := e.wrapped.(*Error); ok {
return inner.InnerMost()
}
return e.wrapped
} | go | func (e *Error) InnerMost() error {
if e.wrapped == nil {
return e
}
if inner, ok := e.wrapped.(*Error); ok {
return inner.InnerMost()
}
return e.wrapped
} | [
"func",
"(",
"e",
"*",
"Error",
")",
"InnerMost",
"(",
")",
"error",
"{",
"if",
"e",
".",
"wrapped",
"==",
"nil",
"{",
"return",
"e",
"\n",
"}",
"\n\n",
"if",
"inner",
",",
"ok",
":=",
"e",
".",
"wrapped",
".",
"(",
"*",
"Error",
")",
";",
"o... | // InnerMost returns the innermost error wrapped by this error | [
"InnerMost",
"returns",
"the",
"innermost",
"error",
"wrapped",
"by",
"this",
"error"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/errors/errors.go#L53-L63 |
16,050 | johnnadratowski/golang-neo4j-bolt-driver | util.go | sprintByteHex | func sprintByteHex(b []byte) string {
output := "\t"
for i, b := range b {
output += fmt.Sprintf("%x", b)
if (i+1)%16 == 0 {
output += "\n\n\t"
} else if (i+1)%4 == 0 {
output += " "
} else {
output += " "
}
}
output += "\n"
return output
} | go | func sprintByteHex(b []byte) string {
output := "\t"
for i, b := range b {
output += fmt.Sprintf("%x", b)
if (i+1)%16 == 0 {
output += "\n\n\t"
} else if (i+1)%4 == 0 {
output += " "
} else {
output += " "
}
}
output += "\n"
return output
} | [
"func",
"sprintByteHex",
"(",
"b",
"[",
"]",
"byte",
")",
"string",
"{",
"output",
":=",
"\"",
"\\t",
"\"",
"\n",
"for",
"i",
",",
"b",
":=",
"range",
"b",
"{",
"output",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
")",
"\n",
"if",
... | // sprintByteHex returns a formatted string of the byte array in hexadecimal
// with a nicely formatted human-readable output | [
"sprintByteHex",
"returns",
"a",
"formatted",
"string",
"of",
"the",
"byte",
"array",
"in",
"hexadecimal",
"with",
"a",
"nicely",
"formatted",
"human",
"-",
"readable",
"output"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/util.go#L13-L28 |
16,051 | johnnadratowski/golang-neo4j-bolt-driver | util.go | driverArgsToMap | func driverArgsToMap(args []driver.Value) (map[string]interface{}, error) {
output := map[string]interface{}{}
for _, arg := range args {
argBytes, ok := arg.([]byte)
if !ok {
return nil, errors.New("You must pass only a gob encoded map to the Exec/Query args")
}
m, err := encoding.Unmarshal(argBytes)
if err != nil {
return nil, err
}
for k, v := range m.(map[string]interface{}) {
output[k] = v
}
}
return output, nil
} | go | func driverArgsToMap(args []driver.Value) (map[string]interface{}, error) {
output := map[string]interface{}{}
for _, arg := range args {
argBytes, ok := arg.([]byte)
if !ok {
return nil, errors.New("You must pass only a gob encoded map to the Exec/Query args")
}
m, err := encoding.Unmarshal(argBytes)
if err != nil {
return nil, err
}
for k, v := range m.(map[string]interface{}) {
output[k] = v
}
}
return output, nil
} | [
"func",
"driverArgsToMap",
"(",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"output",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"for",
... | // driverArgsToMap turns driver.Value list into a parameter map
// for neo4j parameters | [
"driverArgsToMap",
"turns",
"driver",
".",
"Value",
"list",
"into",
"a",
"parameter",
"map",
"for",
"neo4j",
"parameters"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/util.go#L32-L52 |
16,052 | johnnadratowski/golang-neo4j-bolt-driver | tx.go | Commit | func (t *boltTx) Commit() error {
if t.closed {
return errors.New("Transaction already closed")
}
if t.conn.statement != nil {
if err := t.conn.statement.Close(); err != nil {
return errors.Wrap(err, "An error occurred closing open rows in transaction Commit")
}
}
successInt, pullInt, err := t.conn.sendRunPullAllConsumeSingle("COMMIT", nil)
if err != nil {
return errors.Wrap(err, "An error occurred committing transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type committing transaction: %#v", success)
}
log.Infof("Got success message committing transaction: %#v", success)
pull, ok := pullInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type pulling transaction: %#v", pull)
}
log.Infof("Got success message pulling transaction: %#v", pull)
t.conn.transaction = nil
t.closed = true
return err
} | go | func (t *boltTx) Commit() error {
if t.closed {
return errors.New("Transaction already closed")
}
if t.conn.statement != nil {
if err := t.conn.statement.Close(); err != nil {
return errors.Wrap(err, "An error occurred closing open rows in transaction Commit")
}
}
successInt, pullInt, err := t.conn.sendRunPullAllConsumeSingle("COMMIT", nil)
if err != nil {
return errors.Wrap(err, "An error occurred committing transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type committing transaction: %#v", success)
}
log.Infof("Got success message committing transaction: %#v", success)
pull, ok := pullInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type pulling transaction: %#v", pull)
}
log.Infof("Got success message pulling transaction: %#v", pull)
t.conn.transaction = nil
t.closed = true
return err
} | [
"func",
"(",
"t",
"*",
"boltTx",
")",
"Commit",
"(",
")",
"error",
"{",
"if",
"t",
".",
"closed",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"conn",
".",
"statement",
"!=",
"nil",
"{",
"if",
"e... | // Commit commits and closes the transaction | [
"Commit",
"commits",
"and",
"closes",
"the",
"transaction"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/tx.go#L29-L61 |
16,053 | johnnadratowski/golang-neo4j-bolt-driver | driver.go | Open | func (d *boltDriver) Open(connStr string) (driver.Conn, error) {
return newBoltConn(connStr, d) // Never use pooling when using SQL driver
} | go | func (d *boltDriver) Open(connStr string) (driver.Conn, error) {
return newBoltConn(connStr, d) // Never use pooling when using SQL driver
} | [
"func",
"(",
"d",
"*",
"boltDriver",
")",
"Open",
"(",
"connStr",
"string",
")",
"(",
"driver",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"newBoltConn",
"(",
"connStr",
",",
"d",
")",
"// Never use pooling when using SQL driver",
"\n",
"}"
] | // Open opens a new Bolt connection to the Neo4J database | [
"Open",
"opens",
"a",
"new",
"Bolt",
"connection",
"to",
"the",
"Neo4J",
"database"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L58-L60 |
16,054 | johnnadratowski/golang-neo4j-bolt-driver | driver.go | NewDriverPool | func NewDriverPool(connStr string, max int) (DriverPool, error) {
return createDriverPool(connStr, max)
} | go | func NewDriverPool(connStr string, max int) (DriverPool, error) {
return createDriverPool(connStr, max)
} | [
"func",
"NewDriverPool",
"(",
"connStr",
"string",
",",
"max",
"int",
")",
"(",
"DriverPool",
",",
"error",
")",
"{",
"return",
"createDriverPool",
"(",
"connStr",
",",
"max",
")",
"\n",
"}"
] | // NewDriverPool creates a new Driver object with connection pooling | [
"NewDriverPool",
"creates",
"a",
"new",
"Driver",
"object",
"with",
"connection",
"pooling"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L96-L98 |
16,055 | johnnadratowski/golang-neo4j-bolt-driver | driver.go | NewClosableDriverPool | func NewClosableDriverPool(connStr string, max int) (ClosableDriverPool, error) {
return createDriverPool(connStr, max)
} | go | func NewClosableDriverPool(connStr string, max int) (ClosableDriverPool, error) {
return createDriverPool(connStr, max)
} | [
"func",
"NewClosableDriverPool",
"(",
"connStr",
"string",
",",
"max",
"int",
")",
"(",
"ClosableDriverPool",
",",
"error",
")",
"{",
"return",
"createDriverPool",
"(",
"connStr",
",",
"max",
")",
"\n",
"}"
] | // NewClosableDriverPool create a closable driver pool | [
"NewClosableDriverPool",
"create",
"a",
"closable",
"driver",
"pool"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L101-L103 |
16,056 | johnnadratowski/golang-neo4j-bolt-driver | driver.go | OpenPool | func (d *boltDriverPool) OpenPool() (Conn, error) {
// For each connection request we need to block in case the Close function is called. This gives us a guarantee
// when closing the pool no new connections are made.
d.refLock.Lock()
defer d.refLock.Unlock()
if !d.closed {
conn := <-d.pool
if connectionNilOrClosed(conn) {
if err := conn.initialize(); err != nil {
return nil, err
}
d.connRefs = append(d.connRefs, conn)
}
return conn, nil
}
return nil, errors.New("Driver pool has been closed")
} | go | func (d *boltDriverPool) OpenPool() (Conn, error) {
// For each connection request we need to block in case the Close function is called. This gives us a guarantee
// when closing the pool no new connections are made.
d.refLock.Lock()
defer d.refLock.Unlock()
if !d.closed {
conn := <-d.pool
if connectionNilOrClosed(conn) {
if err := conn.initialize(); err != nil {
return nil, err
}
d.connRefs = append(d.connRefs, conn)
}
return conn, nil
}
return nil, errors.New("Driver pool has been closed")
} | [
"func",
"(",
"d",
"*",
"boltDriverPool",
")",
"OpenPool",
"(",
")",
"(",
"Conn",
",",
"error",
")",
"{",
"// For each connection request we need to block in case the Close function is called. This gives us a guarantee",
"// when closing the pool no new connections are made.",
"d",
... | // OpenPool opens a returns a Bolt connection from the pool to the Neo4J database. | [
"OpenPool",
"opens",
"a",
"returns",
"a",
"Bolt",
"connection",
"from",
"the",
"pool",
"to",
"the",
"Neo4J",
"database",
"."
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L125-L141 |
16,057 | johnnadratowski/golang-neo4j-bolt-driver | driver.go | Close | func (d *boltDriverPool) Close() error {
// Lock the connection ref so no new connections can be added
d.refLock.Lock()
defer d.refLock.Unlock()
for _, conn := range d.connRefs {
// Remove the reference to the pool, to allow a clean up of the connection
conn.poolDriver = nil
err := conn.Close()
if err != nil {
d.closed = true
return err
}
}
// Mark the pool as closed to stop any new connections
d.closed = true
return nil
} | go | func (d *boltDriverPool) Close() error {
// Lock the connection ref so no new connections can be added
d.refLock.Lock()
defer d.refLock.Unlock()
for _, conn := range d.connRefs {
// Remove the reference to the pool, to allow a clean up of the connection
conn.poolDriver = nil
err := conn.Close()
if err != nil {
d.closed = true
return err
}
}
// Mark the pool as closed to stop any new connections
d.closed = true
return nil
} | [
"func",
"(",
"d",
"*",
"boltDriverPool",
")",
"Close",
"(",
")",
"error",
"{",
"// Lock the connection ref so no new connections can be added",
"d",
".",
"refLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"refLock",
".",
"Unlock",
"(",
")",
"\n",
"fo... | // Close all connections in the pool | [
"Close",
"all",
"connections",
"in",
"the",
"pool"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/driver.go#L158-L174 |
16,058 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | newBoltConn | func newBoltConn(connStr string, driver *boltDriver) (*boltConn, error) {
c := createBoltConn(connStr)
c.driver = driver
err := c.initialize()
if err != nil {
return nil, errors.Wrap(err, "An error occurred initializing connection")
}
return c, nil
} | go | func newBoltConn(connStr string, driver *boltDriver) (*boltConn, error) {
c := createBoltConn(connStr)
c.driver = driver
err := c.initialize()
if err != nil {
return nil, errors.Wrap(err, "An error occurred initializing connection")
}
return c, nil
} | [
"func",
"newBoltConn",
"(",
"connStr",
"string",
",",
"driver",
"*",
"boltDriver",
")",
"(",
"*",
"boltConn",
",",
"error",
")",
"{",
"c",
":=",
"createBoltConn",
"(",
"connStr",
")",
"\n",
"c",
".",
"driver",
"=",
"driver",
"\n\n",
"err",
":=",
"c",
... | // newBoltConn Creates a new bolt connection | [
"newBoltConn",
"Creates",
"a",
"new",
"bolt",
"connection"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L97-L108 |
16,059 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | newPooledBoltConn | func newPooledBoltConn(connStr string, driver DriverPool) (*boltConn, error) {
c := createBoltConn(connStr)
c.poolDriver = driver
return c, nil
} | go | func newPooledBoltConn(connStr string, driver DriverPool) (*boltConn, error) {
c := createBoltConn(connStr)
c.poolDriver = driver
return c, nil
} | [
"func",
"newPooledBoltConn",
"(",
"connStr",
"string",
",",
"driver",
"DriverPool",
")",
"(",
"*",
"boltConn",
",",
"error",
")",
"{",
"c",
":=",
"createBoltConn",
"(",
"connStr",
")",
"\n",
"c",
".",
"poolDriver",
"=",
"driver",
"\n\n",
"return",
"c",
"... | // newPooledBoltConn Creates a new bolt connection with a pooled driver | [
"newPooledBoltConn",
"Creates",
"a",
"new",
"bolt",
"connection",
"with",
"a",
"pooled",
"driver"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L111-L117 |
16,060 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | Read | func (c *boltConn) Read(b []byte) (n int, err error) {
if err := c.conn.SetReadDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting read deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Read(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Read %d bytes from stream:\n\n%s\n", n, sprintByteHex(b))
}
if err != nil && err != io.EOF {
c.connErr = errors.Wrap(err, "An error occurred reading from stream")
err = driver.ErrBadConn
}
return n, err
} | go | func (c *boltConn) Read(b []byte) (n int, err error) {
if err := c.conn.SetReadDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting read deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Read(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Read %d bytes from stream:\n\n%s\n", n, sprintByteHex(b))
}
if err != nil && err != io.EOF {
c.connErr = errors.Wrap(err, "An error occurred reading from stream")
err = driver.ErrBadConn
}
return n, err
} | [
"func",
"(",
"c",
"*",
"boltConn",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"conn",
".",
"SetReadDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
... | // Read reads the data from the underlying connection | [
"Read",
"reads",
"the",
"data",
"from",
"the",
"underlying",
"connection"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L320-L337 |
16,061 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | Write | func (c *boltConn) Write(b []byte) (n int, err error) {
if err := c.conn.SetWriteDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting write deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Write(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Wrote %d of %d bytes to stream:\n\n%s\n", len(b), n, sprintByteHex(b[:n]))
}
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred writing to stream")
err = driver.ErrBadConn
}
return n, err
} | go | func (c *boltConn) Write(b []byte) (n int, err error) {
if err := c.conn.SetWriteDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting write deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Write(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Wrote %d of %d bytes to stream:\n\n%s\n", len(b), n, sprintByteHex(b[:n]))
}
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred writing to stream")
err = driver.ErrBadConn
}
return n, err
} | [
"func",
"(",
"c",
"*",
"boltConn",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"conn",
".",
"SetWriteDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"("... | // Write writes the data to the underlying connection | [
"Write",
"writes",
"the",
"data",
"to",
"the",
"underlying",
"connection"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L340-L357 |
16,062 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | Close | func (c *boltConn) Close() error {
if c.closed {
return nil
}
if c.statement != nil {
if err := c.statement.Close(); err != nil {
return err
}
}
if c.transaction != nil {
if err := c.transaction.Rollback(); err != nil {
return errors.Wrap(err, "Error rolling back transaction when closing connection")
}
}
if c.poolDriver != nil {
// If using connection pooling, don't close connection, just reclaim it
err := c.poolDriver.reclaim(c)
if err != nil {
log.Errorf("An error occurred reclaiming connection for pool: %s", err)
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
err := c.conn.Close()
c.closed = true
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
} | go | func (c *boltConn) Close() error {
if c.closed {
return nil
}
if c.statement != nil {
if err := c.statement.Close(); err != nil {
return err
}
}
if c.transaction != nil {
if err := c.transaction.Rollback(); err != nil {
return errors.Wrap(err, "Error rolling back transaction when closing connection")
}
}
if c.poolDriver != nil {
// If using connection pooling, don't close connection, just reclaim it
err := c.poolDriver.reclaim(c)
if err != nil {
log.Errorf("An error occurred reclaiming connection for pool: %s", err)
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
err := c.conn.Close()
c.closed = true
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
} | [
"func",
"(",
"c",
"*",
"boltConn",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"statement",
"!=",
"nil",
"{",
"if",
"err",
":=",
"c",
".",
"statement",
".",
"Close",
"... | // Close closes the connection
// Driver may allow for pooling in the future, keeping connections alive | [
"Close",
"closes",
"the",
"connection",
"Driver",
"may",
"allow",
"for",
"pooling",
"in",
"the",
"future",
"keeping",
"connections",
"alive"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L361-L398 |
16,063 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | Prepare | func (c *boltConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(query)
} | go | func (c *boltConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(query)
} | [
"func",
"(",
"c",
"*",
"boltConn",
")",
"Prepare",
"(",
"query",
"string",
")",
"(",
"driver",
".",
"Stmt",
",",
"error",
")",
"{",
"return",
"c",
".",
"prepare",
"(",
"query",
")",
"\n",
"}"
] | // Prepare prepares a new statement for a query | [
"Prepare",
"prepares",
"a",
"new",
"statement",
"for",
"a",
"query"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L473-L475 |
16,064 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | PreparePipeline | func (c *boltConn) PreparePipeline(queries ...string) (PipelineStmt, error) {
if c.statement != nil {
return nil, errors.New("An open statement already exists")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
c.statement = newPipelineStmt(queries, c)
return c.statement, nil
} | go | func (c *boltConn) PreparePipeline(queries ...string) (PipelineStmt, error) {
if c.statement != nil {
return nil, errors.New("An open statement already exists")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
c.statement = newPipelineStmt(queries, c)
return c.statement, nil
} | [
"func",
"(",
"c",
"*",
"boltConn",
")",
"PreparePipeline",
"(",
"queries",
"...",
"string",
")",
"(",
"PipelineStmt",
",",
"error",
")",
"{",
"if",
"c",
".",
"statement",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
... | // PreparePipeline prepares a new pipeline statement for a query. | [
"PreparePipeline",
"prepares",
"a",
"new",
"pipeline",
"statement",
"for",
"a",
"query",
"."
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L483-L492 |
16,065 | johnnadratowski/golang-neo4j-bolt-driver | conn.go | Begin | func (c *boltConn) Begin() (driver.Tx, error) {
if c.transaction != nil {
return nil, errors.New("An open transaction already exists")
}
if c.statement != nil {
return nil, errors.New("Cannot open a transaction when you already have an open statement")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
successInt, pullInt, err := c.sendRunPullAllConsumeSingle("BEGIN", nil)
if err != nil {
return nil, errors.Wrap(err, "An error occurred beginning transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type beginning transaction: %#v", success)
}
log.Infof("Got success message beginning transaction: %#v", success)
success, ok = pullInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type pulling transaction: %#v", success)
}
log.Infof("Got success message pulling transaction: %#v", success)
return newTx(c), nil
} | go | func (c *boltConn) Begin() (driver.Tx, error) {
if c.transaction != nil {
return nil, errors.New("An open transaction already exists")
}
if c.statement != nil {
return nil, errors.New("Cannot open a transaction when you already have an open statement")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
successInt, pullInt, err := c.sendRunPullAllConsumeSingle("BEGIN", nil)
if err != nil {
return nil, errors.Wrap(err, "An error occurred beginning transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type beginning transaction: %#v", success)
}
log.Infof("Got success message beginning transaction: %#v", success)
success, ok = pullInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type pulling transaction: %#v", success)
}
log.Infof("Got success message pulling transaction: %#v", success)
return newTx(c), nil
} | [
"func",
"(",
"c",
"*",
"boltConn",
")",
"Begin",
"(",
")",
"(",
"driver",
".",
"Tx",
",",
"error",
")",
"{",
"if",
"c",
".",
"transaction",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"... | // Begin begins a new transaction with the Neo4J Database | [
"Begin",
"begins",
"a",
"new",
"transaction",
"with",
"the",
"Neo4J",
"Database"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/conn.go#L506-L537 |
16,066 | johnnadratowski/golang-neo4j-bolt-driver | structures/messages/run.go | NewRunMessage | func NewRunMessage(statement string, parameters map[string]interface{}) RunMessage {
return RunMessage{
statement: statement,
parameters: parameters,
}
} | go | func NewRunMessage(statement string, parameters map[string]interface{}) RunMessage {
return RunMessage{
statement: statement,
parameters: parameters,
}
} | [
"func",
"NewRunMessage",
"(",
"statement",
"string",
",",
"parameters",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"RunMessage",
"{",
"return",
"RunMessage",
"{",
"statement",
":",
"statement",
",",
"parameters",
":",
"parameters",
",",
"}",
"\n"... | // NewRunMessage Gets a new RunMessage struct | [
"NewRunMessage",
"Gets",
"a",
"new",
"RunMessage",
"struct"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/structures/messages/run.go#L15-L20 |
16,067 | johnnadratowski/golang-neo4j-bolt-driver | rows.go | Columns | func (r *boltRows) Columns() []string {
fieldsInt, ok := r.metadata["fields"]
if !ok {
return []string{}
}
fields, ok := fieldsInt.([]interface{})
if !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
fieldsStr := make([]string, len(fields))
for i, f := range fields {
if fieldsStr[i], ok = f.(string); !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
}
return fieldsStr
} | go | func (r *boltRows) Columns() []string {
fieldsInt, ok := r.metadata["fields"]
if !ok {
return []string{}
}
fields, ok := fieldsInt.([]interface{})
if !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
fieldsStr := make([]string, len(fields))
for i, f := range fields {
if fieldsStr[i], ok = f.(string); !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
}
return fieldsStr
} | [
"func",
"(",
"r",
"*",
"boltRows",
")",
"Columns",
"(",
")",
"[",
"]",
"string",
"{",
"fieldsInt",
",",
"ok",
":=",
"r",
".",
"metadata",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n... | // Columns returns the columns from the result | [
"Columns",
"returns",
"the",
"columns",
"from",
"the",
"result"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L93-L113 |
16,068 | johnnadratowski/golang-neo4j-bolt-driver | rows.go | Close | func (r *boltRows) Close() error {
if r.closed {
return nil
}
if !r.consumed {
// Discard all messages if not consumed
respInt, err := r.statement.conn.sendDiscardAllConsume()
if err != nil {
return errors.Wrap(err, "An error occurred discarding messages on row close")
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
default:
return errors.New("Unrecognized response type discarding all rows: Value: %#v", resp)
}
} else if !r.finishedConsume {
// If this is a pipeline statement, we need to "consume all" multiple times
numConsume := 1
if r.statement.queries != nil {
numQueries := len(r.statement.queries)
if numQueries > 0 {
// So, every pipeline statement has two successes
// but by the time you get to the row object, one has
// been consumed. Hence we need to clear out the
// rest of the messages on close by taking the current
// index * 2 but removing the first success
numConsume = ((numQueries - r.pipelineIndex) * 2) - 1
}
}
// Clear out all unconsumed messages if we
// never finished consuming them.
_, _, err := r.statement.conn.consumeAllMultiple(numConsume)
if err != nil {
return errors.Wrap(err, "An error occurred clearing out unconsumed stream")
}
}
r.closed = true
r.statement.rows = nil
if r.closeStatement {
return r.statement.Close()
}
return nil
} | go | func (r *boltRows) Close() error {
if r.closed {
return nil
}
if !r.consumed {
// Discard all messages if not consumed
respInt, err := r.statement.conn.sendDiscardAllConsume()
if err != nil {
return errors.Wrap(err, "An error occurred discarding messages on row close")
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
default:
return errors.New("Unrecognized response type discarding all rows: Value: %#v", resp)
}
} else if !r.finishedConsume {
// If this is a pipeline statement, we need to "consume all" multiple times
numConsume := 1
if r.statement.queries != nil {
numQueries := len(r.statement.queries)
if numQueries > 0 {
// So, every pipeline statement has two successes
// but by the time you get to the row object, one has
// been consumed. Hence we need to clear out the
// rest of the messages on close by taking the current
// index * 2 but removing the first success
numConsume = ((numQueries - r.pipelineIndex) * 2) - 1
}
}
// Clear out all unconsumed messages if we
// never finished consuming them.
_, _, err := r.statement.conn.consumeAllMultiple(numConsume)
if err != nil {
return errors.Wrap(err, "An error occurred clearing out unconsumed stream")
}
}
r.closed = true
r.statement.rows = nil
if r.closeStatement {
return r.statement.Close()
}
return nil
} | [
"func",
"(",
"r",
"*",
"boltRows",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"!",
"r",
".",
"consumed",
"{",
"// Discard all messages if not consumed",
"respInt",
",",
"err",
":=",
"r... | // Close closes the rows | [
"Close",
"closes",
"the",
"rows"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L121-L170 |
16,069 | johnnadratowski/golang-neo4j-bolt-driver | rows.go | Next | func (r *boltRows) Next(dest []driver.Value) error {
data, _, err := r.NextNeo()
if err != nil {
return err
}
for i, item := range data {
switch item := item.(type) {
case []interface{}, map[string]interface{}, graph.Node, graph.Path, graph.Relationship, graph.UnboundRelationship:
dest[i], err = encoding.Marshal(item)
if err != nil {
return err
}
default:
dest[i], err = driver.DefaultParameterConverter.ConvertValue(item)
if err != nil {
return err
}
}
}
return nil
} | go | func (r *boltRows) Next(dest []driver.Value) error {
data, _, err := r.NextNeo()
if err != nil {
return err
}
for i, item := range data {
switch item := item.(type) {
case []interface{}, map[string]interface{}, graph.Node, graph.Path, graph.Relationship, graph.UnboundRelationship:
dest[i], err = encoding.Marshal(item)
if err != nil {
return err
}
default:
dest[i], err = driver.DefaultParameterConverter.ConvertValue(item)
if err != nil {
return err
}
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"boltRows",
")",
"Next",
"(",
"dest",
"[",
"]",
"driver",
".",
"Value",
")",
"error",
"{",
"data",
",",
"_",
",",
"err",
":=",
"r",
".",
"NextNeo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"... | // Next gets the next row result | [
"Next",
"gets",
"the",
"next",
"row",
"result"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L173-L196 |
16,070 | johnnadratowski/golang-neo4j-bolt-driver | rows.go | NextNeo | func (r *boltRows) NextNeo() ([]interface{}, map[string]interface{}, error) {
if r.closed {
return nil, nil, errors.New("Rows are already closed")
}
if !r.consumed {
r.consumed = true
if err := r.statement.conn.sendPullAll(); err != nil {
r.finishedConsume = true
return nil, nil, err
}
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
r.finishedConsume = true
return nil, resp.Metadata, io.EOF
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil
default:
return nil, nil, errors.New("Unrecognized response type getting next query row: %#v", resp)
}
} | go | func (r *boltRows) NextNeo() ([]interface{}, map[string]interface{}, error) {
if r.closed {
return nil, nil, errors.New("Rows are already closed")
}
if !r.consumed {
r.consumed = true
if err := r.statement.conn.sendPullAll(); err != nil {
r.finishedConsume = true
return nil, nil, err
}
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
r.finishedConsume = true
return nil, resp.Metadata, io.EOF
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil
default:
return nil, nil, errors.New("Unrecognized response type getting next query row: %#v", resp)
}
} | [
"func",
"(",
"r",
"*",
"boltRows",
")",
"NextNeo",
"(",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"r",
".",
"closed",
"{",
"return",
"nil",
",",
"nil",
",",
... | // NextNeo gets the next row result
// When the rows are completed, returns the success metadata
// and io.EOF | [
"NextNeo",
"gets",
"the",
"next",
"row",
"result",
"When",
"the",
"rows",
"are",
"completed",
"returns",
"the",
"success",
"metadata",
"and",
"io",
".",
"EOF"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L201-L230 |
16,071 | johnnadratowski/golang-neo4j-bolt-driver | rows.go | NextPipeline | func (r *boltRows) NextPipeline() ([]interface{}, map[string]interface{}, PipelineRows, error) {
if r.closed {
return nil, nil, nil, errors.New("Rows are already closed")
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
if r.pipelineIndex == len(r.statement.queries)-1 {
r.finishedConsume = true
return nil, nil, nil, err
}
successResp, err := r.statement.conn.consume()
if err != nil && err != io.EOF {
return nil, nil, nil, errors.Wrap(err, "An error occurred getting next set of rows from pipeline command: %#v", successResp)
}
success, ok := successResp.(messages.SuccessMessage)
if !ok {
return nil, nil, nil, errors.New("Unexpected response getting next set of rows from pipeline command: %#v", successResp)
}
r.statement.rows = newPipelineRows(r.statement, success.Metadata, r.pipelineIndex+1)
r.statement.rows.closeStatement = r.closeStatement
return nil, success.Metadata, r.statement.rows, nil
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil, nil
default:
return nil, nil, nil, errors.New("Unrecognized response type getting next pipeline row: %#v", resp)
}
} | go | func (r *boltRows) NextPipeline() ([]interface{}, map[string]interface{}, PipelineRows, error) {
if r.closed {
return nil, nil, nil, errors.New("Rows are already closed")
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
if r.pipelineIndex == len(r.statement.queries)-1 {
r.finishedConsume = true
return nil, nil, nil, err
}
successResp, err := r.statement.conn.consume()
if err != nil && err != io.EOF {
return nil, nil, nil, errors.Wrap(err, "An error occurred getting next set of rows from pipeline command: %#v", successResp)
}
success, ok := successResp.(messages.SuccessMessage)
if !ok {
return nil, nil, nil, errors.New("Unexpected response getting next set of rows from pipeline command: %#v", successResp)
}
r.statement.rows = newPipelineRows(r.statement, success.Metadata, r.pipelineIndex+1)
r.statement.rows.closeStatement = r.closeStatement
return nil, success.Metadata, r.statement.rows, nil
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil, nil
default:
return nil, nil, nil, errors.New("Unrecognized response type getting next pipeline row: %#v", resp)
}
} | [
"func",
"(",
"r",
"*",
"boltRows",
")",
"NextPipeline",
"(",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"PipelineRows",
",",
"error",
")",
"{",
"if",
"r",
".",
"closed",
"{",
"return",
"... | // NextPipeline gets the next row result
// When the rows are completed, returns the success metadata and the next
// set of rows.
// When all rows are completed, returns io.EOF | [
"NextPipeline",
"gets",
"the",
"next",
"row",
"result",
"When",
"the",
"rows",
"are",
"completed",
"returns",
"the",
"success",
"metadata",
"and",
"the",
"next",
"set",
"of",
"rows",
".",
"When",
"all",
"rows",
"are",
"completed",
"returns",
"io",
".",
"EO... | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/rows.go#L250-L289 |
16,072 | johnnadratowski/golang-neo4j-bolt-driver | structures/messages/init.go | NewInitMessage | func NewInitMessage(clientName string, user string, password string) InitMessage {
var authToken map[string]interface{}
if user == "" {
authToken = map[string]interface{}{
"scheme": "none",
}
} else {
authToken = map[string]interface{}{
"scheme": "basic",
"principal": user,
"credentials": password,
}
}
return InitMessage{
clientName: clientName,
authToken: authToken,
}
} | go | func NewInitMessage(clientName string, user string, password string) InitMessage {
var authToken map[string]interface{}
if user == "" {
authToken = map[string]interface{}{
"scheme": "none",
}
} else {
authToken = map[string]interface{}{
"scheme": "basic",
"principal": user,
"credentials": password,
}
}
return InitMessage{
clientName: clientName,
authToken: authToken,
}
} | [
"func",
"NewInitMessage",
"(",
"clientName",
"string",
",",
"user",
"string",
",",
"password",
"string",
")",
"InitMessage",
"{",
"var",
"authToken",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"if",
"user",
"==",
"\"",
"\"",
"{",
"authToken",
... | // NewInitMessage Gets a new InitMessage struct | [
"NewInitMessage",
"Gets",
"a",
"new",
"InitMessage",
"struct"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/structures/messages/init.go#L15-L33 |
16,073 | johnnadratowski/golang-neo4j-bolt-driver | log/log.go | SetLevel | func SetLevel(levelStr string) {
switch strings.ToLower(levelStr) {
case "trace":
level = TraceLevel
case "info":
level = InfoLevel
case "error":
level = ErrorLevel
default:
level = NoneLevel
}
} | go | func SetLevel(levelStr string) {
switch strings.ToLower(levelStr) {
case "trace":
level = TraceLevel
case "info":
level = InfoLevel
case "error":
level = ErrorLevel
default:
level = NoneLevel
}
} | [
"func",
"SetLevel",
"(",
"levelStr",
"string",
")",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"levelStr",
")",
"{",
"case",
"\"",
"\"",
":",
"level",
"=",
"TraceLevel",
"\n",
"case",
"\"",
"\"",
":",
"level",
"=",
"InfoLevel",
"\n",
"case",
"\"",
... | // SetLevel sets the logging level of this package. levelStr should be one of "trace", "info", or "error | [
"SetLevel",
"sets",
"the",
"logging",
"level",
"of",
"this",
"package",
".",
"levelStr",
"should",
"be",
"one",
"of",
"trace",
"info",
"or",
"error"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L34-L45 |
16,074 | johnnadratowski/golang-neo4j-bolt-driver | log/log.go | Tracef | func Tracef(msg string, args ...interface{}) {
if level >= TraceLevel {
TraceLog.Printf(msg, args...)
}
} | go | func Tracef(msg string, args ...interface{}) {
if level >= TraceLevel {
TraceLog.Printf(msg, args...)
}
} | [
"func",
"Tracef",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">=",
"TraceLevel",
"{",
"TraceLog",
".",
"Printf",
"(",
"msg",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] | // Tracef writes a trace log in the format of Printf | [
"Tracef",
"writes",
"a",
"trace",
"log",
"in",
"the",
"format",
"of",
"Printf"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L60-L64 |
16,075 | johnnadratowski/golang-neo4j-bolt-driver | log/log.go | Infof | func Infof(msg string, args ...interface{}) {
if level >= InfoLevel {
InfoLog.Printf(msg, args...)
}
} | go | func Infof(msg string, args ...interface{}) {
if level >= InfoLevel {
InfoLog.Printf(msg, args...)
}
} | [
"func",
"Infof",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">=",
"InfoLevel",
"{",
"InfoLog",
".",
"Printf",
"(",
"msg",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] | // Infof writes an info log in the format of Printf | [
"Infof",
"writes",
"an",
"info",
"log",
"in",
"the",
"format",
"of",
"Printf"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L74-L78 |
16,076 | johnnadratowski/golang-neo4j-bolt-driver | log/log.go | Errorf | func Errorf(msg string, args ...interface{}) {
if level >= ErrorLevel {
ErrorLog.Printf(msg, args...)
}
} | go | func Errorf(msg string, args ...interface{}) {
if level >= ErrorLevel {
ErrorLog.Printf(msg, args...)
}
} | [
"func",
"Errorf",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">=",
"ErrorLevel",
"{",
"ErrorLog",
".",
"Printf",
"(",
"msg",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"}"
] | // Errorf writes an error log in the format of Printf | [
"Errorf",
"writes",
"an",
"error",
"log",
"in",
"the",
"format",
"of",
"Printf"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/log/log.go#L88-L92 |
16,077 | johnnadratowski/golang-neo4j-bolt-driver | encoding/encoder.go | NewEncoder | func NewEncoder(w io.Writer, chunkSize uint16) Encoder {
return Encoder{
w: w,
buf: &bytes.Buffer{},
chunkSize: chunkSize,
}
} | go | func NewEncoder(w io.Writer, chunkSize uint16) Encoder {
return Encoder{
w: w,
buf: &bytes.Buffer{},
chunkSize: chunkSize,
}
} | [
"func",
"NewEncoder",
"(",
"w",
"io",
".",
"Writer",
",",
"chunkSize",
"uint16",
")",
"Encoder",
"{",
"return",
"Encoder",
"{",
"w",
":",
"w",
",",
"buf",
":",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"chunkSize",
":",
"chunkSize",
",",
"}",
"\n... | // NewEncoder Creates a new Encoder object | [
"NewEncoder",
"Creates",
"a",
"new",
"Encoder",
"object"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L91-L97 |
16,078 | johnnadratowski/golang-neo4j-bolt-driver | encoding/encoder.go | Marshal | func Marshal(v interface{}) ([]byte, error) {
x := &bytes.Buffer{}
err := NewEncoder(x, math.MaxUint16).Encode(v)
return x.Bytes(), err
} | go | func Marshal(v interface{}) ([]byte, error) {
x := &bytes.Buffer{}
err := NewEncoder(x, math.MaxUint16).Encode(v)
return x.Bytes(), err
} | [
"func",
"Marshal",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"x",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"err",
":=",
"NewEncoder",
"(",
"x",
",",
"math",
".",
"MaxUint16",
")",
".",
"Encod... | // Marshal is used to marshal an object to the bolt interface encoded bytes | [
"Marshal",
"is",
"used",
"to",
"marshal",
"an",
"object",
"to",
"the",
"bolt",
"interface",
"encoded",
"bytes"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L100-L104 |
16,079 | johnnadratowski/golang-neo4j-bolt-driver | encoding/encoder.go | Write | func (e Encoder) Write(p []byte) (n int, err error) {
n, err = e.buf.Write(p)
if err != nil {
err = errors.Wrap(err, "An error occurred writing to encoder temp buffer")
return n, err
}
length := e.buf.Len()
for length >= int(e.chunkSize) {
if err := binary.Write(e.w, binary.BigEndian, e.chunkSize); err != nil {
return 0, errors.Wrap(err, "An error occured writing chunksize")
}
numWritten, err := e.w.Write(e.buf.Next(int(e.chunkSize)))
if err != nil {
err = errors.Wrap(err, "An error occured writing a chunk")
}
return numWritten, err
}
return n, nil
} | go | func (e Encoder) Write(p []byte) (n int, err error) {
n, err = e.buf.Write(p)
if err != nil {
err = errors.Wrap(err, "An error occurred writing to encoder temp buffer")
return n, err
}
length := e.buf.Len()
for length >= int(e.chunkSize) {
if err := binary.Write(e.w, binary.BigEndian, e.chunkSize); err != nil {
return 0, errors.Wrap(err, "An error occured writing chunksize")
}
numWritten, err := e.w.Write(e.buf.Next(int(e.chunkSize)))
if err != nil {
err = errors.Wrap(err, "An error occured writing a chunk")
}
return numWritten, err
}
return n, nil
} | [
"func",
"(",
"e",
"Encoder",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"n",
",",
"err",
"=",
"e",
".",
"buf",
".",
"Write",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=... | // write writes to the writer. Buffers the writes using chunkSize. | [
"write",
"writes",
"to",
"the",
"writer",
".",
"Buffers",
"the",
"writes",
"using",
"chunkSize",
"."
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L107-L130 |
16,080 | johnnadratowski/golang-neo4j-bolt-driver | encoding/encoder.go | flush | func (e Encoder) flush() error {
length := e.buf.Len()
if length > 0 {
if err := binary.Write(e.w, binary.BigEndian, uint16(length)); err != nil {
return errors.Wrap(err, "An error occured writing length bytes during flush")
}
if _, err := e.buf.WriteTo(e.w); err != nil {
return errors.Wrap(err, "An error occured writing message bytes during flush")
}
}
_, err := e.w.Write(EndMessage)
if err != nil {
return errors.Wrap(err, "An error occurred ending encoding message")
}
e.buf.Reset()
return nil
} | go | func (e Encoder) flush() error {
length := e.buf.Len()
if length > 0 {
if err := binary.Write(e.w, binary.BigEndian, uint16(length)); err != nil {
return errors.Wrap(err, "An error occured writing length bytes during flush")
}
if _, err := e.buf.WriteTo(e.w); err != nil {
return errors.Wrap(err, "An error occured writing message bytes during flush")
}
}
_, err := e.w.Write(EndMessage)
if err != nil {
return errors.Wrap(err, "An error occurred ending encoding message")
}
e.buf.Reset()
return nil
} | [
"func",
"(",
"e",
"Encoder",
")",
"flush",
"(",
")",
"error",
"{",
"length",
":=",
"e",
".",
"buf",
".",
"Len",
"(",
")",
"\n",
"if",
"length",
">",
"0",
"{",
"if",
"err",
":=",
"binary",
".",
"Write",
"(",
"e",
".",
"w",
",",
"binary",
".",
... | // flush finishes the encoding stream by flushing it to the writer | [
"flush",
"finishes",
"the",
"encoding",
"stream",
"by",
"flushing",
"it",
"to",
"the",
"writer"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/encoding/encoder.go#L133-L152 |
16,081 | johnnadratowski/golang-neo4j-bolt-driver | recorder.go | Read | func (r *recorder) Read(b []byte) (n int, err error) {
if r.Conn != nil {
numRead, err := r.Conn.Read(b)
if numRead > 0 {
r.record(b[:numRead], false)
}
if err != nil {
r.recordErr(err, false)
}
return numRead, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to read past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if event.IsWrite {
return 0, errors.New("Recorder expected Read, got Write! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to read past current event in recorder! Bytes: %s. Recorder %#v, Event; %#v", b, r, event)
}
b[i] = event.Event[0]
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | go | func (r *recorder) Read(b []byte) (n int, err error) {
if r.Conn != nil {
numRead, err := r.Conn.Read(b)
if numRead > 0 {
r.record(b[:numRead], false)
}
if err != nil {
r.recordErr(err, false)
}
return numRead, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to read past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if event.IsWrite {
return 0, errors.New("Recorder expected Read, got Write! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to read past current event in recorder! Bytes: %s. Recorder %#v, Event; %#v", b, r, event)
}
b[i] = event.Event[0]
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"r",
".",
"Conn",
"!=",
"nil",
"{",
"numRead",
",",
"err",
":=",
"r",
".",
"Conn",
".",
"Read",
"(",
"b",... | // Read from the net conn, recording the interaction | [
"Read",
"from",
"the",
"net",
"conn",
"recording",
"the",
"interaction"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/recorder.go#L58-L93 |
16,082 | johnnadratowski/golang-neo4j-bolt-driver | recorder.go | Close | func (r *recorder) Close() error {
if r.Conn != nil {
err := r.flush()
if err != nil {
return err
}
return r.Conn.Close()
} else if len(r.events) > 0 {
if r.currentEvent != len(r.events) {
return errors.New("Didn't read all of the events in the recorder on close! %#v", r)
}
if len(r.events[len(r.events)-1].Event) != 0 {
return errors.New("Left data in an event in the recorder on close! %#v", r)
}
return nil
}
return nil
} | go | func (r *recorder) Close() error {
if r.Conn != nil {
err := r.flush()
if err != nil {
return err
}
return r.Conn.Close()
} else if len(r.events) > 0 {
if r.currentEvent != len(r.events) {
return errors.New("Didn't read all of the events in the recorder on close! %#v", r)
}
if len(r.events[len(r.events)-1].Event) != 0 {
return errors.New("Left data in an event in the recorder on close! %#v", r)
}
return nil
}
return nil
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"Conn",
"!=",
"nil",
"{",
"err",
":=",
"r",
".",
"flush",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"r",... | // Close the net conn, outputting the recording | [
"Close",
"the",
"net",
"conn",
"outputting",
"the",
"recording"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/recorder.go#L96-L116 |
16,083 | johnnadratowski/golang-neo4j-bolt-driver | recorder.go | Write | func (r *recorder) Write(b []byte) (n int, err error) {
if r.Conn != nil {
numWritten, err := r.Conn.Write(b)
if numWritten > 0 {
r.record(b[:numWritten], true)
}
if err != nil {
r.recordErr(err, true)
}
return numWritten, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to write past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if !event.IsWrite {
return 0, errors.New("Recorder expected Write, got Read! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to write past current event in recorder! %#v, Event: %#v", r, event)
}
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | go | func (r *recorder) Write(b []byte) (n int, err error) {
if r.Conn != nil {
numWritten, err := r.Conn.Write(b)
if numWritten > 0 {
r.record(b[:numWritten], true)
}
if err != nil {
r.recordErr(err, true)
}
return numWritten, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to write past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if !event.IsWrite {
return 0, errors.New("Recorder expected Write, got Read! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to write past current event in recorder! %#v, Event: %#v", r, event)
}
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"r",
".",
"Conn",
"!=",
"nil",
"{",
"numWritten",
",",
"err",
":=",
"r",
".",
"Conn",
".",
"Write",
"(",
... | // Write to the net conn, recording the interaction | [
"Write",
"to",
"the",
"net",
"conn",
"recording",
"the",
"interaction"
] | 6b24c0085aaeaf3b2844acd18066864e24b57387 | https://github.com/johnnadratowski/golang-neo4j-bolt-driver/blob/6b24c0085aaeaf3b2844acd18066864e24b57387/recorder.go#L119-L153 |
16,084 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | init | func init() {
revel.RegisterServerEngine("fasthttp", func() revel.ServerEngine {
return &FastHTTPServer{}
})
revel.RegisterModuleInit(func(m *revel.Module) {
serverLog = m.Log
})
} | go | func init() {
revel.RegisterServerEngine("fasthttp", func() revel.ServerEngine {
return &FastHTTPServer{}
})
revel.RegisterModuleInit(func(m *revel.Module) {
serverLog = m.Log
})
} | [
"func",
"init",
"(",
")",
"{",
"revel",
".",
"RegisterServerEngine",
"(",
"\"",
"\"",
",",
"func",
"(",
")",
"revel",
".",
"ServerEngine",
"{",
"return",
"&",
"FastHTTPServer",
"{",
"}",
"\n",
"}",
")",
"\n",
"revel",
".",
"RegisterModuleInit",
"(",
"f... | // Called to initialize | [
"Called",
"to",
"initialize"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L39-L46 |
16,085 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Init | func (f *FastHTTPServer) Init(init *revel.EngineInit) {
f.MaxMultipartSize = int64(revel.Config.IntDefault("server.request.max.multipart.filesize", 32)) << 20 /* 32 MB */
fastHttpContextStack = utils.NewStackLock(revel.Config.IntDefault("server.context.stack", 100),
revel.Config.IntDefault("server.context.maxstack", 200),
func() interface{} { return NewFastHttpContext(f) })
fastHttpMultipartFormStack = utils.NewStackLock(revel.Config.IntDefault("server.form.stack", 100),
revel.Config.IntDefault("server.form.maxstack", 200),
func() interface{} { return &FastHttpMultipartForm{} })
requestHandler := func(ctx *fasthttp.RequestCtx) {
f.RequestHandler(ctx)
}
// Adds the mux list
f.HttpMuxList = init.HTTPMuxList
sort.Sort(f.HttpMuxList)
f.HasAppMux = len(f.HttpMuxList) > 0
f.signalChan = make(chan os.Signal)
f.ServerInit = init
f.Server = &fasthttp.Server{
ReadTimeout: time.Duration(revel.Config.IntDefault("http.timeout.read", 0)) * time.Second,
WriteTimeout: time.Duration(revel.Config.IntDefault("http.timeout.write", 0)) * time.Second,
Handler: requestHandler,
}
} | go | func (f *FastHTTPServer) Init(init *revel.EngineInit) {
f.MaxMultipartSize = int64(revel.Config.IntDefault("server.request.max.multipart.filesize", 32)) << 20 /* 32 MB */
fastHttpContextStack = utils.NewStackLock(revel.Config.IntDefault("server.context.stack", 100),
revel.Config.IntDefault("server.context.maxstack", 200),
func() interface{} { return NewFastHttpContext(f) })
fastHttpMultipartFormStack = utils.NewStackLock(revel.Config.IntDefault("server.form.stack", 100),
revel.Config.IntDefault("server.form.maxstack", 200),
func() interface{} { return &FastHttpMultipartForm{} })
requestHandler := func(ctx *fasthttp.RequestCtx) {
f.RequestHandler(ctx)
}
// Adds the mux list
f.HttpMuxList = init.HTTPMuxList
sort.Sort(f.HttpMuxList)
f.HasAppMux = len(f.HttpMuxList) > 0
f.signalChan = make(chan os.Signal)
f.ServerInit = init
f.Server = &fasthttp.Server{
ReadTimeout: time.Duration(revel.Config.IntDefault("http.timeout.read", 0)) * time.Second,
WriteTimeout: time.Duration(revel.Config.IntDefault("http.timeout.write", 0)) * time.Second,
Handler: requestHandler,
}
} | [
"func",
"(",
"f",
"*",
"FastHTTPServer",
")",
"Init",
"(",
"init",
"*",
"revel",
".",
"EngineInit",
")",
"{",
"f",
".",
"MaxMultipartSize",
"=",
"int64",
"(",
"revel",
".",
"Config",
".",
"IntDefault",
"(",
"\"",
"\"",
",",
"32",
")",
")",
"<<",
"2... | // Called to initialize the FastHttpServer | [
"Called",
"to",
"initialize",
"the",
"FastHttpServer"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L49-L75 |
16,086 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | RequestHandler | func (f *FastHTTPServer) RequestHandler(ctx *fasthttp.RequestCtx) {
// This section is called if the developer has added custom mux to the app
if f.HasAppMux && f.handleAppMux(ctx) {
return
}
f.handleMux(ctx)
} | go | func (f *FastHTTPServer) RequestHandler(ctx *fasthttp.RequestCtx) {
// This section is called if the developer has added custom mux to the app
if f.HasAppMux && f.handleAppMux(ctx) {
return
}
f.handleMux(ctx)
} | [
"func",
"(",
"f",
"*",
"FastHTTPServer",
")",
"RequestHandler",
"(",
"ctx",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"// This section is called if the developer has added custom mux to the app",
"if",
"f",
".",
"HasAppMux",
"&&",
"f",
".",
"handleAppMux",
"(",
... | // The root handler | [
"The",
"root",
"handler"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L111-L117 |
16,087 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Event | func (f *FastHTTPServer) Event(event revel.Event, args interface{}) revel.EventResponse {
switch event {
case revel.ENGINE_STARTED:
signal.Notify(f.signalChan, os.Interrupt, os.Kill)
go func() {
_ = <-f.signalChan
serverLog.Info("Received quit singal Please wait ... ")
revel.StopServer(nil)
}()
case revel.ENGINE_SHUTDOWN_REQUEST:
if err := f.graceful.Close(); err != nil {
serverLog.Fatal("Failed to close fasthttp server gracefully, exiting using os.exit", "error", err)
}
default:
}
return 0
} | go | func (f *FastHTTPServer) Event(event revel.Event, args interface{}) revel.EventResponse {
switch event {
case revel.ENGINE_STARTED:
signal.Notify(f.signalChan, os.Interrupt, os.Kill)
go func() {
_ = <-f.signalChan
serverLog.Info("Received quit singal Please wait ... ")
revel.StopServer(nil)
}()
case revel.ENGINE_SHUTDOWN_REQUEST:
if err := f.graceful.Close(); err != nil {
serverLog.Fatal("Failed to close fasthttp server gracefully, exiting using os.exit", "error", err)
}
default:
}
return 0
} | [
"func",
"(",
"f",
"*",
"FastHTTPServer",
")",
"Event",
"(",
"event",
"revel",
".",
"Event",
",",
"args",
"interface",
"{",
"}",
")",
"revel",
".",
"EventResponse",
"{",
"switch",
"event",
"{",
"case",
"revel",
".",
"ENGINE_STARTED",
":",
"signal",
".",
... | // Handle an event generated from Revel | [
"Handle",
"an",
"event",
"generated",
"from",
"Revel"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L197-L215 |
16,088 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | NewFastHttpContext | func NewFastHttpContext(instance *FastHTTPServer) *FastHttpContext {
if instance == nil {
instance = &FastHTTPServer{MaxMultipartSize: 32 << 20}
}
c := &FastHttpContext{
Request: &FastHttpRequest{header: &FastHttpHeader{isResponse: false},
Engine: instance},
Response: &FastHttpResponse{header: &FastHttpHeader{isResponse: true},
Engine: instance},
}
c.Response.header.Source = c.Response
c.Request.header.Source = c.Request
return c
} | go | func NewFastHttpContext(instance *FastHTTPServer) *FastHttpContext {
if instance == nil {
instance = &FastHTTPServer{MaxMultipartSize: 32 << 20}
}
c := &FastHttpContext{
Request: &FastHttpRequest{header: &FastHttpHeader{isResponse: false},
Engine: instance},
Response: &FastHttpResponse{header: &FastHttpHeader{isResponse: true},
Engine: instance},
}
c.Response.header.Source = c.Response
c.Request.header.Source = c.Request
return c
} | [
"func",
"NewFastHttpContext",
"(",
"instance",
"*",
"FastHTTPServer",
")",
"*",
"FastHttpContext",
"{",
"if",
"instance",
"==",
"nil",
"{",
"instance",
"=",
"&",
"FastHTTPServer",
"{",
"MaxMultipartSize",
":",
"32",
"<<",
"20",
"}",
"\n",
"}",
"\n",
"c",
"... | // Create a new context | [
"Create",
"a",
"new",
"context"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L283-L296 |
16,089 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | SetContext | func (c *FastHttpContext) SetContext(context *fasthttp.RequestCtx) {
c.Response.SetContext(context)
c.Request.SetContext(context)
} | go | func (c *FastHttpContext) SetContext(context *fasthttp.RequestCtx) {
c.Response.SetContext(context)
c.Request.SetContext(context)
} | [
"func",
"(",
"c",
"*",
"FastHttpContext",
")",
"SetContext",
"(",
"context",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"c",
".",
"Response",
".",
"SetContext",
"(",
"context",
")",
"\n",
"c",
".",
"Request",
".",
"SetContext",
"(",
"context",
")",
... | // Called to set the context | [
"Called",
"to",
"set",
"the",
"context"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L309-L312 |
16,090 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Get | func (r *FastHttpRequest) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.GetHeader()
case revel.HTTP_MULTIPART_FORM:
value, err = r.GetMultipartForm()
case revel.HTTP_QUERY:
value = r.GetQuery()
case revel.HTTP_FORM:
value, err = r.GetForm()
case revel.HTTP_REQUEST_URI:
value = string(r.Original.RequestURI())
case revel.HTTP_REMOTE_ADDR:
value = r.Original.RemoteAddr().String()
case revel.HTTP_METHOD:
value = string(r.Original.Method())
case revel.HTTP_PATH:
value = string(r.Original.Path())
case revel.HTTP_HOST:
value = string(r.Original.Request.Host())
case revel.HTTP_URL:
if r.url == nil {
r.url, _ = url.Parse(string(r.Original.Request.URI().FullURI()))
}
value = r.url
case revel.HTTP_BODY:
value = bytes.NewBuffer(r.Original.Request.Body())
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | go | func (r *FastHttpRequest) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.GetHeader()
case revel.HTTP_MULTIPART_FORM:
value, err = r.GetMultipartForm()
case revel.HTTP_QUERY:
value = r.GetQuery()
case revel.HTTP_FORM:
value, err = r.GetForm()
case revel.HTTP_REQUEST_URI:
value = string(r.Original.RequestURI())
case revel.HTTP_REMOTE_ADDR:
value = r.Original.RemoteAddr().String()
case revel.HTTP_METHOD:
value = string(r.Original.Method())
case revel.HTTP_PATH:
value = string(r.Original.Path())
case revel.HTTP_HOST:
value = string(r.Original.Request.Host())
case revel.HTTP_URL:
if r.url == nil {
r.url, _ = url.Parse(string(r.Original.Request.URI().FullURI()))
}
value = r.url
case revel.HTTP_BODY:
value = bytes.NewBuffer(r.Original.Request.Body())
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | [
"func",
"(",
"r",
"*",
"FastHttpRequest",
")",
"Get",
"(",
"key",
"int",
")",
"(",
"value",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"switch",
"key",
"{",
"case",
"revel",
".",
"HTTP_SERVER_HEADER",
":",
"value",
"=",
"r",
".",
"GetHeade... | // Gets the value from the request | [
"Gets",
"the",
"value",
"from",
"the",
"request"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L321-L353 |
16,091 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | GetQuery | func (r *FastHttpRequest) GetQuery() url.Values {
if !r.toQuery {
// Attempt to convert to query
r.query = url.Values{}
r.Original.QueryArgs().VisitAll(func(key, value []byte) {
r.query.Set(string(key), string(value))
})
r.toQuery = true
}
return r.query
} | go | func (r *FastHttpRequest) GetQuery() url.Values {
if !r.toQuery {
// Attempt to convert to query
r.query = url.Values{}
r.Original.QueryArgs().VisitAll(func(key, value []byte) {
r.query.Set(string(key), string(value))
})
r.toQuery = true
}
return r.query
} | [
"func",
"(",
"r",
"*",
"FastHttpRequest",
")",
"GetQuery",
"(",
")",
"url",
".",
"Values",
"{",
"if",
"!",
"r",
".",
"toQuery",
"{",
"// Attempt to convert to query",
"r",
".",
"query",
"=",
"url",
".",
"Values",
"{",
"}",
"\n",
"r",
".",
"Original",
... | // Returns the query string | [
"Returns",
"the",
"query",
"string"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L361-L371 |
16,092 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Destroy | func (r *FastHttpRequest) Destroy() {
r.Original = nil
r.FormParsed = false
r.MultiFormParsed = false
r.ParsedForm = nil
r.toQuery = false
} | go | func (r *FastHttpRequest) Destroy() {
r.Original = nil
r.FormParsed = false
r.MultiFormParsed = false
r.ParsedForm = nil
r.toQuery = false
} | [
"func",
"(",
"r",
"*",
"FastHttpRequest",
")",
"Destroy",
"(",
")",
"{",
"r",
".",
"Original",
"=",
"nil",
"\n",
"r",
".",
"FormParsed",
"=",
"false",
"\n",
"r",
".",
"MultiFormParsed",
"=",
"false",
"\n",
"r",
".",
"ParsedForm",
"=",
"nil",
"\n",
... | // Called when request is done | [
"Called",
"when",
"request",
"is",
"done"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L418-L425 |
16,093 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Get | func (r *FastHttpResponse) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.Header()
case revel.HTTP_STREAM_WRITER:
value = r
case revel.HTTP_WRITER:
value = r.Writer
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | go | func (r *FastHttpResponse) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.Header()
case revel.HTTP_STREAM_WRITER:
value = r
case revel.HTTP_WRITER:
value = r.Writer
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | [
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"Get",
"(",
"key",
"int",
")",
"(",
"value",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"switch",
"key",
"{",
"case",
"revel",
".",
"HTTP_SERVER_HEADER",
":",
"value",
"=",
"r",
".",
"Header"... | // gets the key from the response | [
"gets",
"the",
"key",
"from",
"the",
"response"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L428-L440 |
16,094 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Set | func (r *FastHttpResponse) Set(key int, value interface{}) (set bool) {
switch key {
case revel.ENGINE_RESPONSE_STATUS:
r.Header().SetStatus(value.(int))
set = true
case revel.HTTP_WRITER:
r.SetWriter(value.(io.Writer))
set = true
}
return
} | go | func (r *FastHttpResponse) Set(key int, value interface{}) (set bool) {
switch key {
case revel.ENGINE_RESPONSE_STATUS:
r.Header().SetStatus(value.(int))
set = true
case revel.HTTP_WRITER:
r.SetWriter(value.(io.Writer))
set = true
}
return
} | [
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"Set",
"(",
"key",
"int",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"set",
"bool",
")",
"{",
"switch",
"key",
"{",
"case",
"revel",
".",
"ENGINE_RESPONSE_STATUS",
":",
"r",
".",
"Header",
"(",
")",... | // Sets the key with the value | [
"Sets",
"the",
"key",
"with",
"the",
"value"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L443-L453 |
16,095 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | WriteStream | func (r *FastHttpResponse) WriteStream(name string, contentlen int64, modtime time.Time, reader io.Reader) error {
// do a simple io.Copy, we do it directly into the writer which may be configured to be a compressed
// writer
ius := r.Original.Request.Header.Peek("If-Unmodified-Since")
if t, err := http.ParseTime(string(ius)); ius != nil && err == nil && !modtime.IsZero() {
// The Date-Modified header truncates sub-second precision, so
// use mtime < t+1s instead of mtime <= t to check for unmodified.
if modtime.Before(t.Add(1 * time.Second)) {
h := r.Original.Response.Header
h.Del("Content-Type")
h.Del("Content-Length")
if h.Peek("Etag") != nil {
h.Del("Last-Modified")
}
h.SetStatusCode(http.StatusNotModified)
return nil
}
}
if contentlen != -1 {
r.Original.Response.Header.Set("Content-Length", strconv.FormatInt(contentlen, 10))
}
if _, err := io.Copy(r.Writer, reader); err != nil {
r.Original.Response.Header.SetStatusCode(http.StatusInternalServerError)
return err
} else {
r.Original.Response.Header.SetStatusCode(http.StatusOK)
}
return nil
} | go | func (r *FastHttpResponse) WriteStream(name string, contentlen int64, modtime time.Time, reader io.Reader) error {
// do a simple io.Copy, we do it directly into the writer which may be configured to be a compressed
// writer
ius := r.Original.Request.Header.Peek("If-Unmodified-Since")
if t, err := http.ParseTime(string(ius)); ius != nil && err == nil && !modtime.IsZero() {
// The Date-Modified header truncates sub-second precision, so
// use mtime < t+1s instead of mtime <= t to check for unmodified.
if modtime.Before(t.Add(1 * time.Second)) {
h := r.Original.Response.Header
h.Del("Content-Type")
h.Del("Content-Length")
if h.Peek("Etag") != nil {
h.Del("Last-Modified")
}
h.SetStatusCode(http.StatusNotModified)
return nil
}
}
if contentlen != -1 {
r.Original.Response.Header.Set("Content-Length", strconv.FormatInt(contentlen, 10))
}
if _, err := io.Copy(r.Writer, reader); err != nil {
r.Original.Response.Header.SetStatusCode(http.StatusInternalServerError)
return err
} else {
r.Original.Response.Header.SetStatusCode(http.StatusOK)
}
return nil
} | [
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"WriteStream",
"(",
"name",
"string",
",",
"contentlen",
"int64",
",",
"modtime",
"time",
".",
"Time",
",",
"reader",
"io",
".",
"Reader",
")",
"error",
"{",
"// do a simple io.Copy, we do it directly into the writer... | // Writes a stream to the response | [
"Writes",
"a",
"stream",
"to",
"the",
"response"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L471-L502 |
16,096 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Destroy | func (r *FastHttpResponse) Destroy() {
if c, ok := r.Writer.(io.Closer); ok {
c.Close()
}
r.Original = nil
r.Writer = nil
} | go | func (r *FastHttpResponse) Destroy() {
if c, ok := r.Writer.(io.Closer); ok {
c.Close()
}
r.Original = nil
r.Writer = nil
} | [
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"Destroy",
"(",
")",
"{",
"if",
"c",
",",
"ok",
":=",
"r",
".",
"Writer",
".",
"(",
"io",
".",
"Closer",
")",
";",
"ok",
"{",
"c",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"r",
".",
"Original",
... | // Called to reset this response | [
"Called",
"to",
"reset",
"this",
"response"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L505-L512 |
16,097 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | SetContext | func (r *FastHttpResponse) SetContext(w *fasthttp.RequestCtx) {
r.Original = w
r.Writer = w.Response.BodyWriter()
} | go | func (r *FastHttpResponse) SetContext(w *fasthttp.RequestCtx) {
r.Original = w
r.Writer = w.Response.BodyWriter()
} | [
"func",
"(",
"r",
"*",
"FastHttpResponse",
")",
"SetContext",
"(",
"w",
"*",
"fasthttp",
".",
"RequestCtx",
")",
"{",
"r",
".",
"Original",
"=",
"w",
"\n",
"r",
".",
"Writer",
"=",
"w",
".",
"Response",
".",
"BodyWriter",
"(",
")",
"\n",
"}"
] | // Sets the context | [
"Sets",
"the",
"context"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L515-L518 |
16,098 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | SetCookie | func (r *FastHttpHeader) SetCookie(cookie string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Add("Set-Cookie", cookie)
}
} | go | func (r *FastHttpHeader) SetCookie(cookie string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Add("Set-Cookie", cookie)
}
} | [
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"SetCookie",
"(",
"cookie",
"string",
")",
"{",
"if",
"r",
".",
"isResponse",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"Add",
... | // Sets a cookie | [
"Sets",
"a",
"cookie"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L526-L530 |
16,099 | revel/modules | server-engine/fasthttp/app/server-fasthttp.go | Del | func (r *FastHttpHeader) Del(key string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Del(key)
}
} | go | func (r *FastHttpHeader) Del(key string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Del(key)
}
} | [
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"Del",
"(",
"key",
"string",
")",
"{",
"if",
"r",
".",
"isResponse",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"Del",
"(",
"k... | // Deletes a header key | [
"Deletes",
"a",
"header",
"key"
] | 2737bfdaa8c41da68eae12bb18f7279b9f156048 | https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L561-L565 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.