id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
14,600 | doug-martin/goqu | expressions.go | notILike | func notILike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, true)
} | go | func notILike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, true)
} | [
"func",
"notILike",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkLikeExp",
"(",
"I_LIKE_OP",
",",
"lhs",
",",
"val",
",",
"true",
")",
"\n",
"}"
] | //used internally to create a NOT ILIKE BooleanExpression | [
"used",
"internally",
"to",
"create",
"a",
"NOT",
"ILIKE",
"BooleanExpression"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L985-L987 |
14,601 | doug-martin/goqu | expressions.go | checkLikeExp | func checkLikeExp(op BooleanOperation, lhs Expression, val interface{}, invert bool) BooleanExpression {
rhs := val
switch val.(type) {
case *regexp.Regexp:
if op == LIKE_OP {
op = REGEXP_LIKE_OP
} else if op == I_LIKE_OP {
op = REGEXP_I_LIKE_OP
}
rhs = val.(*regexp.Regexp).String()
}
if invert {
op = operator_inversions[op]
}
return boolean{op: op, lhs: lhs, rhs: rhs}
} | go | func checkLikeExp(op BooleanOperation, lhs Expression, val interface{}, invert bool) BooleanExpression {
rhs := val
switch val.(type) {
case *regexp.Regexp:
if op == LIKE_OP {
op = REGEXP_LIKE_OP
} else if op == I_LIKE_OP {
op = REGEXP_I_LIKE_OP
}
rhs = val.(*regexp.Regexp).String()
}
if invert {
op = operator_inversions[op]
}
return boolean{op: op, lhs: lhs, rhs: rhs}
} | [
"func",
"checkLikeExp",
"(",
"op",
"BooleanOperation",
",",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
",",
"invert",
"bool",
")",
"BooleanExpression",
"{",
"rhs",
":=",
"val",
"\n",
"switch",
"val",
".",
"(",
"type",
")",
"{",
"case",
"*",
... | //checks an like rhs to create the proper like expression for strings or regexps | [
"checks",
"an",
"like",
"rhs",
"to",
"create",
"the",
"proper",
"like",
"expression",
"for",
"strings",
"or",
"regexps"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L990-L1005 |
14,602 | doug-martin/goqu | expressions.go | between | func between(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: BETWEEN_OP, lhs: lhs, rhs: rhs}
} | go | func between(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: BETWEEN_OP, lhs: lhs, rhs: rhs}
} | [
"func",
"between",
"(",
"lhs",
"Expression",
",",
"rhs",
"RangeVal",
")",
"RangeExpression",
"{",
"return",
"ranged",
"{",
"op",
":",
"BETWEEN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] | //used internally to create an BETWEEN comparison RangeExpression | [
"used",
"internally",
"to",
"create",
"an",
"BETWEEN",
"comparison",
"RangeExpression"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1085-L1087 |
14,603 | doug-martin/goqu | expressions.go | notBetween | func notBetween(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: NBETWEEN_OP, lhs: lhs, rhs: rhs}
} | go | func notBetween(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: NBETWEEN_OP, lhs: lhs, rhs: rhs}
} | [
"func",
"notBetween",
"(",
"lhs",
"Expression",
",",
"rhs",
"RangeVal",
")",
"RangeExpression",
"{",
"return",
"ranged",
"{",
"op",
":",
"NBETWEEN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] | //used internally to create an NOT BETWEEN comparison RangeExpression | [
"used",
"internally",
"to",
"create",
"an",
"NOT",
"BETWEEN",
"comparison",
"RangeExpression"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1090-L1092 |
14,604 | doug-martin/goqu | expressions.go | aliased | func aliased(exp Expression, alias interface{}) AliasedExpression {
switch v := alias.(type) {
case string:
return aliasExpression{aliased: exp, alias: I(v)}
case IdentifierExpression:
return aliasExpression{aliased: exp, alias: v}
default:
panic(fmt.Sprintf("Cannot create alias from %+v", v))
}
} | go | func aliased(exp Expression, alias interface{}) AliasedExpression {
switch v := alias.(type) {
case string:
return aliasExpression{aliased: exp, alias: I(v)}
case IdentifierExpression:
return aliasExpression{aliased: exp, alias: v}
default:
panic(fmt.Sprintf("Cannot create alias from %+v", v))
}
} | [
"func",
"aliased",
"(",
"exp",
"Expression",
",",
"alias",
"interface",
"{",
"}",
")",
"AliasedExpression",
"{",
"switch",
"v",
":=",
"alias",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"return",
"aliasExpression",
"{",
"aliased",
":",
"exp",
","... | //used internally by other expressions to create a new aliased expression | [
"used",
"internally",
"by",
"other",
"expressions",
"to",
"create",
"a",
"new",
"aliased",
"expression"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1112-L1121 |
14,605 | doug-martin/goqu | expressions.go | asc | func asc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_ASC, nullSortType: NO_NULLS}
} | go | func asc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_ASC, nullSortType: NO_NULLS}
} | [
"func",
"asc",
"(",
"exp",
"Expression",
")",
"OrderedExpression",
"{",
"return",
"orderedExpression",
"{",
"sortExpression",
":",
"exp",
",",
"direction",
":",
"SORT_ASC",
",",
"nullSortType",
":",
"NO_NULLS",
"}",
"\n",
"}"
] | //used internally to create a new SORT_ASC OrderedExpression | [
"used",
"internally",
"to",
"create",
"a",
"new",
"SORT_ASC",
"OrderedExpression"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1178-L1180 |
14,606 | doug-martin/goqu | expressions.go | desc | func desc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_DESC, nullSortType: NO_NULLS}
} | go | func desc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_DESC, nullSortType: NO_NULLS}
} | [
"func",
"desc",
"(",
"exp",
"Expression",
")",
"OrderedExpression",
"{",
"return",
"orderedExpression",
"{",
"sortExpression",
":",
"exp",
",",
"direction",
":",
"SORT_DESC",
",",
"nullSortType",
":",
"NO_NULLS",
"}",
"\n",
"}"
] | //used internally to create a new SORT_DESC OrderedExpression | [
"used",
"internally",
"to",
"create",
"a",
"new",
"SORT_DESC",
"OrderedExpression"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1183-L1185 |
14,607 | doug-martin/goqu | expressions.go | Func | func Func(name string, args ...interface{}) SqlFunctionExpression {
return sqlFunctionExpression{name: name, args: args}
} | go | func Func(name string, args ...interface{}) SqlFunctionExpression {
return sqlFunctionExpression{name: name, args: args}
} | [
"func",
"Func",
"(",
"name",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"SqlFunctionExpression",
"{",
"return",
"sqlFunctionExpression",
"{",
"name",
":",
"name",
",",
"args",
":",
"args",
"}",
"\n",
"}"
] | //Creates a new SqlFunctionExpression with the given name and arguments | [
"Creates",
"a",
"new",
"SqlFunctionExpression",
"with",
"the",
"given",
"name",
"and",
"arguments"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1234-L1236 |
14,608 | doug-martin/goqu | expressions.go | colFunc | func colFunc(name string, col interface{}) SqlFunctionExpression {
if s, ok := col.(string); ok {
col = I(s)
}
return Func(name, col)
} | go | func colFunc(name string, col interface{}) SqlFunctionExpression {
if s, ok := col.(string); ok {
col = I(s)
}
return Func(name, col)
} | [
"func",
"colFunc",
"(",
"name",
"string",
",",
"col",
"interface",
"{",
"}",
")",
"SqlFunctionExpression",
"{",
"if",
"s",
",",
"ok",
":=",
"col",
".",
"(",
"string",
")",
";",
"ok",
"{",
"col",
"=",
"I",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",... | //used internally to normalize the column name if passed in as a string it should be turned into an identifier | [
"used",
"internally",
"to",
"normalize",
"the",
"column",
"name",
"if",
"passed",
"in",
"as",
"a",
"string",
"it",
"should",
"be",
"turned",
"into",
"an",
"identifier"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1239-L1244 |
14,609 | doug-martin/goqu | expressions.go | With | func With(recursive bool, name string, subQuery SqlExpression) CommonTableExpression {
return commonExpr{recursive: recursive, name: Literal(name), subQuery: subQuery}
} | go | func With(recursive bool, name string, subQuery SqlExpression) CommonTableExpression {
return commonExpr{recursive: recursive, name: Literal(name), subQuery: subQuery}
} | [
"func",
"With",
"(",
"recursive",
"bool",
",",
"name",
"string",
",",
"subQuery",
"SqlExpression",
")",
"CommonTableExpression",
"{",
"return",
"commonExpr",
"{",
"recursive",
":",
"recursive",
",",
"name",
":",
"Literal",
"(",
"name",
")",
",",
"subQuery",
... | //Creates a new WITH common table expression for a SqlExpression, typically Datasets'. This function is used internally by Dataset when a CTE is added to another Dataset | [
"Creates",
"a",
"new",
"WITH",
"common",
"table",
"expression",
"for",
"a",
"SqlExpression",
"typically",
"Datasets",
".",
"This",
"function",
"is",
"used",
"internally",
"by",
"Dataset",
"when",
"a",
"CTE",
"is",
"added",
"to",
"another",
"Dataset"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1446-L1448 |
14,610 | doug-martin/goqu | dataset_select.go | Join | func (me *Dataset) Join(table Expression, condition joinExpression) *Dataset {
return me.InnerJoin(table, condition)
} | go | func (me *Dataset) Join(table Expression, condition joinExpression) *Dataset {
return me.InnerJoin(table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Join",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"InnerJoin",
"(",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Alias to InnerJoin. See examples. | [
"Alias",
"to",
"InnerJoin",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L119-L121 |
14,611 | doug-martin/goqu | dataset_select.go | InnerJoin | func (me *Dataset) InnerJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(INNER_JOIN, table, condition)
} | go | func (me *Dataset) InnerJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(INNER_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"InnerJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"INNER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds an INNER JOIN clause. See examples. | [
"Adds",
"an",
"INNER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L124-L126 |
14,612 | doug-martin/goqu | dataset_select.go | FullOuterJoin | func (me *Dataset) FullOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_OUTER_JOIN, table, condition)
} | go | func (me *Dataset) FullOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_OUTER_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"FullOuterJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"FULL_OUTER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds a FULL OUTER JOIN clause. See examples. | [
"Adds",
"a",
"FULL",
"OUTER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L129-L131 |
14,613 | doug-martin/goqu | dataset_select.go | RightOuterJoin | func (me *Dataset) RightOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_OUTER_JOIN, table, condition)
} | go | func (me *Dataset) RightOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_OUTER_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"RightOuterJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"RIGHT_OUTER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds a RIGHT OUTER JOIN clause. See examples. | [
"Adds",
"a",
"RIGHT",
"OUTER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L134-L136 |
14,614 | doug-martin/goqu | dataset_select.go | LeftOuterJoin | func (me *Dataset) LeftOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_OUTER_JOIN, table, condition)
} | go | func (me *Dataset) LeftOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_OUTER_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"LeftOuterJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"LEFT_OUTER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds a LEFT OUTER JOIN clause. See examples. | [
"Adds",
"a",
"LEFT",
"OUTER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L139-L141 |
14,615 | doug-martin/goqu | dataset_select.go | FullJoin | func (me *Dataset) FullJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_JOIN, table, condition)
} | go | func (me *Dataset) FullJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"FullJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"FULL_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds a FULL JOIN clause. See examples. | [
"Adds",
"a",
"FULL",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L144-L146 |
14,616 | doug-martin/goqu | dataset_select.go | RightJoin | func (me *Dataset) RightJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_JOIN, table, condition)
} | go | func (me *Dataset) RightJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"RightJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"RIGHT_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds a RIGHT JOIN clause. See examples. | [
"Adds",
"a",
"RIGHT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L149-L151 |
14,617 | doug-martin/goqu | dataset_select.go | LeftJoin | func (me *Dataset) LeftJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_JOIN, table, condition)
} | go | func (me *Dataset) LeftJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_JOIN, table, condition)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"LeftJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"LEFT_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] | //Adds a LEFT JOIN clause. See examples. | [
"Adds",
"a",
"LEFT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L154-L156 |
14,618 | doug-martin/goqu | dataset_select.go | NaturalJoin | func (me *Dataset) NaturalJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_JOIN, table, nil)
} | go | func (me *Dataset) NaturalJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_JOIN, table, nil)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] | //Adds a NATURAL JOIN clause. See examples. | [
"Adds",
"a",
"NATURAL",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L159-L161 |
14,619 | doug-martin/goqu | dataset_select.go | NaturalLeftJoin | func (me *Dataset) NaturalLeftJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_LEFT_JOIN, table, nil)
} | go | func (me *Dataset) NaturalLeftJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_LEFT_JOIN, table, nil)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalLeftJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_LEFT_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] | //Adds a NATURAL LEFT JOIN clause. See examples. | [
"Adds",
"a",
"NATURAL",
"LEFT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L164-L166 |
14,620 | doug-martin/goqu | dataset_select.go | NaturalRightJoin | func (me *Dataset) NaturalRightJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_RIGHT_JOIN, table, nil)
} | go | func (me *Dataset) NaturalRightJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_RIGHT_JOIN, table, nil)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalRightJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_RIGHT_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] | //Adds a NATURAL RIGHT JOIN clause. See examples. | [
"Adds",
"a",
"NATURAL",
"RIGHT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L169-L171 |
14,621 | doug-martin/goqu | dataset_select.go | NaturalFullJoin | func (me *Dataset) NaturalFullJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_FULL_JOIN, table, nil)
} | go | func (me *Dataset) NaturalFullJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_FULL_JOIN, table, nil)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalFullJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_FULL_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] | //Adds a NATURAL FULL JOIN clause. See examples. | [
"Adds",
"a",
"NATURAL",
"FULL",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L174-L176 |
14,622 | doug-martin/goqu | dataset_select.go | CrossJoin | func (me *Dataset) CrossJoin(table Expression) *Dataset {
return me.joinTable(CROSS_JOIN, table, nil)
} | go | func (me *Dataset) CrossJoin(table Expression) *Dataset {
return me.joinTable(CROSS_JOIN, table, nil)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"CrossJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"CROSS_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] | //Adds a CROSS JOIN clause. See examples. | [
"Adds",
"a",
"CROSS",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L179-L181 |
14,623 | doug-martin/goqu | dataset_select.go | joinTable | func (me *Dataset) joinTable(joinType JoinType, table Expression, condition joinExpression) *Dataset {
ret := me.copy()
isConditioned := conditioned_join_types[joinType]
ret.clauses.Joins = append(ret.clauses.Joins, JoiningClause{JoinType: joinType, IsConditioned: isConditioned, Table: table, Condition: condition})
return ret
} | go | func (me *Dataset) joinTable(joinType JoinType, table Expression, condition joinExpression) *Dataset {
ret := me.copy()
isConditioned := conditioned_join_types[joinType]
ret.clauses.Joins = append(ret.clauses.Joins, JoiningClause{JoinType: joinType, IsConditioned: isConditioned, Table: table, Condition: condition})
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"joinTable",
"(",
"joinType",
"JoinType",
",",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"isConditioned",
":=",
"conditioned_... | //Joins this Datasets table with another | [
"Joins",
"this",
"Datasets",
"table",
"with",
"another"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L184-L189 |
14,624 | doug-martin/goqu | dataset_select.go | Where | func (me *Dataset) Where(expressions ...Expression) *Dataset {
expLen := len(expressions)
if expLen > 0 {
ret := me.copy()
if ret.clauses.Where == nil {
ret.clauses.Where = And(expressions...)
} else {
ret.clauses.Where = ret.clauses.Where.Append(expressions...)
}
return ret
}
return me
} | go | func (me *Dataset) Where(expressions ...Expression) *Dataset {
expLen := len(expressions)
if expLen > 0 {
ret := me.copy()
if ret.clauses.Where == nil {
ret.clauses.Where = And(expressions...)
} else {
ret.clauses.Where = ret.clauses.Where.Append(expressions...)
}
return ret
}
return me
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Where",
"(",
"expressions",
"...",
"Expression",
")",
"*",
"Dataset",
"{",
"expLen",
":=",
"len",
"(",
"expressions",
")",
"\n",
"if",
"expLen",
">",
"0",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",... | //Adds a WHERE clause. See examples. | [
"Adds",
"a",
"WHERE",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L192-L204 |
14,625 | doug-martin/goqu | dataset_select.go | ClearWhere | func (me *Dataset) ClearWhere() *Dataset {
ret := me.copy()
ret.clauses.Where = nil
return ret
} | go | func (me *Dataset) ClearWhere() *Dataset {
ret := me.copy()
ret.clauses.Where = nil
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"ClearWhere",
"(",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Where",
"=",
"nil",
"\n",
"return",
"ret",
"\n",
"}"
] | //Removes the WHERE clause. See examples. | [
"Removes",
"the",
"WHERE",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L207-L211 |
14,626 | doug-martin/goqu | dataset_select.go | GroupBy | func (me *Dataset) GroupBy(groupBy ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.GroupBy = cols(groupBy...)
return ret
} | go | func (me *Dataset) GroupBy(groupBy ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.GroupBy = cols(groupBy...)
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"GroupBy",
"(",
"groupBy",
"...",
"interface",
"{",
"}",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"GroupBy",
"=",
"cols",
"(",
"groupBy",
"...",
... | //Adds a GROUP BY clause. See examples. | [
"Adds",
"a",
"GROUP",
"BY",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L214-L218 |
14,627 | doug-martin/goqu | dataset_select.go | Order | func (me *Dataset) Order(order ...OrderedExpression) *Dataset {
ret := me.copy()
ret.clauses.Order = orderList(order...)
return ret
} | go | func (me *Dataset) Order(order ...OrderedExpression) *Dataset {
ret := me.copy()
ret.clauses.Order = orderList(order...)
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Order",
"(",
"order",
"...",
"OrderedExpression",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Order",
"=",
"orderList",
"(",
"order",
"...",
")",
"\... | //Adds a ORDER clause. If the ORDER is currently set it replaces it. See examples. | [
"Adds",
"a",
"ORDER",
"clause",
".",
"If",
"the",
"ORDER",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L236-L240 |
14,628 | doug-martin/goqu | dataset_select.go | OrderAppend | func (me *Dataset) OrderAppend(order ...OrderedExpression) *Dataset {
if me.clauses.Order == nil {
return me.Order(order...)
} else {
ret := me.copy()
ret.clauses.Order = ret.clauses.Order.Append(orderList(order...).Columns()...)
return ret
}
return me
} | go | func (me *Dataset) OrderAppend(order ...OrderedExpression) *Dataset {
if me.clauses.Order == nil {
return me.Order(order...)
} else {
ret := me.copy()
ret.clauses.Order = ret.clauses.Order.Append(orderList(order...).Columns()...)
return ret
}
return me
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"OrderAppend",
"(",
"order",
"...",
"OrderedExpression",
")",
"*",
"Dataset",
"{",
"if",
"me",
".",
"clauses",
".",
"Order",
"==",
"nil",
"{",
"return",
"me",
".",
"Order",
"(",
"order",
"...",
")",
"\n",
"}",
... | //Adds a more columns to the current ORDER BY clause. If no order has be previously specified it is the same as calling Order. See examples. | [
"Adds",
"a",
"more",
"columns",
"to",
"the",
"current",
"ORDER",
"BY",
"clause",
".",
"If",
"no",
"order",
"has",
"be",
"previously",
"specified",
"it",
"is",
"the",
"same",
"as",
"calling",
"Order",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L243-L253 |
14,629 | doug-martin/goqu | dataset_select.go | ClearOrder | func (me *Dataset) ClearOrder() *Dataset {
ret := me.copy()
ret.clauses.Order = nil
return ret
} | go | func (me *Dataset) ClearOrder() *Dataset {
ret := me.copy()
ret.clauses.Order = nil
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"ClearOrder",
"(",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Order",
"=",
"nil",
"\n",
"return",
"ret",
"\n",
"}"
] | //Removes the ORDER BY clause. See examples. | [
"Removes",
"the",
"ORDER",
"BY",
"clause",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L256-L260 |
14,630 | doug-martin/goqu | dataset_select.go | Limit | func (me *Dataset) Limit(limit uint) *Dataset {
ret := me.copy()
if limit > 0 {
ret.clauses.Limit = limit
} else {
ret.clauses.Limit = nil
}
return ret
} | go | func (me *Dataset) Limit(limit uint) *Dataset {
ret := me.copy()
if limit > 0 {
ret.clauses.Limit = limit
} else {
ret.clauses.Limit = nil
}
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Limit",
"(",
"limit",
"uint",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"if",
"limit",
">",
"0",
"{",
"ret",
".",
"clauses",
".",
"Limit",
"=",
"limit",
"\n",
"}",
"else",... | //Adds a LIMIT clause. If the LIMIT is currently set it replaces it. See examples. | [
"Adds",
"a",
"LIMIT",
"clause",
".",
"If",
"the",
"LIMIT",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L263-L271 |
14,631 | doug-martin/goqu | dataset_select.go | LimitAll | func (me *Dataset) LimitAll() *Dataset {
ret := me.copy()
ret.clauses.Limit = Literal("ALL")
return ret
} | go | func (me *Dataset) LimitAll() *Dataset {
ret := me.copy()
ret.clauses.Limit = Literal("ALL")
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"LimitAll",
"(",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Limit",
"=",
"Literal",
"(",
"\"",
"\"",
")",
"\n",
"return",
"ret",
"\n",
"}"
] | //Adds a LIMIT ALL clause. If the LIMIT is currently set it replaces it. See examples. | [
"Adds",
"a",
"LIMIT",
"ALL",
"clause",
".",
"If",
"the",
"LIMIT",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L274-L278 |
14,632 | doug-martin/goqu | dataset_select.go | Offset | func (me *Dataset) Offset(offset uint) *Dataset {
ret := me.copy()
ret.clauses.Offset = offset
return ret
} | go | func (me *Dataset) Offset(offset uint) *Dataset {
ret := me.copy()
ret.clauses.Offset = offset
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Offset",
"(",
"offset",
"uint",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Offset",
"=",
"offset",
"\n",
"return",
"ret",
"\n",
"}"
] | //Adds an OFFSET clause. If the OFFSET is currently set it replaces it. See examples. | [
"Adds",
"an",
"OFFSET",
"clause",
".",
"If",
"the",
"OFFSET",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L286-L290 |
14,633 | doug-martin/goqu | dataset_select.go | Intersect | func (me *Dataset) Intersect(other *Dataset) *Dataset {
ret := me.compoundFromSelf()
ret.clauses.Compounds = append(ret.clauses.Compounds, Intersect(other.compoundFromSelf()))
return ret
} | go | func (me *Dataset) Intersect(other *Dataset) *Dataset {
ret := me.compoundFromSelf()
ret.clauses.Compounds = append(ret.clauses.Compounds, Intersect(other.compoundFromSelf()))
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Intersect",
"(",
"other",
"*",
"Dataset",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"compoundFromSelf",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Compounds",
"=",
"append",
"(",
"ret",
".",
"clauses... | //Creates an INTERSECT statement with another dataset.
// If this or the other dataset has a limit or offset it will use that dataset as a subselect in the FROM clause. See examples. | [
"Creates",
"an",
"INTERSECT",
"statement",
"with",
"another",
"dataset",
".",
"If",
"this",
"or",
"the",
"other",
"dataset",
"has",
"a",
"limit",
"or",
"offset",
"it",
"will",
"use",
"that",
"dataset",
"as",
"a",
"subselect",
"in",
"the",
"FROM",
"clause",... | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L315-L319 |
14,634 | doug-martin/goqu | dataset_select.go | compoundFromSelf | func (me *Dataset) compoundFromSelf() *Dataset {
if me.clauses.Order != nil || me.clauses.Limit != nil {
return me.FromSelf()
}
return me.copy()
} | go | func (me *Dataset) compoundFromSelf() *Dataset {
if me.clauses.Order != nil || me.clauses.Limit != nil {
return me.FromSelf()
}
return me.copy()
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"compoundFromSelf",
"(",
")",
"*",
"Dataset",
"{",
"if",
"me",
".",
"clauses",
".",
"Order",
"!=",
"nil",
"||",
"me",
".",
"clauses",
".",
"Limit",
"!=",
"nil",
"{",
"return",
"me",
".",
"FromSelf",
"(",
")",... | //Used internally to determine if the dataset needs to use iteself as a source.
//If the dataset has an order or limit it will select from itself | [
"Used",
"internally",
"to",
"determine",
"if",
"the",
"dataset",
"needs",
"to",
"use",
"iteself",
"as",
"a",
"source",
".",
"If",
"the",
"dataset",
"has",
"an",
"order",
"or",
"limit",
"it",
"will",
"select",
"from",
"itself"
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L331-L336 |
14,635 | doug-martin/goqu | dataset_select.go | Returning | func (me *Dataset) Returning(returning ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.Returning = cols(returning...)
return ret
} | go | func (me *Dataset) Returning(returning ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.Returning = cols(returning...)
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"Returning",
"(",
"returning",
"...",
"interface",
"{",
"}",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Returning",
"=",
"cols",
"(",
"returning",
"... | //Adds a RETURNING clause to the dataset if the adapter supports it. Typically used for INSERT, UPDATE or DELETE. See examples. | [
"Adds",
"a",
"RETURNING",
"clause",
"to",
"the",
"dataset",
"if",
"the",
"adapter",
"supports",
"it",
".",
"Typically",
"used",
"for",
"INSERT",
"UPDATE",
"or",
"DELETE",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L339-L343 |
14,636 | doug-martin/goqu | dataset_select.go | As | func (me *Dataset) As(alias string) *Dataset {
ret := me.copy()
ret.clauses.Alias = I(alias)
return ret
} | go | func (me *Dataset) As(alias string) *Dataset {
ret := me.copy()
ret.clauses.Alias = I(alias)
return ret
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"As",
"(",
"alias",
"string",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Alias",
"=",
"I",
"(",
"alias",
")",
"\n",
"return",
"ret",
"\n",
"}"
] | //Sets the alias for this dataset. This is typically used when using a Dataset as a subselect. See examples. | [
"Sets",
"the",
"alias",
"for",
"this",
"dataset",
".",
"This",
"is",
"typically",
"used",
"when",
"using",
"a",
"Dataset",
"as",
"a",
"subselect",
".",
"See",
"examples",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L346-L350 |
14,637 | doug-martin/goqu | dataset_select.go | selectSqlWriteTo | func (me *Dataset) selectSqlWriteTo(buf *SqlBuilder) error {
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return err
}
if me.clauses.SelectDistinct != nil {
if err := me.adapter.SelectDistinctSql(buf, me.clauses.SelectDistinct); err != nil {
return err
}
} else {
if err := me.adapter.SelectSql(buf, me.clauses.Select); err != nil {
return err
}
}
if err := me.adapter.FromSql(buf, me.clauses.From); err != nil {
return err
}
if err := me.adapter.JoinSql(buf, me.clauses.Joins); err != nil {
return err
}
if err := me.adapter.WhereSql(buf, me.clauses.Where); err != nil {
return err
}
if err := me.adapter.GroupBySql(buf, me.clauses.GroupBy); err != nil {
return err
}
if err := me.adapter.HavingSql(buf, me.clauses.Having); err != nil {
return err
}
if err := me.adapter.CompoundsSql(buf, me.clauses.Compounds); err != nil {
return err
}
if err := me.adapter.OrderSql(buf, me.clauses.Order); err != nil {
return err
}
if err := me.adapter.LimitSql(buf, me.clauses.Limit); err != nil {
return err
}
return me.adapter.OffsetSql(buf, me.clauses.Offset)
} | go | func (me *Dataset) selectSqlWriteTo(buf *SqlBuilder) error {
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return err
}
if me.clauses.SelectDistinct != nil {
if err := me.adapter.SelectDistinctSql(buf, me.clauses.SelectDistinct); err != nil {
return err
}
} else {
if err := me.adapter.SelectSql(buf, me.clauses.Select); err != nil {
return err
}
}
if err := me.adapter.FromSql(buf, me.clauses.From); err != nil {
return err
}
if err := me.adapter.JoinSql(buf, me.clauses.Joins); err != nil {
return err
}
if err := me.adapter.WhereSql(buf, me.clauses.Where); err != nil {
return err
}
if err := me.adapter.GroupBySql(buf, me.clauses.GroupBy); err != nil {
return err
}
if err := me.adapter.HavingSql(buf, me.clauses.Having); err != nil {
return err
}
if err := me.adapter.CompoundsSql(buf, me.clauses.Compounds); err != nil {
return err
}
if err := me.adapter.OrderSql(buf, me.clauses.Order); err != nil {
return err
}
if err := me.adapter.LimitSql(buf, me.clauses.Limit); err != nil {
return err
}
return me.adapter.OffsetSql(buf, me.clauses.Offset)
} | [
"func",
"(",
"me",
"*",
"Dataset",
")",
"selectSqlWriteTo",
"(",
"buf",
"*",
"SqlBuilder",
")",
"error",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"CommonTablesSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"CommonTables",
")",
";",
"err",
... | //Does actual sql generation of sql, accepts an sql builder so other methods can call when creating subselects and needing prepared sql. | [
"Does",
"actual",
"sql",
"generation",
"of",
"sql",
"accepts",
"an",
"sql",
"builder",
"so",
"other",
"methods",
"can",
"call",
"when",
"creating",
"subselects",
"and",
"needing",
"prepared",
"sql",
"."
] | 6803bc2ea3462276f0e87814761a787d5537c4eb | https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L366-L405 |
14,638 | icrowley/fake | products.go | ProductName | func ProductName() string {
productName := lookup(lang, "adjectives", true) + " " + lookup(lang, "nouns", true)
if r.Intn(2) == 1 {
productName = lookup(lang, "adjectives", true) + " " + productName
}
return productName
} | go | func ProductName() string {
productName := lookup(lang, "adjectives", true) + " " + lookup(lang, "nouns", true)
if r.Intn(2) == 1 {
productName = lookup(lang, "adjectives", true) + " " + productName
}
return productName
} | [
"func",
"ProductName",
"(",
")",
"string",
"{",
"productName",
":=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"+",
"\"",
"\"",
"+",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"\n",
"if",
"r",
".",
"Intn",
"(",
"2... | // ProductName generates product name | [
"ProductName",
"generates",
"product",
"name"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/products.go#L9-L15 |
14,639 | icrowley/fake | products.go | Model | func Model() string {
seps := []string{"", " ", "-"}
return CharactersN(r.Intn(3)+1) + seps[r.Intn(len(seps))] + Digits()
} | go | func Model() string {
seps := []string{"", " ", "-"}
return CharactersN(r.Intn(3)+1) + seps[r.Intn(len(seps))] + Digits()
} | [
"func",
"Model",
"(",
")",
"string",
"{",
"seps",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"\n",
"return",
"CharactersN",
"(",
"r",
".",
"Intn",
"(",
"3",
")",
"+",
"1",
")",
"+",
"seps",
"[",
"r",
"... | // Model generates model name that consists of letters and digits, optionally with a hyphen between them | [
"Model",
"generates",
"model",
"name",
"that",
"consists",
"of",
"letters",
"and",
"digits",
"optionally",
"with",
"a",
"hyphen",
"between",
"them"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/products.go#L23-L26 |
14,640 | icrowley/fake | internet.go | UserName | func UserName() string {
gender := randGender()
switch r.Intn(3) {
case 0:
return lookup("en", gender+"_first_names", false) + lookup(lang, gender+"_last_names", false)
case 1:
return Character() + lookup(lang, gender+"_last_names", false)
default:
return strings.Replace(WordsN(r.Intn(3)+1), " ", "_", -1)
}
} | go | func UserName() string {
gender := randGender()
switch r.Intn(3) {
case 0:
return lookup("en", gender+"_first_names", false) + lookup(lang, gender+"_last_names", false)
case 1:
return Character() + lookup(lang, gender+"_last_names", false)
default:
return strings.Replace(WordsN(r.Intn(3)+1), " ", "_", -1)
}
} | [
"func",
"UserName",
"(",
")",
"string",
"{",
"gender",
":=",
"randGender",
"(",
")",
"\n",
"switch",
"r",
".",
"Intn",
"(",
"3",
")",
"{",
"case",
"0",
":",
"return",
"lookup",
"(",
"\"",
"\"",
",",
"gender",
"+",
"\"",
"\"",
",",
"false",
")",
... | // UserName generates user name in one of the following forms
// first name + last name, letter + last names or concatenation of from 1 to 3 lowercased words | [
"UserName",
"generates",
"user",
"name",
"in",
"one",
"of",
"the",
"following",
"forms",
"first",
"name",
"+",
"last",
"name",
"letter",
"+",
"last",
"names",
"or",
"concatenation",
"of",
"from",
"1",
"to",
"3",
"lowercased",
"words"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/internet.go#L12-L22 |
14,641 | icrowley/fake | internet.go | IPv4 | func IPv4() string {
size := 4
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To4().String()
} | go | func IPv4() string {
size := 4
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To4().String()
} | [
"func",
"IPv4",
"(",
")",
"string",
"{",
"size",
":=",
"4",
"\n",
"ip",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"++",
"{",
"ip",
"[",
"i",
"]",
"=",
"byte",
"(",... | // IPv4 generates IPv4 address | [
"IPv4",
"generates",
"IPv4",
"address"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/internet.go#L55-L62 |
14,642 | icrowley/fake | internet.go | IPv6 | func IPv6() string {
size := 16
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To16().String()
} | go | func IPv6() string {
size := 16
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To16().String()
} | [
"func",
"IPv6",
"(",
")",
"string",
"{",
"size",
":=",
"16",
"\n",
"ip",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"++",
"{",
"ip",
"[",
"i",
"]",
"=",
"byte",
"("... | // IPv6 generates IPv6 address | [
"IPv6",
"generates",
"IPv6",
"address"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/internet.go#L65-L72 |
14,643 | icrowley/fake | general.go | DigitsN | func DigitsN(n int) string {
digits := make([]rune, n)
for i := 0; i < n; i++ {
digits[i] = numeric[r.Intn(len(numeric))]
}
return string(digits)
} | go | func DigitsN(n int) string {
digits := make([]rune, n)
for i := 0; i < n; i++ {
digits[i] = numeric[r.Intn(len(numeric))]
}
return string(digits)
} | [
"func",
"DigitsN",
"(",
"n",
"int",
")",
"string",
"{",
"digits",
":=",
"make",
"(",
"[",
"]",
"rune",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"digits",
"[",
"i",
"]",
"=",
"numeric",
"[",
"r",
... | // DigitsN returns n digits as a string | [
"DigitsN",
"returns",
"n",
"digits",
"as",
"a",
"string"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/general.go#L50-L56 |
14,644 | icrowley/fake | credit_cards.go | CreditCardNum | func CreditCardNum(vendor string) string {
if vendor != "" {
vendor = strings.ToLower(vendor)
} else {
var vendors []string
for v := range creditCards {
vendors = append(vendors, v)
}
vendor = vendors[r.Intn(len(vendors))]
}
card := creditCards[vendor]
prefix := strconv.Itoa(card.prefixes[r.Intn(len(card.prefixes))])
num := []rune(prefix)
for i := 0; i < card.length-len(prefix); i++ {
num = append(num, genCCDigit(num))
}
return string(num)
} | go | func CreditCardNum(vendor string) string {
if vendor != "" {
vendor = strings.ToLower(vendor)
} else {
var vendors []string
for v := range creditCards {
vendors = append(vendors, v)
}
vendor = vendors[r.Intn(len(vendors))]
}
card := creditCards[vendor]
prefix := strconv.Itoa(card.prefixes[r.Intn(len(card.prefixes))])
num := []rune(prefix)
for i := 0; i < card.length-len(prefix); i++ {
num = append(num, genCCDigit(num))
}
return string(num)
} | [
"func",
"CreditCardNum",
"(",
"vendor",
"string",
")",
"string",
"{",
"if",
"vendor",
"!=",
"\"",
"\"",
"{",
"vendor",
"=",
"strings",
".",
"ToLower",
"(",
"vendor",
")",
"\n",
"}",
"else",
"{",
"var",
"vendors",
"[",
"]",
"string",
"\n",
"for",
"v",... | // CreditCardNum generated credit card number according to the card number rules | [
"CreditCardNum",
"generated",
"credit",
"card",
"number",
"according",
"to",
"the",
"card",
"number",
"rules"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/credit_cards.go#L35-L52 |
14,645 | icrowley/fake | addresses.go | City | func City() string {
city := lookup(lang, "cities", true)
switch r.Intn(5) {
case 0:
return join(cityPrefix(), city)
case 1:
return join(city, citySuffix())
default:
return city
}
} | go | func City() string {
city := lookup(lang, "cities", true)
switch r.Intn(5) {
case 0:
return join(cityPrefix(), city)
case 1:
return join(city, citySuffix())
default:
return city
}
} | [
"func",
"City",
"(",
")",
"string",
"{",
"city",
":=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"\n",
"switch",
"r",
".",
"Intn",
"(",
"5",
")",
"{",
"case",
"0",
":",
"return",
"join",
"(",
"cityPrefix",
"(",
")",
",",
"city",... | // City generates random city | [
"City",
"generates",
"random",
"city"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/addresses.go#L16-L26 |
14,646 | icrowley/fake | lorem_ipsum.go | CharactersN | func CharactersN(n int) string {
var chars []string
for i := 0; i < n; i++ {
chars = append(chars, Character())
}
return strings.Join(chars, "")
} | go | func CharactersN(n int) string {
var chars []string
for i := 0; i < n; i++ {
chars = append(chars, Character())
}
return strings.Join(chars, "")
} | [
"func",
"CharactersN",
"(",
"n",
"int",
")",
"string",
"{",
"var",
"chars",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"chars",
"=",
"append",
"(",
"chars",
",",
"Character",
"(",
")",
")",
"\n",
... | // CharactersN generates n random characters in the given language | [
"CharactersN",
"generates",
"n",
"random",
"characters",
"in",
"the",
"given",
"language"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L13-L19 |
14,647 | icrowley/fake | lorem_ipsum.go | WordsN | func WordsN(n int) string {
words := make([]string, n)
for i := 0; i < n; i++ {
words[i] = Word()
}
return strings.Join(words, " ")
} | go | func WordsN(n int) string {
words := make([]string, n)
for i := 0; i < n; i++ {
words[i] = Word()
}
return strings.Join(words, " ")
} | [
"func",
"WordsN",
"(",
"n",
"int",
")",
"string",
"{",
"words",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"words",
"[",
"i",
"]",
"=",
"Word",
"(",
")",
"\n... | // WordsN generates n random words | [
"WordsN",
"generates",
"n",
"random",
"words"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L32-L38 |
14,648 | icrowley/fake | lorem_ipsum.go | Sentence | func Sentence() string {
var words []string
for i := 0; i < 3+r.Intn(12); i++ {
word := Word()
if r.Intn(5) == 0 {
word += ","
}
words = append(words, Word())
}
sentence := strings.Join(words, " ")
if r.Intn(8) == 0 {
sentence += "!"
} else {
sentence += "."
}
return sentence
} | go | func Sentence() string {
var words []string
for i := 0; i < 3+r.Intn(12); i++ {
word := Word()
if r.Intn(5) == 0 {
word += ","
}
words = append(words, Word())
}
sentence := strings.Join(words, " ")
if r.Intn(8) == 0 {
sentence += "!"
} else {
sentence += "."
}
return sentence
} | [
"func",
"Sentence",
"(",
")",
"string",
"{",
"var",
"words",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"3",
"+",
"r",
".",
"Intn",
"(",
"12",
")",
";",
"i",
"++",
"{",
"word",
":=",
"Word",
"(",
")",
"\n",
"if",
"r",
... | // Sentence generates random sentence | [
"Sentence",
"generates",
"random",
"sentence"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L51-L70 |
14,649 | icrowley/fake | lorem_ipsum.go | SentencesN | func SentencesN(n int) string {
sentences := make([]string, n)
for i := 0; i < n; i++ {
sentences[i] = Sentence()
}
return strings.Join(sentences, " ")
} | go | func SentencesN(n int) string {
sentences := make([]string, n)
for i := 0; i < n; i++ {
sentences[i] = Sentence()
}
return strings.Join(sentences, " ")
} | [
"func",
"SentencesN",
"(",
"n",
"int",
")",
"string",
"{",
"sentences",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"sentences",
"[",
"i",
"]",
"=",
"Sentence",
"... | // SentencesN generates n random sentences | [
"SentencesN",
"generates",
"n",
"random",
"sentences"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L73-L79 |
14,650 | icrowley/fake | lorem_ipsum.go | ParagraphsN | func ParagraphsN(n int) string {
var paragraphs []string
for i := 0; i < n; i++ {
paragraphs = append(paragraphs, Paragraph())
}
return strings.Join(paragraphs, "\t")
} | go | func ParagraphsN(n int) string {
var paragraphs []string
for i := 0; i < n; i++ {
paragraphs = append(paragraphs, Paragraph())
}
return strings.Join(paragraphs, "\t")
} | [
"func",
"ParagraphsN",
"(",
"n",
"int",
")",
"string",
"{",
"var",
"paragraphs",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"paragraphs",
"=",
"append",
"(",
"paragraphs",
",",
"Paragraph",
"(",
")",
... | // ParagraphsN generates n paragraphs | [
"ParagraphsN",
"generates",
"n",
"paragraphs"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L92-L98 |
14,651 | icrowley/fake | dates.go | Year | func Year(from, to int) int {
n := r.Intn(to-from) + 1
return from + n
} | go | func Year(from, to int) int {
n := r.Intn(to-from) + 1
return from + n
} | [
"func",
"Year",
"(",
"from",
",",
"to",
"int",
")",
"int",
"{",
"n",
":=",
"r",
".",
"Intn",
"(",
"to",
"-",
"from",
")",
"+",
"1",
"\n",
"return",
"from",
"+",
"n",
"\n",
"}"
] | // Year generates year using the given boundaries | [
"Year",
"generates",
"year",
"using",
"the",
"given",
"boundaries"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/dates.go#L39-L42 |
14,652 | icrowley/fake | fake.go | GetLangs | func GetLangs() []string {
var langs []string
for k, v := range data {
if v.isDir && k != "/" && k != "/data" {
langs = append(langs, strings.Replace(k, "/data/", "", 1))
}
}
return langs
} | go | func GetLangs() []string {
var langs []string
for k, v := range data {
if v.isDir && k != "/" && k != "/data" {
langs = append(langs, strings.Replace(k, "/data/", "", 1))
}
}
return langs
} | [
"func",
"GetLangs",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"langs",
"[",
"]",
"string",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"data",
"{",
"if",
"v",
".",
"isDir",
"&&",
"k",
"!=",
"\"",
"\"",
"&&",
"k",
"!=",
"\"",
"\"",
"{",
"langs"... | // GetLangs returns a slice of available languages | [
"GetLangs",
"returns",
"a",
"slice",
"of",
"available",
"languages"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/fake.go#L94-L102 |
14,653 | icrowley/fake | fake.go | SetLang | func SetLang(newLang string) error {
found := false
for _, l := range availLangs {
if newLang == l {
found = true
break
}
}
if !found {
return ErrNoLanguageFn(newLang)
}
lang = newLang
return nil
} | go | func SetLang(newLang string) error {
found := false
for _, l := range availLangs {
if newLang == l {
found = true
break
}
}
if !found {
return ErrNoLanguageFn(newLang)
}
lang = newLang
return nil
} | [
"func",
"SetLang",
"(",
"newLang",
"string",
")",
"error",
"{",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"availLangs",
"{",
"if",
"newLang",
"==",
"l",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
... | // SetLang sets the language in which the data should be generated
// returns error if passed language is not available | [
"SetLang",
"sets",
"the",
"language",
"in",
"which",
"the",
"data",
"should",
"be",
"generated",
"returns",
"error",
"if",
"passed",
"language",
"is",
"not",
"available"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/fake.go#L106-L119 |
14,654 | icrowley/fake | jobs.go | JobTitle | func JobTitle() string {
job := lookup(lang, "jobs", true)
return strings.Replace(job, "#{N}", jobTitleSuffix(), 1)
} | go | func JobTitle() string {
job := lookup(lang, "jobs", true)
return strings.Replace(job, "#{N}", jobTitleSuffix(), 1)
} | [
"func",
"JobTitle",
"(",
")",
"string",
"{",
"job",
":=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"\n",
"return",
"strings",
".",
"Replace",
"(",
"job",
",",
"\"",
"\"",
",",
"jobTitleSuffix",
"(",
")",
",",
"1",
")",
"\n",
"}"
... | // JobTitle generates job title | [
"JobTitle",
"generates",
"job",
"title"
] | 4178557ae428460c3780a381c824a1f3aceb6325 | https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/jobs.go#L13-L16 |
14,655 | mgutz/logxi | v1/env.go | ProcessLogxiFormatEnv | func ProcessLogxiFormatEnv(env string) {
logxiFormat = env
m := parseKVList(logxiFormat, ",")
formatterFormat := ""
tFormat := ""
for key, value := range m {
switch key {
default:
formatterFormat = key
case "t":
tFormat = value
case "pretty":
isPretty = value != "false" && value != "0"
case "maxcol":
col, err := strconv.Atoi(value)
if err == nil {
maxCol = col
} else {
maxCol = defaultMaxCol
}
case "context":
lines, err := strconv.Atoi(value)
if err == nil {
contextLines = lines
} else {
contextLines = defaultContextLines
}
case "LTSV":
formatterFormat = "text"
AssignmentChar = ltsvAssignmentChar
Separator = ltsvSeparator
}
}
if formatterFormat == "" || formatterCreators[formatterFormat] == nil {
formatterFormat = defaultFormat
}
logxiFormat = formatterFormat
if tFormat == "" {
tFormat = defaultTimeFormat
}
timeFormat = tFormat
} | go | func ProcessLogxiFormatEnv(env string) {
logxiFormat = env
m := parseKVList(logxiFormat, ",")
formatterFormat := ""
tFormat := ""
for key, value := range m {
switch key {
default:
formatterFormat = key
case "t":
tFormat = value
case "pretty":
isPretty = value != "false" && value != "0"
case "maxcol":
col, err := strconv.Atoi(value)
if err == nil {
maxCol = col
} else {
maxCol = defaultMaxCol
}
case "context":
lines, err := strconv.Atoi(value)
if err == nil {
contextLines = lines
} else {
contextLines = defaultContextLines
}
case "LTSV":
formatterFormat = "text"
AssignmentChar = ltsvAssignmentChar
Separator = ltsvSeparator
}
}
if formatterFormat == "" || formatterCreators[formatterFormat] == nil {
formatterFormat = defaultFormat
}
logxiFormat = formatterFormat
if tFormat == "" {
tFormat = defaultTimeFormat
}
timeFormat = tFormat
} | [
"func",
"ProcessLogxiFormatEnv",
"(",
"env",
"string",
")",
"{",
"logxiFormat",
"=",
"env",
"\n",
"m",
":=",
"parseKVList",
"(",
"logxiFormat",
",",
"\"",
"\"",
")",
"\n",
"formatterFormat",
":=",
"\"",
"\"",
"\n",
"tFormat",
":=",
"\"",
"\"",
"\n",
"for... | // ProcessLogxiFormatEnv parses LOGXI_FORMAT | [
"ProcessLogxiFormatEnv",
"parses",
"LOGXI_FORMAT"
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/env.go#L46-L87 |
14,656 | mgutz/logxi | v1/env.go | ProcessLogxiEnv | func ProcessLogxiEnv(env string) {
logxiEnable := env
if logxiEnable == "" {
logxiEnable = defaultLogxiEnv
}
logxiNameLevelMap = map[string]int{}
m := parseKVList(logxiEnable, ",")
if m == nil {
logxiNameLevelMap["*"] = defaultLevel
}
for key, value := range m {
if strings.HasPrefix(key, "-") {
// LOGXI=*,-foo => disable foo
logxiNameLevelMap[key[1:]] = LevelOff
} else if value == "" {
// LOGXI=* => default to all
logxiNameLevelMap[key] = LevelAll
} else {
// LOGXI=*=ERR => use user-specified level
level := LevelAtoi[value]
if level == 0 {
InternalLog.Error("Unknown level in LOGXI environment variable", "key", key, "value", value, "LOGXI", env)
level = defaultLevel
}
logxiNameLevelMap[key] = level
}
}
// must always have global default, otherwise errs may get eaten up
if _, ok := logxiNameLevelMap["*"]; !ok {
logxiNameLevelMap["*"] = LevelError
}
} | go | func ProcessLogxiEnv(env string) {
logxiEnable := env
if logxiEnable == "" {
logxiEnable = defaultLogxiEnv
}
logxiNameLevelMap = map[string]int{}
m := parseKVList(logxiEnable, ",")
if m == nil {
logxiNameLevelMap["*"] = defaultLevel
}
for key, value := range m {
if strings.HasPrefix(key, "-") {
// LOGXI=*,-foo => disable foo
logxiNameLevelMap[key[1:]] = LevelOff
} else if value == "" {
// LOGXI=* => default to all
logxiNameLevelMap[key] = LevelAll
} else {
// LOGXI=*=ERR => use user-specified level
level := LevelAtoi[value]
if level == 0 {
InternalLog.Error("Unknown level in LOGXI environment variable", "key", key, "value", value, "LOGXI", env)
level = defaultLevel
}
logxiNameLevelMap[key] = level
}
}
// must always have global default, otherwise errs may get eaten up
if _, ok := logxiNameLevelMap["*"]; !ok {
logxiNameLevelMap["*"] = LevelError
}
} | [
"func",
"ProcessLogxiEnv",
"(",
"env",
"string",
")",
"{",
"logxiEnable",
":=",
"env",
"\n",
"if",
"logxiEnable",
"==",
"\"",
"\"",
"{",
"logxiEnable",
"=",
"defaultLogxiEnv",
"\n",
"}",
"\n\n",
"logxiNameLevelMap",
"=",
"map",
"[",
"string",
"]",
"int",
"... | // ProcessLogxiEnv parses LOGXI variable | [
"ProcessLogxiEnv",
"parses",
"LOGXI",
"variable"
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/env.go#L90-L123 |
14,657 | mgutz/logxi | v1/env.go | ProcessLogxiColorsEnv | func ProcessLogxiColorsEnv(env string) {
colors := env
if colors == "" {
colors = defaultLogxiColorsEnv
} else if colors == "*=off" {
// disable all colors
disableColors = true
}
theme = parseTheme(colors)
} | go | func ProcessLogxiColorsEnv(env string) {
colors := env
if colors == "" {
colors = defaultLogxiColorsEnv
} else if colors == "*=off" {
// disable all colors
disableColors = true
}
theme = parseTheme(colors)
} | [
"func",
"ProcessLogxiColorsEnv",
"(",
"env",
"string",
")",
"{",
"colors",
":=",
"env",
"\n",
"if",
"colors",
"==",
"\"",
"\"",
"{",
"colors",
"=",
"defaultLogxiColorsEnv",
"\n",
"}",
"else",
"if",
"colors",
"==",
"\"",
"\"",
"{",
"// disable all colors",
... | // ProcessLogxiColorsEnv parases LOGXI_COLORS | [
"ProcessLogxiColorsEnv",
"parases",
"LOGXI_COLORS"
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/env.go#L157-L166 |
14,658 | mgutz/logxi | v1/jsonFormatter.go | Format | func (jf *JSONFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
const lead = `", "`
const colon = `":"`
buf.WriteString(`{"`)
buf.WriteString(KeyMap.Time)
buf.WriteString(`":"`)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(`", "`)
buf.WriteString(KeyMap.PID)
buf.WriteString(`":"`)
buf.WriteString(pidStr)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Level)
buf.WriteString(`":"`)
buf.WriteString(LevelMap[level])
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Name)
buf.WriteString(`":"`)
buf.WriteString(jf.name)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Message)
buf.WriteString(`":`)
jf.appendValue(buf, msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
jf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
jf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
jf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteString("}\n")
buf.WriteTo(writer)
} | go | func (jf *JSONFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
const lead = `", "`
const colon = `":"`
buf.WriteString(`{"`)
buf.WriteString(KeyMap.Time)
buf.WriteString(`":"`)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(`", "`)
buf.WriteString(KeyMap.PID)
buf.WriteString(`":"`)
buf.WriteString(pidStr)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Level)
buf.WriteString(`":"`)
buf.WriteString(LevelMap[level])
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Name)
buf.WriteString(`":"`)
buf.WriteString(jf.name)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Message)
buf.WriteString(`":`)
jf.appendValue(buf, msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
jf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
jf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
jf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteString("}\n")
buf.WriteTo(writer)
} | [
"func",
"(",
"jf",
"*",
"JSONFormatter",
")",
"Format",
"(",
"writer",
"io",
".",
"Writer",
",",
"level",
"int",
",",
"msg",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"buf",
":=",
"pool",
".",
"Get",
"(",
")",
"\n",
"defer... | // Format formats log entry as JSON. | [
"Format",
"formats",
"log",
"entry",
"as",
"JSON",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/jsonFormatter.go#L134-L190 |
14,659 | mgutz/logxi | v1/formatter.go | RegisterFormatFactory | func RegisterFormatFactory(kind string, fn CreateFormatterFunc) {
if kind == "" {
panic("kind is empty string")
}
if fn == nil {
panic("creator is nil")
}
formatterCreators[kind] = fn
} | go | func RegisterFormatFactory(kind string, fn CreateFormatterFunc) {
if kind == "" {
panic("kind is empty string")
}
if fn == nil {
panic("creator is nil")
}
formatterCreators[kind] = fn
} | [
"func",
"RegisterFormatFactory",
"(",
"kind",
"string",
",",
"fn",
"CreateFormatterFunc",
")",
"{",
"if",
"kind",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"fn",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\... | // RegisterFormatFactory registers a format factory function. | [
"RegisterFormatFactory",
"registers",
"a",
"format",
"factory",
"function",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/formatter.go#L53-L61 |
14,660 | mgutz/logxi | v1/happyDevFormatter.go | NewHappyDevFormatter | func NewHappyDevFormatter(name string) *HappyDevFormatter {
jf := NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
} | go | func NewHappyDevFormatter(name string) *HappyDevFormatter {
jf := NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
} | [
"func",
"NewHappyDevFormatter",
"(",
"name",
"string",
")",
"*",
"HappyDevFormatter",
"{",
"jf",
":=",
"NewJSONFormatter",
"(",
"name",
")",
"\n",
"return",
"&",
"HappyDevFormatter",
"{",
"name",
":",
"name",
",",
"jsonFormatter",
":",
"jf",
",",
"}",
"\n",
... | // NewHappyDevFormatter returns a new instance of HappyDevFormatter. | [
"NewHappyDevFormatter",
"returns",
"a",
"new",
"instance",
"of",
"HappyDevFormatter",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/happyDevFormatter.go#L120-L126 |
14,661 | mgutz/logxi | v1/happyDevFormatter.go | writeString | func (hd *HappyDevFormatter) writeString(buf bufferWriter, s string) {
buf.WriteString(s)
hd.col += len(s)
} | go | func (hd *HappyDevFormatter) writeString(buf bufferWriter, s string) {
buf.WriteString(s)
hd.col += len(s)
} | [
"func",
"(",
"hd",
"*",
"HappyDevFormatter",
")",
"writeString",
"(",
"buf",
"bufferWriter",
",",
"s",
"string",
")",
"{",
"buf",
".",
"WriteString",
"(",
"s",
")",
"\n",
"hd",
".",
"col",
"+=",
"len",
"(",
"s",
")",
"\n",
"}"
] | // Write a string and tracks the position of the string so we can break lines
// cleanly. Do not send ANSI escape sequences, just raw strings | [
"Write",
"a",
"string",
"and",
"tracks",
"the",
"position",
"of",
"the",
"string",
"so",
"we",
"can",
"break",
"lines",
"cleanly",
".",
"Do",
"not",
"send",
"ANSI",
"escape",
"sequences",
"just",
"raw",
"strings"
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/happyDevFormatter.go#L169-L172 |
14,662 | mgutz/logxi | v1/defaultLogger.go | NewLogger | func NewLogger(writer io.Writer, name string) Logger {
formatter, err := createFormatter(name, logxiFormat)
if err != nil {
panic("Could not create formatter")
}
return NewLogger3(writer, name, formatter)
} | go | func NewLogger(writer io.Writer, name string) Logger {
formatter, err := createFormatter(name, logxiFormat)
if err != nil {
panic("Could not create formatter")
}
return NewLogger3(writer, name, formatter)
} | [
"func",
"NewLogger",
"(",
"writer",
"io",
".",
"Writer",
",",
"name",
"string",
")",
"Logger",
"{",
"formatter",
",",
"err",
":=",
"createFormatter",
"(",
"name",
",",
"logxiFormat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
... | // NewLogger creates a new default logger. If writer is not concurrent
// safe, wrap it with NewConcurrentWriter. | [
"NewLogger",
"creates",
"a",
"new",
"default",
"logger",
".",
"If",
"writer",
"is",
"not",
"concurrent",
"safe",
"wrap",
"it",
"with",
"NewConcurrentWriter",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L18-L24 |
14,663 | mgutz/logxi | v1/defaultLogger.go | NewLogger3 | func NewLogger3(writer io.Writer, name string, formatter Formatter) Logger {
var level int
if name != "__logxi" {
// if err is returned, then it means the log is disabled
level = getLogLevel(name)
if level == LevelOff {
return NullLog
}
}
log := &DefaultLogger{
formatter: formatter,
writer: writer,
name: name,
level: level,
}
// TODO loggers will be used when watching changes to configuration such
// as in consul, etcd
loggers.Lock()
loggers.loggers[name] = log
loggers.Unlock()
return log
} | go | func NewLogger3(writer io.Writer, name string, formatter Formatter) Logger {
var level int
if name != "__logxi" {
// if err is returned, then it means the log is disabled
level = getLogLevel(name)
if level == LevelOff {
return NullLog
}
}
log := &DefaultLogger{
formatter: formatter,
writer: writer,
name: name,
level: level,
}
// TODO loggers will be used when watching changes to configuration such
// as in consul, etcd
loggers.Lock()
loggers.loggers[name] = log
loggers.Unlock()
return log
} | [
"func",
"NewLogger3",
"(",
"writer",
"io",
".",
"Writer",
",",
"name",
"string",
",",
"formatter",
"Formatter",
")",
"Logger",
"{",
"var",
"level",
"int",
"\n",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"// if err is returned, then it means the log is disabled",
"lev... | // NewLogger3 creates a new logger with a writer, name and formatter. If writer is not concurrent
// safe, wrap it with NewConcurrentWriter. | [
"NewLogger3",
"creates",
"a",
"new",
"logger",
"with",
"a",
"writer",
"name",
"and",
"formatter",
".",
"If",
"writer",
"is",
"not",
"concurrent",
"safe",
"wrap",
"it",
"with",
"NewConcurrentWriter",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L28-L51 |
14,664 | mgutz/logxi | v1/defaultLogger.go | Trace | func (l *DefaultLogger) Trace(msg string, args ...interface{}) {
l.Log(LevelTrace, msg, args)
} | go | func (l *DefaultLogger) Trace(msg string, args ...interface{}) {
l.Log(LevelTrace, msg, args)
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Trace",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"LevelTrace",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] | // Trace logs a debug entry. | [
"Trace",
"logs",
"a",
"debug",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L59-L61 |
14,665 | mgutz/logxi | v1/defaultLogger.go | Debug | func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
l.Log(LevelDebug, msg, args)
} | go | func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
l.Log(LevelDebug, msg, args)
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Debug",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"LevelDebug",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] | // Debug logs a debug entry. | [
"Debug",
"logs",
"a",
"debug",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L64-L66 |
14,666 | mgutz/logxi | v1/defaultLogger.go | Info | func (l *DefaultLogger) Info(msg string, args ...interface{}) {
l.Log(LevelInfo, msg, args)
} | go | func (l *DefaultLogger) Info(msg string, args ...interface{}) {
l.Log(LevelInfo, msg, args)
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Info",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"LevelInfo",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] | // Info logs an info entry. | [
"Info",
"logs",
"an",
"info",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L69-L71 |
14,667 | mgutz/logxi | v1/defaultLogger.go | Warn | func (l *DefaultLogger) Warn(msg string, args ...interface{}) error {
if l.IsWarn() {
defer l.Log(LevelWarn, msg, args)
for _, arg := range args {
if err, ok := arg.(error); ok {
return err
}
}
return nil
}
return nil
} | go | func (l *DefaultLogger) Warn(msg string, args ...interface{}) error {
if l.IsWarn() {
defer l.Log(LevelWarn, msg, args)
for _, arg := range args {
if err, ok := arg.(error); ok {
return err
}
}
return nil
}
return nil
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Warn",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"l",
".",
"IsWarn",
"(",
")",
"{",
"defer",
"l",
".",
"Log",
"(",
"LevelWarn",
",",
"msg",
",",
"args",... | // Warn logs a warn entry. | [
"Warn",
"logs",
"a",
"warn",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L74-L87 |
14,668 | mgutz/logxi | v1/defaultLogger.go | Error | func (l *DefaultLogger) Error(msg string, args ...interface{}) error {
return l.extractLogError(LevelError, msg, args)
} | go | func (l *DefaultLogger) Error(msg string, args ...interface{}) error {
return l.extractLogError(LevelError, msg, args)
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Error",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"l",
".",
"extractLogError",
"(",
"LevelError",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] | // Error logs an error entry. | [
"Error",
"logs",
"an",
"error",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L101-L103 |
14,669 | mgutz/logxi | v1/defaultLogger.go | Fatal | func (l *DefaultLogger) Fatal(msg string, args ...interface{}) {
l.extractLogError(LevelFatal, msg, args)
defer panic("Exit due to fatal error: ")
} | go | func (l *DefaultLogger) Fatal(msg string, args ...interface{}) {
l.extractLogError(LevelFatal, msg, args)
defer panic("Exit due to fatal error: ")
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Fatal",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"extractLogError",
"(",
"LevelFatal",
",",
"msg",
",",
"args",
")",
"\n",
"defer",
"panic",
"(",
"\"",
"\"",
... | // Fatal logs a fatal entry then panics. | [
"Fatal",
"logs",
"a",
"fatal",
"entry",
"then",
"panics",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L106-L109 |
14,670 | mgutz/logxi | v1/defaultLogger.go | Log | func (l *DefaultLogger) Log(level int, msg string, args []interface{}) {
// log if the log level (warn=4) >= level of message (err=3)
if l.level < level || silent {
return
}
l.formatter.Format(l.writer, level, msg, args)
} | go | func (l *DefaultLogger) Log(level int, msg string, args []interface{}) {
// log if the log level (warn=4) >= level of message (err=3)
if l.level < level || silent {
return
}
l.formatter.Format(l.writer, level, msg, args)
} | [
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Log",
"(",
"level",
"int",
",",
"msg",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"// log if the log level (warn=4) >= level of message (err=3)",
"if",
"l",
".",
"level",
"<",
"level",
"||"... | // Log logs a leveled entry. | [
"Log",
"logs",
"a",
"leveled",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L112-L118 |
14,671 | mgutz/logxi | v1/textFormatter.go | NewTextFormatter | func NewTextFormatter(name string) *TextFormatter {
timeLabel := KeyMap.Time + AssignmentChar
levelLabel := Separator + KeyMap.Level + AssignmentChar
messageLabel := Separator + KeyMap.Message + AssignmentChar
nameLabel := Separator + KeyMap.Name + AssignmentChar
pidLabel := Separator + KeyMap.PID + AssignmentChar
var buildKV = func(level string) string {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(pidLabel)
buf.WriteString(pidStr)
//buf.WriteString(Separator)
buf.WriteString(nameLabel)
buf.WriteString(name)
//buf.WriteString(Separator)
buf.WriteString(levelLabel)
buf.WriteString(level)
//buf.WriteString(Separator)
buf.WriteString(messageLabel)
return buf.String()
}
itoaLevelMap := map[int]string{
LevelDebug: buildKV(LevelMap[LevelDebug]),
LevelWarn: buildKV(LevelMap[LevelWarn]),
LevelInfo: buildKV(LevelMap[LevelInfo]),
LevelError: buildKV(LevelMap[LevelError]),
LevelFatal: buildKV(LevelMap[LevelFatal]),
}
return &TextFormatter{itoaLevelMap: itoaLevelMap, name: name, timeLabel: timeLabel}
} | go | func NewTextFormatter(name string) *TextFormatter {
timeLabel := KeyMap.Time + AssignmentChar
levelLabel := Separator + KeyMap.Level + AssignmentChar
messageLabel := Separator + KeyMap.Message + AssignmentChar
nameLabel := Separator + KeyMap.Name + AssignmentChar
pidLabel := Separator + KeyMap.PID + AssignmentChar
var buildKV = func(level string) string {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(pidLabel)
buf.WriteString(pidStr)
//buf.WriteString(Separator)
buf.WriteString(nameLabel)
buf.WriteString(name)
//buf.WriteString(Separator)
buf.WriteString(levelLabel)
buf.WriteString(level)
//buf.WriteString(Separator)
buf.WriteString(messageLabel)
return buf.String()
}
itoaLevelMap := map[int]string{
LevelDebug: buildKV(LevelMap[LevelDebug]),
LevelWarn: buildKV(LevelMap[LevelWarn]),
LevelInfo: buildKV(LevelMap[LevelInfo]),
LevelError: buildKV(LevelMap[LevelError]),
LevelFatal: buildKV(LevelMap[LevelFatal]),
}
return &TextFormatter{itoaLevelMap: itoaLevelMap, name: name, timeLabel: timeLabel}
} | [
"func",
"NewTextFormatter",
"(",
"name",
"string",
")",
"*",
"TextFormatter",
"{",
"timeLabel",
":=",
"KeyMap",
".",
"Time",
"+",
"AssignmentChar",
"\n",
"levelLabel",
":=",
"Separator",
"+",
"KeyMap",
".",
"Level",
"+",
"AssignmentChar",
"\n",
"messageLabel",
... | // NewTextFormatter returns a new instance of TextFormatter. SetName
// must be called befored using it. | [
"NewTextFormatter",
"returns",
"a",
"new",
"instance",
"of",
"TextFormatter",
".",
"SetName",
"must",
"be",
"called",
"befored",
"using",
"it",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/textFormatter.go#L25-L60 |
14,672 | mgutz/logxi | v1/textFormatter.go | Format | func (tf *TextFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(tf.timeLabel)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(tf.itoaLevelMap[level])
buf.WriteString(msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
tf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
tf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
tf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteRune('\n')
buf.WriteTo(writer)
} | go | func (tf *TextFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(tf.timeLabel)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(tf.itoaLevelMap[level])
buf.WriteString(msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
tf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
tf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
tf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteRune('\n')
buf.WriteTo(writer)
} | [
"func",
"(",
"tf",
"*",
"TextFormatter",
")",
"Format",
"(",
"writer",
"io",
".",
"Writer",
",",
"level",
"int",
",",
"msg",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"buf",
":=",
"pool",
".",
"Get",
"(",
")",
"\n",
"defer... | // Format records a log entry. | [
"Format",
"records",
"a",
"log",
"entry",
"."
] | aebf8a7d67ab4625e0fd4a665766fef9a709161b | https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/textFormatter.go#L76-L107 |
14,673 | dhowden/tag | mp4.go | ReadAtoms | func ReadAtoms(r io.ReadSeeker) (Metadata, error) {
m := metadataMP4{
data: make(map[string]interface{}),
fileType: UnknownFileType,
}
err := m.readAtoms(r)
return m, err
} | go | func ReadAtoms(r io.ReadSeeker) (Metadata, error) {
m := metadataMP4{
data: make(map[string]interface{}),
fileType: UnknownFileType,
}
err := m.readAtoms(r)
return m, err
} | [
"func",
"ReadAtoms",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"Metadata",
",",
"error",
")",
"{",
"m",
":=",
"metadataMP4",
"{",
"data",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
",",
"fileType",
":",
"UnknownFileTy... | // ReadAtoms reads MP4 metadata atoms from the io.ReadSeeker into a Metadata, returning
// non-nil error if there was a problem. | [
"ReadAtoms",
"reads",
"MP4",
"metadata",
"atoms",
"from",
"the",
"io",
".",
"ReadSeeker",
"into",
"a",
"Metadata",
"returning",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/mp4.go#L70-L77 |
14,674 | dhowden/tag | sum.go | SumAtoms | func SumAtoms(r io.ReadSeeker) (string, error) {
for {
var size uint32
err := binary.Read(r, binary.BigEndian, &size)
if err != nil {
if err == io.EOF {
return "", fmt.Errorf("reached EOF before audio data")
}
return "", err
}
name, err := readString(r, 4)
if err != nil {
return "", err
}
switch name {
case "meta":
// next_item_id (int32)
_, err := r.Seek(4, io.SeekCurrent)
if err != nil {
return "", err
}
fallthrough
case "moov", "udta", "ilst":
continue
case "mdat": // stop when we get to the data
h := sha1.New()
_, err := io.CopyN(h, r, int64(size-8))
if err != nil {
return "", fmt.Errorf("error reading audio data: %v", err)
}
return hashSum(h), nil
}
_, err = r.Seek(int64(size-8), io.SeekCurrent)
if err != nil {
return "", fmt.Errorf("error reading '%v' tag: %v", name, err)
}
}
} | go | func SumAtoms(r io.ReadSeeker) (string, error) {
for {
var size uint32
err := binary.Read(r, binary.BigEndian, &size)
if err != nil {
if err == io.EOF {
return "", fmt.Errorf("reached EOF before audio data")
}
return "", err
}
name, err := readString(r, 4)
if err != nil {
return "", err
}
switch name {
case "meta":
// next_item_id (int32)
_, err := r.Seek(4, io.SeekCurrent)
if err != nil {
return "", err
}
fallthrough
case "moov", "udta", "ilst":
continue
case "mdat": // stop when we get to the data
h := sha1.New()
_, err := io.CopyN(h, r, int64(size-8))
if err != nil {
return "", fmt.Errorf("error reading audio data: %v", err)
}
return hashSum(h), nil
}
_, err = r.Seek(int64(size-8), io.SeekCurrent)
if err != nil {
return "", fmt.Errorf("error reading '%v' tag: %v", name, err)
}
}
} | [
"func",
"SumAtoms",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"string",
",",
"error",
")",
"{",
"for",
"{",
"var",
"size",
"uint32",
"\n",
"err",
":=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"BigEndian",
",",
"&",
"size",
")",
"\... | // SumAtoms constructs a checksum of MP4 audio file data provided by the io.ReadSeeker which is
// metadata invariant. | [
"SumAtoms",
"constructs",
"a",
"checksum",
"of",
"MP4",
"audio",
"file",
"data",
"provided",
"by",
"the",
"io",
".",
"ReadSeeker",
"which",
"is",
"metadata",
"invariant",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/sum.go#L58-L100 |
14,675 | dhowden/tag | id3v2frames.go | String | func (t Comm) String() string {
if t.Language != "" {
return fmt.Sprintf("Text{Lang: '%v', Description: '%v', %v lines}",
t.Language, t.Description, strings.Count(t.Text, "\n"))
}
return fmt.Sprintf("Text{Description: '%v', %v}", t.Description, t.Text)
} | go | func (t Comm) String() string {
if t.Language != "" {
return fmt.Sprintf("Text{Lang: '%v', Description: '%v', %v lines}",
t.Language, t.Description, strings.Count(t.Text, "\n"))
}
return fmt.Sprintf("Text{Description: '%v', %v}", t.Description, t.Text)
} | [
"func",
"(",
"t",
"Comm",
")",
"String",
"(",
")",
"string",
"{",
"if",
"t",
".",
"Language",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Language",
",",
"t",
".",
"Description",
",",
"strings",
".",
... | // String returns a string representation of the underlying Comm instance. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"underlying",
"Comm",
"instance",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2frames.go#L430-L436 |
14,676 | dhowden/tag | id3v2frames.go | String | func (p Picture) String() string {
return fmt.Sprintf("Picture{Ext: %v, MIMEType: %v, Type: %v, Description: %v, Data.Size: %v}",
p.Ext, p.MIMEType, p.Type, p.Description, len(p.Data))
} | go | func (p Picture) String() string {
return fmt.Sprintf("Picture{Ext: %v, MIMEType: %v, Type: %v, Description: %v, Data.Size: %v}",
p.Ext, p.MIMEType, p.Type, p.Description, len(p.Data))
} | [
"func",
"(",
"p",
"Picture",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"Ext",
",",
"p",
".",
"MIMEType",
",",
"p",
".",
"Type",
",",
"p",
".",
"Description",
",",
"len",
"(",
"p",
... | // String returns a string representation of the underlying Picture instance. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"underlying",
"Picture",
"instance",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2frames.go#L548-L551 |
14,677 | dhowden/tag | id3v1.go | ReadID3v1Tags | func ReadID3v1Tags(r io.ReadSeeker) (Metadata, error) {
_, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return nil, err
}
if tag, err := readString(r, 3); err != nil {
return nil, err
} else if tag != "TAG" {
return nil, ErrNotID3v1
}
title, err := readString(r, 30)
if err != nil {
return nil, err
}
artist, err := readString(r, 30)
if err != nil {
return nil, err
}
album, err := readString(r, 30)
if err != nil {
return nil, err
}
year, err := readString(r, 4)
if err != nil {
return nil, err
}
commentBytes, err := readBytes(r, 30)
if err != nil {
return nil, err
}
var comment string
var track int
if commentBytes[28] == 0 {
comment = trimString(string(commentBytes[:28]))
track = int(commentBytes[29])
} else {
comment = trimString(string(commentBytes))
}
var genre string
genreID, err := readBytes(r, 1)
if err != nil {
return nil, err
}
if int(genreID[0]) < len(id3v1Genres) {
genre = id3v1Genres[int(genreID[0])]
}
m := make(map[string]interface{})
m["title"] = trimString(title)
m["artist"] = trimString(artist)
m["album"] = trimString(album)
m["year"] = trimString(year)
m["comment"] = trimString(comment)
m["track"] = track
m["genre"] = genre
return metadataID3v1(m), nil
} | go | func ReadID3v1Tags(r io.ReadSeeker) (Metadata, error) {
_, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return nil, err
}
if tag, err := readString(r, 3); err != nil {
return nil, err
} else if tag != "TAG" {
return nil, ErrNotID3v1
}
title, err := readString(r, 30)
if err != nil {
return nil, err
}
artist, err := readString(r, 30)
if err != nil {
return nil, err
}
album, err := readString(r, 30)
if err != nil {
return nil, err
}
year, err := readString(r, 4)
if err != nil {
return nil, err
}
commentBytes, err := readBytes(r, 30)
if err != nil {
return nil, err
}
var comment string
var track int
if commentBytes[28] == 0 {
comment = trimString(string(commentBytes[:28]))
track = int(commentBytes[29])
} else {
comment = trimString(string(commentBytes))
}
var genre string
genreID, err := readBytes(r, 1)
if err != nil {
return nil, err
}
if int(genreID[0]) < len(id3v1Genres) {
genre = id3v1Genres[int(genreID[0])]
}
m := make(map[string]interface{})
m["title"] = trimString(title)
m["artist"] = trimString(artist)
m["album"] = trimString(album)
m["year"] = trimString(year)
m["comment"] = trimString(comment)
m["track"] = track
m["genre"] = genre
return metadataID3v1(m), nil
} | [
"func",
"ReadID3v1Tags",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"Metadata",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"r",
".",
"Seek",
"(",
"-",
"128",
",",
"io",
".",
"SeekEnd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"... | // ReadID3v1Tags reads ID3v1 tags from the io.ReadSeeker. Returns ErrNotID3v1
// if there are no ID3v1 tags, otherwise non-nil error if there was a problem. | [
"ReadID3v1Tags",
"reads",
"ID3v1",
"tags",
"from",
"the",
"io",
".",
"ReadSeeker",
".",
"Returns",
"ErrNotID3v1",
"if",
"there",
"are",
"no",
"ID3v1",
"tags",
"otherwise",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v1.go#L45-L110 |
14,678 | dhowden/tag | id.go | Identify | func Identify(r io.ReadSeeker) (format Format, fileType FileType, err error) {
b, err := readBytes(r, 11)
if err != nil {
return
}
_, err = r.Seek(-11, io.SeekCurrent)
if err != nil {
err = fmt.Errorf("could not seek back to original position: %v", err)
return
}
switch {
case string(b[0:4]) == "fLaC":
return VORBIS, FLAC, nil
case string(b[0:4]) == "OggS":
return VORBIS, OGG, nil
case string(b[4:8]) == "ftyp":
b = b[8:11]
fileType = UnknownFileType
switch string(b) {
case "M4A":
fileType = M4A
case "M4B":
fileType = M4B
case "M4P":
fileType = M4P
}
return MP4, fileType, nil
case string(b[0:3]) == "ID3":
b := b[3:]
switch uint(b[0]) {
case 2:
format = ID3v2_2
case 3:
format = ID3v2_3
case 4:
format = ID3v2_4
case 0, 1:
fallthrough
default:
err = fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
return
}
return format, MP3, nil
}
n, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return
}
tag, err := readString(r, 3)
if err != nil {
return
}
_, err = r.Seek(-n, io.SeekCurrent)
if err != nil {
return
}
if tag != "TAG" {
err = ErrNoTagsFound
return
}
return ID3v1, MP3, nil
} | go | func Identify(r io.ReadSeeker) (format Format, fileType FileType, err error) {
b, err := readBytes(r, 11)
if err != nil {
return
}
_, err = r.Seek(-11, io.SeekCurrent)
if err != nil {
err = fmt.Errorf("could not seek back to original position: %v", err)
return
}
switch {
case string(b[0:4]) == "fLaC":
return VORBIS, FLAC, nil
case string(b[0:4]) == "OggS":
return VORBIS, OGG, nil
case string(b[4:8]) == "ftyp":
b = b[8:11]
fileType = UnknownFileType
switch string(b) {
case "M4A":
fileType = M4A
case "M4B":
fileType = M4B
case "M4P":
fileType = M4P
}
return MP4, fileType, nil
case string(b[0:3]) == "ID3":
b := b[3:]
switch uint(b[0]) {
case 2:
format = ID3v2_2
case 3:
format = ID3v2_3
case 4:
format = ID3v2_4
case 0, 1:
fallthrough
default:
err = fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
return
}
return format, MP3, nil
}
n, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return
}
tag, err := readString(r, 3)
if err != nil {
return
}
_, err = r.Seek(-n, io.SeekCurrent)
if err != nil {
return
}
if tag != "TAG" {
err = ErrNoTagsFound
return
}
return ID3v1, MP3, nil
} | [
"func",
"Identify",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"format",
"Format",
",",
"fileType",
"FileType",
",",
"err",
"error",
")",
"{",
"b",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"11",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r... | // Identify identifies the format and file type of the data in the ReadSeeker. | [
"Identify",
"identifies",
"the",
"format",
"and",
"file",
"type",
"of",
"the",
"data",
"in",
"the",
"ReadSeeker",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id.go#L9-L81 |
14,679 | dhowden/tag | id3v2.go | readID3v2Header | func readID3v2Header(r io.Reader) (h *id3v2Header, offset int, err error) {
offset = 10
b, err := readBytes(r, offset)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 10 bytes (ID3v2Header): %v", err)
}
if string(b[0:3]) != "ID3" {
return nil, 0, fmt.Errorf("expected to read \"ID3\"")
}
b = b[3:]
var vers Format
switch uint(b[0]) {
case 2:
vers = ID3v2_2
case 3:
vers = ID3v2_3
case 4:
vers = ID3v2_4
case 0, 1:
fallthrough
default:
return nil, 0, fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
}
// NB: We ignore b[1] (the revision) as we don't currently rely on it.
h = &id3v2Header{
Version: vers,
Unsynchronisation: getBit(b[2], 7),
ExtendedHeader: getBit(b[2], 6),
Experimental: getBit(b[2], 5),
Size: get7BitChunkedInt(b[3:7]),
}
if h.ExtendedHeader {
switch vers {
case ID3v2_3:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v23 extended header len): %v", err)
}
// skip header, size is excluding len bytes
extendedHeaderSize := getInt(b)
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v23 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
case ID3v2_4:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v24 extended header len): %v", err)
}
// skip header, size is synchsafe int including len bytes
extendedHeaderSize := get7BitChunkedInt(b) - 4
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v24 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
default:
// nop, only 2.3 and 2.4 should have extended header
}
}
return h, offset, nil
} | go | func readID3v2Header(r io.Reader) (h *id3v2Header, offset int, err error) {
offset = 10
b, err := readBytes(r, offset)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 10 bytes (ID3v2Header): %v", err)
}
if string(b[0:3]) != "ID3" {
return nil, 0, fmt.Errorf("expected to read \"ID3\"")
}
b = b[3:]
var vers Format
switch uint(b[0]) {
case 2:
vers = ID3v2_2
case 3:
vers = ID3v2_3
case 4:
vers = ID3v2_4
case 0, 1:
fallthrough
default:
return nil, 0, fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
}
// NB: We ignore b[1] (the revision) as we don't currently rely on it.
h = &id3v2Header{
Version: vers,
Unsynchronisation: getBit(b[2], 7),
ExtendedHeader: getBit(b[2], 6),
Experimental: getBit(b[2], 5),
Size: get7BitChunkedInt(b[3:7]),
}
if h.ExtendedHeader {
switch vers {
case ID3v2_3:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v23 extended header len): %v", err)
}
// skip header, size is excluding len bytes
extendedHeaderSize := getInt(b)
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v23 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
case ID3v2_4:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v24 extended header len): %v", err)
}
// skip header, size is synchsafe int including len bytes
extendedHeaderSize := get7BitChunkedInt(b) - 4
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v24 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
default:
// nop, only 2.3 and 2.4 should have extended header
}
}
return h, offset, nil
} | [
"func",
"readID3v2Header",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"h",
"*",
"id3v2Header",
",",
"offset",
"int",
",",
"err",
"error",
")",
"{",
"offset",
"=",
"10",
"\n",
"b",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"offset",
")",
"\n",
"... | // readID3v2Header reads the ID3v2 header from the given io.Reader.
// offset it number of bytes of header that was read | [
"readID3v2Header",
"reads",
"the",
"ID3v2",
"header",
"from",
"the",
"given",
"io",
".",
"Reader",
".",
"offset",
"it",
"number",
"of",
"bytes",
"of",
"header",
"that",
"was",
"read"
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2.go#L56-L123 |
14,680 | dhowden/tag | id3v2.go | Read | func (r *unsynchroniser) Read(p []byte) (int, error) {
b := make([]byte, 1)
i := 0
for i < len(p) {
if n, err := r.Reader.Read(b); err != nil || n == 0 {
return i, err
}
if r.ff && b[0] == 0x00 {
r.ff = false
continue
}
p[i] = b[0]
i++
r.ff = (b[0] == 0xFF)
}
return i, nil
} | go | func (r *unsynchroniser) Read(p []byte) (int, error) {
b := make([]byte, 1)
i := 0
for i < len(p) {
if n, err := r.Reader.Read(b); err != nil || n == 0 {
return i, err
}
if r.ff && b[0] == 0x00 {
r.ff = false
continue
}
p[i] = b[0]
i++
r.ff = (b[0] == 0xFF)
}
return i, nil
} | [
"func",
"(",
"r",
"*",
"unsynchroniser",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"i",
":=",
"0",
"\n",
"for",
"i",
"<",
"len",
"(",
"... | // filter io.Reader which skip the Unsynchronisation bytes | [
"filter",
"io",
".",
"Reader",
"which",
"skip",
"the",
"Unsynchronisation",
"bytes"
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2.go#L373-L389 |
14,681 | dhowden/tag | id3v2.go | id3v2genre | func id3v2genre(genre string) string {
c := true
for c {
orig := genre
if match := id3v2genreRe.FindStringSubmatch(genre); len(match) > 0 {
if genreID, err := strconv.Atoi(match[2]); err == nil {
if genreID < len(id3v2Genres) {
genre = id3v2Genres[genreID]
if match[1] != "" {
genre = strings.TrimSpace(match[1]) + " " + genre
}
if match[3] != "" {
genre = genre + " " + match[3]
}
}
}
}
c = (orig != genre)
}
return strings.Replace(genre, "((", "(", -1)
} | go | func id3v2genre(genre string) string {
c := true
for c {
orig := genre
if match := id3v2genreRe.FindStringSubmatch(genre); len(match) > 0 {
if genreID, err := strconv.Atoi(match[2]); err == nil {
if genreID < len(id3v2Genres) {
genre = id3v2Genres[genreID]
if match[1] != "" {
genre = strings.TrimSpace(match[1]) + " " + genre
}
if match[3] != "" {
genre = genre + " " + match[3]
}
}
}
}
c = (orig != genre)
}
return strings.Replace(genre, "((", "(", -1)
} | [
"func",
"id3v2genre",
"(",
"genre",
"string",
")",
"string",
"{",
"c",
":=",
"true",
"\n",
"for",
"c",
"{",
"orig",
":=",
"genre",
"\n",
"if",
"match",
":=",
"id3v2genreRe",
".",
"FindStringSubmatch",
"(",
"genre",
")",
";",
"len",
"(",
"match",
")",
... | // id3v2genre parse a id3v2 genre tag and expand the numeric genres | [
"id3v2genre",
"parse",
"a",
"id3v2",
"genre",
"tag",
"and",
"expand",
"the",
"numeric",
"genres"
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2.go#L414-L434 |
14,682 | dhowden/tag | flac.go | ReadFLACTags | func ReadFLACTags(r io.ReadSeeker) (Metadata, error) {
flac, err := readString(r, 4)
if err != nil {
return nil, err
}
if flac != "fLaC" {
return nil, errors.New("expected 'fLaC'")
}
m := &metadataFLAC{
newMetadataVorbis(),
}
for {
last, err := m.readFLACMetadataBlock(r)
if err != nil {
return nil, err
}
if last {
break
}
}
return m, nil
} | go | func ReadFLACTags(r io.ReadSeeker) (Metadata, error) {
flac, err := readString(r, 4)
if err != nil {
return nil, err
}
if flac != "fLaC" {
return nil, errors.New("expected 'fLaC'")
}
m := &metadataFLAC{
newMetadataVorbis(),
}
for {
last, err := m.readFLACMetadataBlock(r)
if err != nil {
return nil, err
}
if last {
break
}
}
return m, nil
} | [
"func",
"ReadFLACTags",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"Metadata",
",",
"error",
")",
"{",
"flac",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",... | // ReadFLACTags reads FLAC metadata from the io.ReadSeeker, returning the resulting
// metadata in a Metadata implementation, or non-nil error if there was a problem. | [
"ReadFLACTags",
"reads",
"FLAC",
"metadata",
"from",
"the",
"io",
".",
"ReadSeeker",
"returning",
"the",
"resulting",
"metadata",
"in",
"a",
"Metadata",
"implementation",
"or",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/flac.go#L28-L52 |
14,683 | dhowden/tag | mbz/mbz.go | set | func (i Info) set(t, v string) {
if _, ok := tags[t]; ok {
i[t] = v
return
}
for k, tt := range tags {
if tt == t {
i[k] = v
return
}
}
} | go | func (i Info) set(t, v string) {
if _, ok := tags[t]; ok {
i[t] = v
return
}
for k, tt := range tags {
if tt == t {
i[k] = v
return
}
}
} | [
"func",
"(",
"i",
"Info",
")",
"set",
"(",
"t",
",",
"v",
"string",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"tags",
"[",
"t",
"]",
";",
"ok",
"{",
"i",
"[",
"t",
"]",
"=",
"v",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"tt",
":=... | // set the MusicBrainz tag to the given value. | [
"set",
"the",
"MusicBrainz",
"tag",
"to",
"the",
"given",
"value",
"."
] | a9f04c2798caa184ec116ff25e9a1a15e9b3f79a | https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/mbz/mbz.go#L51-L63 |
14,684 | kolide/osquery-go | plugin/logger/logger.go | NewPlugin | func NewPlugin(name string, fn LogFunc) *Plugin {
return &Plugin{name: name, logFn: fn}
} | go | func NewPlugin(name string, fn LogFunc) *Plugin {
return &Plugin{name: name, logFn: fn}
} | [
"func",
"NewPlugin",
"(",
"name",
"string",
",",
"fn",
"LogFunc",
")",
"*",
"Plugin",
"{",
"return",
"&",
"Plugin",
"{",
"name",
":",
"name",
",",
"logFn",
":",
"fn",
"}",
"\n",
"}"
] | // NewPlugin takes a value that implements LoggerPlugin and wraps it with
// the appropriate methods to satisfy the OsqueryPlugin interface. Use this to
// easily create plugins implementing osquery loggers. | [
"NewPlugin",
"takes",
"a",
"value",
"that",
"implements",
"LoggerPlugin",
"and",
"wraps",
"it",
"with",
"the",
"appropriate",
"methods",
"to",
"satisfy",
"the",
"OsqueryPlugin",
"interface",
".",
"Use",
"this",
"to",
"easily",
"create",
"plugins",
"implementing",
... | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/logger/logger.go#L32-L34 |
14,685 | kolide/osquery-go | plugin/logger/logger.go | String | func (l LogType) String() string {
var typeString string
switch l {
case LogTypeString:
typeString = "string"
case LogTypeSnapshot:
typeString = "snapshot"
case LogTypeHealth:
typeString = "health"
case LogTypeInit:
typeString = "init"
case LogTypeStatus:
typeString = "status"
default:
typeString = "unknown"
}
return typeString
} | go | func (l LogType) String() string {
var typeString string
switch l {
case LogTypeString:
typeString = "string"
case LogTypeSnapshot:
typeString = "snapshot"
case LogTypeHealth:
typeString = "health"
case LogTypeInit:
typeString = "init"
case LogTypeStatus:
typeString = "status"
default:
typeString = "unknown"
}
return typeString
} | [
"func",
"(",
"l",
"LogType",
")",
"String",
"(",
")",
"string",
"{",
"var",
"typeString",
"string",
"\n",
"switch",
"l",
"{",
"case",
"LogTypeString",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"case",
"LogTypeSnapshot",
":",
"typeString",
"=",
"\"",
"\""... | // String implements the fmt.Stringer interface for LogType. | [
"String",
"implements",
"the",
"fmt",
".",
"Stringer",
"interface",
"for",
"LogType",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/logger/logger.go#L129-L146 |
14,686 | kolide/osquery-go | transport/transport_windows.go | Open | func Open(path string, timeout time.Duration) (*thrift.TSocket, error) {
conn, err := winio.DialPipe(path, &timeout)
if err != nil {
return nil, errors.Wrapf(err, "dialing pipe '%s'", path)
}
return thrift.NewTSocketFromConnTimeout(conn, timeout), nil
} | go | func Open(path string, timeout time.Duration) (*thrift.TSocket, error) {
conn, err := winio.DialPipe(path, &timeout)
if err != nil {
return nil, errors.Wrapf(err, "dialing pipe '%s'", path)
}
return thrift.NewTSocketFromConnTimeout(conn, timeout), nil
} | [
"func",
"Open",
"(",
"path",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"thrift",
".",
"TSocket",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"winio",
".",
"DialPipe",
"(",
"path",
",",
"&",
"timeout",
")",
"\n",
"if",
... | // Open opens the named pipe with the provided path and timeout,
// returning a TTransport. | [
"Open",
"opens",
"the",
"named",
"pipe",
"with",
"the",
"provided",
"path",
"and",
"timeout",
"returning",
"a",
"TTransport",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/transport/transport_windows.go#L16-L22 |
14,687 | kolide/osquery-go | transport/transport_windows.go | Accept | func (p *TServerPipe) Accept() (thrift.TTransport, error) {
p.mu.RLock()
interrupted := p.interrupted
listener := p.listener
p.mu.RUnlock()
if interrupted {
return nil, errors.New("transport interrupted")
}
conn, err := listener.Accept()
if err != nil {
return nil, thrift.NewTTransportExceptionFromError(err)
}
return thrift.NewTSocketFromConnTimeout(conn, p.clientTimeout), nil
} | go | func (p *TServerPipe) Accept() (thrift.TTransport, error) {
p.mu.RLock()
interrupted := p.interrupted
listener := p.listener
p.mu.RUnlock()
if interrupted {
return nil, errors.New("transport interrupted")
}
conn, err := listener.Accept()
if err != nil {
return nil, thrift.NewTTransportExceptionFromError(err)
}
return thrift.NewTSocketFromConnTimeout(conn, p.clientTimeout), nil
} | [
"func",
"(",
"p",
"*",
"TServerPipe",
")",
"Accept",
"(",
")",
"(",
"thrift",
".",
"TTransport",
",",
"error",
")",
"{",
"p",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"interrupted",
":=",
"p",
".",
"interrupted",
"\n",
"listener",
":=",
"p",
".",
... | // Accept wraps the standard net.Listener accept to return a thrift.TTransport. | [
"Accept",
"wraps",
"the",
"standard",
"net",
".",
"Listener",
"accept",
"to",
"return",
"a",
"thrift",
".",
"TTransport",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/transport/transport_windows.go#L66-L81 |
14,688 | kolide/osquery-go | server.go | NewExtensionManagerServer | func NewExtensionManagerServer(name string, sockPath string, opts ...ServerOption) (*ExtensionManagerServer, error) {
// Initialize nested registry maps
registry := make(map[string](map[string]OsqueryPlugin))
for reg, _ := range validRegistryNames {
registry[reg] = make(map[string]OsqueryPlugin)
}
manager := &ExtensionManagerServer{
name: name,
sockPath: sockPath,
registry: registry,
timeout: defaultTimeout,
pingInterval: defaultPingInterval,
}
for _, opt := range opts {
opt(manager)
}
serverClient, err := NewClient(sockPath, manager.timeout)
if err != nil {
return nil, err
}
manager.serverClient = serverClient
return manager, nil
} | go | func NewExtensionManagerServer(name string, sockPath string, opts ...ServerOption) (*ExtensionManagerServer, error) {
// Initialize nested registry maps
registry := make(map[string](map[string]OsqueryPlugin))
for reg, _ := range validRegistryNames {
registry[reg] = make(map[string]OsqueryPlugin)
}
manager := &ExtensionManagerServer{
name: name,
sockPath: sockPath,
registry: registry,
timeout: defaultTimeout,
pingInterval: defaultPingInterval,
}
for _, opt := range opts {
opt(manager)
}
serverClient, err := NewClient(sockPath, manager.timeout)
if err != nil {
return nil, err
}
manager.serverClient = serverClient
return manager, nil
} | [
"func",
"NewExtensionManagerServer",
"(",
"name",
"string",
",",
"sockPath",
"string",
",",
"opts",
"...",
"ServerOption",
")",
"(",
"*",
"ExtensionManagerServer",
",",
"error",
")",
"{",
"// Initialize nested registry maps",
"registry",
":=",
"make",
"(",
"map",
... | // NewExtensionManagerServer creates a new extension management server
// communicating with osquery over the socket at the provided path. If
// resolving the address or connecting to the socket fails, this function will
// error. | [
"NewExtensionManagerServer",
"creates",
"a",
"new",
"extension",
"management",
"server",
"communicating",
"with",
"osquery",
"over",
"the",
"socket",
"at",
"the",
"provided",
"path",
".",
"If",
"resolving",
"the",
"address",
"or",
"connecting",
"to",
"the",
"socke... | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L82-L108 |
14,689 | kolide/osquery-go | server.go | RegisterPlugin | func (s *ExtensionManagerServer) RegisterPlugin(plugins ...OsqueryPlugin) {
s.mutex.Lock()
defer s.mutex.Unlock()
for _, plugin := range plugins {
if !validRegistryNames[plugin.RegistryName()] {
panic("invalid registry name: " + plugin.RegistryName())
}
s.registry[plugin.RegistryName()][plugin.Name()] = plugin
}
} | go | func (s *ExtensionManagerServer) RegisterPlugin(plugins ...OsqueryPlugin) {
s.mutex.Lock()
defer s.mutex.Unlock()
for _, plugin := range plugins {
if !validRegistryNames[plugin.RegistryName()] {
panic("invalid registry name: " + plugin.RegistryName())
}
s.registry[plugin.RegistryName()][plugin.Name()] = plugin
}
} | [
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"RegisterPlugin",
"(",
"plugins",
"...",
"OsqueryPlugin",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"plu... | // RegisterPlugin adds one or more OsqueryPlugins to this extension manager. | [
"RegisterPlugin",
"adds",
"one",
"or",
"more",
"OsqueryPlugins",
"to",
"this",
"extension",
"manager",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L111-L120 |
14,690 | kolide/osquery-go | server.go | Run | func (s *ExtensionManagerServer) Run() error {
errc := make(chan error)
go func() {
errc <- s.Start()
}()
// Watch for the osquery process going away. If so, initiate shutdown.
go func() {
for {
time.Sleep(s.pingInterval)
status, err := s.serverClient.Ping()
if err != nil {
errc <- errors.Wrap(err, "extension ping failed")
break
}
if status.Code != 0 {
errc <- errors.Errorf("ping returned status %d", status.Code)
break
}
}
}()
err := <-errc
if err := s.Shutdown(context.Background()); err != nil {
return err
}
return err
} | go | func (s *ExtensionManagerServer) Run() error {
errc := make(chan error)
go func() {
errc <- s.Start()
}()
// Watch for the osquery process going away. If so, initiate shutdown.
go func() {
for {
time.Sleep(s.pingInterval)
status, err := s.serverClient.Ping()
if err != nil {
errc <- errors.Wrap(err, "extension ping failed")
break
}
if status.Code != 0 {
errc <- errors.Errorf("ping returned status %d", status.Code)
break
}
}
}()
err := <-errc
if err := s.Shutdown(context.Background()); err != nil {
return err
}
return err
} | [
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Run",
"(",
")",
"error",
"{",
"errc",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"errc",
"<-",
"s",
".",
"Start",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"//... | // Run starts the extension manager and runs until osquery calls for a shutdown
// or the osquery instance goes away. | [
"Run",
"starts",
"the",
"extension",
"manager",
"and",
"runs",
"until",
"osquery",
"calls",
"for",
"a",
"shutdown",
"or",
"the",
"osquery",
"instance",
"goes",
"away",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L183-L211 |
14,691 | kolide/osquery-go | server.go | Ping | func (s *ExtensionManagerServer) Ping(ctx context.Context) (*osquery.ExtensionStatus, error) {
return &osquery.ExtensionStatus{Code: 0, Message: "OK"}, nil
} | go | func (s *ExtensionManagerServer) Ping(ctx context.Context) (*osquery.ExtensionStatus, error) {
return &osquery.ExtensionStatus{Code: 0, Message: "OK"}, nil
} | [
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Ping",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"osquery",
".",
"ExtensionStatus",
",",
"error",
")",
"{",
"return",
"&",
"osquery",
".",
"ExtensionStatus",
"{",
"Code",
":",
"0",
",",
... | // Ping implements the basic health check. | [
"Ping",
"implements",
"the",
"basic",
"health",
"check",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L214-L216 |
14,692 | kolide/osquery-go | server.go | Call | func (s *ExtensionManagerServer) Call(ctx context.Context, registry string, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
subreg, ok := s.registry[registry]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry: " + registry,
},
}, nil
}
plugin, ok := subreg[item]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry item: " + item,
},
}, nil
}
response := plugin.Call(context.Background(), request)
return &response, nil
} | go | func (s *ExtensionManagerServer) Call(ctx context.Context, registry string, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
subreg, ok := s.registry[registry]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry: " + registry,
},
}, nil
}
plugin, ok := subreg[item]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry item: " + item,
},
}, nil
}
response := plugin.Call(context.Background(), request)
return &response, nil
} | [
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"registry",
"string",
",",
"item",
"string",
",",
"request",
"osquery",
".",
"ExtensionPluginRequest",
")",
"(",
"*",
"osquery",
".",
"ExtensionResponse",... | // Call routes a call from the osquery process to the appropriate registered
// plugin. | [
"Call",
"routes",
"a",
"call",
"from",
"the",
"osquery",
"process",
"to",
"the",
"appropriate",
"registered",
"plugin",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L220-L243 |
14,693 | kolide/osquery-go | server.go | Shutdown | func (s *ExtensionManagerServer) Shutdown(ctx context.Context) error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.server != nil {
server := s.server
s.server = nil
// Stop the server asynchronously so that the current request
// can complete. Otherwise, this is vulnerable to deadlock if a
// shutdown request is being processed when shutdown is
// explicitly called.
go func() {
server.Stop()
}()
}
return nil
} | go | func (s *ExtensionManagerServer) Shutdown(ctx context.Context) error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.server != nil {
server := s.server
s.server = nil
// Stop the server asynchronously so that the current request
// can complete. Otherwise, this is vulnerable to deadlock if a
// shutdown request is being processed when shutdown is
// explicitly called.
go func() {
server.Stop()
}()
}
return nil
} | [
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
... | // Shutdown stops the server and closes the listening socket. | [
"Shutdown",
"stops",
"the",
"server",
"and",
"closes",
"the",
"listening",
"socket",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L246-L262 |
14,694 | kolide/osquery-go | server.go | waitStarted | func (s *ExtensionManagerServer) waitStarted() {
for {
s.mutex.Lock()
started := s.started
s.mutex.Unlock()
if started {
time.Sleep(10 * time.Millisecond)
break
}
}
} | go | func (s *ExtensionManagerServer) waitStarted() {
for {
s.mutex.Lock()
started := s.started
s.mutex.Unlock()
if started {
time.Sleep(10 * time.Millisecond)
break
}
}
} | [
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"waitStarted",
"(",
")",
"{",
"for",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"started",
":=",
"s",
".",
"started",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s... | // Useful for testing | [
"Useful",
"for",
"testing"
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L265-L275 |
14,695 | kolide/osquery-go | plugin/config/config.go | NewPlugin | func NewPlugin(name string, fn GenerateConfigsFunc) *Plugin {
return &Plugin{name: name, generate: fn}
} | go | func NewPlugin(name string, fn GenerateConfigsFunc) *Plugin {
return &Plugin{name: name, generate: fn}
} | [
"func",
"NewPlugin",
"(",
"name",
"string",
",",
"fn",
"GenerateConfigsFunc",
")",
"*",
"Plugin",
"{",
"return",
"&",
"Plugin",
"{",
"name",
":",
"name",
",",
"generate",
":",
"fn",
"}",
"\n",
"}"
] | // NewConfigPlugin takes a value that implements ConfigPlugin and wraps it with
// the appropriate methods to satisfy the OsqueryPlugin interface. Use this to
// easily create configuration plugins. | [
"NewConfigPlugin",
"takes",
"a",
"value",
"that",
"implements",
"ConfigPlugin",
"and",
"wraps",
"it",
"with",
"the",
"appropriate",
"methods",
"to",
"satisfy",
"the",
"OsqueryPlugin",
"interface",
".",
"Use",
"this",
"to",
"easily",
"create",
"configuration",
"plu... | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/config/config.go#L28-L30 |
14,696 | kolide/osquery-go | transport/transport.go | Open | func Open(sockPath string, timeout time.Duration) (*thrift.TSocket, error) {
addr, err := net.ResolveUnixAddr("unix", sockPath)
if err != nil {
return nil, errors.Wrapf(err, "resolving socket path '%s'", sockPath)
}
// the timeout parameter is passed to thrift, which passes it to net.DialTimeout
// but it looks like net.DialTimeout ignores timeouts for unix socket and immediately returns an error
// waitForSocket will loop every 200ms to stat the socket path,
// or until the timeout value passes, similar to the C++ and python implementations.
if err := waitForSocket(sockPath, timeout); err != nil {
return nil, errors.Wrapf(err, "waiting for unix socket to be available: %s", sockPath)
}
trans := thrift.NewTSocketFromAddrTimeout(addr, timeout)
if err := trans.Open(); err != nil {
return nil, errors.Wrap(err, "opening socket transport")
}
return trans, nil
} | go | func Open(sockPath string, timeout time.Duration) (*thrift.TSocket, error) {
addr, err := net.ResolveUnixAddr("unix", sockPath)
if err != nil {
return nil, errors.Wrapf(err, "resolving socket path '%s'", sockPath)
}
// the timeout parameter is passed to thrift, which passes it to net.DialTimeout
// but it looks like net.DialTimeout ignores timeouts for unix socket and immediately returns an error
// waitForSocket will loop every 200ms to stat the socket path,
// or until the timeout value passes, similar to the C++ and python implementations.
if err := waitForSocket(sockPath, timeout); err != nil {
return nil, errors.Wrapf(err, "waiting for unix socket to be available: %s", sockPath)
}
trans := thrift.NewTSocketFromAddrTimeout(addr, timeout)
if err := trans.Open(); err != nil {
return nil, errors.Wrap(err, "opening socket transport")
}
return trans, nil
} | [
"func",
"Open",
"(",
"sockPath",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"thrift",
".",
"TSocket",
",",
"error",
")",
"{",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveUnixAddr",
"(",
"\"",
"\"",
",",
"sockPath",
")",
"\n",... | // Open opens the unix domain socket with the provided path and timeout,
// returning a TTransport. | [
"Open",
"opens",
"the",
"unix",
"domain",
"socket",
"with",
"the",
"provided",
"path",
"and",
"timeout",
"returning",
"a",
"TTransport",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/transport/transport.go#L17-L37 |
14,697 | kolide/osquery-go | client.go | NewClient | func NewClient(path string, timeout time.Duration) (*ExtensionManagerClient, error) {
trans, err := transport.Open(path, timeout)
if err != nil {
return nil, err
}
client := osquery.NewExtensionManagerClientFactory(
trans,
thrift.NewTBinaryProtocolFactoryDefault(),
)
return &ExtensionManagerClient{client, trans}, nil
} | go | func NewClient(path string, timeout time.Duration) (*ExtensionManagerClient, error) {
trans, err := transport.Open(path, timeout)
if err != nil {
return nil, err
}
client := osquery.NewExtensionManagerClientFactory(
trans,
thrift.NewTBinaryProtocolFactoryDefault(),
)
return &ExtensionManagerClient{client, trans}, nil
} | [
"func",
"NewClient",
"(",
"path",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"ExtensionManagerClient",
",",
"error",
")",
"{",
"trans",
",",
"err",
":=",
"transport",
".",
"Open",
"(",
"path",
",",
"timeout",
")",
"\n",
"if",
"er... | // NewClient creates a new client communicating to osquery over the socket at
// the provided path. If resolving the address or connecting to the socket
// fails, this function will error. | [
"NewClient",
"creates",
"a",
"new",
"client",
"communicating",
"to",
"osquery",
"over",
"the",
"socket",
"at",
"the",
"provided",
"path",
".",
"If",
"resolving",
"the",
"address",
"or",
"connecting",
"to",
"the",
"socket",
"fails",
"this",
"function",
"will",
... | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L34-L46 |
14,698 | kolide/osquery-go | client.go | Close | func (c *ExtensionManagerClient) Close() {
if c.transport != nil && c.transport.IsOpen() {
c.transport.Close()
}
} | go | func (c *ExtensionManagerClient) Close() {
if c.transport != nil && c.transport.IsOpen() {
c.transport.Close()
}
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Close",
"(",
")",
"{",
"if",
"c",
".",
"transport",
"!=",
"nil",
"&&",
"c",
".",
"transport",
".",
"IsOpen",
"(",
")",
"{",
"c",
".",
"transport",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}"... | // Close should be called to close the transport when use of the client is
// completed. | [
"Close",
"should",
"be",
"called",
"to",
"close",
"the",
"transport",
"when",
"use",
"of",
"the",
"client",
"is",
"completed",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L50-L54 |
14,699 | kolide/osquery-go | client.go | Ping | func (c *ExtensionManagerClient) Ping() (*osquery.ExtensionStatus, error) {
return c.Client.Ping(context.Background())
} | go | func (c *ExtensionManagerClient) Ping() (*osquery.ExtensionStatus, error) {
return c.Client.Ping(context.Background())
} | [
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Ping",
"(",
")",
"(",
"*",
"osquery",
".",
"ExtensionStatus",
",",
"error",
")",
"{",
"return",
"c",
".",
"Client",
".",
"Ping",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}"
] | // Ping requests metadata from the extension manager. | [
"Ping",
"requests",
"metadata",
"from",
"the",
"extension",
"manager",
"."
] | be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0 | https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L57-L59 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.