id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
141,700 | markbates/inflect | inflect.go | Camelize | func (rs *Ruleset) Camelize(word string) string {
if rs.isAcronym(word) {
return strings.ToUpper(word)
}
words := splitAtCaseChangeWithTitlecase(word)
return strings.Join(words, "")
} | go | func (rs *Ruleset) Camelize(word string) string {
if rs.isAcronym(word) {
return strings.ToUpper(word)
}
words := splitAtCaseChangeWithTitlecase(word)
return strings.Join(words, "")
} | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"Camelize",
"(",
"word",
"string",
")",
"string",
"{",
"if",
"rs",
".",
"isAcronym",
"(",
"word",
")",
"{",
"return",
"strings",
".",
"ToUpper",
"(",
"word",
")",
"\n",
"}",
"\n",
"words",
":=",
"splitAtCaseCha... | //Camelize "dino_party" -> "DinoParty" | [
"Camelize",
"dino_party",
"-",
">",
"DinoParty"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L467-L473 |
141,701 | markbates/inflect | inflect.go | CamelizeDownFirst | func (rs *Ruleset) CamelizeDownFirst(word string) string {
word = Camelize(word)
return strings.ToLower(word[:1]) + word[1:]
} | go | func (rs *Ruleset) CamelizeDownFirst(word string) string {
word = Camelize(word)
return strings.ToLower(word[:1]) + word[1:]
} | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"CamelizeDownFirst",
"(",
"word",
"string",
")",
"string",
"{",
"word",
"=",
"Camelize",
"(",
"word",
")",
"\n",
"return",
"strings",
".",
"ToLower",
"(",
"word",
"[",
":",
"1",
"]",
")",
"+",
"word",
"[",
"1... | //CamelizeDownFirst same as Camelcase but with first letter downcased | [
"CamelizeDownFirst",
"same",
"as",
"Camelcase",
"but",
"with",
"first",
"letter",
"downcased"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L476-L479 |
141,702 | markbates/inflect | inflect.go | Titleize | func (rs *Ruleset) Titleize(word string) string {
words := splitAtCaseChangeWithTitlecase(word)
result := strings.Join(words, " ")
var acronymWords []string
for index, word := range words {
if len(word) == 1 {
acronymWords = append(acronymWords, word)
}
if len(word) > 1 || index == len(words)-1 || len(ac... | go | func (rs *Ruleset) Titleize(word string) string {
words := splitAtCaseChangeWithTitlecase(word)
result := strings.Join(words, " ")
var acronymWords []string
for index, word := range words {
if len(word) == 1 {
acronymWords = append(acronymWords, word)
}
if len(word) > 1 || index == len(words)-1 || len(ac... | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"Titleize",
"(",
"word",
"string",
")",
"string",
"{",
"words",
":=",
"splitAtCaseChangeWithTitlecase",
"(",
"word",
")",
"\n",
"result",
":=",
"strings",
".",
"Join",
"(",
"words",
",",
"\"",
"\"",
")",
"\n\n",
... | //Titleize Capitalize every word in sentence "hello there" -> "Hello There" | [
"Titleize",
"Capitalize",
"every",
"word",
"in",
"sentence",
"hello",
"there",
"-",
">",
"Hello",
"There"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L482-L505 |
141,703 | markbates/inflect | inflect.go | ForeignKey | func (rs *Ruleset) ForeignKey(word string) string {
return rs.Underscore(rs.Singularize(word)) + "_id"
} | go | func (rs *Ruleset) ForeignKey(word string) string {
return rs.Underscore(rs.Singularize(word)) + "_id"
} | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"ForeignKey",
"(",
"word",
"string",
")",
"string",
"{",
"return",
"rs",
".",
"Underscore",
"(",
"rs",
".",
"Singularize",
"(",
"word",
")",
")",
"+",
"\"",
"\"",
"\n",
"}"
] | //ForeignKey an underscored foreign key name "Person" -> "person_id" | [
"ForeignKey",
"an",
"underscored",
"foreign",
"key",
"name",
"Person",
"-",
">",
"person_id"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L541-L543 |
141,704 | markbates/inflect | inflect.go | ParameterizeJoin | func (rs *Ruleset) ParameterizeJoin(word, sep string) string {
word = strings.ToLower(word)
word = rs.Asciify(word)
word = notUrlSafe.ReplaceAllString(word, "")
word = strings.Replace(word, " ", sep, -1)
if len(sep) > 0 {
squash, err := regexp.Compile(sep + "+")
if err == nil {
word = squash.ReplaceAllStrin... | go | func (rs *Ruleset) ParameterizeJoin(word, sep string) string {
word = strings.ToLower(word)
word = rs.Asciify(word)
word = notUrlSafe.ReplaceAllString(word, "")
word = strings.Replace(word, " ", sep, -1)
if len(sep) > 0 {
squash, err := regexp.Compile(sep + "+")
if err == nil {
word = squash.ReplaceAllStrin... | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"ParameterizeJoin",
"(",
"word",
",",
"sep",
"string",
")",
"string",
"{",
"word",
"=",
"strings",
".",
"ToLower",
"(",
"word",
")",
"\n",
"word",
"=",
"rs",
".",
"Asciify",
"(",
"word",
")",
"\n",
"word",
"=... | //ParameterizeJoin param safe dasherized names with custom separator | [
"ParameterizeJoin",
"param",
"safe",
"dasherized",
"names",
"with",
"custom",
"separator"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L563-L576 |
141,705 | markbates/inflect | inflect.go | Typeify | func (rs *Ruleset) Typeify(word string) string {
word = tablePrefix.ReplaceAllString(word, "")
return rs.Camelize(rs.Singularize(word))
} | go | func (rs *Ruleset) Typeify(word string) string {
word = tablePrefix.ReplaceAllString(word, "")
return rs.Camelize(rs.Singularize(word))
} | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"Typeify",
"(",
"word",
"string",
")",
"string",
"{",
"word",
"=",
"tablePrefix",
".",
"ReplaceAllString",
"(",
"word",
",",
"\"",
"\"",
")",
"\n",
"return",
"rs",
".",
"Camelize",
"(",
"rs",
".",
"Singularize",
... | //Typeify "something_like_this" -> "SomethingLikeThis" | [
"Typeify",
"something_like_this",
"-",
">",
"SomethingLikeThis"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L615-L618 |
141,706 | markbates/inflect | inflect.go | Ordinalize | func (rs *Ruleset) Ordinalize(str string) string {
number, err := strconv.Atoi(str)
if err != nil {
return str
}
switch abs(number) % 100 {
case 11, 12, 13:
return fmt.Sprintf("%dth", number)
default:
switch abs(number) % 10 {
case 1:
return fmt.Sprintf("%dst", number)
case 2:
return fmt.Sprintf("... | go | func (rs *Ruleset) Ordinalize(str string) string {
number, err := strconv.Atoi(str)
if err != nil {
return str
}
switch abs(number) % 100 {
case 11, 12, 13:
return fmt.Sprintf("%dth", number)
default:
switch abs(number) % 10 {
case 1:
return fmt.Sprintf("%dst", number)
case 2:
return fmt.Sprintf("... | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"Ordinalize",
"(",
"str",
"string",
")",
"string",
"{",
"number",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"str",
"\n",
"}",
"\n",
"switch",
... | //Ordinalize "1031" -> "1031st" | [
"Ordinalize",
"1031",
"-",
">",
"1031st"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L626-L645 |
141,707 | markbates/inflect | inflect.go | ForeignKeyToAttribute | func (rs *Ruleset) ForeignKeyToAttribute(str string) string {
w := rs.Camelize(str)
if strings.HasSuffix(w, "Id") {
return strings.TrimSuffix(w, "Id") + "ID"
}
return w
} | go | func (rs *Ruleset) ForeignKeyToAttribute(str string) string {
w := rs.Camelize(str)
if strings.HasSuffix(w, "Id") {
return strings.TrimSuffix(w, "Id") + "ID"
}
return w
} | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"ForeignKeyToAttribute",
"(",
"str",
"string",
")",
"string",
"{",
"w",
":=",
"rs",
".",
"Camelize",
"(",
"str",
")",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"w",
",",
"\"",
"\"",
")",
"{",
"return",
"s... | //ForeignKeyToAttribute returns the attribute name from the foreign key | [
"ForeignKeyToAttribute",
"returns",
"the",
"attribute",
"name",
"from",
"the",
"foreign",
"key"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L648-L654 |
141,708 | markbates/inflect | inflect.go | LoadReader | func (rs *Ruleset) LoadReader(r io.Reader) error {
m := map[string]string{}
err := json.NewDecoder(r).Decode(&m)
if err != nil {
return fmt.Errorf("could not decode inflection JSON from reader: %s", err)
}
for s, p := range m {
defaultRuleset.AddIrregular(s, p)
}
return nil
} | go | func (rs *Ruleset) LoadReader(r io.Reader) error {
m := map[string]string{}
err := json.NewDecoder(r).Decode(&m)
if err != nil {
return fmt.Errorf("could not decode inflection JSON from reader: %s", err)
}
for s, p := range m {
defaultRuleset.AddIrregular(s, p)
}
return nil
} | [
"func",
"(",
"rs",
"*",
"Ruleset",
")",
"LoadReader",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
")",
".",
"Decode",
"(",
"... | //LoadReader loads rules from io.Reader param | [
"LoadReader",
"loads",
"rules",
"from",
"io",
".",
"Reader",
"param"
] | d582c680dc4d29c2279628ae00e743005bfcd4fe | https://github.com/markbates/inflect/blob/d582c680dc4d29c2279628ae00e743005bfcd4fe/inflect.go#L657-L667 |
141,709 | ChannelMeter/iso8601duration | duration.go | String | func (d *Duration) String() string {
var s bytes.Buffer
err := tmpl.Execute(&s, d)
if err != nil {
panic(err)
}
return s.String()
} | go | func (d *Duration) String() string {
var s bytes.Buffer
err := tmpl.Execute(&s, d)
if err != nil {
panic(err)
}
return s.String()
} | [
"func",
"(",
"d",
"*",
"Duration",
")",
"String",
"(",
")",
"string",
"{",
"var",
"s",
"bytes",
".",
"Buffer",
"\n\n",
"err",
":=",
"tmpl",
".",
"Execute",
"(",
"&",
"s",
",",
"d",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
... | // String prints out the value passed in. It's not strictly according to the
// ISO spec, but it's pretty close. In particular, to completely conform it
// would need to round up to the next largest unit. 61 seconds to 1 minute 1
// second, for example. It would also need to disallow weeks mingling with
// other units. | [
"String",
"prints",
"out",
"the",
"value",
"passed",
"in",
".",
"It",
"s",
"not",
"strictly",
"according",
"to",
"the",
"ISO",
"spec",
"but",
"it",
"s",
"pretty",
"close",
".",
"In",
"particular",
"to",
"completely",
"conform",
"it",
"would",
"need",
"to... | 8da3af7a2a61a4eb5ae9bddec06bf637fa9593da | https://github.com/ChannelMeter/iso8601duration/blob/8da3af7a2a61a4eb5ae9bddec06bf637fa9593da/duration.go#L92-L101 |
141,710 | peterbourgon/g2s | g2s.go | bufferize | func bufferize(sendables []sendable, max int) [][]byte {
bN := [][]byte{}
b1, b1sz := []byte{}, 0
for _, sendable := range sendables {
buf := []byte(sendable.Message())
if b1sz+len(buf) > max {
bN = append(bN, b1)
b1, b1sz = []byte{}, 0
}
b1 = append(b1, buf...)
b1sz += len(buf)
}
if len(b1) > 0 ... | go | func bufferize(sendables []sendable, max int) [][]byte {
bN := [][]byte{}
b1, b1sz := []byte{}, 0
for _, sendable := range sendables {
buf := []byte(sendable.Message())
if b1sz+len(buf) > max {
bN = append(bN, b1)
b1, b1sz = []byte{}, 0
}
b1 = append(b1, buf...)
b1sz += len(buf)
}
if len(b1) > 0 ... | [
"func",
"bufferize",
"(",
"sendables",
"[",
"]",
"sendable",
",",
"max",
"int",
")",
"[",
"]",
"[",
"]",
"byte",
"{",
"bN",
":=",
"[",
"]",
"[",
"]",
"byte",
"{",
"}",
"\n",
"b1",
",",
"b1sz",
":=",
"[",
"]",
"byte",
"{",
"}",
",",
"0",
"\n... | // bufferize folds the slice of sendables into a slice of byte-buffers,
// each of which shall be no larger than max bytes. | [
"bufferize",
"folds",
"the",
"slice",
"of",
"sendables",
"into",
"a",
"slice",
"of",
"byte",
"-",
"buffers",
"each",
"of",
"which",
"shall",
"be",
"no",
"larger",
"than",
"max",
"bytes",
"."
] | d4e7ad98afea530d947adb4490aa062353856767 | https://github.com/peterbourgon/g2s/blob/d4e7ad98afea530d947adb4490aa062353856767/g2s.go#L69-L88 |
141,711 | peterbourgon/g2s | g2s.go | publish | func (s *Statsd) publish(msgs []sendable) {
for _, buf := range bufferize(msgs, maxPacketSize) {
// In the base case, when the Statsd struct is backed by a net.Conn,
// "Multiple goroutines may invoke methods on a Conn simultaneously."
// -- http://golang.org/pkg/net/#Conn
// Otherwise, Bring Your Own Synchr... | go | func (s *Statsd) publish(msgs []sendable) {
for _, buf := range bufferize(msgs, maxPacketSize) {
// In the base case, when the Statsd struct is backed by a net.Conn,
// "Multiple goroutines may invoke methods on a Conn simultaneously."
// -- http://golang.org/pkg/net/#Conn
// Otherwise, Bring Your Own Synchr... | [
"func",
"(",
"s",
"*",
"Statsd",
")",
"publish",
"(",
"msgs",
"[",
"]",
"sendable",
")",
"{",
"for",
"_",
",",
"buf",
":=",
"range",
"bufferize",
"(",
"msgs",
",",
"maxPacketSize",
")",
"{",
"// In the base case, when the Statsd struct is backed by a net.Conn,",... | // publish folds the slice of sendables into one or more packets, each of which
// will be no larger than maxPacketSize. It then writes them, one by one,
// into the Statsd io.Writer. | [
"publish",
"folds",
"the",
"slice",
"of",
"sendables",
"into",
"one",
"or",
"more",
"packets",
"each",
"of",
"which",
"will",
"be",
"no",
"larger",
"than",
"maxPacketSize",
".",
"It",
"then",
"writes",
"them",
"one",
"by",
"one",
"into",
"the",
"Statsd",
... | d4e7ad98afea530d947adb4490aa062353856767 | https://github.com/peterbourgon/g2s/blob/d4e7ad98afea530d947adb4490aa062353856767/g2s.go#L93-L106 |
141,712 | peterbourgon/g2s | g2s.go | maybeSample | func maybeSample(r float32) (sampling, bool) {
if r >= 1.0 {
return sampling{}, true
}
if rand.Float32() > r {
return sampling{}, false
}
return sampling{
enabled: true,
rate: r,
}, true
} | go | func maybeSample(r float32) (sampling, bool) {
if r >= 1.0 {
return sampling{}, true
}
if rand.Float32() > r {
return sampling{}, false
}
return sampling{
enabled: true,
rate: r,
}, true
} | [
"func",
"maybeSample",
"(",
"r",
"float32",
")",
"(",
"sampling",
",",
"bool",
")",
"{",
"if",
"r",
">=",
"1.0",
"{",
"return",
"sampling",
"{",
"}",
",",
"true",
"\n",
"}",
"\n\n",
"if",
"rand",
".",
"Float32",
"(",
")",
">",
"r",
"{",
"return",... | // maybeSample returns a sampling structure and true if a pseudorandom number
// in the range 0..1 is less than or equal to the passed rate.
//
// As a special case, if r >= 1.0, maybeSample will return an uninitialized
// sampling structure and true. The uninitialized sampling structure implies
// enabled == false, wh... | [
"maybeSample",
"returns",
"a",
"sampling",
"structure",
"and",
"true",
"if",
"a",
"pseudorandom",
"number",
"in",
"the",
"range",
"0",
"..",
"1",
"is",
"less",
"than",
"or",
"equal",
"to",
"the",
"passed",
"rate",
".",
"As",
"a",
"special",
"case",
"if",... | d4e7ad98afea530d947adb4490aa062353856767 | https://github.com/peterbourgon/g2s/blob/d4e7ad98afea530d947adb4490aa062353856767/g2s.go#L114-L127 |
141,713 | peterbourgon/g2s | g2s.go | Counter | func (s *Statsd) Counter(sampleRate float32, bucket string, n ...int) {
samp, ok := maybeSample(sampleRate)
if !ok {
return
}
msgs := make([]sendable, len(n))
for i, ni := range n {
msgs[i] = &counterUpdate{
prefix: s.prefix,
bucket: bucket,
n: ni,
sampling: samp,
}
}
s.publish(msg... | go | func (s *Statsd) Counter(sampleRate float32, bucket string, n ...int) {
samp, ok := maybeSample(sampleRate)
if !ok {
return
}
msgs := make([]sendable, len(n))
for i, ni := range n {
msgs[i] = &counterUpdate{
prefix: s.prefix,
bucket: bucket,
n: ni,
sampling: samp,
}
}
s.publish(msg... | [
"func",
"(",
"s",
"*",
"Statsd",
")",
"Counter",
"(",
"sampleRate",
"float32",
",",
"bucket",
"string",
",",
"n",
"...",
"int",
")",
"{",
"samp",
",",
"ok",
":=",
"maybeSample",
"(",
"sampleRate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}... | // Counter sends one or more counter statistics to StatsD.
//
// Application code should call it for every potential invocation of a
// statistic; it uses the sampleRate to determine whether or not to send or
// squelch the data, on an aggregate basis. | [
"Counter",
"sends",
"one",
"or",
"more",
"counter",
"statistics",
"to",
"StatsD",
".",
"Application",
"code",
"should",
"call",
"it",
"for",
"every",
"potential",
"invocation",
"of",
"a",
"statistic",
";",
"it",
"uses",
"the",
"sampleRate",
"to",
"determine",
... | d4e7ad98afea530d947adb4490aa062353856767 | https://github.com/peterbourgon/g2s/blob/d4e7ad98afea530d947adb4490aa062353856767/g2s.go#L134-L151 |
141,714 | peterbourgon/g2s | g2s.go | Timing | func (s *Statsd) Timing(sampleRate float32, bucket string, d ...time.Duration) {
samp, ok := maybeSample(sampleRate)
if !ok {
return
}
msgs := make([]sendable, len(d))
for i, di := range d {
msgs[i] = &timingUpdate{
prefix: s.prefix,
bucket: bucket,
ms: int(di.Nanoseconds() / 1e6),
sampl... | go | func (s *Statsd) Timing(sampleRate float32, bucket string, d ...time.Duration) {
samp, ok := maybeSample(sampleRate)
if !ok {
return
}
msgs := make([]sendable, len(d))
for i, di := range d {
msgs[i] = &timingUpdate{
prefix: s.prefix,
bucket: bucket,
ms: int(di.Nanoseconds() / 1e6),
sampl... | [
"func",
"(",
"s",
"*",
"Statsd",
")",
"Timing",
"(",
"sampleRate",
"float32",
",",
"bucket",
"string",
",",
"d",
"...",
"time",
".",
"Duration",
")",
"{",
"samp",
",",
"ok",
":=",
"maybeSample",
"(",
"sampleRate",
")",
"\n",
"if",
"!",
"ok",
"{",
"... | // Timing sends one or more timing statistics to StatsD.
//
// Application code should call it for every potential invocation of a
// statistic; it uses the sampleRate to determine whether or not to send or
// squelch the data, on an aggregate basis. | [
"Timing",
"sends",
"one",
"or",
"more",
"timing",
"statistics",
"to",
"StatsD",
".",
"Application",
"code",
"should",
"call",
"it",
"for",
"every",
"potential",
"invocation",
"of",
"a",
"statistic",
";",
"it",
"uses",
"the",
"sampleRate",
"to",
"determine",
... | d4e7ad98afea530d947adb4490aa062353856767 | https://github.com/peterbourgon/g2s/blob/d4e7ad98afea530d947adb4490aa062353856767/g2s.go#L158-L175 |
141,715 | peterbourgon/g2s | g2s.go | Gauge | func (s *Statsd) Gauge(sampleRate float32, bucket string, v ...string) {
samp, ok := maybeSample(sampleRate)
if !ok {
return
}
msgs := make([]sendable, len(v))
for i, vi := range v {
msgs[i] = &gaugeUpdate{
prefix: s.prefix,
bucket: bucket,
val: vi,
sampling: samp,
}
}
s.publish(msgs... | go | func (s *Statsd) Gauge(sampleRate float32, bucket string, v ...string) {
samp, ok := maybeSample(sampleRate)
if !ok {
return
}
msgs := make([]sendable, len(v))
for i, vi := range v {
msgs[i] = &gaugeUpdate{
prefix: s.prefix,
bucket: bucket,
val: vi,
sampling: samp,
}
}
s.publish(msgs... | [
"func",
"(",
"s",
"*",
"Statsd",
")",
"Gauge",
"(",
"sampleRate",
"float32",
",",
"bucket",
"string",
",",
"v",
"...",
"string",
")",
"{",
"samp",
",",
"ok",
":=",
"maybeSample",
"(",
"sampleRate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"... | // Gauge sends one or more gauge statistics to Statsd.
//
// Application code should call it for every potential invocation of a
// statistic; it uses the sampleRate to determine whether or not to send or
// squelch the data, on an aggregate basis. | [
"Gauge",
"sends",
"one",
"or",
"more",
"gauge",
"statistics",
"to",
"Statsd",
".",
"Application",
"code",
"should",
"call",
"it",
"for",
"every",
"potential",
"invocation",
"of",
"a",
"statistic",
";",
"it",
"uses",
"the",
"sampleRate",
"to",
"determine",
"w... | d4e7ad98afea530d947adb4490aa062353856767 | https://github.com/peterbourgon/g2s/blob/d4e7ad98afea530d947adb4490aa062353856767/g2s.go#L182-L199 |
141,716 | shengdoushi/base58 | base58.go | Encode | func Encode(input []byte, alphabet *Alphabet) string {
// prefix 0
inputLength := len(input)
prefixZeroes := 0
for prefixZeroes < inputLength && input[prefixZeroes] == 0 {
prefixZeroes++
}
capacity := (inputLength-prefixZeroes)*138/100 + 1 // log256 / log58
output := make([]byte, capacity)
outputReverseEnd :... | go | func Encode(input []byte, alphabet *Alphabet) string {
// prefix 0
inputLength := len(input)
prefixZeroes := 0
for prefixZeroes < inputLength && input[prefixZeroes] == 0 {
prefixZeroes++
}
capacity := (inputLength-prefixZeroes)*138/100 + 1 // log256 / log58
output := make([]byte, capacity)
outputReverseEnd :... | [
"func",
"Encode",
"(",
"input",
"[",
"]",
"byte",
",",
"alphabet",
"*",
"Alphabet",
")",
"string",
"{",
"// prefix 0",
"inputLength",
":=",
"len",
"(",
"input",
")",
"\n",
"prefixZeroes",
":=",
"0",
"\n",
"for",
"prefixZeroes",
"<",
"inputLength",
"&&",
... | // Encode encode with custom alphabet | [
"Encode",
"encode",
"with",
"custom",
"alphabet"
] | 0aaa1e1672a21a3a515de16cb1cf814d8271a371 | https://github.com/shengdoushi/base58/blob/0aaa1e1672a21a3a515de16cb1cf814d8271a371/base58.go#L62-L108 |
141,717 | shengdoushi/base58 | base58.go | Decode | func Decode(input string, alphabet *Alphabet) ([]byte, error) {
capacity := utf8.RuneCountInString(input)*733/1000 + 1 // log(58) / log(256)
output := make([]byte, capacity)
outputReverseEnd := capacity - 1
var carry, outputIdx, i int
var target rune
// prefix 0
zero58Byte := alphabet.encodeTable[0]
prefixZero... | go | func Decode(input string, alphabet *Alphabet) ([]byte, error) {
capacity := utf8.RuneCountInString(input)*733/1000 + 1 // log(58) / log(256)
output := make([]byte, capacity)
outputReverseEnd := capacity - 1
var carry, outputIdx, i int
var target rune
// prefix 0
zero58Byte := alphabet.encodeTable[0]
prefixZero... | [
"func",
"Decode",
"(",
"input",
"string",
",",
"alphabet",
"*",
"Alphabet",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"capacity",
":=",
"utf8",
".",
"RuneCountInString",
"(",
"input",
")",
"*",
"733",
"/",
"1000",
"+",
"1",
"// log(58) / log(... | // Decode docode with custom alphabet | [
"Decode",
"docode",
"with",
"custom",
"alphabet"
] | 0aaa1e1672a21a3a515de16cb1cf814d8271a371 | https://github.com/shengdoushi/base58/blob/0aaa1e1672a21a3a515de16cb1cf814d8271a371/base58.go#L111-L161 |
141,718 | rendon/testcli | main.go | Run | func (c *Cmd) Run() {
if c.stdin != nil {
c.cmd.Stdin = c.stdin
}
if c.env != nil {
c.cmd.Env = c.env
} else {
c.cmd.Env = os.Environ()
}
var outBuf bytes.Buffer
c.cmd.Stdout = &outBuf
var errBuf bytes.Buffer
c.cmd.Stderr = &errBuf
if err := c.cmd.Run(); err != nil {
c.exitError = err
}
c.stdout... | go | func (c *Cmd) Run() {
if c.stdin != nil {
c.cmd.Stdin = c.stdin
}
if c.env != nil {
c.cmd.Env = c.env
} else {
c.cmd.Env = os.Environ()
}
var outBuf bytes.Buffer
c.cmd.Stdout = &outBuf
var errBuf bytes.Buffer
c.cmd.Stderr = &errBuf
if err := c.cmd.Run(); err != nil {
c.exitError = err
}
c.stdout... | [
"func",
"(",
"c",
"*",
"Cmd",
")",
"Run",
"(",
")",
"{",
"if",
"c",
".",
"stdin",
"!=",
"nil",
"{",
"c",
".",
"cmd",
".",
"Stdin",
"=",
"c",
".",
"stdin",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"env",
"!=",
"nil",
"{",
"c",
".",
"cmd",
".",
... | // Run runs the command. | [
"Run",
"runs",
"the",
"command",
"."
] | 6283090d169f51a2410b4e260341a01c9a4c0ca7 | https://github.com/rendon/testcli/blob/6283090d169f51a2410b4e260341a01c9a4c0ca7/main.go#L65-L88 |
141,719 | rendon/testcli | main.go | Run | func Run(name string, arg ...string) {
pkgCmd = Command(name, arg...)
pkgCmd.Run()
} | go | func Run(name string, arg ...string) {
pkgCmd = Command(name, arg...)
pkgCmd.Run()
} | [
"func",
"Run",
"(",
"name",
"string",
",",
"arg",
"...",
"string",
")",
"{",
"pkgCmd",
"=",
"Command",
"(",
"name",
",",
"arg",
"...",
")",
"\n",
"pkgCmd",
".",
"Run",
"(",
")",
"\n",
"}"
] | // Run runs a command with name and arguments. After this, package-level
// functions will return the data about the last command run. | [
"Run",
"runs",
"a",
"command",
"with",
"name",
"and",
"arguments",
".",
"After",
"this",
"package",
"-",
"level",
"functions",
"will",
"return",
"the",
"data",
"about",
"the",
"last",
"command",
"run",
"."
] | 6283090d169f51a2410b4e260341a01c9a4c0ca7 | https://github.com/rendon/testcli/blob/6283090d169f51a2410b4e260341a01c9a4c0ca7/main.go#L92-L95 |
141,720 | rendon/testcli | main.go | StdoutContains | func (c *Cmd) StdoutContains(str string) bool {
c.validate()
str = strings.ToLower(str)
return strings.Contains(strings.ToLower(c.stdout), str)
} | go | func (c *Cmd) StdoutContains(str string) bool {
c.validate()
str = strings.ToLower(str)
return strings.Contains(strings.ToLower(c.stdout), str)
} | [
"func",
"(",
"c",
"*",
"Cmd",
")",
"StdoutContains",
"(",
"str",
"string",
")",
"bool",
"{",
"c",
".",
"validate",
"(",
")",
"\n",
"str",
"=",
"strings",
".",
"ToLower",
"(",
"str",
")",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"strings",
"... | // StdoutContains determines if command's STDOUT contains `str`, this operation
// is case insensitive. | [
"StdoutContains",
"determines",
"if",
"command",
"s",
"STDOUT",
"contains",
"str",
"this",
"operation",
"is",
"case",
"insensitive",
"."
] | 6283090d169f51a2410b4e260341a01c9a4c0ca7 | https://github.com/rendon/testcli/blob/6283090d169f51a2410b4e260341a01c9a4c0ca7/main.go#L132-L136 |
141,721 | rendon/testcli | main.go | StderrContains | func (c *Cmd) StderrContains(str string) bool {
c.validate()
str = strings.ToLower(str)
return strings.Contains(strings.ToLower(c.stderr), str)
} | go | func (c *Cmd) StderrContains(str string) bool {
c.validate()
str = strings.ToLower(str)
return strings.Contains(strings.ToLower(c.stderr), str)
} | [
"func",
"(",
"c",
"*",
"Cmd",
")",
"StderrContains",
"(",
"str",
"string",
")",
"bool",
"{",
"c",
".",
"validate",
"(",
")",
"\n",
"str",
"=",
"strings",
".",
"ToLower",
"(",
"str",
")",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"strings",
"... | // StderrContains determines if command's STDERR contains `str`, this operation
// is case insensitive. | [
"StderrContains",
"determines",
"if",
"command",
"s",
"STDERR",
"contains",
"str",
"this",
"operation",
"is",
"case",
"insensitive",
"."
] | 6283090d169f51a2410b4e260341a01c9a4c0ca7 | https://github.com/rendon/testcli/blob/6283090d169f51a2410b4e260341a01c9a4c0ca7/main.go#L146-L150 |
141,722 | rendon/testcli | main.go | StdoutMatches | func (c *Cmd) StdoutMatches(regex string) bool {
c.validate()
re := regexp.MustCompile(regex)
return re.MatchString(c.Stdout())
} | go | func (c *Cmd) StdoutMatches(regex string) bool {
c.validate()
re := regexp.MustCompile(regex)
return re.MatchString(c.Stdout())
} | [
"func",
"(",
"c",
"*",
"Cmd",
")",
"StdoutMatches",
"(",
"regex",
"string",
")",
"bool",
"{",
"c",
".",
"validate",
"(",
")",
"\n",
"re",
":=",
"regexp",
".",
"MustCompile",
"(",
"regex",
")",
"\n",
"return",
"re",
".",
"MatchString",
"(",
"c",
"."... | // StdoutMatches compares a regex to the stdout produced by the command. | [
"StdoutMatches",
"compares",
"a",
"regex",
"to",
"the",
"stdout",
"produced",
"by",
"the",
"command",
"."
] | 6283090d169f51a2410b4e260341a01c9a4c0ca7 | https://github.com/rendon/testcli/blob/6283090d169f51a2410b4e260341a01c9a4c0ca7/main.go#L183-L187 |
141,723 | rendon/testcli | main.go | StderrMatches | func (c *Cmd) StderrMatches(regex string) bool {
c.validate()
re := regexp.MustCompile(regex)
return re.MatchString(c.Stderr())
} | go | func (c *Cmd) StderrMatches(regex string) bool {
c.validate()
re := regexp.MustCompile(regex)
return re.MatchString(c.Stderr())
} | [
"func",
"(",
"c",
"*",
"Cmd",
")",
"StderrMatches",
"(",
"regex",
"string",
")",
"bool",
"{",
"c",
".",
"validate",
"(",
")",
"\n",
"re",
":=",
"regexp",
".",
"MustCompile",
"(",
"regex",
")",
"\n",
"return",
"re",
".",
"MatchString",
"(",
"c",
"."... | // StderrMatches compares a regex to the stderr produced by the command. | [
"StderrMatches",
"compares",
"a",
"regex",
"to",
"the",
"stderr",
"produced",
"by",
"the",
"command",
"."
] | 6283090d169f51a2410b4e260341a01c9a4c0ca7 | https://github.com/rendon/testcli/blob/6283090d169f51a2410b4e260341a01c9a4c0ca7/main.go#L195-L199 |
141,724 | jcelliott/lumber | multilog.go | Fatal | func (p *MultiLogger) Fatal(s string, v ...interface{}) {
for _, logger := range p.loggers {
logger.Fatal(s, v...)
}
} | go | func (p *MultiLogger) Fatal(s string, v ...interface{}) {
for _, logger := range p.loggers {
logger.Fatal(s, v...)
}
} | [
"func",
"(",
"p",
"*",
"MultiLogger",
")",
"Fatal",
"(",
"s",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"for",
"_",
",",
"logger",
":=",
"range",
"p",
".",
"loggers",
"{",
"logger",
".",
"Fatal",
"(",
"s",
",",
"v",
"...",
")"... | // All of these implement the Logger interface and distribute calls to it over
// all of the member Logger objects. | [
"All",
"of",
"these",
"implement",
"the",
"Logger",
"interface",
"and",
"distribute",
"calls",
"to",
"it",
"over",
"all",
"of",
"the",
"member",
"Logger",
"objects",
"."
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/multilog.go#L28-L32 |
141,725 | jcelliott/lumber | lumber.go | LvlStr | func LvlStr(l int) string {
if l >= 0 && l <= len(levels)-1 {
return levels[l]
}
return ""
} | go | func LvlStr(l int) string {
if l >= 0 && l <= len(levels)-1 {
return levels[l]
}
return ""
} | [
"func",
"LvlStr",
"(",
"l",
"int",
")",
"string",
"{",
"if",
"l",
">=",
"0",
"&&",
"l",
"<=",
"len",
"(",
"levels",
")",
"-",
"1",
"{",
"return",
"levels",
"[",
"l",
"]",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Returns the string representation of the level | [
"Returns",
"the",
"string",
"representation",
"of",
"the",
"level"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/lumber.go#L65-L70 |
141,726 | jcelliott/lumber | lumber.go | LvlInt | func LvlInt(s string) int {
for i, str := range levels {
if strings.TrimSpace(str) == strings.ToUpper(s) {
return i
}
}
return 0
} | go | func LvlInt(s string) int {
for i, str := range levels {
if strings.TrimSpace(str) == strings.ToUpper(s) {
return i
}
}
return 0
} | [
"func",
"LvlInt",
"(",
"s",
"string",
")",
"int",
"{",
"for",
"i",
",",
"str",
":=",
"range",
"levels",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"str",
")",
"==",
"strings",
".",
"ToUpper",
"(",
"s",
")",
"{",
"return",
"i",
"\n",
"}",
"\n",
... | // Returns the int value of the level | [
"Returns",
"the",
"int",
"value",
"of",
"the",
"level"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/lumber.go#L73-L80 |
141,727 | jcelliott/lumber | filelog.go | NewAppendLogger | func NewAppendLogger(f string) (*FileLogger, error) {
return NewFileLogger(f, INFO, APPEND, 0, 0, BUFSIZE)
} | go | func NewAppendLogger(f string) (*FileLogger, error) {
return NewFileLogger(f, INFO, APPEND, 0, 0, BUFSIZE)
} | [
"func",
"NewAppendLogger",
"(",
"f",
"string",
")",
"(",
"*",
"FileLogger",
",",
"error",
")",
"{",
"return",
"NewFileLogger",
"(",
"f",
",",
"INFO",
",",
"APPEND",
",",
"0",
",",
"0",
",",
"BUFSIZE",
")",
"\n",
"}"
] | // Convenience function to create a new append-only logger | [
"Convenience",
"function",
"to",
"create",
"a",
"new",
"append",
"-",
"only",
"logger"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L37-L39 |
141,728 | jcelliott/lumber | filelog.go | NewTruncateLogger | func NewTruncateLogger(f string) (*FileLogger, error) {
return NewFileLogger(f, INFO, TRUNC, 0, 0, BUFSIZE)
} | go | func NewTruncateLogger(f string) (*FileLogger, error) {
return NewFileLogger(f, INFO, TRUNC, 0, 0, BUFSIZE)
} | [
"func",
"NewTruncateLogger",
"(",
"f",
"string",
")",
"(",
"*",
"FileLogger",
",",
"error",
")",
"{",
"return",
"NewFileLogger",
"(",
"f",
",",
"INFO",
",",
"TRUNC",
",",
"0",
",",
"0",
",",
"BUFSIZE",
")",
"\n",
"}"
] | // Convenience function to create a new truncating logger | [
"Convenience",
"function",
"to",
"create",
"a",
"new",
"truncating",
"logger"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L42-L44 |
141,729 | jcelliott/lumber | filelog.go | NewBackupLogger | func NewBackupLogger(f string, maxBackup int) (*FileLogger, error) {
return NewFileLogger(f, INFO, BACKUP, 0, maxBackup, BUFSIZE)
} | go | func NewBackupLogger(f string, maxBackup int) (*FileLogger, error) {
return NewFileLogger(f, INFO, BACKUP, 0, maxBackup, BUFSIZE)
} | [
"func",
"NewBackupLogger",
"(",
"f",
"string",
",",
"maxBackup",
"int",
")",
"(",
"*",
"FileLogger",
",",
"error",
")",
"{",
"return",
"NewFileLogger",
"(",
"f",
",",
"INFO",
",",
"BACKUP",
",",
"0",
",",
"maxBackup",
",",
"BUFSIZE",
")",
"\n",
"}"
] | // Convenience function to create a new backup logger | [
"Convenience",
"function",
"to",
"create",
"a",
"new",
"backup",
"logger"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L47-L49 |
141,730 | jcelliott/lumber | filelog.go | NewRotateLogger | func NewRotateLogger(f string, maxLines, maxRotate int) (*FileLogger, error) {
return NewFileLogger(f, INFO, ROTATE, maxLines, maxRotate, BUFSIZE)
} | go | func NewRotateLogger(f string, maxLines, maxRotate int) (*FileLogger, error) {
return NewFileLogger(f, INFO, ROTATE, maxLines, maxRotate, BUFSIZE)
} | [
"func",
"NewRotateLogger",
"(",
"f",
"string",
",",
"maxLines",
",",
"maxRotate",
"int",
")",
"(",
"*",
"FileLogger",
",",
"error",
")",
"{",
"return",
"NewFileLogger",
"(",
"f",
",",
"INFO",
",",
"ROTATE",
",",
"maxLines",
",",
"maxRotate",
",",
"BUFSIZ... | // Convenience function to create a new rotating logger | [
"Convenience",
"function",
"to",
"create",
"a",
"new",
"rotating",
"logger"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L52-L54 |
141,731 | jcelliott/lumber | filelog.go | NewFileLogger | func NewFileLogger(f string, o, mode, maxLines, maxRotate, bufsize int) (*FileLogger, error) {
var file *os.File
var err error
switch mode {
case APPEND:
// open log file, append if it already exists
file, err = os.OpenFile(f, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
case TRUNC:
// just truncate file and st... | go | func NewFileLogger(f string, o, mode, maxLines, maxRotate, bufsize int) (*FileLogger, error) {
var file *os.File
var err error
switch mode {
case APPEND:
// open log file, append if it already exists
file, err = os.OpenFile(f, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
case TRUNC:
// just truncate file and st... | [
"func",
"NewFileLogger",
"(",
"f",
"string",
",",
"o",
",",
"mode",
",",
"maxLines",
",",
"maxRotate",
",",
"bufsize",
"int",
")",
"(",
"*",
"FileLogger",
",",
"error",
")",
"{",
"var",
"file",
"*",
"os",
".",
"File",
"\n",
"var",
"err",
"error",
"... | // Creates a new FileLogger with filename f, output level o, and an empty prefix.
// Modes are described in the documentation; maxLines and maxRotate are only significant
// for some modes. | [
"Creates",
"a",
"new",
"FileLogger",
"with",
"filename",
"f",
"output",
"level",
"o",
"and",
"an",
"empty",
"prefix",
".",
"Modes",
"are",
"described",
"in",
"the",
"documentation",
";",
"maxLines",
"and",
"maxRotate",
"are",
"only",
"significant",
"for",
"s... | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L59-L84 |
141,732 | jcelliott/lumber | filelog.go | openBackup | func openBackup(f string, maxLines, maxRotate int) (*os.File, error) {
// first try to open the file with O_EXCL (file must not already exist)
file, err := os.OpenFile(f, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0644)
// if there are no errors (it's a new file), we can just use this file
if err == nil {
return file, nil
... | go | func openBackup(f string, maxLines, maxRotate int) (*os.File, error) {
// first try to open the file with O_EXCL (file must not already exist)
file, err := os.OpenFile(f, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0644)
// if there are no errors (it's a new file), we can just use this file
if err == nil {
return file, nil
... | [
"func",
"openBackup",
"(",
"f",
"string",
",",
"maxLines",
",",
"maxRotate",
"int",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"// first try to open the file with O_EXCL (file must not already exist)",
"file",
",",
"err",
":=",
"os",
".",
"OpenFil... | // Attempt to create new log. Specific behavior depends on the maxLines setting | [
"Attempt",
"to",
"create",
"new",
"log",
".",
"Specific",
"behavior",
"depends",
"on",
"the",
"maxLines",
"setting"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L131-L150 |
141,733 | jcelliott/lumber | filelog.go | rotate | func (l *FileLogger) rotate() error {
oldFile := l.out
file, err := doRotate(l.out.Name(), l.maxRotate)
if err != nil {
return fmt.Errorf("Error rotating logs: %s", err)
}
l.curLines = 0
l.out = file
oldFile.Close()
return nil
} | go | func (l *FileLogger) rotate() error {
oldFile := l.out
file, err := doRotate(l.out.Name(), l.maxRotate)
if err != nil {
return fmt.Errorf("Error rotating logs: %s", err)
}
l.curLines = 0
l.out = file
oldFile.Close()
return nil
} | [
"func",
"(",
"l",
"*",
"FileLogger",
")",
"rotate",
"(",
")",
"error",
"{",
"oldFile",
":=",
"l",
".",
"out",
"\n",
"file",
",",
"err",
":=",
"doRotate",
"(",
"l",
".",
"out",
".",
"Name",
"(",
")",
",",
"l",
".",
"maxRotate",
")",
"\n",
"if",
... | // Rotate the logs | [
"Rotate",
"the",
"logs"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L153-L163 |
141,734 | jcelliott/lumber | filelog.go | doRotate | func doRotate(f string, limit int) (*os.File, error) {
// create a format string with the correct amount of zero-padding for the limit
numFmt := fmt.Sprintf(".%%0%dd", len(fmt.Sprintf("%d", limit)))
// get all rotated files and sort them in reverse order
list, err := filepath.Glob(fmt.Sprintf("%s.*", f))
if err !=... | go | func doRotate(f string, limit int) (*os.File, error) {
// create a format string with the correct amount of zero-padding for the limit
numFmt := fmt.Sprintf(".%%0%dd", len(fmt.Sprintf("%d", limit)))
// get all rotated files and sort them in reverse order
list, err := filepath.Glob(fmt.Sprintf("%s.*", f))
if err !=... | [
"func",
"doRotate",
"(",
"f",
"string",
",",
"limit",
"int",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"// create a format string with the correct amount of zero-padding for the limit",
"numFmt",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",... | // Rotate all the logs and return a file with newly vacated filename
// Rename 'log.name' to 'log.name.1' and 'log.name.1' to 'log.name.2' etc | [
"Rotate",
"all",
"the",
"logs",
"and",
"return",
"a",
"file",
"with",
"newly",
"vacated",
"filename",
"Rename",
"log",
".",
"name",
"to",
"log",
".",
"name",
".",
"1",
"and",
"log",
".",
"name",
".",
"1",
"to",
"log",
".",
"name",
".",
"2",
"etc"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L167-L198 |
141,735 | jcelliott/lumber | filelog.go | output | func (l *FileLogger) output(msg *Message) {
if l.mode == ROTATE && l.curLines >= l.maxLines && !l.errored {
err := l.rotate()
if err != nil {
// if we can't rotate the logs, we should stop logging to prevent the log file from growing
// past the limit and continuously retrying the rotate operation (but log c... | go | func (l *FileLogger) output(msg *Message) {
if l.mode == ROTATE && l.curLines >= l.maxLines && !l.errored {
err := l.rotate()
if err != nil {
// if we can't rotate the logs, we should stop logging to prevent the log file from growing
// past the limit and continuously retrying the rotate operation (but log c... | [
"func",
"(",
"l",
"*",
"FileLogger",
")",
"output",
"(",
"msg",
"*",
"Message",
")",
"{",
"if",
"l",
".",
"mode",
"==",
"ROTATE",
"&&",
"l",
".",
"curLines",
">=",
"l",
".",
"maxLines",
"&&",
"!",
"l",
".",
"errored",
"{",
"err",
":=",
"l",
"."... | // Generic output function. Outputs messages if they are higher level than outLevel for this
// specific logger. If msg does not end with a newline, one will be appended. | [
"Generic",
"output",
"function",
".",
"Outputs",
"messages",
"if",
"they",
"are",
"higher",
"level",
"than",
"outLevel",
"for",
"this",
"specific",
"logger",
".",
"If",
"msg",
"does",
"not",
"end",
"with",
"a",
"newline",
"one",
"will",
"be",
"appended",
"... | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L202-L215 |
141,736 | jcelliott/lumber | filelog.go | countLines | func countLines(f *os.File) int {
r := bufio.NewReader(f)
count := 0
var err error = nil
for err == nil {
prefix := true
_, prefix, err = r.ReadLine()
if err != nil {
}
// sometimes we don't get the whole line at once
if !prefix && err == nil {
count++
}
}
return count
} | go | func countLines(f *os.File) int {
r := bufio.NewReader(f)
count := 0
var err error = nil
for err == nil {
prefix := true
_, prefix, err = r.ReadLine()
if err != nil {
}
// sometimes we don't get the whole line at once
if !prefix && err == nil {
count++
}
}
return count
} | [
"func",
"countLines",
"(",
"f",
"*",
"os",
".",
"File",
")",
"int",
"{",
"r",
":=",
"bufio",
".",
"NewReader",
"(",
"f",
")",
"\n",
"count",
":=",
"0",
"\n",
"var",
"err",
"error",
"=",
"nil",
"\n",
"for",
"err",
"==",
"nil",
"{",
"prefix",
":=... | // return the number of lines in the given file | [
"return",
"the",
"number",
"of",
"lines",
"in",
"the",
"given",
"file"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/filelog.go#L276-L291 |
141,737 | jcelliott/lumber | consolelog.go | NewConsoleLogger | func NewConsoleLogger(o int) *ConsoleLogger {
return &ConsoleLogger{
out: os.Stdout,
outLevel: o,
timeFormat: TIMEFORMAT,
prefix: "",
levels: levels,
}
} | go | func NewConsoleLogger(o int) *ConsoleLogger {
return &ConsoleLogger{
out: os.Stdout,
outLevel: o,
timeFormat: TIMEFORMAT,
prefix: "",
levels: levels,
}
} | [
"func",
"NewConsoleLogger",
"(",
"o",
"int",
")",
"*",
"ConsoleLogger",
"{",
"return",
"&",
"ConsoleLogger",
"{",
"out",
":",
"os",
".",
"Stdout",
",",
"outLevel",
":",
"o",
",",
"timeFormat",
":",
"TIMEFORMAT",
",",
"prefix",
":",
"\"",
"\"",
",",
"le... | // Create a new console logger with output level o, and an empty prefix | [
"Create",
"a",
"new",
"console",
"logger",
"with",
"output",
"level",
"o",
"and",
"an",
"empty",
"prefix"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/consolelog.go#L20-L28 |
141,738 | jcelliott/lumber | consolelog.go | output | func (l *ConsoleLogger) output(msg *Message) {
buf := []byte{}
buf = append(buf, msg.time.Format(l.timeFormat)...)
if l.prefix != "" {
buf = append(buf, ' ')
buf = append(buf, l.prefix...)
}
buf = append(buf, ' ')
buf = append(buf, l.levels[msg.level]...)
buf = append(buf, ' ')
buf = append(buf, msg.m...)
... | go | func (l *ConsoleLogger) output(msg *Message) {
buf := []byte{}
buf = append(buf, msg.time.Format(l.timeFormat)...)
if l.prefix != "" {
buf = append(buf, ' ')
buf = append(buf, l.prefix...)
}
buf = append(buf, ' ')
buf = append(buf, l.levels[msg.level]...)
buf = append(buf, ' ')
buf = append(buf, msg.m...)
... | [
"func",
"(",
"l",
"*",
"ConsoleLogger",
")",
"output",
"(",
"msg",
"*",
"Message",
")",
"{",
"buf",
":=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"msg",
".",
"time",
".",
"Format",
"(",
"l",
".",
"timeFormat",
"... | // Generic output function. If msg does not end with a newline, one will be appended. | [
"Generic",
"output",
"function",
".",
"If",
"msg",
"does",
"not",
"end",
"with",
"a",
"newline",
"one",
"will",
"be",
"appended",
"."
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/consolelog.go#L41-L56 |
141,739 | jcelliott/lumber | consolelog.go | SetLevels | func (l *ConsoleLogger) SetLevels(lvls []string) {
if lvls[len(lvls)-1] != "*LOG*" {
lvls = append(lvls, "*LOG*")
}
l.levels = lvls
} | go | func (l *ConsoleLogger) SetLevels(lvls []string) {
if lvls[len(lvls)-1] != "*LOG*" {
lvls = append(lvls, "*LOG*")
}
l.levels = lvls
} | [
"func",
"(",
"l",
"*",
"ConsoleLogger",
")",
"SetLevels",
"(",
"lvls",
"[",
"]",
"string",
")",
"{",
"if",
"lvls",
"[",
"len",
"(",
"lvls",
")",
"-",
"1",
"]",
"!=",
"\"",
"\"",
"{",
"lvls",
"=",
"append",
"(",
"lvls",
",",
"\"",
"\"",
")",
"... | // Sets the available levels for this logger | [
"Sets",
"the",
"available",
"levels",
"for",
"this",
"logger"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/consolelog.go#L59-L64 |
141,740 | jcelliott/lumber | consolelog.go | Close | func (l *ConsoleLogger) Close() {
l.closed = true
l.output(&Message{len(l.levels) - 1, "Closing log now", time.Now()})
l.out.Close()
} | go | func (l *ConsoleLogger) Close() {
l.closed = true
l.output(&Message{len(l.levels) - 1, "Closing log now", time.Now()})
l.out.Close()
} | [
"func",
"(",
"l",
"*",
"ConsoleLogger",
")",
"Close",
"(",
")",
"{",
"l",
".",
"closed",
"=",
"true",
"\n",
"l",
".",
"output",
"(",
"&",
"Message",
"{",
"len",
"(",
"l",
".",
"levels",
")",
"-",
"1",
",",
"\"",
"\"",
",",
"time",
".",
"Now",... | // Close the logger | [
"Close",
"the",
"logger"
] | dd349441af25132d146d7095c6693a15431fc9b1 | https://github.com/jcelliott/lumber/blob/dd349441af25132d146d7095c6693a15431fc9b1/consolelog.go#L84-L88 |
141,741 | jhoonb/archivex | archivex.go | Create | func (z *ZipFile) Create(name string) error {
// check extension .zip
if strings.HasSuffix(name, ".zip") != true {
if strings.HasSuffix(name, ".tar.gz") == true {
name = strings.Replace(name, ".tar.gz", ".zip", -1)
} else {
name = name + ".zip"
}
}
z.Name = name
file, err := os.Create(z.Name)
if err !... | go | func (z *ZipFile) Create(name string) error {
// check extension .zip
if strings.HasSuffix(name, ".zip") != true {
if strings.HasSuffix(name, ".tar.gz") == true {
name = strings.Replace(name, ".tar.gz", ".zip", -1)
} else {
name = name + ".zip"
}
}
z.Name = name
file, err := os.Create(z.Name)
if err !... | [
"func",
"(",
"z",
"*",
"ZipFile",
")",
"Create",
"(",
"name",
"string",
")",
"error",
"{",
"// check extension .zip",
"if",
"strings",
".",
"HasSuffix",
"(",
"name",
",",
"\"",
"\"",
")",
"!=",
"true",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"name... | // Create new file zip | [
"Create",
"new",
"file",
"zip"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L54-L70 |
141,742 | jhoonb/archivex | archivex.go | CreateWriter | func (z *ZipFile) CreateWriter(name string, w io.Writer) error {
z.Writer = zip.NewWriter(w)
z.Name = name
return nil
} | go | func (z *ZipFile) CreateWriter(name string, w io.Writer) error {
z.Writer = zip.NewWriter(w)
z.Name = name
return nil
} | [
"func",
"(",
"z",
"*",
"ZipFile",
")",
"CreateWriter",
"(",
"name",
"string",
",",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"z",
".",
"Writer",
"=",
"zip",
".",
"NewWriter",
"(",
"w",
")",
"\n",
"z",
".",
"Name",
"=",
"name",
"\n",
"return",
... | // Create a new ZIP and write it to a given writer | [
"Create",
"a",
"new",
"ZIP",
"and",
"write",
"it",
"to",
"a",
"given",
"writer"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L73-L77 |
141,743 | jhoonb/archivex | archivex.go | Add | func (z *ZipFile) Add(name string, file io.Reader, info os.FileInfo) error {
var header *zip.FileHeader
if info == nil {
header = &zip.FileHeader{
Name: name,
Flags: 1 << 11, // use utf8 encoding the file Name
Method: zip.Deflate,
}
} else {
var err error
header, err = zip.FileInfoHeader(info)
... | go | func (z *ZipFile) Add(name string, file io.Reader, info os.FileInfo) error {
var header *zip.FileHeader
if info == nil {
header = &zip.FileHeader{
Name: name,
Flags: 1 << 11, // use utf8 encoding the file Name
Method: zip.Deflate,
}
} else {
var err error
header, err = zip.FileInfoHeader(info)
... | [
"func",
"(",
"z",
"*",
"ZipFile",
")",
"Add",
"(",
"name",
"string",
",",
"file",
"io",
".",
"Reader",
",",
"info",
"os",
".",
"FileInfo",
")",
"error",
"{",
"var",
"header",
"*",
"zip",
".",
"FileHeader",
"\n",
"if",
"info",
"==",
"nil",
"{",
"h... | // Add file reader in archive zip | [
"Add",
"file",
"reader",
"in",
"archive",
"zip"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L80-L102 |
141,744 | jhoonb/archivex | archivex.go | AddAll | func (z *ZipFile) AddAll(dir string, includeCurrentFolder bool) error {
dir = path.Clean(dir)
return addAll(dir, dir, includeCurrentFolder, func(info os.FileInfo, file io.Reader, entryName string) (err error) {
// Create a header based off of the fileinfo
header, err := zip.FileInfoHeader(info)
if err != nil {
... | go | func (z *ZipFile) AddAll(dir string, includeCurrentFolder bool) error {
dir = path.Clean(dir)
return addAll(dir, dir, includeCurrentFolder, func(info os.FileInfo, file io.Reader, entryName string) (err error) {
// Create a header based off of the fileinfo
header, err := zip.FileInfoHeader(info)
if err != nil {
... | [
"func",
"(",
"z",
"*",
"ZipFile",
")",
"AddAll",
"(",
"dir",
"string",
",",
"includeCurrentFolder",
"bool",
")",
"error",
"{",
"dir",
"=",
"path",
".",
"Clean",
"(",
"dir",
")",
"\n",
"return",
"addAll",
"(",
"dir",
",",
"dir",
",",
"includeCurrentFold... | // AddAll adds all files from dir in archive, recursively.
// Directories receive a zero-size entry in the archive, with a trailing slash in the header name, and no compression | [
"AddAll",
"adds",
"all",
"files",
"from",
"dir",
"in",
"archive",
"recursively",
".",
"Directories",
"receive",
"a",
"zero",
"-",
"size",
"entry",
"in",
"the",
"archive",
"with",
"a",
"trailing",
"slash",
"in",
"the",
"header",
"name",
"and",
"no",
"compre... | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L106-L143 |
141,745 | jhoonb/archivex | archivex.go | Close | func (z *ZipFile) Close() error {
err := z.Writer.Close()
// If the out writer supports io.Closer, Close it.
if c, ok := z.out.(io.Closer); ok {
c.Close()
}
return err
} | go | func (z *ZipFile) Close() error {
err := z.Writer.Close()
// If the out writer supports io.Closer, Close it.
if c, ok := z.out.(io.Closer); ok {
c.Close()
}
return err
} | [
"func",
"(",
"z",
"*",
"ZipFile",
")",
"Close",
"(",
")",
"error",
"{",
"err",
":=",
"z",
".",
"Writer",
".",
"Close",
"(",
")",
"\n",
"// If the out writer supports io.Closer, Close it.",
"if",
"c",
",",
"ok",
":=",
"z",
".",
"out",
".",
"(",
"io",
... | //Close close the zip file | [
"Close",
"close",
"the",
"zip",
"file"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L146-L153 |
141,746 | jhoonb/archivex | archivex.go | Create | func (t *TarFile) Create(name string) error {
t.configureName(name)
file, err := os.Create(name)
if err != nil {
return err
}
if t.Compressed {
t.GzWriter = gzip.NewWriter(file)
t.Writer = tar.NewWriter(t.GzWriter)
} else {
t.Writer = tar.NewWriter(file)
}
t.out = file
return nil
} | go | func (t *TarFile) Create(name string) error {
t.configureName(name)
file, err := os.Create(name)
if err != nil {
return err
}
if t.Compressed {
t.GzWriter = gzip.NewWriter(file)
t.Writer = tar.NewWriter(t.GzWriter)
} else {
t.Writer = tar.NewWriter(file)
}
t.out = file
return nil
} | [
"func",
"(",
"t",
"*",
"TarFile",
")",
"Create",
"(",
"name",
"string",
")",
"error",
"{",
"t",
".",
"configureName",
"(",
"name",
")",
"\n\n",
"file",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Create new Tar file | [
"Create",
"new",
"Tar",
"file"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L178-L194 |
141,747 | jhoonb/archivex | archivex.go | CreateWriter | func (t *TarFile) CreateWriter(name string, w io.Writer) error {
t.configureName(name)
if t.Compressed {
t.GzWriter = gzip.NewWriter(w)
t.Writer = tar.NewWriter(t.GzWriter)
} else {
t.Writer = tar.NewWriter(w)
}
t.out = w
return nil
} | go | func (t *TarFile) CreateWriter(name string, w io.Writer) error {
t.configureName(name)
if t.Compressed {
t.GzWriter = gzip.NewWriter(w)
t.Writer = tar.NewWriter(t.GzWriter)
} else {
t.Writer = tar.NewWriter(w)
}
t.out = w
return nil
} | [
"func",
"(",
"t",
"*",
"TarFile",
")",
"CreateWriter",
"(",
"name",
"string",
",",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"t",
".",
"configureName",
"(",
"name",
")",
"\n\n",
"if",
"t",
".",
"Compressed",
"{",
"t",
".",
"GzWriter",
"=",
"gzip... | // Create a new Tar and write it to a given writer | [
"Create",
"a",
"new",
"Tar",
"and",
"write",
"it",
"to",
"a",
"given",
"writer"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L197-L208 |
141,748 | jhoonb/archivex | archivex.go | Add | func (t *TarFile) Add(name string, file io.Reader, info os.FileInfo) error {
var header *tar.Header
if info == nil {
// Unfortunately, we need to know the size for the tar header, making it necessary to read the full file into memory
// TODO: FIXME: We could check if the io.Reader supports io.Seek, so we can do a... | go | func (t *TarFile) Add(name string, file io.Reader, info os.FileInfo) error {
var header *tar.Header
if info == nil {
// Unfortunately, we need to know the size for the tar header, making it necessary to read the full file into memory
// TODO: FIXME: We could check if the io.Reader supports io.Seek, so we can do a... | [
"func",
"(",
"t",
"*",
"TarFile",
")",
"Add",
"(",
"name",
"string",
",",
"file",
"io",
".",
"Reader",
",",
"info",
"os",
".",
"FileInfo",
")",
"error",
"{",
"var",
"header",
"*",
"tar",
".",
"Header",
"\n",
"if",
"info",
"==",
"nil",
"{",
"// Un... | // Add add byte in archive tar | [
"Add",
"add",
"byte",
"in",
"archive",
"tar"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L211-L252 |
141,749 | jhoonb/archivex | archivex.go | AddAll | func (t *TarFile) AddAll(dir string, includeCurrentFolder bool) error {
dir = path.Clean(dir)
return addAll(dir, dir, includeCurrentFolder, func(info os.FileInfo, file io.Reader, entryName string) (err error) {
// Create a header based off of the fileinfo
header, err := tar.FileInfoHeader(info, "")
if err != ni... | go | func (t *TarFile) AddAll(dir string, includeCurrentFolder bool) error {
dir = path.Clean(dir)
return addAll(dir, dir, includeCurrentFolder, func(info os.FileInfo, file io.Reader, entryName string) (err error) {
// Create a header based off of the fileinfo
header, err := tar.FileInfoHeader(info, "")
if err != ni... | [
"func",
"(",
"t",
"*",
"TarFile",
")",
"AddAll",
"(",
"dir",
"string",
",",
"includeCurrentFolder",
"bool",
")",
"error",
"{",
"dir",
"=",
"path",
".",
"Clean",
"(",
"dir",
")",
"\n",
"return",
"addAll",
"(",
"dir",
",",
"dir",
",",
"includeCurrentFold... | // AddAll adds all files from dir in archive
// Tar does not support directories | [
"AddAll",
"adds",
"all",
"files",
"from",
"dir",
"in",
"archive",
"Tar",
"does",
"not",
"support",
"directories"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L256-L285 |
141,750 | jhoonb/archivex | archivex.go | Close | func (t *TarFile) Close() error {
err := t.Writer.Close()
if err != nil {
return err
}
if t.Compressed {
err = t.GzWriter.Close()
if err != nil {
return err
}
}
// If the out writer supports io.Closer, Close it.
if c, ok := t.out.(io.Closer); ok {
c.Close()
}
return err
} | go | func (t *TarFile) Close() error {
err := t.Writer.Close()
if err != nil {
return err
}
if t.Compressed {
err = t.GzWriter.Close()
if err != nil {
return err
}
}
// If the out writer supports io.Closer, Close it.
if c, ok := t.out.(io.Closer); ok {
c.Close()
}
return err
} | [
"func",
"(",
"t",
"*",
"TarFile",
")",
"Close",
"(",
")",
"error",
"{",
"err",
":=",
"t",
".",
"Writer",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"t",
".",
"Compressed",
"{",
"err",
... | // Close the file Tar | [
"Close",
"the",
"file",
"Tar"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L288-L306 |
141,751 | jhoonb/archivex | archivex.go | addAll | func addAll(dir, rootDir string, includeCurrentFolder bool, writerFunc ArchiveWriteFunc) error {
// Get a list of all entries in the directory, as []os.FileInfo
fileInfos, err := ioutil.ReadDir(dir)
if err != nil {
return err
}
// Loop through all entries
for _, info := range fileInfos {
full := filepath.Joi... | go | func addAll(dir, rootDir string, includeCurrentFolder bool, writerFunc ArchiveWriteFunc) error {
// Get a list of all entries in the directory, as []os.FileInfo
fileInfos, err := ioutil.ReadDir(dir)
if err != nil {
return err
}
// Loop through all entries
for _, info := range fileInfos {
full := filepath.Joi... | [
"func",
"addAll",
"(",
"dir",
",",
"rootDir",
"string",
",",
"includeCurrentFolder",
"bool",
",",
"writerFunc",
"ArchiveWriteFunc",
")",
"error",
"{",
"// Get a list of all entries in the directory, as []os.FileInfo",
"fileInfos",
",",
"err",
":=",
"ioutil",
".",
"ReadD... | // addAll is used to recursively go down through directories and add each file and directory to an archive, based on an ArchiveWriteFunc given to it | [
"addAll",
"is",
"used",
"to",
"recursively",
"go",
"down",
"through",
"directories",
"and",
"add",
"each",
"file",
"and",
"directory",
"to",
"an",
"archive",
"based",
"on",
"an",
"ArchiveWriteFunc",
"given",
"to",
"it"
] | 0488e4ce168110297b49ad60bee94d38de70dd8a | https://github.com/jhoonb/archivex/blob/0488e4ce168110297b49ad60bee94d38de70dd8a/archivex.go#L324-L368 |
141,752 | serenize/snaker | snaker.go | CamelToSnake | func CamelToSnake(s string) string {
var result string
var words []string
var lastPos int
rs := []rune(s)
for i := 0; i < len(rs); i++ {
if i > 0 && unicode.IsUpper(rs[i]) {
if initialism := startsWithInitialism(s[lastPos:]); initialism != "" {
words = append(words, initialism)
i += len(initialism) ... | go | func CamelToSnake(s string) string {
var result string
var words []string
var lastPos int
rs := []rune(s)
for i := 0; i < len(rs); i++ {
if i > 0 && unicode.IsUpper(rs[i]) {
if initialism := startsWithInitialism(s[lastPos:]); initialism != "" {
words = append(words, initialism)
i += len(initialism) ... | [
"func",
"CamelToSnake",
"(",
"s",
"string",
")",
"string",
"{",
"var",
"result",
"string",
"\n",
"var",
"words",
"[",
"]",
"string",
"\n",
"var",
"lastPos",
"int",
"\n",
"rs",
":=",
"[",
"]",
"rune",
"(",
"s",
")",
"\n\n",
"for",
"i",
":=",
"0",
... | // CamelToSnake converts a given string to snake case | [
"CamelToSnake",
"converts",
"a",
"given",
"string",
"to",
"snake",
"case"
] | a683aaf2d516deecd70cad0c72e3ca773ecfcef0 | https://github.com/serenize/snaker/blob/a683aaf2d516deecd70cad0c72e3ca773ecfcef0/snaker.go#L11-L46 |
141,753 | serenize/snaker | snaker.go | startsWithInitialism | func startsWithInitialism(s string) string {
var initialism string
// the longest initialism is 5 char, the shortest 2
for i := 1; i <= 5; i++ {
if len(s) > i-1 && commonInitialisms[s[:i]] {
initialism = s[:i]
}
}
return initialism
} | go | func startsWithInitialism(s string) string {
var initialism string
// the longest initialism is 5 char, the shortest 2
for i := 1; i <= 5; i++ {
if len(s) > i-1 && commonInitialisms[s[:i]] {
initialism = s[:i]
}
}
return initialism
} | [
"func",
"startsWithInitialism",
"(",
"s",
"string",
")",
"string",
"{",
"var",
"initialism",
"string",
"\n",
"// the longest initialism is 5 char, the shortest 2",
"for",
"i",
":=",
"1",
";",
"i",
"<=",
"5",
";",
"i",
"++",
"{",
"if",
"len",
"(",
"s",
")",
... | // startsWithInitialism returns the initialism if the given string begins with it | [
"startsWithInitialism",
"returns",
"the",
"initialism",
"if",
"the",
"given",
"string",
"begins",
"with",
"it"
] | a683aaf2d516deecd70cad0c72e3ca773ecfcef0 | https://github.com/serenize/snaker/blob/a683aaf2d516deecd70cad0c72e3ca773ecfcef0/snaker.go#L89-L98 |
141,754 | smallfish/simpleyaml | simpleyaml.go | NewYaml | func NewYaml(body []byte) (*Yaml, error) {
var val interface{}
err := yaml.Unmarshal(body, &val)
if err != nil {
return nil, errors.New("unmarshal []byte to yaml failed: " + err.Error())
}
return &Yaml{val}, nil
} | go | func NewYaml(body []byte) (*Yaml, error) {
var val interface{}
err := yaml.Unmarshal(body, &val)
if err != nil {
return nil, errors.New("unmarshal []byte to yaml failed: " + err.Error())
}
return &Yaml{val}, nil
} | [
"func",
"NewYaml",
"(",
"body",
"[",
"]",
"byte",
")",
"(",
"*",
"Yaml",
",",
"error",
")",
"{",
"var",
"val",
"interface",
"{",
"}",
"\n",
"err",
":=",
"yaml",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil"... | // NewYaml returns a pointer to a new `Yaml` object after unmarshaling `body` bytes | [
"NewYaml",
"returns",
"a",
"pointer",
"to",
"a",
"new",
"Yaml",
"object",
"after",
"unmarshaling",
"body",
"bytes"
] | a32031077861b1fbdf988d2c0865e98ec832dd4c | https://github.com/smallfish/simpleyaml/blob/a32031077861b1fbdf988d2c0865e98ec832dd4c/simpleyaml.go#L42-L49 |
141,755 | smallfish/simpleyaml | simpleyaml.go | GetArraySize | func (y *Yaml) GetArraySize() (int, error) {
a, err := y.Array()
if err != nil {
return 0, err
}
return len(a), nil
} | go | func (y *Yaml) GetArraySize() (int, error) {
a, err := y.Array()
if err != nil {
return 0, err
}
return len(a), nil
} | [
"func",
"(",
"y",
"*",
"Yaml",
")",
"GetArraySize",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"a",
",",
"err",
":=",
"y",
".",
"Array",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
... | // return the size of array | [
"return",
"the",
"size",
"of",
"array"
] | a32031077861b1fbdf988d2c0865e98ec832dd4c | https://github.com/smallfish/simpleyaml/blob/a32031077861b1fbdf988d2c0865e98ec832dd4c/simpleyaml.go#L100-L106 |
141,756 | smallfish/simpleyaml | simpleyaml.go | Int | func (y *Yaml) Int() (int, error) {
if v, ok := (y.data).(int); ok {
return v, nil
}
return 0, errors.New("type assertion to int failed")
} | go | func (y *Yaml) Int() (int, error) {
if v, ok := (y.data).(int); ok {
return v, nil
}
return 0, errors.New("type assertion to int failed")
} | [
"func",
"(",
"y",
"*",
"Yaml",
")",
"Int",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"v",
",",
"ok",
":=",
"(",
"y",
".",
"data",
")",
".",
"(",
"int",
")",
";",
"ok",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n",
"return",
... | // Int type asserts to `int` | [
"Int",
"type",
"asserts",
"to",
"int"
] | a32031077861b1fbdf988d2c0865e98ec832dd4c | https://github.com/smallfish/simpleyaml/blob/a32031077861b1fbdf988d2c0865e98ec832dd4c/simpleyaml.go#L124-L129 |
141,757 | smallfish/simpleyaml | simpleyaml.go | IsMap | func (y *Yaml) IsMap() bool {
_, err := y.Map()
return err == nil
} | go | func (y *Yaml) IsMap() bool {
_, err := y.Map()
return err == nil
} | [
"func",
"(",
"y",
"*",
"Yaml",
")",
"IsMap",
"(",
")",
"bool",
"{",
"_",
",",
"err",
":=",
"y",
".",
"Map",
"(",
")",
"\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] | // Check if it is a map | [
"Check",
"if",
"it",
"is",
"a",
"map"
] | a32031077861b1fbdf988d2c0865e98ec832dd4c | https://github.com/smallfish/simpleyaml/blob/a32031077861b1fbdf988d2c0865e98ec832dd4c/simpleyaml.go#L163-L166 |
141,758 | smallfish/simpleyaml | simpleyaml.go | GetMapKeys | func (y *Yaml) GetMapKeys() ([]string, error) {
m, err := y.Map()
if err != nil {
return nil, err
}
keys := make([]string, 0)
for k, _ := range m {
if s, ok := k.(string); ok {
keys = append(keys, s)
}
}
return keys, nil
} | go | func (y *Yaml) GetMapKeys() ([]string, error) {
m, err := y.Map()
if err != nil {
return nil, err
}
keys := make([]string, 0)
for k, _ := range m {
if s, ok := k.(string); ok {
keys = append(keys, s)
}
}
return keys, nil
} | [
"func",
"(",
"y",
"*",
"Yaml",
")",
"GetMapKeys",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"m",
",",
"err",
":=",
"y",
".",
"Map",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\... | // Get all the keys of the map | [
"Get",
"all",
"the",
"keys",
"of",
"the",
"map"
] | a32031077861b1fbdf988d2c0865e98ec832dd4c | https://github.com/smallfish/simpleyaml/blob/a32031077861b1fbdf988d2c0865e98ec832dd4c/simpleyaml.go#L169-L182 |
141,759 | go-sourcemap/sourcemap | consumer.go | Source | func (c *Consumer) Source(
genLine, genColumn int,
) (source, name string, line, column int, ok bool) {
for i := range c.sections {
s := &c.sections[i]
if s.Offset.Line < genLine ||
(s.Offset.Line+1 == genLine && s.Offset.Column <= genColumn) {
genLine -= s.Offset.Line
genColumn -= s.Offset.Column
ret... | go | func (c *Consumer) Source(
genLine, genColumn int,
) (source, name string, line, column int, ok bool) {
for i := range c.sections {
s := &c.sections[i]
if s.Offset.Line < genLine ||
(s.Offset.Line+1 == genLine && s.Offset.Column <= genColumn) {
genLine -= s.Offset.Line
genColumn -= s.Offset.Column
ret... | [
"func",
"(",
"c",
"*",
"Consumer",
")",
"Source",
"(",
"genLine",
",",
"genColumn",
"int",
",",
")",
"(",
"source",
",",
"name",
"string",
",",
"line",
",",
"column",
"int",
",",
"ok",
"bool",
")",
"{",
"for",
"i",
":=",
"range",
"c",
".",
"secti... | // Source returns the original source, name, line, and column information
// for the generated source's line and column positions. | [
"Source",
"returns",
"the",
"original",
"source",
"name",
"line",
"and",
"column",
"information",
"for",
"the",
"generated",
"source",
"s",
"line",
"and",
"column",
"positions",
"."
] | b019cc30c1eaa584753491b0d8f8c1534bf1eb44 | https://github.com/go-sourcemap/sourcemap/blob/b019cc30c1eaa584753491b0d8f8c1534bf1eb44/consumer.go#L149-L162 |
141,760 | go-sourcemap/sourcemap | consumer.go | SourceContent | func (c *Consumer) SourceContent(source string) string {
for i := range c.sections {
s := &c.sections[i]
for i, src := range s.Map.Sources {
if src == source {
if i < len(s.Map.SourcesContent) {
return s.Map.SourcesContent[i]
}
break
}
}
}
return ""
} | go | func (c *Consumer) SourceContent(source string) string {
for i := range c.sections {
s := &c.sections[i]
for i, src := range s.Map.Sources {
if src == source {
if i < len(s.Map.SourcesContent) {
return s.Map.SourcesContent[i]
}
break
}
}
}
return ""
} | [
"func",
"(",
"c",
"*",
"Consumer",
")",
"SourceContent",
"(",
"source",
"string",
")",
"string",
"{",
"for",
"i",
":=",
"range",
"c",
".",
"sections",
"{",
"s",
":=",
"&",
"c",
".",
"sections",
"[",
"i",
"]",
"\n",
"for",
"i",
",",
"src",
":=",
... | // SourceContent returns the original source content for the source. | [
"SourceContent",
"returns",
"the",
"original",
"source",
"content",
"for",
"the",
"source",
"."
] | b019cc30c1eaa584753491b0d8f8c1534bf1eb44 | https://github.com/go-sourcemap/sourcemap/blob/b019cc30c1eaa584753491b0d8f8c1534bf1eb44/consumer.go#L203-L216 |
141,761 | j-keck/arping | arping.go | Ping | func Ping(dstIP net.IP) (net.HardwareAddr, time.Duration, error) {
if err := validateIP(dstIP); err != nil {
return nil, 0, err
}
iface, err := findUsableInterfaceForNetwork(dstIP)
if err != nil {
return nil, 0, err
}
return PingOverIface(dstIP, *iface)
} | go | func Ping(dstIP net.IP) (net.HardwareAddr, time.Duration, error) {
if err := validateIP(dstIP); err != nil {
return nil, 0, err
}
iface, err := findUsableInterfaceForNetwork(dstIP)
if err != nil {
return nil, 0, err
}
return PingOverIface(dstIP, *iface)
} | [
"func",
"Ping",
"(",
"dstIP",
"net",
".",
"IP",
")",
"(",
"net",
".",
"HardwareAddr",
",",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateIP",
"(",
"dstIP",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0... | // Ping sends an arp ping to 'dstIP' | [
"Ping",
"sends",
"an",
"arp",
"ping",
"to",
"dstIP"
] | 52070c5014d8939fc2d5e7bdf8d8124b423cbf45 | https://github.com/j-keck/arping/blob/52070c5014d8939fc2d5e7bdf8d8124b423cbf45/arping.go#L80-L90 |
141,762 | j-keck/arping | arping.go | PingOverIfaceByName | func PingOverIfaceByName(dstIP net.IP, ifaceName string) (net.HardwareAddr, time.Duration, error) {
if err := validateIP(dstIP); err != nil {
return nil, 0, err
}
iface, err := net.InterfaceByName(ifaceName)
if err != nil {
return nil, 0, err
}
return PingOverIface(dstIP, *iface)
} | go | func PingOverIfaceByName(dstIP net.IP, ifaceName string) (net.HardwareAddr, time.Duration, error) {
if err := validateIP(dstIP); err != nil {
return nil, 0, err
}
iface, err := net.InterfaceByName(ifaceName)
if err != nil {
return nil, 0, err
}
return PingOverIface(dstIP, *iface)
} | [
"func",
"PingOverIfaceByName",
"(",
"dstIP",
"net",
".",
"IP",
",",
"ifaceName",
"string",
")",
"(",
"net",
".",
"HardwareAddr",
",",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateIP",
"(",
"dstIP",
")",
";",
"err",
"!=",... | // PingOverIfaceByName sends an arp ping over interface name 'ifaceName' to 'dstIP' | [
"PingOverIfaceByName",
"sends",
"an",
"arp",
"ping",
"over",
"interface",
"name",
"ifaceName",
"to",
"dstIP"
] | 52070c5014d8939fc2d5e7bdf8d8124b423cbf45 | https://github.com/j-keck/arping/blob/52070c5014d8939fc2d5e7bdf8d8124b423cbf45/arping.go#L93-L103 |
141,763 | j-keck/arping | arping.go | PingOverIface | func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Duration, error) {
if err := validateIP(dstIP); err != nil {
return nil, 0, err
}
srcMac := iface.HardwareAddr
srcIP, err := findIPInNetworkFromIface(dstIP, iface)
if err != nil {
return nil, 0, err
}
broadcastMac := []byte{0xff,... | go | func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Duration, error) {
if err := validateIP(dstIP); err != nil {
return nil, 0, err
}
srcMac := iface.HardwareAddr
srcIP, err := findIPInNetworkFromIface(dstIP, iface)
if err != nil {
return nil, 0, err
}
broadcastMac := []byte{0xff,... | [
"func",
"PingOverIface",
"(",
"dstIP",
"net",
".",
"IP",
",",
"iface",
"net",
".",
"Interface",
")",
"(",
"net",
".",
"HardwareAddr",
",",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateIP",
"(",
"dstIP",
")",
";",
"err"... | // PingOverIface sends an arp ping over interface 'iface' to 'dstIP' | [
"PingOverIface",
"sends",
"an",
"arp",
"ping",
"over",
"interface",
"iface",
"to",
"dstIP"
] | 52070c5014d8939fc2d5e7bdf8d8124b423cbf45 | https://github.com/j-keck/arping/blob/52070c5014d8939fc2d5e7bdf8d8124b423cbf45/arping.go#L106-L167 |
141,764 | j-keck/arping | arping.go | GratuitousArp | func GratuitousArp(srcIP net.IP) error {
if err := validateIP(srcIP); err != nil {
return err
}
iface, err := findUsableInterfaceForNetwork(srcIP)
if err != nil {
return err
}
return GratuitousArpOverIface(srcIP, *iface)
} | go | func GratuitousArp(srcIP net.IP) error {
if err := validateIP(srcIP); err != nil {
return err
}
iface, err := findUsableInterfaceForNetwork(srcIP)
if err != nil {
return err
}
return GratuitousArpOverIface(srcIP, *iface)
} | [
"func",
"GratuitousArp",
"(",
"srcIP",
"net",
".",
"IP",
")",
"error",
"{",
"if",
"err",
":=",
"validateIP",
"(",
"srcIP",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"iface",
",",
"err",
":=",
"findUsableInterfaceForNetwork",
... | // GratuitousArp sends an gratuitous arp from 'srcIP' | [
"GratuitousArp",
"sends",
"an",
"gratuitous",
"arp",
"from",
"srcIP"
] | 52070c5014d8939fc2d5e7bdf8d8124b423cbf45 | https://github.com/j-keck/arping/blob/52070c5014d8939fc2d5e7bdf8d8124b423cbf45/arping.go#L170-L180 |
141,765 | j-keck/arping | arping.go | GratuitousArpOverIfaceByName | func GratuitousArpOverIfaceByName(srcIP net.IP, ifaceName string) error {
if err := validateIP(srcIP); err != nil {
return err
}
iface, err := net.InterfaceByName(ifaceName)
if err != nil {
return err
}
return GratuitousArpOverIface(srcIP, *iface)
} | go | func GratuitousArpOverIfaceByName(srcIP net.IP, ifaceName string) error {
if err := validateIP(srcIP); err != nil {
return err
}
iface, err := net.InterfaceByName(ifaceName)
if err != nil {
return err
}
return GratuitousArpOverIface(srcIP, *iface)
} | [
"func",
"GratuitousArpOverIfaceByName",
"(",
"srcIP",
"net",
".",
"IP",
",",
"ifaceName",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"validateIP",
"(",
"srcIP",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"iface",
",",
"... | // GratuitousArpOverIfaceByName sends an gratuitous arp over interface name 'ifaceName' from 'srcIP' | [
"GratuitousArpOverIfaceByName",
"sends",
"an",
"gratuitous",
"arp",
"over",
"interface",
"name",
"ifaceName",
"from",
"srcIP"
] | 52070c5014d8939fc2d5e7bdf8d8124b423cbf45 | https://github.com/j-keck/arping/blob/52070c5014d8939fc2d5e7bdf8d8124b423cbf45/arping.go#L183-L193 |
141,766 | j-keck/arping | arping.go | GratuitousArpOverIface | func GratuitousArpOverIface(srcIP net.IP, iface net.Interface) error {
if err := validateIP(srcIP); err != nil {
return err
}
srcMac := iface.HardwareAddr
broadcastMac := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
request := newArpRequest(srcMac, srcIP, broadcastMac, srcIP)
if err := initialize(iface); err !=... | go | func GratuitousArpOverIface(srcIP net.IP, iface net.Interface) error {
if err := validateIP(srcIP); err != nil {
return err
}
srcMac := iface.HardwareAddr
broadcastMac := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
request := newArpRequest(srcMac, srcIP, broadcastMac, srcIP)
if err := initialize(iface); err !=... | [
"func",
"GratuitousArpOverIface",
"(",
"srcIP",
"net",
".",
"IP",
",",
"iface",
"net",
".",
"Interface",
")",
"error",
"{",
"if",
"err",
":=",
"validateIP",
"(",
"srcIP",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"srcMac",
... | // GratuitousArpOverIface sends an gratuitous arp over interface 'iface' from 'srcIP' | [
"GratuitousArpOverIface",
"sends",
"an",
"gratuitous",
"arp",
"over",
"interface",
"iface",
"from",
"srcIP"
] | 52070c5014d8939fc2d5e7bdf8d8124b423cbf45 | https://github.com/j-keck/arping/blob/52070c5014d8939fc2d5e7bdf8d8124b423cbf45/arping.go#L196-L212 |
141,767 | joyent/gocommon | errors/errors.go | code | func (err *gojoyentError) code() Code {
if err.errcode != UnknownErrorError {
return err.errcode
}
if e, ok := err.cause.(*gojoyentError); ok {
return e.code()
}
return UnknownErrorError
} | go | func (err *gojoyentError) code() Code {
if err.errcode != UnknownErrorError {
return err.errcode
}
if e, ok := err.cause.(*gojoyentError); ok {
return e.code()
}
return UnknownErrorError
} | [
"func",
"(",
"err",
"*",
"gojoyentError",
")",
"code",
"(",
")",
"Code",
"{",
"if",
"err",
".",
"errcode",
"!=",
"UnknownErrorError",
"{",
"return",
"err",
".",
"errcode",
"\n",
"}",
"\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"cause",
".",
"(",
... | // Code returns the error code. | [
"Code",
"returns",
"the",
"error",
"code",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L51-L59 |
141,768 | joyent/gocommon | errors/errors.go | causedBy | func (err *gojoyentError) causedBy(code Code) bool {
if err.code() == code {
return true
}
if cause, ok := err.cause.(*gojoyentError); ok {
return cause.code() == code
}
return false
} | go | func (err *gojoyentError) causedBy(code Code) bool {
if err.code() == code {
return true
}
if cause, ok := err.cause.(*gojoyentError); ok {
return cause.code() == code
}
return false
} | [
"func",
"(",
"err",
"*",
"gojoyentError",
")",
"causedBy",
"(",
"code",
"Code",
")",
"bool",
"{",
"if",
"err",
".",
"code",
"(",
")",
"==",
"code",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"cause",
",",
"ok",
":=",
"err",
".",
"cause",
".",
... | // CausedBy returns true if this error or its cause are of the specified error code. | [
"CausedBy",
"returns",
"true",
"if",
"this",
"error",
"or",
"its",
"cause",
"are",
"of",
"the",
"specified",
"error",
"code",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L67-L75 |
141,769 | joyent/gocommon | errors/errors.go | Error | func (err *gojoyentError) Error() string {
if err.cause != nil {
return fmt.Sprintf("%v\ncaused by: %v", err.error, err.cause)
}
return err.error.Error()
} | go | func (err *gojoyentError) Error() string {
if err.cause != nil {
return fmt.Sprintf("%v\ncaused by: %v", err.error, err.cause)
}
return err.error.Error()
} | [
"func",
"(",
"err",
"*",
"gojoyentError",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"err",
".",
"cause",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
".",
"error",
",",
"err",
".",
"cause",
")",
"\n",
... | // Error fulfills the error interface, taking account of any caused by error. | [
"Error",
"fulfills",
"the",
"error",
"interface",
"taking",
"account",
"of",
"any",
"caused",
"by",
"error",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L78-L83 |
141,770 | joyent/gocommon | errors/errors.go | makeErrorf | func makeErrorf(code Code, cause error, format string, args ...interface{}) Error {
return &gojoyentError{
errcode: code,
error: fmt.Errorf(format, args...),
cause: cause,
}
} | go | func makeErrorf(code Code, cause error, format string, args ...interface{}) Error {
return &gojoyentError{
errcode: code,
error: fmt.Errorf(format, args...),
cause: cause,
}
} | [
"func",
"makeErrorf",
"(",
"code",
"Code",
",",
"cause",
"error",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"return",
"&",
"gojoyentError",
"{",
"errcode",
":",
"code",
",",
"error",
":",
"fmt",
".",
"Errorf... | // New creates a new Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L177-L183 |
141,771 | joyent/gocommon | errors/errors.go | NewBadRequestf | func NewBadRequestf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Bad Request: %s", context)
}
return makeErrorf(BadRequestError, cause, format, args...)
} | go | func NewBadRequestf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Bad Request: %s", context)
}
return makeErrorf(BadRequestError, cause, format, args...)
} | [
"func",
"NewBadRequestf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprintf",
... | // New creates a new BadRequest Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"BadRequest",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L191-L196 |
141,772 | joyent/gocommon | errors/errors.go | NewInternalErrorf | func NewInternalErrorf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Internal Error: %s", context)
}
return makeErrorf(InternalErrorError, cause, format, args...)
} | go | func NewInternalErrorf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Internal Error: %s", context)
}
return makeErrorf(InternalErrorError, cause, format, args...)
} | [
"func",
"NewInternalErrorf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprintf... | // New creates a new InternalError Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"InternalError",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L199-L204 |
141,773 | joyent/gocommon | errors/errors.go | NewInvalidArgumentf | func NewInvalidArgumentf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Argument: %s", context)
}
return makeErrorf(InvalidArgumentError, cause, format, args...)
} | go | func NewInvalidArgumentf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Argument: %s", context)
}
return makeErrorf(InvalidArgumentError, cause, format, args...)
} | [
"func",
"NewInvalidArgumentf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprin... | // New creates a new InvalidArgument Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"InvalidArgument",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L207-L212 |
141,774 | joyent/gocommon | errors/errors.go | NewInvalidCredentialsf | func NewInvalidCredentialsf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Credentials: %s", context)
}
return makeErrorf(InvalidCredentialsError, cause, format, args...)
} | go | func NewInvalidCredentialsf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Credentials: %s", context)
}
return makeErrorf(InvalidCredentialsError, cause, format, args...)
} | [
"func",
"NewInvalidCredentialsf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sp... | // New creates a new InvalidCredentials Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"InvalidCredentials",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L215-L220 |
141,775 | joyent/gocommon | errors/errors.go | NewInvalidHeaderf | func NewInvalidHeaderf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Header: %s", context)
}
return makeErrorf(InvalidHeaderError, cause, format, args...)
} | go | func NewInvalidHeaderf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Header: %s", context)
}
return makeErrorf(InvalidHeaderError, cause, format, args...)
} | [
"func",
"NewInvalidHeaderf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprintf... | // New creates a new InvalidHeader Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"InvalidHeader",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L223-L228 |
141,776 | joyent/gocommon | errors/errors.go | NewInvalidVersionf | func NewInvalidVersionf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Version: %s", context)
}
return makeErrorf(InvalidVersionError, cause, format, args...)
} | go | func NewInvalidVersionf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Invalid Version: %s", context)
}
return makeErrorf(InvalidVersionError, cause, format, args...)
} | [
"func",
"NewInvalidVersionf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprint... | // New creates a new InvalidVersion Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"InvalidVersion",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L231-L236 |
141,777 | joyent/gocommon | errors/errors.go | NewMissingParameterf | func NewMissingParameterf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Missing Parameter: %s", context)
}
return makeErrorf(MissingParameterError, cause, format, args...)
} | go | func NewMissingParameterf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Missing Parameter: %s", context)
}
return makeErrorf(MissingParameterError, cause, format, args...)
} | [
"func",
"NewMissingParameterf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Spri... | // New creates a new MissingParameter Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"MissingParameter",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L239-L244 |
141,778 | joyent/gocommon | errors/errors.go | NewNotAuthorizedf | func NewNotAuthorizedf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Not Authorized: %s", context)
}
return makeErrorf(NotAuthorizedError, cause, format, args...)
} | go | func NewNotAuthorizedf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Not Authorized: %s", context)
}
return makeErrorf(NotAuthorizedError, cause, format, args...)
} | [
"func",
"NewNotAuthorizedf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprintf... | // New creates a new NotAuthorized Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"NotAuthorized",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L247-L252 |
141,779 | joyent/gocommon | errors/errors.go | NewRequestThrottledf | func NewRequestThrottledf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Request Throttled: %s", context)
}
return makeErrorf(RequestThrottledError, cause, format, args...)
} | go | func NewRequestThrottledf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Request Throttled: %s", context)
}
return makeErrorf(RequestThrottledError, cause, format, args...)
} | [
"func",
"NewRequestThrottledf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Spri... | // New creates a new RequestThrottled Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"RequestThrottled",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L255-L260 |
141,780 | joyent/gocommon | errors/errors.go | NewRequestTooLargef | func NewRequestTooLargef(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Request Too Large: %s", context)
}
return makeErrorf(RequestTooLargeError, cause, format, args...)
} | go | func NewRequestTooLargef(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Request Too Large: %s", context)
}
return makeErrorf(RequestTooLargeError, cause, format, args...)
} | [
"func",
"NewRequestTooLargef",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprin... | // New creates a new RequestTooLarge Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"RequestTooLarge",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L263-L268 |
141,781 | joyent/gocommon | errors/errors.go | NewRequestMovedf | func NewRequestMovedf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Request Moved: %s", context)
}
return makeErrorf(RequestMovedError, cause, format, args...)
} | go | func NewRequestMovedf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Request Moved: %s", context)
}
return makeErrorf(RequestMovedError, cause, format, args...)
} | [
"func",
"NewRequestMovedf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Sprintf"... | // New creates a new RequestMoved Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"RequestMoved",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L271-L276 |
141,782 | joyent/gocommon | errors/errors.go | NewResourceNotFoundf | func NewResourceNotFoundf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Resource Not Found: %s", context)
}
return makeErrorf(ResourceNotFoundError, cause, format, args...)
} | go | func NewResourceNotFoundf(cause error, context interface{}, format string, args ...interface{}) Error {
if format == "" {
format = fmt.Sprintf("Resource Not Found: %s", context)
}
return makeErrorf(ResourceNotFoundError, cause, format, args...)
} | [
"func",
"NewResourceNotFoundf",
"(",
"cause",
"error",
",",
"context",
"interface",
"{",
"}",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"format",
"==",
"\"",
"\"",
"{",
"format",
"=",
"fmt",
".",
"Spri... | // New creates a new ResourceNotFound Error instance with the specified cause. | [
"New",
"creates",
"a",
"new",
"ResourceNotFound",
"Error",
"instance",
"with",
"the",
"specified",
"cause",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/errors/errors.go#L279-L284 |
141,783 | joyent/gocommon | jpc/jpc.go | getConfig | func getConfig(envVars ...string) (value string) {
value = ""
for _, v := range envVars {
value = os.Getenv(v)
if value != "" {
break
}
}
return
} | go | func getConfig(envVars ...string) (value string) {
value = ""
for _, v := range envVars {
value = os.Getenv(v)
if value != "" {
break
}
}
return
} | [
"func",
"getConfig",
"(",
"envVars",
"...",
"string",
")",
"(",
"value",
"string",
")",
"{",
"value",
"=",
"\"",
"\"",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"envVars",
"{",
"value",
"=",
"os",
".",
"Getenv",
"(",
"v",
")",
"\n",
"if",
"value... | // getConfig returns the value of the first available environment
// variable, among the given ones. | [
"getConfig",
"returns",
"the",
"value",
"of",
"the",
"first",
"available",
"environment",
"variable",
"among",
"the",
"given",
"ones",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/jpc/jpc.go#L49-L58 |
141,784 | joyent/gocommon | jpc/jpc.go | credentialsFromEnv | func credentialsFromEnv(key string) (*auth.Credentials, error) {
var keyName string
if key == "" {
keyName = getUserHome() + "/.ssh/id_rsa"
} else {
keyName = key
}
privateKey, err := ioutil.ReadFile(keyName)
if err != nil {
return nil, err
}
authentication, err := auth.NewAuth(getConfig(TritonAccount, Sd... | go | func credentialsFromEnv(key string) (*auth.Credentials, error) {
var keyName string
if key == "" {
keyName = getUserHome() + "/.ssh/id_rsa"
} else {
keyName = key
}
privateKey, err := ioutil.ReadFile(keyName)
if err != nil {
return nil, err
}
authentication, err := auth.NewAuth(getConfig(TritonAccount, Sd... | [
"func",
"credentialsFromEnv",
"(",
"key",
"string",
")",
"(",
"*",
"auth",
".",
"Credentials",
",",
"error",
")",
"{",
"var",
"keyName",
"string",
"\n",
"if",
"key",
"==",
"\"",
"\"",
"{",
"keyName",
"=",
"getUserHome",
"(",
")",
"+",
"\"",
"\"",
"\n... | // credentialsFromEnv creates and initializes the credentials from the
// environment variables. | [
"credentialsFromEnv",
"creates",
"and",
"initializes",
"the",
"credentials",
"from",
"the",
"environment",
"variables",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/jpc/jpc.go#L72-L95 |
141,785 | joyent/gocommon | jpc/jpc.go | CompleteCredentialsFromEnv | func CompleteCredentialsFromEnv(keyName string) (cred *auth.Credentials, err error) {
cred, err = credentialsFromEnv(keyName)
if err != nil {
return nil, err
}
v := reflect.ValueOf(cred).Elem()
t := v.Type()
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
if f.String() == "" {
return nil, fmt.Errorf(... | go | func CompleteCredentialsFromEnv(keyName string) (cred *auth.Credentials, err error) {
cred, err = credentialsFromEnv(keyName)
if err != nil {
return nil, err
}
v := reflect.ValueOf(cred).Elem()
t := v.Type()
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
if f.String() == "" {
return nil, fmt.Errorf(... | [
"func",
"CompleteCredentialsFromEnv",
"(",
"keyName",
"string",
")",
"(",
"cred",
"*",
"auth",
".",
"Credentials",
",",
"err",
"error",
")",
"{",
"cred",
",",
"err",
"=",
"credentialsFromEnv",
"(",
"keyName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"re... | // CompleteCredentialsFromEnv gets and verifies all the required
// authentication parameters have values in the environment. | [
"CompleteCredentialsFromEnv",
"gets",
"and",
"verifies",
"all",
"the",
"required",
"authentication",
"parameters",
"have",
"values",
"in",
"the",
"environment",
"."
] | b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2 | https://github.com/joyent/gocommon/blob/b78708995d1c2ebdb64a3061b0bca5d8ccdf0fc2/jpc/jpc.go#L99-L113 |
141,786 | riemann/riemann-go-client | client.go | SendEvent | func SendEvent(c Client, e *Event) (*proto.Msg, error) {
return SendEvents(
c, &([]Event{*e}),
)
} | go | func SendEvent(c Client, e *Event) (*proto.Msg, error) {
return SendEvents(
c, &([]Event{*e}),
)
} | [
"func",
"SendEvent",
"(",
"c",
"Client",
",",
"e",
"*",
"Event",
")",
"(",
"*",
"proto",
".",
"Msg",
",",
"error",
")",
"{",
"return",
"SendEvents",
"(",
"c",
",",
"&",
"(",
"[",
"]",
"Event",
"{",
"*",
"e",
"}",
")",
",",
")",
"\n",
"}"
] | // SendEvent send an event using a client | [
"SendEvent",
"send",
"an",
"event",
"using",
"a",
"client"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/client.go#L35-L39 |
141,787 | riemann/riemann-go-client | client.go | SendEvents | func SendEvents(c Client, e *[]Event) (*proto.Msg, error) {
buff := make(
[]*proto.Event, len(*e),
)
for i, elem := range *e {
epb, err := EventToProtocolBuffer(
&elem,
)
if err != nil {
return nil, err
}
buff[i] = epb
}
message := new(proto.Msg)
message.Events = buff
return c.Send(message... | go | func SendEvents(c Client, e *[]Event) (*proto.Msg, error) {
buff := make(
[]*proto.Event, len(*e),
)
for i, elem := range *e {
epb, err := EventToProtocolBuffer(
&elem,
)
if err != nil {
return nil, err
}
buff[i] = epb
}
message := new(proto.Msg)
message.Events = buff
return c.Send(message... | [
"func",
"SendEvents",
"(",
"c",
"Client",
",",
"e",
"*",
"[",
"]",
"Event",
")",
"(",
"*",
"proto",
".",
"Msg",
",",
"error",
")",
"{",
"buff",
":=",
"make",
"(",
"[",
"]",
"*",
"proto",
".",
"Event",
",",
"len",
"(",
"*",
"e",
")",
",",
")... | // SendEvents send multiple events using a client | [
"SendEvents",
"send",
"multiple",
"events",
"using",
"a",
"client"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/client.go#L42-L63 |
141,788 | riemann/riemann-go-client | marshal.go | EventToProtocolBuffer | func EventToProtocolBuffer(event *Event) (*proto.Event, error) {
if event.Host == "" {
event.Host, _ = os.Hostname()
}
if event.Time.IsZero() {
event.Time = time.Now()
}
var e proto.Event
e.Host = pb.String(event.Host)
e.Time = pb.Int64(event.Time.Unix())
e.TimeMicros = pb.Int64(event.Time.UnixNano() / i... | go | func EventToProtocolBuffer(event *Event) (*proto.Event, error) {
if event.Host == "" {
event.Host, _ = os.Hostname()
}
if event.Time.IsZero() {
event.Time = time.Now()
}
var e proto.Event
e.Host = pb.String(event.Host)
e.Time = pb.Int64(event.Time.Unix())
e.TimeMicros = pb.Int64(event.Time.UnixNano() / i... | [
"func",
"EventToProtocolBuffer",
"(",
"event",
"*",
"Event",
")",
"(",
"*",
"proto",
".",
"Event",
",",
"error",
")",
"{",
"if",
"event",
".",
"Host",
"==",
"\"",
"\"",
"{",
"event",
".",
"Host",
",",
"_",
"=",
"os",
".",
"Hostname",
"(",
")",
"\... | // EventToProtocolBuffer convert an event to a protobuf Event | [
"EventToProtocolBuffer",
"convert",
"an",
"event",
"to",
"a",
"protobuf",
"Event"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/marshal.go#L15-L69 |
141,789 | riemann/riemann-go-client | tcp.go | NewTLSClient | func NewTLSClient(addr string, tlsConfig *tls.Config, timeout time.Duration) (*TCPClient, error) {
t := &TCPClient{
tls: true,
addr: addr,
tlsConfig: tlsConfig,
requestQueue: make(chan request),
timeout: timeout,
}
return t, nil
} | go | func NewTLSClient(addr string, tlsConfig *tls.Config, timeout time.Duration) (*TCPClient, error) {
t := &TCPClient{
tls: true,
addr: addr,
tlsConfig: tlsConfig,
requestQueue: make(chan request),
timeout: timeout,
}
return t, nil
} | [
"func",
"NewTLSClient",
"(",
"addr",
"string",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"TCPClient",
",",
"error",
")",
"{",
"t",
":=",
"&",
"TCPClient",
"{",
"tls",
":",
"true",
",",
"addr"... | // NewTLSClient - Factory | [
"NewTLSClient",
"-",
"Factory"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/tcp.go#L30-L39 |
141,790 | riemann/riemann-go-client | tcp.go | NewTCPClient | func NewTCPClient(addr string, timeout time.Duration) *TCPClient {
t := &TCPClient{
tls: false,
addr: addr,
requestQueue: make(chan request),
timeout: timeout,
}
return t
} | go | func NewTCPClient(addr string, timeout time.Duration) *TCPClient {
t := &TCPClient{
tls: false,
addr: addr,
requestQueue: make(chan request),
timeout: timeout,
}
return t
} | [
"func",
"NewTCPClient",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"*",
"TCPClient",
"{",
"t",
":=",
"&",
"TCPClient",
"{",
"tls",
":",
"false",
",",
"addr",
":",
"addr",
",",
"requestQueue",
":",
"make",
"(",
"chan",
"request... | // NewTCPClient - Factory | [
"NewTCPClient",
"-",
"Factory"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/tcp.go#L67-L75 |
141,791 | riemann/riemann-go-client | tcp.go | Connect | func (c *TCPClient) Connect() error {
c.t.Go(func() error {
return c.runRequestQueue()
})
connection, err := net.DialTimeout("tcp", c.addr, c.timeout)
if err != nil {
return err
}
if c.tls {
tlsConn := tls.Client(connection, c.tlsConfig)
err = tlsConn.Handshake()
if err != nil {
return err
}
c.co... | go | func (c *TCPClient) Connect() error {
c.t.Go(func() error {
return c.runRequestQueue()
})
connection, err := net.DialTimeout("tcp", c.addr, c.timeout)
if err != nil {
return err
}
if c.tls {
tlsConn := tls.Client(connection, c.tlsConfig)
err = tlsConn.Handshake()
if err != nil {
return err
}
c.co... | [
"func",
"(",
"c",
"*",
"TCPClient",
")",
"Connect",
"(",
")",
"error",
"{",
"c",
".",
"t",
".",
"Go",
"(",
"func",
"(",
")",
"error",
"{",
"return",
"c",
".",
"runRequestQueue",
"(",
")",
"\n",
"}",
")",
"\n",
"connection",
",",
"err",
":=",
"n... | // Connect the tcp client | [
"Connect",
"the",
"tcp",
"client"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/tcp.go#L78-L97 |
141,792 | riemann/riemann-go-client | tcp.go | Close | func (c *TCPClient) Close() error {
c.t.Kill(nil)
_ = c.t.Wait()
close(c.requestQueue)
err := c.conn.Close()
return err
} | go | func (c *TCPClient) Close() error {
c.t.Kill(nil)
_ = c.t.Wait()
close(c.requestQueue)
err := c.conn.Close()
return err
} | [
"func",
"(",
"c",
"*",
"TCPClient",
")",
"Close",
"(",
")",
"error",
"{",
"c",
".",
"t",
".",
"Kill",
"(",
"nil",
")",
"\n",
"_",
"=",
"c",
".",
"t",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"c",
".",
"requestQueue",
")",
"\n",
"err",
":=... | // Close will close the TCPClient | [
"Close",
"will",
"close",
"the",
"TCPClient"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/tcp.go#L100-L106 |
141,793 | riemann/riemann-go-client | tcp.go | readMessages | func readMessages(r io.Reader, p []byte) error {
for len(p) > 0 {
n, err := r.Read(p)
p = p[n:]
if err != nil {
return err
}
}
return nil
} | go | func readMessages(r io.Reader, p []byte) error {
for len(p) > 0 {
n, err := r.Read(p)
p = p[n:]
if err != nil {
return err
}
}
return nil
} | [
"func",
"readMessages",
"(",
"r",
"io",
".",
"Reader",
",",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"for",
"len",
"(",
"p",
")",
">",
"0",
"{",
"n",
",",
"err",
":=",
"r",
".",
"Read",
"(",
"p",
")",
"\n",
"p",
"=",
"p",
"[",
"n",
":",
... | // readMessages will read Riemann messages from the TCP connection | [
"readMessages",
"will",
"read",
"Riemann",
"messages",
"from",
"the",
"TCP",
"connection"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/tcp.go#L172-L181 |
141,794 | riemann/riemann-go-client | tcp.go | QueryIndex | func (c *TCPClient) QueryIndex(q string) ([]Event, error) {
err := c.conn.SetDeadline(time.Now().Add(c.timeout))
if err != nil {
return nil, err
}
query := &proto.Query{}
query.String_ = pb.String(q)
message := &proto.Msg{}
message.Query = query
response, err := c.Send(message)
if err != nil {
return nil... | go | func (c *TCPClient) QueryIndex(q string) ([]Event, error) {
err := c.conn.SetDeadline(time.Now().Add(c.timeout))
if err != nil {
return nil, err
}
query := &proto.Query{}
query.String_ = pb.String(q)
message := &proto.Msg{}
message.Query = query
response, err := c.Send(message)
if err != nil {
return nil... | [
"func",
"(",
"c",
"*",
"TCPClient",
")",
"QueryIndex",
"(",
"q",
"string",
")",
"(",
"[",
"]",
"Event",
",",
"error",
")",
"{",
"err",
":=",
"c",
".",
"conn",
".",
"SetDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"c",
".",
"... | // QueryIndex query the server for events using the client | [
"QueryIndex",
"query",
"the",
"server",
"for",
"events",
"using",
"the",
"client"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/tcp.go#L184-L201 |
141,795 | riemann/riemann-go-client | udp.go | NewUDPClient | func NewUDPClient(addr string, timeout time.Duration) *UDPClient {
t := &UDPClient{
addr: addr,
requestQueue: make(chan request),
timeout: timeout,
}
return t
} | go | func NewUDPClient(addr string, timeout time.Duration) *UDPClient {
t := &UDPClient{
addr: addr,
requestQueue: make(chan request),
timeout: timeout,
}
return t
} | [
"func",
"NewUDPClient",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"*",
"UDPClient",
"{",
"t",
":=",
"&",
"UDPClient",
"{",
"addr",
":",
"addr",
",",
"requestQueue",
":",
"make",
"(",
"chan",
"request",
")",
",",
"timeout",
":... | // NewUDPClient - Factory | [
"NewUDPClient",
"-",
"Factory"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/udp.go#L26-L33 |
141,796 | riemann/riemann-go-client | udp.go | Connect | func (c *UDPClient) Connect() error {
c.t.Go(func() error {
return c.runRequestQueue()
})
udp, err := net.DialTimeout("udp", c.addr, c.timeout)
if err != nil {
return err
}
c.conn = udp
return nil
} | go | func (c *UDPClient) Connect() error {
c.t.Go(func() error {
return c.runRequestQueue()
})
udp, err := net.DialTimeout("udp", c.addr, c.timeout)
if err != nil {
return err
}
c.conn = udp
return nil
} | [
"func",
"(",
"c",
"*",
"UDPClient",
")",
"Connect",
"(",
")",
"error",
"{",
"c",
".",
"t",
".",
"Go",
"(",
"func",
"(",
")",
"error",
"{",
"return",
"c",
".",
"runRequestQueue",
"(",
")",
"\n",
"}",
")",
"\n",
"udp",
",",
"err",
":=",
"net",
... | // Connect the udp client | [
"Connect",
"the",
"udp",
"client"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/udp.go#L36-L46 |
141,797 | riemann/riemann-go-client | udp.go | Send | func (c *UDPClient) Send(message *proto.Msg) (*proto.Msg, error) {
responseCh := make(chan response)
c.requestQueue <- request{message, responseCh}
r := <-responseCh
return r.message, r.err
} | go | func (c *UDPClient) Send(message *proto.Msg) (*proto.Msg, error) {
responseCh := make(chan response)
c.requestQueue <- request{message, responseCh}
r := <-responseCh
return r.message, r.err
} | [
"func",
"(",
"c",
"*",
"UDPClient",
")",
"Send",
"(",
"message",
"*",
"proto",
".",
"Msg",
")",
"(",
"*",
"proto",
".",
"Msg",
",",
"error",
")",
"{",
"responseCh",
":=",
"make",
"(",
"chan",
"response",
")",
"\n",
"c",
".",
"requestQueue",
"<-",
... | // Send queues a request to send a message to the server | [
"Send",
"queues",
"a",
"request",
"to",
"send",
"a",
"message",
"to",
"the",
"server"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/udp.go#L49-L54 |
141,798 | riemann/riemann-go-client | udp.go | runRequestQueue | func (c *UDPClient) runRequestQueue() error {
for {
select {
case <-c.t.Dying():
return nil
case req := <-c.requestQueue:
message := req.message
responseCh := req.responseCh
msg, err := c.execRequest(message)
responseCh <- response{msg, err}
}
}
} | go | func (c *UDPClient) runRequestQueue() error {
for {
select {
case <-c.t.Dying():
return nil
case req := <-c.requestQueue:
message := req.message
responseCh := req.responseCh
msg, err := c.execRequest(message)
responseCh <- response{msg, err}
}
}
} | [
"func",
"(",
"c",
"*",
"UDPClient",
")",
"runRequestQueue",
"(",
")",
"error",
"{",
"for",
"{",
"select",
"{",
"case",
"<-",
"c",
".",
"t",
".",
"Dying",
"(",
")",
":",
"return",
"nil",
"\n",
"case",
"req",
":=",
"<-",
"c",
".",
"requestQueue",
"... | // runRequestQueue services the UDPClient request queue | [
"runRequestQueue",
"services",
"the",
"UDPClient",
"request",
"queue"
] | cdaa2ff120f72ab3153d09a6e1be0db320c1d691 | https://github.com/riemann/riemann-go-client/blob/cdaa2ff120f72ab3153d09a6e1be0db320c1d691/udp.go#L66-L82 |
141,799 | ipsn/go-ipfs | core/coreapi/path.go | ResolveNode | func (api *CoreAPI) ResolveNode(ctx context.Context, p coreiface.Path) (ipld.Node, error) {
rp, err := api.ResolvePath(ctx, p)
if err != nil {
return nil, err
}
node, err := api.dag.Get(ctx, rp.Cid())
if err != nil {
return nil, err
}
return node, nil
} | go | func (api *CoreAPI) ResolveNode(ctx context.Context, p coreiface.Path) (ipld.Node, error) {
rp, err := api.ResolvePath(ctx, p)
if err != nil {
return nil, err
}
node, err := api.dag.Get(ctx, rp.Cid())
if err != nil {
return nil, err
}
return node, nil
} | [
"func",
"(",
"api",
"*",
"CoreAPI",
")",
"ResolveNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"p",
"coreiface",
".",
"Path",
")",
"(",
"ipld",
".",
"Node",
",",
"error",
")",
"{",
"rp",
",",
"err",
":=",
"api",
".",
"ResolvePath",
"(",
"ctx",... | // ResolveNode resolves the path `p` using Unixfs resolver, gets and returns the
// resolved Node. | [
"ResolveNode",
"resolves",
"the",
"path",
"p",
"using",
"Unixfs",
"resolver",
"gets",
"and",
"returns",
"the",
"resolved",
"Node",
"."
] | 8b9b72514244155bc38ab21eac7f4d950ea97c28 | https://github.com/ipsn/go-ipfs/blob/8b9b72514244155bc38ab21eac7f4d950ea97c28/core/coreapi/path.go#L20-L31 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.