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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
19,700
|
awalterschulze/goderive
|
derive/fields.go
|
Private
|
func (f *Field) Private() bool {
return strings.ToLower(f.name[0:1]) == f.name[0:1]
}
|
go
|
func (f *Field) Private() bool {
return strings.ToLower(f.name[0:1]) == f.name[0:1]
}
|
[
"func",
"(",
"f",
"*",
"Field",
")",
"Private",
"(",
")",
"bool",
"{",
"return",
"strings",
".",
"ToLower",
"(",
"f",
".",
"name",
"[",
"0",
":",
"1",
"]",
")",
"==",
"f",
".",
"name",
"[",
"0",
":",
"1",
"]",
"\n",
"}"
] |
// Private whether the field is private
|
[
"Private",
"whether",
"the",
"field",
"is",
"private"
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/fields.go#L50-L52
|
19,701
|
awalterschulze/goderive
|
derive/fields.go
|
Fields
|
func Fields(typesMap TypesMap, typ *types.Struct, external bool) *Named {
numFields := typ.NumFields()
n := &Named{
Fields: make([]*Field, numFields),
}
for i := 0; i < numFields; i++ {
field := typ.Field(i)
fieldType := field.Type()
fieldName := field.Name()
n.Fields[i] = &Field{
name: fieldName,
external: external,
Type: fieldType,
typeStr: func() string {
return typesMap.TypeString(fieldType)
},
}
if n.Fields[i].Private() {
if external {
n.Reflect = true
}
}
}
return n
}
|
go
|
func Fields(typesMap TypesMap, typ *types.Struct, external bool) *Named {
numFields := typ.NumFields()
n := &Named{
Fields: make([]*Field, numFields),
}
for i := 0; i < numFields; i++ {
field := typ.Field(i)
fieldType := field.Type()
fieldName := field.Name()
n.Fields[i] = &Field{
name: fieldName,
external: external,
Type: fieldType,
typeStr: func() string {
return typesMap.TypeString(fieldType)
},
}
if n.Fields[i].Private() {
if external {
n.Reflect = true
}
}
}
return n
}
|
[
"func",
"Fields",
"(",
"typesMap",
"TypesMap",
",",
"typ",
"*",
"types",
".",
"Struct",
",",
"external",
"bool",
")",
"*",
"Named",
"{",
"numFields",
":=",
"typ",
".",
"NumFields",
"(",
")",
"\n",
"n",
":=",
"&",
"Named",
"{",
"Fields",
":",
"make",
"(",
"[",
"]",
"*",
"Field",
",",
"numFields",
")",
",",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numFields",
";",
"i",
"++",
"{",
"field",
":=",
"typ",
".",
"Field",
"(",
"i",
")",
"\n",
"fieldType",
":=",
"field",
".",
"Type",
"(",
")",
"\n",
"fieldName",
":=",
"field",
".",
"Name",
"(",
")",
"\n",
"n",
".",
"Fields",
"[",
"i",
"]",
"=",
"&",
"Field",
"{",
"name",
":",
"fieldName",
",",
"external",
":",
"external",
",",
"Type",
":",
"fieldType",
",",
"typeStr",
":",
"func",
"(",
")",
"string",
"{",
"return",
"typesMap",
".",
"TypeString",
"(",
"fieldType",
")",
"\n",
"}",
",",
"}",
"\n",
"if",
"n",
".",
"Fields",
"[",
"i",
"]",
".",
"Private",
"(",
")",
"{",
"if",
"external",
"{",
"n",
".",
"Reflect",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}"
] |
// Fields returns a new Named object containing a list of Fields for a given input struct.
|
[
"Fields",
"returns",
"a",
"new",
"Named",
"object",
"containing",
"a",
"list",
"of",
"Fields",
"for",
"a",
"given",
"input",
"struct",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/fields.go#L55-L79
|
19,702
|
awalterschulze/goderive
|
example/plugin/sort/derived.gen.go
|
deriveSort
|
func deriveSort(list []*MyStruct) []*MyStruct {
sort.Slice(list, func(i, j int) bool { return deriveCompare_(list[i], list[j]) < 0 })
return list
}
|
go
|
func deriveSort(list []*MyStruct) []*MyStruct {
sort.Slice(list, func(i, j int) bool { return deriveCompare_(list[i], list[j]) < 0 })
return list
}
|
[
"func",
"deriveSort",
"(",
"list",
"[",
"]",
"*",
"MyStruct",
")",
"[",
"]",
"*",
"MyStruct",
"{",
"sort",
".",
"Slice",
"(",
"list",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"deriveCompare_",
"(",
"list",
"[",
"i",
"]",
",",
"list",
"[",
"j",
"]",
")",
"<",
"0",
"}",
")",
"\n",
"return",
"list",
"\n",
"}"
] |
// deriveSort sorts the slice inplace and also returns it.
|
[
"deriveSort",
"sorts",
"the",
"slice",
"inplace",
"and",
"also",
"returns",
"it",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/sort/derived.gen.go#L39-L42
|
19,703
|
awalterschulze/goderive
|
derive/types.go
|
IsError
|
func IsError(t types.Type) bool {
typ, ok := t.(*types.Named)
if !ok {
return false
}
if typ.Obj().Name() == "error" {
return true
}
for i := 0; i < typ.NumMethods(); i++ {
meth := typ.Method(i)
if meth.Name() != "Error" {
continue
}
sig, ok := meth.Type().(*types.Signature)
if !ok {
// impossible, but lets check anyway
continue
}
if sig.Params().Len() != 0 {
continue
}
res := sig.Results()
if res.Len() != 1 {
continue
}
b, ok := res.At(0).Type().(*types.Basic)
if !ok {
continue
}
if b.Kind() != types.String {
continue
}
return true
}
return false
}
|
go
|
func IsError(t types.Type) bool {
typ, ok := t.(*types.Named)
if !ok {
return false
}
if typ.Obj().Name() == "error" {
return true
}
for i := 0; i < typ.NumMethods(); i++ {
meth := typ.Method(i)
if meth.Name() != "Error" {
continue
}
sig, ok := meth.Type().(*types.Signature)
if !ok {
// impossible, but lets check anyway
continue
}
if sig.Params().Len() != 0 {
continue
}
res := sig.Results()
if res.Len() != 1 {
continue
}
b, ok := res.At(0).Type().(*types.Basic)
if !ok {
continue
}
if b.Kind() != types.String {
continue
}
return true
}
return false
}
|
[
"func",
"IsError",
"(",
"t",
"types",
".",
"Type",
")",
"bool",
"{",
"typ",
",",
"ok",
":=",
"t",
".",
"(",
"*",
"types",
".",
"Named",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"typ",
".",
"Obj",
"(",
")",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"typ",
".",
"NumMethods",
"(",
")",
";",
"i",
"++",
"{",
"meth",
":=",
"typ",
".",
"Method",
"(",
"i",
")",
"\n",
"if",
"meth",
".",
"Name",
"(",
")",
"!=",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"sig",
",",
"ok",
":=",
"meth",
".",
"Type",
"(",
")",
".",
"(",
"*",
"types",
".",
"Signature",
")",
"\n",
"if",
"!",
"ok",
"{",
"// impossible, but lets check anyway",
"continue",
"\n",
"}",
"\n",
"if",
"sig",
".",
"Params",
"(",
")",
".",
"Len",
"(",
")",
"!=",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"res",
":=",
"sig",
".",
"Results",
"(",
")",
"\n",
"if",
"res",
".",
"Len",
"(",
")",
"!=",
"1",
"{",
"continue",
"\n",
"}",
"\n",
"b",
",",
"ok",
":=",
"res",
".",
"At",
"(",
"0",
")",
".",
"Type",
"(",
")",
".",
"(",
"*",
"types",
".",
"Basic",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"b",
".",
"Kind",
"(",
")",
"!=",
"types",
".",
"String",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// IsError returns whether a type implements the Error interface.
|
[
"IsError",
"returns",
"whether",
"a",
"type",
"implements",
"the",
"Error",
"interface",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/types.go#L20-L55
|
19,704
|
awalterschulze/goderive
|
derive/types.go
|
Zero
|
func Zero(typ types.Type) string {
switch t := typ.(type) {
case *types.Basic:
switch t.Kind() {
case types.String:
return `""`
case types.Bool:
return "false"
default:
return "0"
}
}
return "nil"
}
|
go
|
func Zero(typ types.Type) string {
switch t := typ.(type) {
case *types.Basic:
switch t.Kind() {
case types.String:
return `""`
case types.Bool:
return "false"
default:
return "0"
}
}
return "nil"
}
|
[
"func",
"Zero",
"(",
"typ",
"types",
".",
"Type",
")",
"string",
"{",
"switch",
"t",
":=",
"typ",
".",
"(",
"type",
")",
"{",
"case",
"*",
"types",
".",
"Basic",
":",
"switch",
"t",
".",
"Kind",
"(",
")",
"{",
"case",
"types",
".",
"String",
":",
"return",
"`\"\"`",
"\n",
"case",
"types",
".",
"Bool",
":",
"return",
"\"",
"\"",
"\n",
"default",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// Zero returns the zero value as a string, for a given type.
|
[
"Zero",
"returns",
"the",
"zero",
"value",
"as",
"a",
"string",
"for",
"a",
"given",
"type",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/types.go#L58-L71
|
19,705
|
awalterschulze/goderive
|
example/plugin/traverse/derived.gen.go
|
deriveTraverse
|
func deriveTraverse(f func(string) (int, error), list []string) ([]int, error) {
out := make([]int, len(list))
var err error
for i, elem := range list {
out[i], err = f(elem)
if err != nil {
return nil, err
}
}
return out, nil
}
|
go
|
func deriveTraverse(f func(string) (int, error), list []string) ([]int, error) {
out := make([]int, len(list))
var err error
for i, elem := range list {
out[i], err = f(elem)
if err != nil {
return nil, err
}
}
return out, nil
}
|
[
"func",
"deriveTraverse",
"(",
"f",
"func",
"(",
"string",
")",
"(",
"int",
",",
"error",
")",
",",
"list",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"int",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"len",
"(",
"list",
")",
")",
"\n",
"var",
"err",
"error",
"\n",
"for",
"i",
",",
"elem",
":=",
"range",
"list",
"{",
"out",
"[",
"i",
"]",
",",
"err",
"=",
"f",
"(",
"elem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// deriveTraverse returns a list where each element of the input list has been morphed by the input function or an error.
|
[
"deriveTraverse",
"returns",
"a",
"list",
"where",
"each",
"element",
"of",
"the",
"input",
"list",
"has",
"been",
"morphed",
"by",
"the",
"input",
"function",
"or",
"an",
"error",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/traverse/derived.gen.go#L6-L16
|
19,706
|
awalterschulze/goderive
|
example/pluginprefix/derived.gen.go
|
eq
|
func eq(this, that *MyStruct) bool {
return (this == nil && that == nil) ||
this != nil && that != nil &&
this.Int64 == that.Int64 &&
((this.StringPtr == nil && that.StringPtr == nil) || (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
}
|
go
|
func eq(this, that *MyStruct) bool {
return (this == nil && that == nil) ||
this != nil && that != nil &&
this.Int64 == that.Int64 &&
((this.StringPtr == nil && that.StringPtr == nil) || (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
}
|
[
"func",
"eq",
"(",
"this",
",",
"that",
"*",
"MyStruct",
")",
"bool",
"{",
"return",
"(",
"this",
"==",
"nil",
"&&",
"that",
"==",
"nil",
")",
"||",
"this",
"!=",
"nil",
"&&",
"that",
"!=",
"nil",
"&&",
"this",
".",
"Int64",
"==",
"that",
".",
"Int64",
"&&",
"(",
"(",
"this",
".",
"StringPtr",
"==",
"nil",
"&&",
"that",
".",
"StringPtr",
"==",
"nil",
")",
"||",
"(",
"this",
".",
"StringPtr",
"!=",
"nil",
"&&",
"that",
".",
"StringPtr",
"!=",
"nil",
"&&",
"*",
"(",
"this",
".",
"StringPtr",
")",
"==",
"*",
"(",
"that",
".",
"StringPtr",
")",
")",
")",
"\n",
"}"
] |
// eq returns whether this and that are equal.
|
[
"eq",
"returns",
"whether",
"this",
"and",
"that",
"are",
"equal",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/pluginprefix/derived.gen.go#L6-L11
|
19,707
|
awalterschulze/goderive
|
plugin/compose/compose.go
|
New
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
fmap: deps["fmap"],
join: deps["join"],
}
}
|
go
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
fmap: deps["fmap"],
join: deps["join"],
}
}
|
[
"func",
"New",
"(",
"typesMap",
"derive",
".",
"TypesMap",
",",
"p",
"derive",
".",
"Printer",
",",
"deps",
"map",
"[",
"string",
"]",
"derive",
".",
"Dependency",
")",
"derive",
".",
"Generator",
"{",
"return",
"&",
"gen",
"{",
"TypesMap",
":",
"typesMap",
",",
"printer",
":",
"p",
",",
"fmap",
":",
"deps",
"[",
"\"",
"\"",
"]",
",",
"join",
":",
"deps",
"[",
"\"",
"\"",
"]",
",",
"}",
"\n",
"}"
] |
// New is a constructor for the compose code generator.
// This generator should be reconstructed for each package.
|
[
"New",
"is",
"a",
"constructor",
"for",
"the",
"compose",
"code",
"generator",
".",
"This",
"generator",
"should",
"be",
"reconstructed",
"for",
"each",
"package",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/plugin/compose/compose.go#L44-L51
|
19,708
|
awalterschulze/goderive
|
example/plugin/mem/derived.gen.go
|
deriveMem
|
func deriveMem(f func(version int, id int) (User, error)) func(version int, id int) (User, error) {
type input struct {
Param0 int
Param1 int
}
type output struct {
Res0 User
Res1 error
}
m := make(map[input]output)
return func(param0 int, param1 int) (User, error) {
in := input{param0, param1}
if o, ok := m[in]; ok {
return o.Res0, o.Res1
}
res0, res1 := f(param0, param1)
m[in] = output{res0, res1}
return res0, res1
}
}
|
go
|
func deriveMem(f func(version int, id int) (User, error)) func(version int, id int) (User, error) {
type input struct {
Param0 int
Param1 int
}
type output struct {
Res0 User
Res1 error
}
m := make(map[input]output)
return func(param0 int, param1 int) (User, error) {
in := input{param0, param1}
if o, ok := m[in]; ok {
return o.Res0, o.Res1
}
res0, res1 := f(param0, param1)
m[in] = output{res0, res1}
return res0, res1
}
}
|
[
"func",
"deriveMem",
"(",
"f",
"func",
"(",
"version",
"int",
",",
"id",
"int",
")",
"(",
"User",
",",
"error",
")",
")",
"func",
"(",
"version",
"int",
",",
"id",
"int",
")",
"(",
"User",
",",
"error",
")",
"{",
"type",
"input",
"struct",
"{",
"Param0",
"int",
"\n",
"Param1",
"int",
"\n",
"}",
"\n",
"type",
"output",
"struct",
"{",
"Res0",
"User",
"\n",
"Res1",
"error",
"\n",
"}",
"\n",
"m",
":=",
"make",
"(",
"map",
"[",
"input",
"]",
"output",
")",
"\n",
"return",
"func",
"(",
"param0",
"int",
",",
"param1",
"int",
")",
"(",
"User",
",",
"error",
")",
"{",
"in",
":=",
"input",
"{",
"param0",
",",
"param1",
"}",
"\n",
"if",
"o",
",",
"ok",
":=",
"m",
"[",
"in",
"]",
";",
"ok",
"{",
"return",
"o",
".",
"Res0",
",",
"o",
".",
"Res1",
"\n",
"}",
"\n",
"res0",
",",
"res1",
":=",
"f",
"(",
"param0",
",",
"param1",
")",
"\n",
"m",
"[",
"in",
"]",
"=",
"output",
"{",
"res0",
",",
"res1",
"}",
"\n",
"return",
"res0",
",",
"res1",
"\n",
"}",
"\n",
"}"
] |
// deriveMem returns a memoized version of the input function.
|
[
"deriveMem",
"returns",
"a",
"memoized",
"version",
"of",
"the",
"input",
"function",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/mem/derived.gen.go#L6-L25
|
19,709
|
awalterschulze/goderive
|
derive/generate.go
|
NewPlugins
|
func NewPlugins(ps []Plugin, autoname bool, dedup bool) Plugins {
sortPlugins(ps)
return &plugins{
plugins: ps,
autoname: autoname,
dedup: dedup,
}
}
|
go
|
func NewPlugins(ps []Plugin, autoname bool, dedup bool) Plugins {
sortPlugins(ps)
return &plugins{
plugins: ps,
autoname: autoname,
dedup: dedup,
}
}
|
[
"func",
"NewPlugins",
"(",
"ps",
"[",
"]",
"Plugin",
",",
"autoname",
"bool",
",",
"dedup",
"bool",
")",
"Plugins",
"{",
"sortPlugins",
"(",
"ps",
")",
"\n",
"return",
"&",
"plugins",
"{",
"plugins",
":",
"ps",
",",
"autoname",
":",
"autoname",
",",
"dedup",
":",
"dedup",
",",
"}",
"\n",
"}"
] |
// NewPlugins returns a collection of plugins that is ready to generate code.
|
[
"NewPlugins",
"returns",
"a",
"collection",
"of",
"plugins",
"that",
"is",
"ready",
"to",
"generate",
"code",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/generate.go#L49-L56
|
19,710
|
awalterschulze/goderive
|
example/plugin/keys/derived.gen.go
|
deriveKeys
|
func deriveKeys(m map[string]int) []string {
keys := make([]string, 0, len(m))
for key := range m {
keys = append(keys, key)
}
return keys
}
|
go
|
func deriveKeys(m map[string]int) []string {
keys := make([]string, 0, len(m))
for key := range m {
keys = append(keys, key)
}
return keys
}
|
[
"func",
"deriveKeys",
"(",
"m",
"map",
"[",
"string",
"]",
"int",
")",
"[",
"]",
"string",
"{",
"keys",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
")",
")",
"\n",
"for",
"key",
":=",
"range",
"m",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"return",
"keys",
"\n",
"}"
] |
// deriveKeys returns the keys of the input map as a slice.
|
[
"deriveKeys",
"returns",
"the",
"keys",
"of",
"the",
"input",
"map",
"as",
"a",
"slice",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/keys/derived.gen.go#L16-L22
|
19,711
|
awalterschulze/goderive
|
example/plugin/min/derived.gen.go
|
deriveMins
|
func deriveMins(list []boat, def boat) boat {
if len(list) == 0 {
return def
}
m := list[0]
list = list[1:]
for i, v := range list {
if deriveCompare(v, m) < 0 {
m = list[i]
}
}
return m
}
|
go
|
func deriveMins(list []boat, def boat) boat {
if len(list) == 0 {
return def
}
m := list[0]
list = list[1:]
for i, v := range list {
if deriveCompare(v, m) < 0 {
m = list[i]
}
}
return m
}
|
[
"func",
"deriveMins",
"(",
"list",
"[",
"]",
"boat",
",",
"def",
"boat",
")",
"boat",
"{",
"if",
"len",
"(",
"list",
")",
"==",
"0",
"{",
"return",
"def",
"\n",
"}",
"\n",
"m",
":=",
"list",
"[",
"0",
"]",
"\n",
"list",
"=",
"list",
"[",
"1",
":",
"]",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"list",
"{",
"if",
"deriveCompare",
"(",
"v",
",",
"m",
")",
"<",
"0",
"{",
"m",
"=",
"list",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"m",
"\n",
"}"
] |
// deriveMins returns the minimum value from the list, or the default value if the list is empty.
|
[
"deriveMins",
"returns",
"the",
"minimum",
"value",
"from",
"the",
"list",
"or",
"the",
"default",
"value",
"if",
"the",
"list",
"is",
"empty",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/min/derived.gen.go#L28-L40
|
19,712
|
awalterschulze/goderive
|
plugin/equal/equal.go
|
New
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
bytesPkg: p.NewImport("bytes", "bytes"),
reflectPkg: p.NewImport("reflect", "reflect"),
unsafePkg: p.NewImport("unsafe", "unsafe"),
}
}
|
go
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
bytesPkg: p.NewImport("bytes", "bytes"),
reflectPkg: p.NewImport("reflect", "reflect"),
unsafePkg: p.NewImport("unsafe", "unsafe"),
}
}
|
[
"func",
"New",
"(",
"typesMap",
"derive",
".",
"TypesMap",
",",
"p",
"derive",
".",
"Printer",
",",
"deps",
"map",
"[",
"string",
"]",
"derive",
".",
"Dependency",
")",
"derive",
".",
"Generator",
"{",
"return",
"&",
"gen",
"{",
"TypesMap",
":",
"typesMap",
",",
"printer",
":",
"p",
",",
"bytesPkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"reflectPkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"unsafePkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"}",
"\n",
"}"
] |
// New is a constructor for the equal code generator.
// This generator should be reconstructed for each package.
|
[
"New",
"is",
"a",
"constructor",
"for",
"the",
"equal",
"code",
"generator",
".",
"This",
"generator",
"should",
"be",
"reconstructed",
"for",
"each",
"package",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/plugin/equal/equal.go#L86-L94
|
19,713
|
awalterschulze/goderive
|
example/plugin/do/derived.gen.go
|
deriveDo
|
func deriveDo(f0 func() (string, error), f1 func() (int, error)) (string, int, error) {
errChan := make(chan error)
var v0 string
go func() {
var v0err error
v0, v0err = f0()
errChan <- v0err
}()
var v1 int
go func() {
var v1err error
v1, v1err = f1()
errChan <- v1err
}()
var err error
for i := 0; i < 2; i++ {
errc := <-errChan
if errc != nil {
if err == nil {
err = errc
}
}
}
return v0, v1, err
}
|
go
|
func deriveDo(f0 func() (string, error), f1 func() (int, error)) (string, int, error) {
errChan := make(chan error)
var v0 string
go func() {
var v0err error
v0, v0err = f0()
errChan <- v0err
}()
var v1 int
go func() {
var v1err error
v1, v1err = f1()
errChan <- v1err
}()
var err error
for i := 0; i < 2; i++ {
errc := <-errChan
if errc != nil {
if err == nil {
err = errc
}
}
}
return v0, v1, err
}
|
[
"func",
"deriveDo",
"(",
"f0",
"func",
"(",
")",
"(",
"string",
",",
"error",
")",
",",
"f1",
"func",
"(",
")",
"(",
"int",
",",
"error",
")",
")",
"(",
"string",
",",
"int",
",",
"error",
")",
"{",
"errChan",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"var",
"v0",
"string",
"\n",
"go",
"func",
"(",
")",
"{",
"var",
"v0err",
"error",
"\n",
"v0",
",",
"v0err",
"=",
"f0",
"(",
")",
"\n",
"errChan",
"<-",
"v0err",
"\n",
"}",
"(",
")",
"\n",
"var",
"v1",
"int",
"\n",
"go",
"func",
"(",
")",
"{",
"var",
"v1err",
"error",
"\n",
"v1",
",",
"v1err",
"=",
"f1",
"(",
")",
"\n",
"errChan",
"<-",
"v1err",
"\n",
"}",
"(",
")",
"\n",
"var",
"err",
"error",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"2",
";",
"i",
"++",
"{",
"errc",
":=",
"<-",
"errChan",
"\n",
"if",
"errc",
"!=",
"nil",
"{",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"errc",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"v0",
",",
"v1",
",",
"err",
"\n",
"}"
] |
// deriveDo concurrently executes the input functions f0 and f1 and when all functions are finished the first error, if any, and results are returned.
|
[
"deriveDo",
"concurrently",
"executes",
"the",
"input",
"functions",
"f0",
"and",
"f1",
"and",
"when",
"all",
"functions",
"are",
"finished",
"the",
"first",
"error",
"if",
"any",
"and",
"results",
"are",
"returned",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/do/derived.gen.go#L6-L30
|
19,714
|
awalterschulze/goderive
|
example/plugin/unique/derived.gen.go
|
deriveUnique
|
func deriveUnique(list []*Visitor) []*Visitor {
if len(list) == 0 {
return nil
}
table := make(map[uint64][]int)
u := 0
for i := 0; i < len(list); i++ {
contains := false
hash := deriveHash(list[i])
indexes := table[hash]
for _, index := range indexes {
if deriveEqual(list[index], list[i]) {
contains = true
break
}
}
if contains {
continue
}
if i != u {
list[u] = list[i]
}
table[hash] = append(table[hash], u)
u++
}
return list[:u]
}
|
go
|
func deriveUnique(list []*Visitor) []*Visitor {
if len(list) == 0 {
return nil
}
table := make(map[uint64][]int)
u := 0
for i := 0; i < len(list); i++ {
contains := false
hash := deriveHash(list[i])
indexes := table[hash]
for _, index := range indexes {
if deriveEqual(list[index], list[i]) {
contains = true
break
}
}
if contains {
continue
}
if i != u {
list[u] = list[i]
}
table[hash] = append(table[hash], u)
u++
}
return list[:u]
}
|
[
"func",
"deriveUnique",
"(",
"list",
"[",
"]",
"*",
"Visitor",
")",
"[",
"]",
"*",
"Visitor",
"{",
"if",
"len",
"(",
"list",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"table",
":=",
"make",
"(",
"map",
"[",
"uint64",
"]",
"[",
"]",
"int",
")",
"\n",
"u",
":=",
"0",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"list",
")",
";",
"i",
"++",
"{",
"contains",
":=",
"false",
"\n",
"hash",
":=",
"deriveHash",
"(",
"list",
"[",
"i",
"]",
")",
"\n",
"indexes",
":=",
"table",
"[",
"hash",
"]",
"\n",
"for",
"_",
",",
"index",
":=",
"range",
"indexes",
"{",
"if",
"deriveEqual",
"(",
"list",
"[",
"index",
"]",
",",
"list",
"[",
"i",
"]",
")",
"{",
"contains",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"contains",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"i",
"!=",
"u",
"{",
"list",
"[",
"u",
"]",
"=",
"list",
"[",
"i",
"]",
"\n",
"}",
"\n",
"table",
"[",
"hash",
"]",
"=",
"append",
"(",
"table",
"[",
"hash",
"]",
",",
"u",
")",
"\n",
"u",
"++",
"\n",
"}",
"\n",
"return",
"list",
"[",
":",
"u",
"]",
"\n",
"}"
] |
// deriveUnique returns a list containing only the unique items from the input list.
// It does this by reusing the input list.
|
[
"deriveUnique",
"returns",
"a",
"list",
"containing",
"only",
"the",
"unique",
"items",
"from",
"the",
"input",
"list",
".",
"It",
"does",
"this",
"by",
"reusing",
"the",
"input",
"list",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/unique/derived.gen.go#L7-L33
|
19,715
|
awalterschulze/goderive
|
example/plugin/unique/derived.gen.go
|
deriveHash_s
|
func deriveHash_s(object string) uint64 {
var h uint64
for _, c := range object {
h = 31*h + uint64(c)
}
return h
}
|
go
|
func deriveHash_s(object string) uint64 {
var h uint64
for _, c := range object {
h = 31*h + uint64(c)
}
return h
}
|
[
"func",
"deriveHash_s",
"(",
"object",
"string",
")",
"uint64",
"{",
"var",
"h",
"uint64",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"object",
"{",
"h",
"=",
"31",
"*",
"h",
"+",
"uint64",
"(",
"c",
")",
"\n",
"}",
"\n",
"return",
"h",
"\n",
"}"
] |
// deriveHash_s returns the hash of the object.
|
[
"deriveHash_s",
"returns",
"the",
"hash",
"of",
"the",
"object",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/unique/derived.gen.go#L63-L69
|
19,716
|
awalterschulze/goderive
|
example/plugin/compose/derived.gen.go
|
deriveCompose
|
func deriveCompose(f0 func(string) (*http.Response, error), f1 func(*http.Response) ([]byte, error), f2 func([]byte) (*user, error), f3 func(*user) (*newUser, error), f4 func(interface{}) ([]byte, error), f5 func([]byte) (*http.Response, error)) func(string) (*http.Response, error) {
return func(v_0_0 string) (*http.Response, error) {
v_1_0, err0 := f0(v_0_0)
if err0 != nil {
return nil, err0
}
v_2_0, err1 := f1(v_1_0)
if err1 != nil {
return nil, err1
}
v_3_0, err2 := f2(v_2_0)
if err2 != nil {
return nil, err2
}
v_4_0, err3 := f3(v_3_0)
if err3 != nil {
return nil, err3
}
v_5_0, err4 := f4(v_4_0)
if err4 != nil {
return nil, err4
}
v_6_0, err5 := f5(v_5_0)
if err5 != nil {
return nil, err5
}
return v_6_0, nil
}
}
|
go
|
func deriveCompose(f0 func(string) (*http.Response, error), f1 func(*http.Response) ([]byte, error), f2 func([]byte) (*user, error), f3 func(*user) (*newUser, error), f4 func(interface{}) ([]byte, error), f5 func([]byte) (*http.Response, error)) func(string) (*http.Response, error) {
return func(v_0_0 string) (*http.Response, error) {
v_1_0, err0 := f0(v_0_0)
if err0 != nil {
return nil, err0
}
v_2_0, err1 := f1(v_1_0)
if err1 != nil {
return nil, err1
}
v_3_0, err2 := f2(v_2_0)
if err2 != nil {
return nil, err2
}
v_4_0, err3 := f3(v_3_0)
if err3 != nil {
return nil, err3
}
v_5_0, err4 := f4(v_4_0)
if err4 != nil {
return nil, err4
}
v_6_0, err5 := f5(v_5_0)
if err5 != nil {
return nil, err5
}
return v_6_0, nil
}
}
|
[
"func",
"deriveCompose",
"(",
"f0",
"func",
"(",
"string",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
",",
"f1",
"func",
"(",
"*",
"http",
".",
"Response",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
",",
"f2",
"func",
"(",
"[",
"]",
"byte",
")",
"(",
"*",
"user",
",",
"error",
")",
",",
"f3",
"func",
"(",
"*",
"user",
")",
"(",
"*",
"newUser",
",",
"error",
")",
",",
"f4",
"func",
"(",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
",",
"f5",
"func",
"(",
"[",
"]",
"byte",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
")",
"func",
"(",
"string",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"func",
"(",
"v_0_0",
"string",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"v_1_0",
",",
"err0",
":=",
"f0",
"(",
"v_0_0",
")",
"\n",
"if",
"err0",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err0",
"\n",
"}",
"\n",
"v_2_0",
",",
"err1",
":=",
"f1",
"(",
"v_1_0",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err1",
"\n",
"}",
"\n",
"v_3_0",
",",
"err2",
":=",
"f2",
"(",
"v_2_0",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err2",
"\n",
"}",
"\n",
"v_4_0",
",",
"err3",
":=",
"f3",
"(",
"v_3_0",
")",
"\n",
"if",
"err3",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err3",
"\n",
"}",
"\n",
"v_5_0",
",",
"err4",
":=",
"f4",
"(",
"v_4_0",
")",
"\n",
"if",
"err4",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err4",
"\n",
"}",
"\n",
"v_6_0",
",",
"err5",
":=",
"f5",
"(",
"v_5_0",
")",
"\n",
"if",
"err5",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err5",
"\n",
"}",
"\n",
"return",
"v_6_0",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// deriveCompose composes functions f0, f1, f2, f3, f4 and f5 into one function, that takes the parameters from f0 and returns the results from f5.
|
[
"deriveCompose",
"composes",
"functions",
"f0",
"f1",
"f2",
"f3",
"f4",
"and",
"f5",
"into",
"one",
"function",
"that",
"takes",
"the",
"parameters",
"from",
"f0",
"and",
"returns",
"the",
"results",
"from",
"f5",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/compose/derived.gen.go#L10-L38
|
19,717
|
awalterschulze/goderive
|
derive/find.go
|
getInputTypes
|
func getInputTypes(pkgInfo *loader.PackageInfo, call *ast.CallExpr) []types.Type {
typs := make([]types.Type, len(call.Args))
for i, a := range call.Args {
typs[i] = pkgInfo.TypeOf(a)
}
return typs
}
|
go
|
func getInputTypes(pkgInfo *loader.PackageInfo, call *ast.CallExpr) []types.Type {
typs := make([]types.Type, len(call.Args))
for i, a := range call.Args {
typs[i] = pkgInfo.TypeOf(a)
}
return typs
}
|
[
"func",
"getInputTypes",
"(",
"pkgInfo",
"*",
"loader",
".",
"PackageInfo",
",",
"call",
"*",
"ast",
".",
"CallExpr",
")",
"[",
"]",
"types",
".",
"Type",
"{",
"typs",
":=",
"make",
"(",
"[",
"]",
"types",
".",
"Type",
",",
"len",
"(",
"call",
".",
"Args",
")",
")",
"\n",
"for",
"i",
",",
"a",
":=",
"range",
"call",
".",
"Args",
"{",
"typs",
"[",
"i",
"]",
"=",
"pkgInfo",
".",
"TypeOf",
"(",
"a",
")",
"\n",
"}",
"\n",
"return",
"typs",
"\n",
"}"
] |
// argTypes returns the argument types of a function call.
|
[
"argTypes",
"returns",
"the",
"argument",
"types",
"of",
"a",
"function",
"call",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/find.go#L132-L138
|
19,718
|
awalterschulze/goderive
|
derive/find.go
|
HasUndefined
|
func (c *call) HasUndefined() bool {
for i := range c.Args {
if c.Args[i] == nil {
return true
}
if basic, ok := c.Args[i].(*types.Basic); ok {
if basic.Kind() == types.Invalid {
return true
}
}
if strings.Index(c.Args[i].String(), "invalid type") >= 0 {
return true
}
}
return false
}
|
go
|
func (c *call) HasUndefined() bool {
for i := range c.Args {
if c.Args[i] == nil {
return true
}
if basic, ok := c.Args[i].(*types.Basic); ok {
if basic.Kind() == types.Invalid {
return true
}
}
if strings.Index(c.Args[i].String(), "invalid type") >= 0 {
return true
}
}
return false
}
|
[
"func",
"(",
"c",
"*",
"call",
")",
"HasUndefined",
"(",
")",
"bool",
"{",
"for",
"i",
":=",
"range",
"c",
".",
"Args",
"{",
"if",
"c",
".",
"Args",
"[",
"i",
"]",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"basic",
",",
"ok",
":=",
"c",
".",
"Args",
"[",
"i",
"]",
".",
"(",
"*",
"types",
".",
"Basic",
")",
";",
"ok",
"{",
"if",
"basic",
".",
"Kind",
"(",
")",
"==",
"types",
".",
"Invalid",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Index",
"(",
"c",
".",
"Args",
"[",
"i",
"]",
".",
"String",
"(",
")",
",",
"\"",
"\"",
")",
">=",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// HasUndefined returns whether the call has undefined arguments
|
[
"HasUndefined",
"returns",
"whether",
"the",
"call",
"has",
"undefined",
"arguments"
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/derive/find.go#L141-L156
|
19,719
|
awalterschulze/goderive
|
plugin/gostring/gostring.go
|
New
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
strconvPkg: p.NewImport("strconv", "strconv"),
bytesPkg: p.NewImport("bytes", "bytes"),
fmtPkg: p.NewImport("fmt", "fmt"),
}
}
|
go
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
strconvPkg: p.NewImport("strconv", "strconv"),
bytesPkg: p.NewImport("bytes", "bytes"),
fmtPkg: p.NewImport("fmt", "fmt"),
}
}
|
[
"func",
"New",
"(",
"typesMap",
"derive",
".",
"TypesMap",
",",
"p",
"derive",
".",
"Printer",
",",
"deps",
"map",
"[",
"string",
"]",
"derive",
".",
"Dependency",
")",
"derive",
".",
"Generator",
"{",
"return",
"&",
"gen",
"{",
"TypesMap",
":",
"typesMap",
",",
"printer",
":",
"p",
",",
"strconvPkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"bytesPkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"fmtPkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"}",
"\n",
"}"
] |
// New is a constructor for the gostring code generator.
// This generator should be reconstructed for each package.
|
[
"New",
"is",
"a",
"constructor",
"for",
"the",
"gostring",
"code",
"generator",
".",
"This",
"generator",
"should",
"be",
"reconstructed",
"for",
"each",
"package",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/plugin/gostring/gostring.go#L82-L90
|
19,720
|
awalterschulze/goderive
|
example/prefix/derived.gen.go
|
generateEqual
|
func generateEqual(this, that *MyStruct) bool {
return (this == nil && that == nil) ||
this != nil && that != nil &&
this.Int64 == that.Int64 &&
((this.StringPtr == nil && that.StringPtr == nil) || (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
}
|
go
|
func generateEqual(this, that *MyStruct) bool {
return (this == nil && that == nil) ||
this != nil && that != nil &&
this.Int64 == that.Int64 &&
((this.StringPtr == nil && that.StringPtr == nil) || (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
}
|
[
"func",
"generateEqual",
"(",
"this",
",",
"that",
"*",
"MyStruct",
")",
"bool",
"{",
"return",
"(",
"this",
"==",
"nil",
"&&",
"that",
"==",
"nil",
")",
"||",
"this",
"!=",
"nil",
"&&",
"that",
"!=",
"nil",
"&&",
"this",
".",
"Int64",
"==",
"that",
".",
"Int64",
"&&",
"(",
"(",
"this",
".",
"StringPtr",
"==",
"nil",
"&&",
"that",
".",
"StringPtr",
"==",
"nil",
")",
"||",
"(",
"this",
".",
"StringPtr",
"!=",
"nil",
"&&",
"that",
".",
"StringPtr",
"!=",
"nil",
"&&",
"*",
"(",
"this",
".",
"StringPtr",
")",
"==",
"*",
"(",
"that",
".",
"StringPtr",
")",
")",
")",
"\n",
"}"
] |
// generateEqual returns whether this and that are equal.
|
[
"generateEqual",
"returns",
"whether",
"this",
"and",
"that",
"are",
"equal",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/prefix/derived.gen.go#L6-L11
|
19,721
|
awalterschulze/goderive
|
example/plugin/toerror/derived.gen.go
|
deriveToError
|
func deriveToError(err error, f func(vers string) (major int, minor int, ok bool)) func(vers string) (int, int, error) {
return func(vers string) (int, int, error) {
out0, out1, success := f(vers)
if success {
return out0, out1, nil
}
return out0, out1, err
}
}
|
go
|
func deriveToError(err error, f func(vers string) (major int, minor int, ok bool)) func(vers string) (int, int, error) {
return func(vers string) (int, int, error) {
out0, out1, success := f(vers)
if success {
return out0, out1, nil
}
return out0, out1, err
}
}
|
[
"func",
"deriveToError",
"(",
"err",
"error",
",",
"f",
"func",
"(",
"vers",
"string",
")",
"(",
"major",
"int",
",",
"minor",
"int",
",",
"ok",
"bool",
")",
")",
"func",
"(",
"vers",
"string",
")",
"(",
"int",
",",
"int",
",",
"error",
")",
"{",
"return",
"func",
"(",
"vers",
"string",
")",
"(",
"int",
",",
"int",
",",
"error",
")",
"{",
"out0",
",",
"out1",
",",
"success",
":=",
"f",
"(",
"vers",
")",
"\n",
"if",
"success",
"{",
"return",
"out0",
",",
"out1",
",",
"nil",
"\n",
"}",
"\n",
"return",
"out0",
",",
"out1",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// deriveToError transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
|
[
"deriveToError",
"transforms",
"the",
"given",
"function",
"s",
"last",
"bool",
"type",
"into",
"an",
"error",
"type",
".",
"The",
"transformed",
"function",
"returns",
"the",
"given",
"error",
"when",
"the",
"result",
"of",
"the",
"given",
"function",
"is",
"false",
"otherwise",
"it",
"returns",
"nil",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/toerror/derived.gen.go#L6-L14
|
19,722
|
awalterschulze/goderive
|
example/plugin/toerror/derived.gen.go
|
deriveCompose
|
func deriveCompose(f0 func(string) (int, int, error), f1 func(int, int) (int, error)) func(string) (int, error) {
return func(v_0_0 string) (int, error) {
v_1_0, v_1_1, err0 := f0(v_0_0)
if err0 != nil {
return 0, err0
}
v_2_0, err1 := f1(v_1_0, v_1_1)
if err1 != nil {
return 0, err1
}
return v_2_0, nil
}
}
|
go
|
func deriveCompose(f0 func(string) (int, int, error), f1 func(int, int) (int, error)) func(string) (int, error) {
return func(v_0_0 string) (int, error) {
v_1_0, v_1_1, err0 := f0(v_0_0)
if err0 != nil {
return 0, err0
}
v_2_0, err1 := f1(v_1_0, v_1_1)
if err1 != nil {
return 0, err1
}
return v_2_0, nil
}
}
|
[
"func",
"deriveCompose",
"(",
"f0",
"func",
"(",
"string",
")",
"(",
"int",
",",
"int",
",",
"error",
")",
",",
"f1",
"func",
"(",
"int",
",",
"int",
")",
"(",
"int",
",",
"error",
")",
")",
"func",
"(",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"func",
"(",
"v_0_0",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"v_1_0",
",",
"v_1_1",
",",
"err0",
":=",
"f0",
"(",
"v_0_0",
")",
"\n",
"if",
"err0",
"!=",
"nil",
"{",
"return",
"0",
",",
"err0",
"\n",
"}",
"\n",
"v_2_0",
",",
"err1",
":=",
"f1",
"(",
"v_1_0",
",",
"v_1_1",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"{",
"return",
"0",
",",
"err1",
"\n",
"}",
"\n",
"return",
"v_2_0",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// deriveCompose composes functions f0 and f1 into one function, that takes the parameters from f0 and returns the results from f1.
|
[
"deriveCompose",
"composes",
"functions",
"f0",
"and",
"f1",
"into",
"one",
"function",
"that",
"takes",
"the",
"parameters",
"from",
"f0",
"and",
"returns",
"the",
"results",
"from",
"f1",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/toerror/derived.gen.go#L17-L29
|
19,723
|
awalterschulze/goderive
|
example/plugin/set/derived.gen.go
|
deriveSet
|
func deriveSet(list []int) map[int]struct{} {
set := make(map[int]struct{}, len(list))
for _, v := range list {
set[v] = struct{}{}
}
return set
}
|
go
|
func deriveSet(list []int) map[int]struct{} {
set := make(map[int]struct{}, len(list))
for _, v := range list {
set[v] = struct{}{}
}
return set
}
|
[
"func",
"deriveSet",
"(",
"list",
"[",
"]",
"int",
")",
"map",
"[",
"int",
"]",
"struct",
"{",
"}",
"{",
"set",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"struct",
"{",
"}",
",",
"len",
"(",
"list",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"list",
"{",
"set",
"[",
"v",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"return",
"set",
"\n",
"}"
] |
// deriveSet returns the input list as a map with the items of the list as the keys of the map.
|
[
"deriveSet",
"returns",
"the",
"input",
"list",
"as",
"a",
"map",
"with",
"the",
"items",
"of",
"the",
"list",
"as",
"the",
"keys",
"of",
"the",
"map",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/set/derived.gen.go#L6-L12
|
19,724
|
awalterschulze/goderive
|
example/plugin/hash/derived.gen.go
|
deriveHash_
|
func deriveHash_(object string) uint64 {
var h uint64
for _, c := range object {
h = 31*h + uint64(c)
}
return h
}
|
go
|
func deriveHash_(object string) uint64 {
var h uint64
for _, c := range object {
h = 31*h + uint64(c)
}
return h
}
|
[
"func",
"deriveHash_",
"(",
"object",
"string",
")",
"uint64",
"{",
"var",
"h",
"uint64",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"object",
"{",
"h",
"=",
"31",
"*",
"h",
"+",
"uint64",
"(",
"c",
")",
"\n",
"}",
"\n",
"return",
"h",
"\n",
"}"
] |
// deriveHash_ returns the hash of the object.
|
[
"deriveHash_",
"returns",
"the",
"hash",
"of",
"the",
"object",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/hash/derived.gen.go#L17-L23
|
19,725
|
awalterschulze/goderive
|
example/plugin/hash/derived.gen.go
|
deriveHash_1
|
func deriveHash_1(object []int) uint64 {
if object == nil {
return 0
}
h := uint64(17)
for i := 0; i < len(object); i++ {
h = 31*h + uint64(object[i])
}
return h
}
|
go
|
func deriveHash_1(object []int) uint64 {
if object == nil {
return 0
}
h := uint64(17)
for i := 0; i < len(object); i++ {
h = 31*h + uint64(object[i])
}
return h
}
|
[
"func",
"deriveHash_1",
"(",
"object",
"[",
"]",
"int",
")",
"uint64",
"{",
"if",
"object",
"==",
"nil",
"{",
"return",
"0",
"\n",
"}",
"\n",
"h",
":=",
"uint64",
"(",
"17",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"object",
")",
";",
"i",
"++",
"{",
"h",
"=",
"31",
"*",
"h",
"+",
"uint64",
"(",
"object",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"return",
"h",
"\n",
"}"
] |
// deriveHash_1 returns the hash of the object.
|
[
"deriveHash_1",
"returns",
"the",
"hash",
"of",
"the",
"object",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/hash/derived.gen.go#L26-L35
|
19,726
|
awalterschulze/goderive
|
example/plugin/union/derived.gen.go
|
deriveUnion
|
func deriveUnion(this, that []*Person) []*Person {
for i, v := range that {
if !deriveContains(this, v) {
this = append(this, that[i])
}
}
return this
}
|
go
|
func deriveUnion(this, that []*Person) []*Person {
for i, v := range that {
if !deriveContains(this, v) {
this = append(this, that[i])
}
}
return this
}
|
[
"func",
"deriveUnion",
"(",
"this",
",",
"that",
"[",
"]",
"*",
"Person",
")",
"[",
"]",
"*",
"Person",
"{",
"for",
"i",
",",
"v",
":=",
"range",
"that",
"{",
"if",
"!",
"deriveContains",
"(",
"this",
",",
"v",
")",
"{",
"this",
"=",
"append",
"(",
"this",
",",
"that",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"this",
"\n",
"}"
] |
// deriveUnion returns the union of the items of the two input lists.
// It does this by append items to the first list.
|
[
"deriveUnion",
"returns",
"the",
"union",
"of",
"the",
"items",
"of",
"the",
"two",
"input",
"lists",
".",
"It",
"does",
"this",
"by",
"append",
"items",
"to",
"the",
"first",
"list",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/union/derived.gen.go#L51-L58
|
19,727
|
awalterschulze/goderive
|
plugin/hash/hash.go
|
New
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
mathPkg: p.NewImport("math", "math"),
keys: deps["keys"],
sort: deps["sort"],
}
}
|
go
|
func New(typesMap derive.TypesMap, p derive.Printer, deps map[string]derive.Dependency) derive.Generator {
return &gen{
TypesMap: typesMap,
printer: p,
mathPkg: p.NewImport("math", "math"),
keys: deps["keys"],
sort: deps["sort"],
}
}
|
[
"func",
"New",
"(",
"typesMap",
"derive",
".",
"TypesMap",
",",
"p",
"derive",
".",
"Printer",
",",
"deps",
"map",
"[",
"string",
"]",
"derive",
".",
"Dependency",
")",
"derive",
".",
"Generator",
"{",
"return",
"&",
"gen",
"{",
"TypesMap",
":",
"typesMap",
",",
"printer",
":",
"p",
",",
"mathPkg",
":",
"p",
".",
"NewImport",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"keys",
":",
"deps",
"[",
"\"",
"\"",
"]",
",",
"sort",
":",
"deps",
"[",
"\"",
"\"",
"]",
",",
"}",
"\n",
"}"
] |
// New is a constructor for the hash code generator.
// This generator should be reconstructed for each package.
|
[
"New",
"is",
"a",
"constructor",
"for",
"the",
"hash",
"code",
"generator",
".",
"This",
"generator",
"should",
"be",
"reconstructed",
"for",
"each",
"package",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/plugin/hash/hash.go#L55-L63
|
19,728
|
awalterschulze/goderive
|
example/plugin/intersect/derived.gen.go
|
deriveIntersect
|
func deriveIntersect(this, that []int) []int {
intersect := make([]int, 0, deriveMin(len(this), len(that)))
for i, v := range this {
if deriveContains(that, v) {
intersect = append(intersect, this[i])
}
}
return intersect
}
|
go
|
func deriveIntersect(this, that []int) []int {
intersect := make([]int, 0, deriveMin(len(this), len(that)))
for i, v := range this {
if deriveContains(that, v) {
intersect = append(intersect, this[i])
}
}
return intersect
}
|
[
"func",
"deriveIntersect",
"(",
"this",
",",
"that",
"[",
"]",
"int",
")",
"[",
"]",
"int",
"{",
"intersect",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"0",
",",
"deriveMin",
"(",
"len",
"(",
"this",
")",
",",
"len",
"(",
"that",
")",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"this",
"{",
"if",
"deriveContains",
"(",
"that",
",",
"v",
")",
"{",
"intersect",
"=",
"append",
"(",
"intersect",
",",
"this",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"intersect",
"\n",
"}"
] |
// deriveIntersect returns the intersection of the two lists' values
// It assumes that the first list only contains unique items.
|
[
"deriveIntersect",
"returns",
"the",
"intersection",
"of",
"the",
"two",
"lists",
"values",
"It",
"assumes",
"that",
"the",
"first",
"list",
"only",
"contains",
"unique",
"items",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/intersect/derived.gen.go#L7-L15
|
19,729
|
awalterschulze/goderive
|
example/plugin/gostring/derived.gen.go
|
deriveGoString
|
func deriveGoString(this *MyStruct) string {
buf := bytes.NewBuffer(nil)
fmt.Fprintf(buf, "func() *gostring.MyStruct {\n")
if this == nil {
fmt.Fprintf(buf, "return nil\n")
} else {
fmt.Fprintf(buf, "this := &gostring.MyStruct{}\n")
fmt.Fprintf(buf, "this.Int64 = %#v\n", this.Int64)
if this.StringPtr != nil {
fmt.Fprintf(buf, "this.StringPtr = func (v string) *string { return &v }(%#v)\n", *this.StringPtr)
}
fmt.Fprintf(buf, "return this\n")
}
fmt.Fprintf(buf, "}()\n")
return buf.String()
}
|
go
|
func deriveGoString(this *MyStruct) string {
buf := bytes.NewBuffer(nil)
fmt.Fprintf(buf, "func() *gostring.MyStruct {\n")
if this == nil {
fmt.Fprintf(buf, "return nil\n")
} else {
fmt.Fprintf(buf, "this := &gostring.MyStruct{}\n")
fmt.Fprintf(buf, "this.Int64 = %#v\n", this.Int64)
if this.StringPtr != nil {
fmt.Fprintf(buf, "this.StringPtr = func (v string) *string { return &v }(%#v)\n", *this.StringPtr)
}
fmt.Fprintf(buf, "return this\n")
}
fmt.Fprintf(buf, "}()\n")
return buf.String()
}
|
[
"func",
"deriveGoString",
"(",
"this",
"*",
"MyStruct",
")",
"string",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"this",
"==",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
",",
"this",
".",
"Int64",
")",
"\n",
"if",
"this",
".",
"StringPtr",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
",",
"*",
"this",
".",
"StringPtr",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"buf",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] |
// deriveGoString returns a recursive representation of this as a valid go string.
|
[
"deriveGoString",
"returns",
"a",
"recursive",
"representation",
"of",
"this",
"as",
"a",
"valid",
"go",
"string",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/gostring/derived.gen.go#L11-L26
|
19,730
|
awalterschulze/goderive
|
example/plugin/pipeline/derived.gen.go
|
derivePipeline
|
func derivePipeline(f func(lines []string) <-chan string, g func(line string) <-chan int) func([]string) <-chan int {
return func(a []string) <-chan int {
b := f(a)
return deriveJoin(deriveFmap(g, b))
}
}
|
go
|
func derivePipeline(f func(lines []string) <-chan string, g func(line string) <-chan int) func([]string) <-chan int {
return func(a []string) <-chan int {
b := f(a)
return deriveJoin(deriveFmap(g, b))
}
}
|
[
"func",
"derivePipeline",
"(",
"f",
"func",
"(",
"lines",
"[",
"]",
"string",
")",
"<-",
"chan",
"string",
",",
"g",
"func",
"(",
"line",
"string",
")",
"<-",
"chan",
"int",
")",
"func",
"(",
"[",
"]",
"string",
")",
"<-",
"chan",
"int",
"{",
"return",
"func",
"(",
"a",
"[",
"]",
"string",
")",
"<-",
"chan",
"int",
"{",
"b",
":=",
"f",
"(",
"a",
")",
"\n",
"return",
"deriveJoin",
"(",
"deriveFmap",
"(",
"g",
",",
"b",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// derivePipeline composes f and g into a concurrent pipeline.
|
[
"derivePipeline",
"composes",
"f",
"and",
"g",
"into",
"a",
"concurrent",
"pipeline",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/pipeline/derived.gen.go#L10-L15
|
19,731
|
awalterschulze/goderive
|
example/plugin/pipeline/derived.gen.go
|
deriveJoin
|
func deriveJoin(in <-chan (<-chan int)) <-chan int {
out := make(chan int)
go func() {
wait := sync.WaitGroup{}
for c := range in {
wait.Add(1)
res := c
go func() {
for r := range res {
out <- r
}
wait.Done()
}()
}
wait.Wait()
close(out)
}()
return out
}
|
go
|
func deriveJoin(in <-chan (<-chan int)) <-chan int {
out := make(chan int)
go func() {
wait := sync.WaitGroup{}
for c := range in {
wait.Add(1)
res := c
go func() {
for r := range res {
out <- r
}
wait.Done()
}()
}
wait.Wait()
close(out)
}()
return out
}
|
[
"func",
"deriveJoin",
"(",
"in",
"<-",
"chan",
"(",
"<-",
"chan",
"int",
")",
")",
"<-",
"chan",
"int",
"{",
"out",
":=",
"make",
"(",
"chan",
"int",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"wait",
":=",
"sync",
".",
"WaitGroup",
"{",
"}",
"\n",
"for",
"c",
":=",
"range",
"in",
"{",
"wait",
".",
"Add",
"(",
"1",
")",
"\n",
"res",
":=",
"c",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"r",
":=",
"range",
"res",
"{",
"out",
"<-",
"r",
"\n",
"}",
"\n",
"wait",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"wait",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"out",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"out",
"\n",
"}"
] |
// deriveJoin listens on all channels resulting from the input channel and sends all their results on the output channel.
|
[
"deriveJoin",
"listens",
"on",
"all",
"channels",
"resulting",
"from",
"the",
"input",
"channel",
"and",
"sends",
"all",
"their",
"results",
"on",
"the",
"output",
"channel",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/pipeline/derived.gen.go#L18-L36
|
19,732
|
awalterschulze/goderive
|
example/plugin/pipeline/derived.gen.go
|
deriveFmap
|
func deriveFmap(f func(string) <-chan int, in <-chan string) <-chan (<-chan int) {
out := make(chan (<-chan int), cap(in))
go func() {
for a := range in {
b := f(a)
out <- b
}
close(out)
}()
return out
}
|
go
|
func deriveFmap(f func(string) <-chan int, in <-chan string) <-chan (<-chan int) {
out := make(chan (<-chan int), cap(in))
go func() {
for a := range in {
b := f(a)
out <- b
}
close(out)
}()
return out
}
|
[
"func",
"deriveFmap",
"(",
"f",
"func",
"(",
"string",
")",
"<-",
"chan",
"int",
",",
"in",
"<-",
"chan",
"string",
")",
"<-",
"chan",
"(",
"<-",
"chan",
"int",
")",
"{",
"out",
":=",
"make",
"(",
"chan",
"(",
"<-",
"chan",
"int",
")",
",",
"cap",
"(",
"in",
")",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"a",
":=",
"range",
"in",
"{",
"b",
":=",
"f",
"(",
"a",
")",
"\n",
"out",
"<-",
"b",
"\n",
"}",
"\n",
"close",
"(",
"out",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"out",
"\n",
"}"
] |
// deriveFmap returns an output channel where the items are the result of the input function being applied to the items on the input channel.
|
[
"deriveFmap",
"returns",
"an",
"output",
"channel",
"where",
"the",
"items",
"are",
"the",
"result",
"of",
"the",
"input",
"function",
"being",
"applied",
"to",
"the",
"items",
"on",
"the",
"input",
"channel",
"."
] |
71608c676057f3512b43cbd61d645b0dc6bcfc20
|
https://github.com/awalterschulze/goderive/blob/71608c676057f3512b43cbd61d645b0dc6bcfc20/example/plugin/pipeline/derived.gen.go#L39-L49
|
19,733
|
go-zoo/bone
|
mux.go
|
Register
|
func (m *Mux) Register(method string, path string, handler http.Handler) *Route {
return m.register(method, path, handler)
}
|
go
|
func (m *Mux) Register(method string, path string, handler http.Handler) *Route {
return m.register(method, path, handler)
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"Register",
"(",
"method",
"string",
",",
"path",
"string",
",",
"handler",
"http",
".",
"Handler",
")",
"*",
"Route",
"{",
"return",
"m",
".",
"register",
"(",
"method",
",",
"path",
",",
"handler",
")",
"\n",
"}"
] |
// Register the route in the router
|
[
"Register",
"the",
"route",
"in",
"the",
"router"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/mux.go#L18-L20
|
19,734
|
go-zoo/bone
|
mux.go
|
GetFunc
|
func (m *Mux) GetFunc(path string, handler http.HandlerFunc) *Route {
return m.register("GET", path, handler)
}
|
go
|
func (m *Mux) GetFunc(path string, handler http.HandlerFunc) *Route {
return m.register("GET", path, handler)
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"GetFunc",
"(",
"path",
"string",
",",
"handler",
"http",
".",
"HandlerFunc",
")",
"*",
"Route",
"{",
"return",
"m",
".",
"register",
"(",
"\"",
"\"",
",",
"path",
",",
"handler",
")",
"\n",
"}"
] |
// GetFunc add a new route to the Mux with the Get method
|
[
"GetFunc",
"add",
"a",
"new",
"route",
"to",
"the",
"Mux",
"with",
"the",
"Get",
"method"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/mux.go#L23-L25
|
19,735
|
go-zoo/bone
|
mux.go
|
Handle
|
func (m *Mux) Handle(path string, handler http.Handler) {
for _, mt := range method {
m.register(mt, path, handler)
}
}
|
go
|
func (m *Mux) Handle(path string, handler http.Handler) {
for _, mt := range method {
m.register(mt, path, handler)
}
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"Handle",
"(",
"path",
"string",
",",
"handler",
"http",
".",
"Handler",
")",
"{",
"for",
"_",
",",
"mt",
":=",
"range",
"method",
"{",
"m",
".",
"register",
"(",
"mt",
",",
"path",
",",
"handler",
")",
"\n",
"}",
"\n",
"}"
] |
// Handle add a new route to the Mux without a HTTP method
|
[
"Handle",
"add",
"a",
"new",
"route",
"to",
"the",
"Mux",
"without",
"a",
"HTTP",
"method"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/mux.go#L63-L67
|
19,736
|
go-zoo/bone
|
mux.go
|
Options
|
func (m *Mux) Options(path string, handler http.Handler) *Route {
return m.register("OPTIONS", path, handler)
}
|
go
|
func (m *Mux) Options(path string, handler http.Handler) *Route {
return m.register("OPTIONS", path, handler)
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"Options",
"(",
"path",
"string",
",",
"handler",
"http",
".",
"Handler",
")",
"*",
"Route",
"{",
"return",
"m",
".",
"register",
"(",
"\"",
"\"",
",",
"path",
",",
"handler",
")",
"\n",
"}"
] |
// Options add a new route to the Mux with the Options method
|
[
"Options",
"add",
"a",
"new",
"route",
"to",
"the",
"Mux",
"with",
"the",
"Options",
"method"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/mux.go#L105-L107
|
19,737
|
go-zoo/bone
|
mux.go
|
register
|
func (m *Mux) register(method string, path string, handler http.Handler) *Route {
r := NewRoute(m, m.prefix+path, handler)
r.Method = method
if valid(path) {
m.Routes[method] = append(m.Routes[method], r)
return r
}
m.Routes[static] = append(m.Routes[static], r)
return r
}
|
go
|
func (m *Mux) register(method string, path string, handler http.Handler) *Route {
r := NewRoute(m, m.prefix+path, handler)
r.Method = method
if valid(path) {
m.Routes[method] = append(m.Routes[method], r)
return r
}
m.Routes[static] = append(m.Routes[static], r)
return r
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"register",
"(",
"method",
"string",
",",
"path",
"string",
",",
"handler",
"http",
".",
"Handler",
")",
"*",
"Route",
"{",
"r",
":=",
"NewRoute",
"(",
"m",
",",
"m",
".",
"prefix",
"+",
"path",
",",
"handler",
")",
"\n",
"r",
".",
"Method",
"=",
"method",
"\n",
"if",
"valid",
"(",
"path",
")",
"{",
"m",
".",
"Routes",
"[",
"method",
"]",
"=",
"append",
"(",
"m",
".",
"Routes",
"[",
"method",
"]",
",",
"r",
")",
"\n",
"return",
"r",
"\n",
"}",
"\n",
"m",
".",
"Routes",
"[",
"static",
"]",
"=",
"append",
"(",
"m",
".",
"Routes",
"[",
"static",
"]",
",",
"r",
")",
"\n",
"return",
"r",
"\n",
"}"
] |
// Register the new route in the router with the provided method and handler
|
[
"Register",
"the",
"new",
"route",
"in",
"the",
"router",
"with",
"the",
"provided",
"method",
"and",
"handler"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/mux.go#L115-L124
|
19,738
|
go-zoo/bone
|
mux.go
|
SubRoute
|
func (m *Mux) SubRoute(path string, router Router) *Route {
r := NewRoute(m, m.prefix+path, router)
if valid(path) {
r.Atts += SUB
for _, mt := range method {
m.Routes[mt] = append(m.Routes[mt], r)
}
return r
}
return nil
}
|
go
|
func (m *Mux) SubRoute(path string, router Router) *Route {
r := NewRoute(m, m.prefix+path, router)
if valid(path) {
r.Atts += SUB
for _, mt := range method {
m.Routes[mt] = append(m.Routes[mt], r)
}
return r
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"SubRoute",
"(",
"path",
"string",
",",
"router",
"Router",
")",
"*",
"Route",
"{",
"r",
":=",
"NewRoute",
"(",
"m",
",",
"m",
".",
"prefix",
"+",
"path",
",",
"router",
")",
"\n",
"if",
"valid",
"(",
"path",
")",
"{",
"r",
".",
"Atts",
"+=",
"SUB",
"\n",
"for",
"_",
",",
"mt",
":=",
"range",
"method",
"{",
"m",
".",
"Routes",
"[",
"mt",
"]",
"=",
"append",
"(",
"m",
".",
"Routes",
"[",
"mt",
"]",
",",
"r",
")",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SubRoute register a router as a SubRouter of bone
|
[
"SubRoute",
"register",
"a",
"router",
"as",
"a",
"SubRouter",
"of",
"bone"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/mux.go#L127-L137
|
19,739
|
go-zoo/bone
|
route.go
|
save
|
func (r *Route) save() {
r.Size = len(r.Path)
r.Token.Tokens = strings.Split(r.Path, "/")
for i, s := range r.Token.Tokens {
if len(s) >= 1 {
switch s[:1] {
case ":":
s = s[1:]
if r.Pattern == nil {
r.Pattern = make(map[int]string)
}
if validators := containsValidators(s); validators != nil {
if r.validators == nil {
r.validators = make(map[string][]string)
}
for _, vali := range validators {
s = s[:validators[0].start]
r.validators[s] = append(r.validators[s], vali.name[1:])
}
}
r.Pattern[i] = s
r.Atts |= PARAM
case "#":
if r.Compile == nil {
r.Compile = make(map[int]*regexp.Regexp)
r.Tag = make(map[int]string)
}
tmp := strings.Split(s, "^")
r.Tag[i] = tmp[0][1:]
r.Compile[i] = regexp.MustCompile("^" + tmp[1][:len(tmp[1])-1])
r.Atts |= REGEX
case "*":
r.wildPos = i
r.Atts |= WC
default:
r.Token.raw = append(r.Token.raw, i)
}
}
r.Token.Size++
}
}
|
go
|
func (r *Route) save() {
r.Size = len(r.Path)
r.Token.Tokens = strings.Split(r.Path, "/")
for i, s := range r.Token.Tokens {
if len(s) >= 1 {
switch s[:1] {
case ":":
s = s[1:]
if r.Pattern == nil {
r.Pattern = make(map[int]string)
}
if validators := containsValidators(s); validators != nil {
if r.validators == nil {
r.validators = make(map[string][]string)
}
for _, vali := range validators {
s = s[:validators[0].start]
r.validators[s] = append(r.validators[s], vali.name[1:])
}
}
r.Pattern[i] = s
r.Atts |= PARAM
case "#":
if r.Compile == nil {
r.Compile = make(map[int]*regexp.Regexp)
r.Tag = make(map[int]string)
}
tmp := strings.Split(s, "^")
r.Tag[i] = tmp[0][1:]
r.Compile[i] = regexp.MustCompile("^" + tmp[1][:len(tmp[1])-1])
r.Atts |= REGEX
case "*":
r.wildPos = i
r.Atts |= WC
default:
r.Token.raw = append(r.Token.raw, i)
}
}
r.Token.Size++
}
}
|
[
"func",
"(",
"r",
"*",
"Route",
")",
"save",
"(",
")",
"{",
"r",
".",
"Size",
"=",
"len",
"(",
"r",
".",
"Path",
")",
"\n",
"r",
".",
"Token",
".",
"Tokens",
"=",
"strings",
".",
"Split",
"(",
"r",
".",
"Path",
",",
"\"",
"\"",
")",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"r",
".",
"Token",
".",
"Tokens",
"{",
"if",
"len",
"(",
"s",
")",
">=",
"1",
"{",
"switch",
"s",
"[",
":",
"1",
"]",
"{",
"case",
"\"",
"\"",
":",
"s",
"=",
"s",
"[",
"1",
":",
"]",
"\n",
"if",
"r",
".",
"Pattern",
"==",
"nil",
"{",
"r",
".",
"Pattern",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"string",
")",
"\n",
"}",
"\n",
"if",
"validators",
":=",
"containsValidators",
"(",
"s",
")",
";",
"validators",
"!=",
"nil",
"{",
"if",
"r",
".",
"validators",
"==",
"nil",
"{",
"r",
".",
"validators",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"vali",
":=",
"range",
"validators",
"{",
"s",
"=",
"s",
"[",
":",
"validators",
"[",
"0",
"]",
".",
"start",
"]",
"\n",
"r",
".",
"validators",
"[",
"s",
"]",
"=",
"append",
"(",
"r",
".",
"validators",
"[",
"s",
"]",
",",
"vali",
".",
"name",
"[",
"1",
":",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"Pattern",
"[",
"i",
"]",
"=",
"s",
"\n",
"r",
".",
"Atts",
"|=",
"PARAM",
"\n",
"case",
"\"",
"\"",
":",
"if",
"r",
".",
"Compile",
"==",
"nil",
"{",
"r",
".",
"Compile",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"*",
"regexp",
".",
"Regexp",
")",
"\n",
"r",
".",
"Tag",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"string",
")",
"\n",
"}",
"\n",
"tmp",
":=",
"strings",
".",
"Split",
"(",
"s",
",",
"\"",
"\"",
")",
"\n",
"r",
".",
"Tag",
"[",
"i",
"]",
"=",
"tmp",
"[",
"0",
"]",
"[",
"1",
":",
"]",
"\n",
"r",
".",
"Compile",
"[",
"i",
"]",
"=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\"",
"+",
"tmp",
"[",
"1",
"]",
"[",
":",
"len",
"(",
"tmp",
"[",
"1",
"]",
")",
"-",
"1",
"]",
")",
"\n",
"r",
".",
"Atts",
"|=",
"REGEX",
"\n",
"case",
"\"",
"\"",
":",
"r",
".",
"wildPos",
"=",
"i",
"\n",
"r",
".",
"Atts",
"|=",
"WC",
"\n",
"default",
":",
"r",
".",
"Token",
".",
"raw",
"=",
"append",
"(",
"r",
".",
"Token",
".",
"raw",
",",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"Token",
".",
"Size",
"++",
"\n",
"}",
"\n",
"}"
] |
// Save, set automatically the Route.Size and Route.Pattern value
|
[
"Save",
"set",
"automatically",
"the",
"Route",
".",
"Size",
"and",
"Route",
".",
"Pattern",
"value"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/route.go#L67-L107
|
19,740
|
go-zoo/bone
|
route.go
|
Match
|
func (r *Route) Match(req *http.Request) bool {
ok, _ := r.matchAndParse(req)
return ok
}
|
go
|
func (r *Route) Match(req *http.Request) bool {
ok, _ := r.matchAndParse(req)
return ok
}
|
[
"func",
"(",
"r",
"*",
"Route",
")",
"Match",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"ok",
",",
"_",
":=",
"r",
".",
"matchAndParse",
"(",
"req",
")",
"\n",
"return",
"ok",
"\n",
"}"
] |
// Match check if the request match the route Pattern
|
[
"Match",
"check",
"if",
"the",
"request",
"match",
"the",
"route",
"Pattern"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/route.go#L110-L113
|
19,741
|
go-zoo/bone
|
route.go
|
matchAndParse
|
func (r *Route) matchAndParse(req *http.Request) (bool, map[string]string) {
ss := strings.Split(req.URL.EscapedPath(), "/")
if r.matchRawTokens(&ss) {
if len(ss) == r.Token.Size || r.Atts&WC != 0 {
totalSize := len(r.Pattern)
if r.Atts®EX != 0 {
totalSize += len(r.Compile)
}
vars := make(map[string]string, totalSize)
for k, v := range r.Pattern {
if validators := r.validators[v]; validators != nil {
for _, vname := range validators {
if !(*r.mux).Validators[vname].Validate(ss[k]) {
return false, nil
}
}
}
vars[v], _ = url.QueryUnescape(ss[k])
}
if r.Atts®EX != 0 {
for k, v := range r.Compile {
if !v.MatchString(ss[k]) {
return false, nil
}
vars[r.Tag[k]], _ = url.QueryUnescape(ss[k])
}
}
return true, vars
}
}
return false, nil
}
|
go
|
func (r *Route) matchAndParse(req *http.Request) (bool, map[string]string) {
ss := strings.Split(req.URL.EscapedPath(), "/")
if r.matchRawTokens(&ss) {
if len(ss) == r.Token.Size || r.Atts&WC != 0 {
totalSize := len(r.Pattern)
if r.Atts®EX != 0 {
totalSize += len(r.Compile)
}
vars := make(map[string]string, totalSize)
for k, v := range r.Pattern {
if validators := r.validators[v]; validators != nil {
for _, vname := range validators {
if !(*r.mux).Validators[vname].Validate(ss[k]) {
return false, nil
}
}
}
vars[v], _ = url.QueryUnescape(ss[k])
}
if r.Atts®EX != 0 {
for k, v := range r.Compile {
if !v.MatchString(ss[k]) {
return false, nil
}
vars[r.Tag[k]], _ = url.QueryUnescape(ss[k])
}
}
return true, vars
}
}
return false, nil
}
|
[
"func",
"(",
"r",
"*",
"Route",
")",
"matchAndParse",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"bool",
",",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"ss",
":=",
"strings",
".",
"Split",
"(",
"req",
".",
"URL",
".",
"EscapedPath",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"r",
".",
"matchRawTokens",
"(",
"&",
"ss",
")",
"{",
"if",
"len",
"(",
"ss",
")",
"==",
"r",
".",
"Token",
".",
"Size",
"||",
"r",
".",
"Atts",
"&",
"WC",
"!=",
"0",
"{",
"totalSize",
":=",
"len",
"(",
"r",
".",
"Pattern",
")",
"\n",
"if",
"r",
".",
"Atts",
"&",
"REGEX",
"!=",
"0",
"{",
"totalSize",
"+=",
"len",
"(",
"r",
".",
"Compile",
")",
"\n",
"}",
"\n\n",
"vars",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"totalSize",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"r",
".",
"Pattern",
"{",
"if",
"validators",
":=",
"r",
".",
"validators",
"[",
"v",
"]",
";",
"validators",
"!=",
"nil",
"{",
"for",
"_",
",",
"vname",
":=",
"range",
"validators",
"{",
"if",
"!",
"(",
"*",
"r",
".",
"mux",
")",
".",
"Validators",
"[",
"vname",
"]",
".",
"Validate",
"(",
"ss",
"[",
"k",
"]",
")",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"vars",
"[",
"v",
"]",
",",
"_",
"=",
"url",
".",
"QueryUnescape",
"(",
"ss",
"[",
"k",
"]",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Atts",
"&",
"REGEX",
"!=",
"0",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"r",
".",
"Compile",
"{",
"if",
"!",
"v",
".",
"MatchString",
"(",
"ss",
"[",
"k",
"]",
")",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"vars",
"[",
"r",
".",
"Tag",
"[",
"k",
"]",
"]",
",",
"_",
"=",
"url",
".",
"QueryUnescape",
"(",
"ss",
"[",
"k",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"vars",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] |
// matchAndParse check if the request matches the route Pattern and returns a map of the parsed
// variables if it matches
|
[
"matchAndParse",
"check",
"if",
"the",
"request",
"matches",
"the",
"route",
"Pattern",
"and",
"returns",
"a",
"map",
"of",
"the",
"parsed",
"variables",
"if",
"it",
"matches"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/route.go#L117-L151
|
19,742
|
go-zoo/bone
|
bone.go
|
New
|
func New(adapters ...adapter) *Mux {
m := &Mux{Routes: make(map[string][]*Route), Serve: nil, CaseSensitive: true}
for _, adap := range adapters {
adap(m)
}
if m.Serve == nil {
m.Serve = m.DefaultServe
}
return m
}
|
go
|
func New(adapters ...adapter) *Mux {
m := &Mux{Routes: make(map[string][]*Route), Serve: nil, CaseSensitive: true}
for _, adap := range adapters {
adap(m)
}
if m.Serve == nil {
m.Serve = m.DefaultServe
}
return m
}
|
[
"func",
"New",
"(",
"adapters",
"...",
"adapter",
")",
"*",
"Mux",
"{",
"m",
":=",
"&",
"Mux",
"{",
"Routes",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"Route",
")",
",",
"Serve",
":",
"nil",
",",
"CaseSensitive",
":",
"true",
"}",
"\n",
"for",
"_",
",",
"adap",
":=",
"range",
"adapters",
"{",
"adap",
"(",
"m",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"Serve",
"==",
"nil",
"{",
"m",
".",
"Serve",
"=",
"m",
".",
"DefaultServe",
"\n",
"}",
"\n",
"return",
"m",
"\n",
"}"
] |
// New create a pointer to a Mux instance
|
[
"New",
"create",
"a",
"pointer",
"to",
"a",
"Mux",
"instance"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/bone.go#L35-L44
|
19,743
|
go-zoo/bone
|
bone.go
|
RegisterValidatorFunc
|
func (m *Mux) RegisterValidatorFunc(name string, validator func(string) bool) {
if m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = newValidatorFunc(validator)
}
|
go
|
func (m *Mux) RegisterValidatorFunc(name string, validator func(string) bool) {
if m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = newValidatorFunc(validator)
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"RegisterValidatorFunc",
"(",
"name",
"string",
",",
"validator",
"func",
"(",
"string",
")",
"bool",
")",
"{",
"if",
"m",
".",
"Validators",
"==",
"nil",
"{",
"m",
".",
"Validators",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"Validator",
")",
"\n",
"}",
"\n",
"m",
".",
"Validators",
"[",
"name",
"]",
"=",
"newValidatorFunc",
"(",
"validator",
")",
"\n",
"}"
] |
// RegisterValidatorFunc makes the provided function available to the routes register on that mux as a validator
|
[
"RegisterValidatorFunc",
"makes",
"the",
"provided",
"function",
"available",
"to",
"the",
"routes",
"register",
"on",
"that",
"mux",
"as",
"a",
"validator"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/bone.go#L47-L52
|
19,744
|
go-zoo/bone
|
bone.go
|
RegisterValidator
|
func (m *Mux) RegisterValidator(name string, validator Validator) {
if m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = validator
}
|
go
|
func (m *Mux) RegisterValidator(name string, validator Validator) {
if m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = validator
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"RegisterValidator",
"(",
"name",
"string",
",",
"validator",
"Validator",
")",
"{",
"if",
"m",
".",
"Validators",
"==",
"nil",
"{",
"m",
".",
"Validators",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"Validator",
")",
"\n",
"}",
"\n",
"m",
".",
"Validators",
"[",
"name",
"]",
"=",
"validator",
"\n",
"}"
] |
// RegisterValidator makes the provided validator available to the routes register on that mux
|
[
"RegisterValidator",
"makes",
"the",
"provided",
"validator",
"available",
"to",
"the",
"routes",
"register",
"on",
"that",
"mux"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/bone.go#L55-L60
|
19,745
|
go-zoo/bone
|
bone.go
|
Prefix
|
func (m *Mux) Prefix(p string) *Mux {
m.prefix = strings.TrimSuffix(p, "/")
return m
}
|
go
|
func (m *Mux) Prefix(p string) *Mux {
m.prefix = strings.TrimSuffix(p, "/")
return m
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"Prefix",
"(",
"p",
"string",
")",
"*",
"Mux",
"{",
"m",
".",
"prefix",
"=",
"strings",
".",
"TrimSuffix",
"(",
"p",
",",
"\"",
"\"",
")",
"\n",
"return",
"m",
"\n",
"}"
] |
// Prefix set a default prefix for all routes registred on the router
|
[
"Prefix",
"set",
"a",
"default",
"prefix",
"for",
"all",
"routes",
"registred",
"on",
"the",
"router"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/bone.go#L63-L66
|
19,746
|
go-zoo/bone
|
bone.go
|
DefaultServe
|
func (m *Mux) DefaultServe(rw http.ResponseWriter, req *http.Request) {
// Check if a route match
if !m.parse(rw, req) {
// Check if it's a static ressource
if !m.staticRoute(rw, req) {
// Check if the request path doesn't end with /
if !m.validate(rw, req) {
// Check if same route exists for another HTTP method
if !m.otherMethods(rw, req) {
m.HandleNotFound(rw, req)
}
}
}
}
}
|
go
|
func (m *Mux) DefaultServe(rw http.ResponseWriter, req *http.Request) {
// Check if a route match
if !m.parse(rw, req) {
// Check if it's a static ressource
if !m.staticRoute(rw, req) {
// Check if the request path doesn't end with /
if !m.validate(rw, req) {
// Check if same route exists for another HTTP method
if !m.otherMethods(rw, req) {
m.HandleNotFound(rw, req)
}
}
}
}
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"DefaultServe",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"// Check if a route match",
"if",
"!",
"m",
".",
"parse",
"(",
"rw",
",",
"req",
")",
"{",
"// Check if it's a static ressource",
"if",
"!",
"m",
".",
"staticRoute",
"(",
"rw",
",",
"req",
")",
"{",
"// Check if the request path doesn't end with /",
"if",
"!",
"m",
".",
"validate",
"(",
"rw",
",",
"req",
")",
"{",
"// Check if same route exists for another HTTP method",
"if",
"!",
"m",
".",
"otherMethods",
"(",
"rw",
",",
"req",
")",
"{",
"m",
".",
"HandleNotFound",
"(",
"rw",
",",
"req",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// DefaultServe is the default http request handler
|
[
"DefaultServe",
"is",
"the",
"default",
"http",
"request",
"handler"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/bone.go#L69-L83
|
19,747
|
go-zoo/bone
|
bone.go
|
ServeHTTP
|
func (m *Mux) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
if !m.CaseSensitive {
req.URL.Path = strings.ToLower(req.URL.Path)
}
m.Serve(rw, req)
}
|
go
|
func (m *Mux) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
if !m.CaseSensitive {
req.URL.Path = strings.ToLower(req.URL.Path)
}
m.Serve(rw, req)
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"ServeHTTP",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"!",
"m",
".",
"CaseSensitive",
"{",
"req",
".",
"URL",
".",
"Path",
"=",
"strings",
".",
"ToLower",
"(",
"req",
".",
"URL",
".",
"Path",
")",
"\n",
"}",
"\n",
"m",
".",
"Serve",
"(",
"rw",
",",
"req",
")",
"\n",
"}"
] |
// ServeHTTP pass the request to the serve method of Mux
|
[
"ServeHTTP",
"pass",
"the",
"request",
"to",
"the",
"serve",
"method",
"of",
"Mux"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/bone.go#L86-L91
|
19,748
|
go-zoo/bone
|
helper.go
|
staticRoute
|
func (m *Mux) staticRoute(rw http.ResponseWriter, req *http.Request) bool {
for _, s := range m.Routes[static] {
if len(req.URL.Path) >= s.Size {
if req.URL.Path[:s.Size] == s.Path {
s.Handler.ServeHTTP(rw, req)
return true
}
}
}
return false
}
|
go
|
func (m *Mux) staticRoute(rw http.ResponseWriter, req *http.Request) bool {
for _, s := range m.Routes[static] {
if len(req.URL.Path) >= s.Size {
if req.URL.Path[:s.Size] == s.Path {
s.Handler.ServeHTTP(rw, req)
return true
}
}
}
return false
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"staticRoute",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"m",
".",
"Routes",
"[",
"static",
"]",
"{",
"if",
"len",
"(",
"req",
".",
"URL",
".",
"Path",
")",
">=",
"s",
".",
"Size",
"{",
"if",
"req",
".",
"URL",
".",
"Path",
"[",
":",
"s",
".",
"Size",
"]",
"==",
"s",
".",
"Path",
"{",
"s",
".",
"Handler",
".",
"ServeHTTP",
"(",
"rw",
",",
"req",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// StaticRoute check if the request path is for Static route
|
[
"StaticRoute",
"check",
"if",
"the",
"request",
"path",
"is",
"for",
"Static",
"route"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/helper.go#L41-L51
|
19,749
|
go-zoo/bone
|
helper.go
|
HandleNotFound
|
func (m *Mux) HandleNotFound(rw http.ResponseWriter, req *http.Request) {
if m.notFound != nil {
m.notFound.ServeHTTP(rw, req)
} else {
http.NotFound(rw, req)
}
}
|
go
|
func (m *Mux) HandleNotFound(rw http.ResponseWriter, req *http.Request) {
if m.notFound != nil {
m.notFound.ServeHTTP(rw, req)
} else {
http.NotFound(rw, req)
}
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"HandleNotFound",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"m",
".",
"notFound",
"!=",
"nil",
"{",
"m",
".",
"notFound",
".",
"ServeHTTP",
"(",
"rw",
",",
"req",
")",
"\n",
"}",
"else",
"{",
"http",
".",
"NotFound",
"(",
"rw",
",",
"req",
")",
"\n",
"}",
"\n",
"}"
] |
// HandleNotFound handle when a request does not match a registered handler.
|
[
"HandleNotFound",
"handle",
"when",
"a",
"request",
"does",
"not",
"match",
"a",
"registered",
"handler",
"."
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/helper.go#L54-L60
|
19,750
|
go-zoo/bone
|
helper.go
|
cleanURL
|
func cleanURL(url *string) {
ulen := len((*url))
if ulen > 1 {
if (*url)[ulen-1:] == "/" {
*url = (*url)[:ulen-1]
cleanURL(url)
}
}
}
|
go
|
func cleanURL(url *string) {
ulen := len((*url))
if ulen > 1 {
if (*url)[ulen-1:] == "/" {
*url = (*url)[:ulen-1]
cleanURL(url)
}
}
}
|
[
"func",
"cleanURL",
"(",
"url",
"*",
"string",
")",
"{",
"ulen",
":=",
"len",
"(",
"(",
"*",
"url",
")",
")",
"\n",
"if",
"ulen",
">",
"1",
"{",
"if",
"(",
"*",
"url",
")",
"[",
"ulen",
"-",
"1",
":",
"]",
"==",
"\"",
"\"",
"{",
"*",
"url",
"=",
"(",
"*",
"url",
")",
"[",
":",
"ulen",
"-",
"1",
"]",
"\n",
"cleanURL",
"(",
"url",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Clean url path
|
[
"Clean",
"url",
"path"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/helper.go#L84-L92
|
19,751
|
go-zoo/bone
|
helper.go
|
GetRequestRoute
|
func (m *Mux) GetRequestRoute(req *http.Request) string {
cleanURL(&req.URL.Path)
for _, r := range m.Routes[req.Method] {
if r.Atts != 0 {
if r.Atts&SUB != 0 {
return r.Handler.(*Mux).GetRequestRoute(req)
}
if r.Match(req) {
return r.Path
}
}
if req.URL.Path == r.Path {
return r.Path
}
}
for _, s := range m.Routes[static] {
if len(req.URL.Path) >= s.Size {
if req.URL.Path[:s.Size] == s.Path {
return s.Path
}
}
}
return "NotFound"
}
|
go
|
func (m *Mux) GetRequestRoute(req *http.Request) string {
cleanURL(&req.URL.Path)
for _, r := range m.Routes[req.Method] {
if r.Atts != 0 {
if r.Atts&SUB != 0 {
return r.Handler.(*Mux).GetRequestRoute(req)
}
if r.Match(req) {
return r.Path
}
}
if req.URL.Path == r.Path {
return r.Path
}
}
for _, s := range m.Routes[static] {
if len(req.URL.Path) >= s.Size {
if req.URL.Path[:s.Size] == s.Path {
return s.Path
}
}
}
return "NotFound"
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"GetRequestRoute",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"string",
"{",
"cleanURL",
"(",
"&",
"req",
".",
"URL",
".",
"Path",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"m",
".",
"Routes",
"[",
"req",
".",
"Method",
"]",
"{",
"if",
"r",
".",
"Atts",
"!=",
"0",
"{",
"if",
"r",
".",
"Atts",
"&",
"SUB",
"!=",
"0",
"{",
"return",
"r",
".",
"Handler",
".",
"(",
"*",
"Mux",
")",
".",
"GetRequestRoute",
"(",
"req",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Match",
"(",
"req",
")",
"{",
"return",
"r",
".",
"Path",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"req",
".",
"URL",
".",
"Path",
"==",
"r",
".",
"Path",
"{",
"return",
"r",
".",
"Path",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"m",
".",
"Routes",
"[",
"static",
"]",
"{",
"if",
"len",
"(",
"req",
".",
"URL",
".",
"Path",
")",
">=",
"s",
".",
"Size",
"{",
"if",
"req",
".",
"URL",
".",
"Path",
"[",
":",
"s",
".",
"Size",
"]",
"==",
"s",
".",
"Path",
"{",
"return",
"s",
".",
"Path",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// GetRequestRoute returns the route of given Request
|
[
"GetRequestRoute",
"returns",
"the",
"route",
"of",
"given",
"Request"
] |
31c3a0bb520c6d7a63dbb942459a3067787a975e
|
https://github.com/go-zoo/bone/blob/31c3a0bb520c6d7a63dbb942459a3067787a975e/helper.go#L100-L125
|
19,752
|
gordonklaus/portaudio
|
portaudio.go
|
HostApis
|
func HostApis() ([]*HostApiInfo, error) {
hosts, _, err := hostsAndDevices()
if err != nil {
return nil, err
}
return hosts, nil
}
|
go
|
func HostApis() ([]*HostApiInfo, error) {
hosts, _, err := hostsAndDevices()
if err != nil {
return nil, err
}
return hosts, nil
}
|
[
"func",
"HostApis",
"(",
")",
"(",
"[",
"]",
"*",
"HostApiInfo",
",",
"error",
")",
"{",
"hosts",
",",
"_",
",",
"err",
":=",
"hostsAndDevices",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"hosts",
",",
"nil",
"\n",
"}"
] |
// HostApis returns all information available for HostApis.
|
[
"HostApis",
"returns",
"all",
"information",
"available",
"for",
"HostApis",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L217-L223
|
19,753
|
gordonklaus/portaudio
|
portaudio.go
|
HostApi
|
func HostApi(apiType HostApiType) (*HostApiInfo, error) {
hosts, err := HostApis()
if err != nil {
return nil, err
}
i := C.Pa_HostApiTypeIdToHostApiIndex(C.PaHostApiTypeId(apiType))
if i < 0 {
return nil, newError(C.PaError(i))
}
return hosts[i], nil
}
|
go
|
func HostApi(apiType HostApiType) (*HostApiInfo, error) {
hosts, err := HostApis()
if err != nil {
return nil, err
}
i := C.Pa_HostApiTypeIdToHostApiIndex(C.PaHostApiTypeId(apiType))
if i < 0 {
return nil, newError(C.PaError(i))
}
return hosts[i], nil
}
|
[
"func",
"HostApi",
"(",
"apiType",
"HostApiType",
")",
"(",
"*",
"HostApiInfo",
",",
"error",
")",
"{",
"hosts",
",",
"err",
":=",
"HostApis",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"i",
":=",
"C",
".",
"Pa_HostApiTypeIdToHostApiIndex",
"(",
"C",
".",
"PaHostApiTypeId",
"(",
"apiType",
")",
")",
"\n",
"if",
"i",
"<",
"0",
"{",
"return",
"nil",
",",
"newError",
"(",
"C",
".",
"PaError",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"hosts",
"[",
"i",
"]",
",",
"nil",
"\n",
"}"
] |
// HostApi returns information for a requested HostApiType.
|
[
"HostApi",
"returns",
"information",
"for",
"a",
"requested",
"HostApiType",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L226-L236
|
19,754
|
gordonklaus/portaudio
|
portaudio.go
|
DefaultHostApi
|
func DefaultHostApi() (*HostApiInfo, error) {
hosts, err := HostApis()
if err != nil {
return nil, err
}
i := C.Pa_GetDefaultHostApi()
if i < 0 {
return nil, newError(C.PaError(i))
}
return hosts[i], nil
}
|
go
|
func DefaultHostApi() (*HostApiInfo, error) {
hosts, err := HostApis()
if err != nil {
return nil, err
}
i := C.Pa_GetDefaultHostApi()
if i < 0 {
return nil, newError(C.PaError(i))
}
return hosts[i], nil
}
|
[
"func",
"DefaultHostApi",
"(",
")",
"(",
"*",
"HostApiInfo",
",",
"error",
")",
"{",
"hosts",
",",
"err",
":=",
"HostApis",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"i",
":=",
"C",
".",
"Pa_GetDefaultHostApi",
"(",
")",
"\n",
"if",
"i",
"<",
"0",
"{",
"return",
"nil",
",",
"newError",
"(",
"C",
".",
"PaError",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"hosts",
"[",
"i",
"]",
",",
"nil",
"\n",
"}"
] |
// DefaultHostApi returns information of the default HostApi available on the system.
//
// The default host API will be the lowest common denominator host API
// on the current platform and is unlikely to provide the best performance.
|
[
"DefaultHostApi",
"returns",
"information",
"of",
"the",
"default",
"HostApi",
"available",
"on",
"the",
"system",
".",
"The",
"default",
"host",
"API",
"will",
"be",
"the",
"lowest",
"common",
"denominator",
"host",
"API",
"on",
"the",
"current",
"platform",
"and",
"is",
"unlikely",
"to",
"provide",
"the",
"best",
"performance",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L242-L252
|
19,755
|
gordonklaus/portaudio
|
portaudio.go
|
Devices
|
func Devices() ([]*DeviceInfo, error) {
_, devs, err := hostsAndDevices()
if err != nil {
return nil, err
}
return devs, nil
}
|
go
|
func Devices() ([]*DeviceInfo, error) {
_, devs, err := hostsAndDevices()
if err != nil {
return nil, err
}
return devs, nil
}
|
[
"func",
"Devices",
"(",
")",
"(",
"[",
"]",
"*",
"DeviceInfo",
",",
"error",
")",
"{",
"_",
",",
"devs",
",",
"err",
":=",
"hostsAndDevices",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"devs",
",",
"nil",
"\n",
"}"
] |
// Devices returns information for all available devices on the system.
|
[
"Devices",
"returns",
"information",
"for",
"all",
"available",
"devices",
"on",
"the",
"system",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L255-L261
|
19,756
|
gordonklaus/portaudio
|
portaudio.go
|
DefaultInputDevice
|
func DefaultInputDevice() (*DeviceInfo, error) {
devs, err := Devices()
if err != nil {
return nil, err
}
i := C.Pa_GetDefaultInputDevice()
if i < 0 {
return nil, newError(C.PaError(i))
}
return devs[i], nil
}
|
go
|
func DefaultInputDevice() (*DeviceInfo, error) {
devs, err := Devices()
if err != nil {
return nil, err
}
i := C.Pa_GetDefaultInputDevice()
if i < 0 {
return nil, newError(C.PaError(i))
}
return devs[i], nil
}
|
[
"func",
"DefaultInputDevice",
"(",
")",
"(",
"*",
"DeviceInfo",
",",
"error",
")",
"{",
"devs",
",",
"err",
":=",
"Devices",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"i",
":=",
"C",
".",
"Pa_GetDefaultInputDevice",
"(",
")",
"\n",
"if",
"i",
"<",
"0",
"{",
"return",
"nil",
",",
"newError",
"(",
"C",
".",
"PaError",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"devs",
"[",
"i",
"]",
",",
"nil",
"\n",
"}"
] |
// DefaultInputDevice returns information for the default
// input device on the system.
|
[
"DefaultInputDevice",
"returns",
"information",
"for",
"the",
"default",
"input",
"device",
"on",
"the",
"system",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L265-L275
|
19,757
|
gordonklaus/portaudio
|
portaudio.go
|
DefaultOutputDevice
|
func DefaultOutputDevice() (*DeviceInfo, error) {
devs, err := Devices()
if err != nil {
return nil, err
}
i := C.Pa_GetDefaultOutputDevice()
if i < 0 {
return nil, newError(C.PaError(i))
}
return devs[i], nil
}
|
go
|
func DefaultOutputDevice() (*DeviceInfo, error) {
devs, err := Devices()
if err != nil {
return nil, err
}
i := C.Pa_GetDefaultOutputDevice()
if i < 0 {
return nil, newError(C.PaError(i))
}
return devs[i], nil
}
|
[
"func",
"DefaultOutputDevice",
"(",
")",
"(",
"*",
"DeviceInfo",
",",
"error",
")",
"{",
"devs",
",",
"err",
":=",
"Devices",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"i",
":=",
"C",
".",
"Pa_GetDefaultOutputDevice",
"(",
")",
"\n",
"if",
"i",
"<",
"0",
"{",
"return",
"nil",
",",
"newError",
"(",
"C",
".",
"PaError",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"devs",
"[",
"i",
"]",
",",
"nil",
"\n",
"}"
] |
// DefaultOutputDevice returns information for the default
// output device on the system.
|
[
"DefaultOutputDevice",
"returns",
"information",
"for",
"the",
"default",
"output",
"device",
"on",
"the",
"system",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L279-L289
|
19,758
|
gordonklaus/portaudio
|
portaudio.go
|
IsFormatSupported
|
func IsFormatSupported(p StreamParameters, args ...interface{}) error {
s := &Stream{}
err := s.init(p, args...)
if err != nil {
return err
}
return newError(C.Pa_IsFormatSupported(s.inParams, s.outParams, C.double(p.SampleRate)))
}
|
go
|
func IsFormatSupported(p StreamParameters, args ...interface{}) error {
s := &Stream{}
err := s.init(p, args...)
if err != nil {
return err
}
return newError(C.Pa_IsFormatSupported(s.inParams, s.outParams, C.double(p.SampleRate)))
}
|
[
"func",
"IsFormatSupported",
"(",
"p",
"StreamParameters",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"s",
":=",
"&",
"Stream",
"{",
"}",
"\n",
"err",
":=",
"s",
".",
"init",
"(",
"p",
",",
"args",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"newError",
"(",
"C",
".",
"Pa_IsFormatSupported",
"(",
"s",
".",
"inParams",
",",
"s",
".",
"outParams",
",",
"C",
".",
"double",
"(",
"p",
".",
"SampleRate",
")",
")",
")",
"\n",
"}"
] |
// IsFormatSupported Returns nil if the format is supported, otherwise an error.
// The args parameter has the same meaning as in OpenStream.
|
[
"IsFormatSupported",
"Returns",
"nil",
"if",
"the",
"format",
"is",
"supported",
"otherwise",
"an",
"error",
".",
"The",
"args",
"parameter",
"has",
"the",
"same",
"meaning",
"as",
"in",
"OpenStream",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L469-L476
|
19,759
|
gordonklaus/portaudio
|
portaudio.go
|
PutInt32
|
func (i24 *Int24) PutInt32(i32 int32) {
if littleEndian {
i24[0] = byte(i32 >> 8)
i24[1] = byte(i32 >> 16)
i24[2] = byte(i32 >> 24)
} else {
i24[2] = byte(i32 >> 8)
i24[1] = byte(i32 >> 16)
i24[0] = byte(i32 >> 24)
}
}
|
go
|
func (i24 *Int24) PutInt32(i32 int32) {
if littleEndian {
i24[0] = byte(i32 >> 8)
i24[1] = byte(i32 >> 16)
i24[2] = byte(i32 >> 24)
} else {
i24[2] = byte(i32 >> 8)
i24[1] = byte(i32 >> 16)
i24[0] = byte(i32 >> 24)
}
}
|
[
"func",
"(",
"i24",
"*",
"Int24",
")",
"PutInt32",
"(",
"i32",
"int32",
")",
"{",
"if",
"littleEndian",
"{",
"i24",
"[",
"0",
"]",
"=",
"byte",
"(",
"i32",
">>",
"8",
")",
"\n",
"i24",
"[",
"1",
"]",
"=",
"byte",
"(",
"i32",
">>",
"16",
")",
"\n",
"i24",
"[",
"2",
"]",
"=",
"byte",
"(",
"i32",
">>",
"24",
")",
"\n",
"}",
"else",
"{",
"i24",
"[",
"2",
"]",
"=",
"byte",
"(",
"i32",
">>",
"8",
")",
"\n",
"i24",
"[",
"1",
"]",
"=",
"byte",
"(",
"i32",
">>",
"16",
")",
"\n",
"i24",
"[",
"0",
"]",
"=",
"byte",
"(",
"i32",
">>",
"24",
")",
"\n",
"}",
"\n",
"}"
] |
// PutInt32 puts the three most significant bytes of i32 into i24.
|
[
"PutInt32",
"puts",
"the",
"three",
"most",
"significant",
"bytes",
"of",
"i32",
"into",
"i24",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L482-L492
|
19,760
|
gordonklaus/portaudio
|
portaudio.go
|
OpenStream
|
func OpenStream(p StreamParameters, args ...interface{}) (*Stream, error) {
if initialized <= 0 {
return nil, NotInitialized
}
s := newStream()
err := s.init(p, args...)
if err != nil {
delStream(s)
return nil, err
}
cb := C.paStreamCallback
if !s.callback.IsValid() {
cb = nil
}
paErr := C.Pa_OpenStream(&s.paStream, s.inParams, s.outParams, C.double(p.SampleRate), C.ulong(p.FramesPerBuffer), C.PaStreamFlags(p.Flags), cb, unsafe.Pointer(s.id))
if paErr != C.paNoError {
delStream(s)
return nil, newError(paErr)
}
return s, nil
}
|
go
|
func OpenStream(p StreamParameters, args ...interface{}) (*Stream, error) {
if initialized <= 0 {
return nil, NotInitialized
}
s := newStream()
err := s.init(p, args...)
if err != nil {
delStream(s)
return nil, err
}
cb := C.paStreamCallback
if !s.callback.IsValid() {
cb = nil
}
paErr := C.Pa_OpenStream(&s.paStream, s.inParams, s.outParams, C.double(p.SampleRate), C.ulong(p.FramesPerBuffer), C.PaStreamFlags(p.Flags), cb, unsafe.Pointer(s.id))
if paErr != C.paNoError {
delStream(s)
return nil, newError(paErr)
}
return s, nil
}
|
[
"func",
"OpenStream",
"(",
"p",
"StreamParameters",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Stream",
",",
"error",
")",
"{",
"if",
"initialized",
"<=",
"0",
"{",
"return",
"nil",
",",
"NotInitialized",
"\n",
"}",
"\n\n",
"s",
":=",
"newStream",
"(",
")",
"\n",
"err",
":=",
"s",
".",
"init",
"(",
"p",
",",
"args",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"delStream",
"(",
"s",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cb",
":=",
"C",
".",
"paStreamCallback",
"\n",
"if",
"!",
"s",
".",
"callback",
".",
"IsValid",
"(",
")",
"{",
"cb",
"=",
"nil",
"\n",
"}",
"\n",
"paErr",
":=",
"C",
".",
"Pa_OpenStream",
"(",
"&",
"s",
".",
"paStream",
",",
"s",
".",
"inParams",
",",
"s",
".",
"outParams",
",",
"C",
".",
"double",
"(",
"p",
".",
"SampleRate",
")",
",",
"C",
".",
"ulong",
"(",
"p",
".",
"FramesPerBuffer",
")",
",",
"C",
".",
"PaStreamFlags",
"(",
"p",
".",
"Flags",
")",
",",
"cb",
",",
"unsafe",
".",
"Pointer",
"(",
"s",
".",
"id",
")",
")",
"\n",
"if",
"paErr",
"!=",
"C",
".",
"paNoError",
"{",
"delStream",
"(",
"s",
")",
"\n",
"return",
"nil",
",",
"newError",
"(",
"paErr",
")",
"\n",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] |
// OpenStream creates an instance of a Stream.
//
// For an input- or output-only stream, p.Output.Device or p.Input.Device must be nil, respectively.
//
// The args may consist of either a single StreamCallback or,
// for a blocking stream, two Buffers or pointers to Buffers.
//
// For an input- or output-only stream, one of the Buffer args may be omitted.
|
[
"OpenStream",
"creates",
"an",
"instance",
"of",
"a",
"Stream",
".",
"For",
"an",
"input",
"-",
"or",
"output",
"-",
"only",
"stream",
"p",
".",
"Output",
".",
"Device",
"or",
"p",
".",
"Input",
".",
"Device",
"must",
"be",
"nil",
"respectively",
".",
"The",
"args",
"may",
"consist",
"of",
"either",
"a",
"single",
"StreamCallback",
"or",
"for",
"a",
"blocking",
"stream",
"two",
"Buffers",
"or",
"pointers",
"to",
"Buffers",
".",
"For",
"an",
"input",
"-",
"or",
"output",
"-",
"only",
"stream",
"one",
"of",
"the",
"Buffer",
"args",
"may",
"be",
"omitted",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L626-L647
|
19,761
|
gordonklaus/portaudio
|
portaudio.go
|
Close
|
func (s *Stream) Close() error {
if !s.closed {
s.closed = true
err := newError(C.Pa_CloseStream(s.paStream))
delStream(s)
return err
}
return nil
}
|
go
|
func (s *Stream) Close() error {
if !s.closed {
s.closed = true
err := newError(C.Pa_CloseStream(s.paStream))
delStream(s)
return err
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"!",
"s",
".",
"closed",
"{",
"s",
".",
"closed",
"=",
"true",
"\n",
"err",
":=",
"newError",
"(",
"C",
".",
"Pa_CloseStream",
"(",
"s",
".",
"paStream",
")",
")",
"\n",
"delStream",
"(",
"s",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close terminates the stream.
|
[
"Close",
"terminates",
"the",
"stream",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L848-L856
|
19,762
|
gordonklaus/portaudio
|
portaudio.go
|
Info
|
func (s *Stream) Info() *StreamInfo {
i := C.Pa_GetStreamInfo(s.paStream)
if i == nil {
return nil
}
return &StreamInfo{duration(i.inputLatency), duration(i.outputLatency), float64(i.sampleRate)}
}
|
go
|
func (s *Stream) Info() *StreamInfo {
i := C.Pa_GetStreamInfo(s.paStream)
if i == nil {
return nil
}
return &StreamInfo{duration(i.inputLatency), duration(i.outputLatency), float64(i.sampleRate)}
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"Info",
"(",
")",
"*",
"StreamInfo",
"{",
"i",
":=",
"C",
".",
"Pa_GetStreamInfo",
"(",
"s",
".",
"paStream",
")",
"\n",
"if",
"i",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"StreamInfo",
"{",
"duration",
"(",
"i",
".",
"inputLatency",
")",
",",
"duration",
"(",
"i",
".",
"outputLatency",
")",
",",
"float64",
"(",
"i",
".",
"sampleRate",
")",
"}",
"\n",
"}"
] |
// Info returns information about the Stream instance.
|
[
"Info",
"returns",
"information",
"about",
"the",
"Stream",
"instance",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L924-L930
|
19,763
|
gordonklaus/portaudio
|
portaudio.go
|
Time
|
func (s *Stream) Time() time.Duration {
return duration(C.Pa_GetStreamTime(s.paStream))
}
|
go
|
func (s *Stream) Time() time.Duration {
return duration(C.Pa_GetStreamTime(s.paStream))
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"Time",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"duration",
"(",
"C",
".",
"Pa_GetStreamTime",
"(",
"s",
".",
"paStream",
")",
")",
"\n",
"}"
] |
// Time returns the current time in seconds for a lifespan of a stream.
// Starting and stopping the stream does not affect the passage of time.
|
[
"Time",
"returns",
"the",
"current",
"time",
"in",
"seconds",
"for",
"a",
"lifespan",
"of",
"a",
"stream",
".",
"Starting",
"and",
"stopping",
"the",
"stream",
"does",
"not",
"affect",
"the",
"passage",
"of",
"time",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L940-L942
|
19,764
|
gordonklaus/portaudio
|
portaudio.go
|
AvailableToRead
|
func (s *Stream) AvailableToRead() (int, error) {
n := C.Pa_GetStreamReadAvailable(s.paStream)
if n < 0 {
return 0, newError(C.PaError(n))
}
return int(n), nil
}
|
go
|
func (s *Stream) AvailableToRead() (int, error) {
n := C.Pa_GetStreamReadAvailable(s.paStream)
if n < 0 {
return 0, newError(C.PaError(n))
}
return int(n), nil
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"AvailableToRead",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"n",
":=",
"C",
".",
"Pa_GetStreamReadAvailable",
"(",
"s",
".",
"paStream",
")",
"\n",
"if",
"n",
"<",
"0",
"{",
"return",
"0",
",",
"newError",
"(",
"C",
".",
"PaError",
"(",
"n",
")",
")",
"\n",
"}",
"\n",
"return",
"int",
"(",
"n",
")",
",",
"nil",
"\n",
"}"
] |
// AvailableToRead returns the number of frames that
// can be read from the stream without waiting.
|
[
"AvailableToRead",
"returns",
"the",
"number",
"of",
"frames",
"that",
"can",
"be",
"read",
"from",
"the",
"stream",
"without",
"waiting",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L960-L966
|
19,765
|
gordonklaus/portaudio
|
portaudio.go
|
AvailableToWrite
|
func (s *Stream) AvailableToWrite() (int, error) {
n := C.Pa_GetStreamWriteAvailable(s.paStream)
if n < 0 {
return 0, newError(C.PaError(n))
}
return int(n), nil
}
|
go
|
func (s *Stream) AvailableToWrite() (int, error) {
n := C.Pa_GetStreamWriteAvailable(s.paStream)
if n < 0 {
return 0, newError(C.PaError(n))
}
return int(n), nil
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"AvailableToWrite",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"n",
":=",
"C",
".",
"Pa_GetStreamWriteAvailable",
"(",
"s",
".",
"paStream",
")",
"\n",
"if",
"n",
"<",
"0",
"{",
"return",
"0",
",",
"newError",
"(",
"C",
".",
"PaError",
"(",
"n",
")",
")",
"\n",
"}",
"\n",
"return",
"int",
"(",
"n",
")",
",",
"nil",
"\n",
"}"
] |
// AvailableToWrite returns the number of frames that
// can be written from the stream without waiting.
|
[
"AvailableToWrite",
"returns",
"the",
"number",
"of",
"frames",
"that",
"can",
"be",
"written",
"from",
"the",
"stream",
"without",
"waiting",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L970-L976
|
19,766
|
gordonklaus/portaudio
|
portaudio.go
|
Read
|
func (s *Stream) Read() error {
if s.callback.IsValid() {
return CanNotReadFromACallbackStream
}
if s.in == nil {
return CanNotReadFromAnOutputOnlyStream
}
buf, frames, err := getBuffer(s.in, s.inParams)
if err != nil {
return err
}
return newError(C.Pa_ReadStream(s.paStream, buf, C.ulong(frames)))
}
|
go
|
func (s *Stream) Read() error {
if s.callback.IsValid() {
return CanNotReadFromACallbackStream
}
if s.in == nil {
return CanNotReadFromAnOutputOnlyStream
}
buf, frames, err := getBuffer(s.in, s.inParams)
if err != nil {
return err
}
return newError(C.Pa_ReadStream(s.paStream, buf, C.ulong(frames)))
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"Read",
"(",
")",
"error",
"{",
"if",
"s",
".",
"callback",
".",
"IsValid",
"(",
")",
"{",
"return",
"CanNotReadFromACallbackStream",
"\n",
"}",
"\n",
"if",
"s",
".",
"in",
"==",
"nil",
"{",
"return",
"CanNotReadFromAnOutputOnlyStream",
"\n",
"}",
"\n",
"buf",
",",
"frames",
",",
"err",
":=",
"getBuffer",
"(",
"s",
".",
"in",
",",
"s",
".",
"inParams",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"newError",
"(",
"C",
".",
"Pa_ReadStream",
"(",
"s",
".",
"paStream",
",",
"buf",
",",
"C",
".",
"ulong",
"(",
"frames",
")",
")",
")",
"\n",
"}"
] |
// Read uses the buffer provided to OpenStream.
// The number of samples to read is determined by the size of the buffer.
|
[
"Read",
"uses",
"the",
"buffer",
"provided",
"to",
"OpenStream",
".",
"The",
"number",
"of",
"samples",
"to",
"read",
"is",
"determined",
"by",
"the",
"size",
"of",
"the",
"buffer",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L980-L992
|
19,767
|
gordonklaus/portaudio
|
portaudio.go
|
Write
|
func (s *Stream) Write() error {
if s.callback.IsValid() {
return CanNotWriteToACallbackStream
}
if s.out == nil {
return CanNotWriteToAnInputOnlyStream
}
buf, frames, err := getBuffer(s.out, s.outParams)
if err != nil {
return err
}
return newError(C.Pa_WriteStream(s.paStream, buf, C.ulong(frames)))
}
|
go
|
func (s *Stream) Write() error {
if s.callback.IsValid() {
return CanNotWriteToACallbackStream
}
if s.out == nil {
return CanNotWriteToAnInputOnlyStream
}
buf, frames, err := getBuffer(s.out, s.outParams)
if err != nil {
return err
}
return newError(C.Pa_WriteStream(s.paStream, buf, C.ulong(frames)))
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"Write",
"(",
")",
"error",
"{",
"if",
"s",
".",
"callback",
".",
"IsValid",
"(",
")",
"{",
"return",
"CanNotWriteToACallbackStream",
"\n",
"}",
"\n",
"if",
"s",
".",
"out",
"==",
"nil",
"{",
"return",
"CanNotWriteToAnInputOnlyStream",
"\n",
"}",
"\n",
"buf",
",",
"frames",
",",
"err",
":=",
"getBuffer",
"(",
"s",
".",
"out",
",",
"s",
".",
"outParams",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"newError",
"(",
"C",
".",
"Pa_WriteStream",
"(",
"s",
".",
"paStream",
",",
"buf",
",",
"C",
".",
"ulong",
"(",
"frames",
")",
")",
")",
"\n",
"}"
] |
// Write uses the buffer provided to OpenStream.
// The number of samples to write is determined by the size of the buffer.
|
[
"Write",
"uses",
"the",
"buffer",
"provided",
"to",
"OpenStream",
".",
"The",
"number",
"of",
"samples",
"to",
"write",
"is",
"determined",
"by",
"the",
"size",
"of",
"the",
"buffer",
"."
] |
00e7307ccd93051979a933c6fd5ead641eba5686
|
https://github.com/gordonklaus/portaudio/blob/00e7307ccd93051979a933c6fd5ead641eba5686/portaudio.go#L996-L1008
|
19,768
|
cuigh/swirl
|
biz/docker/config.go
|
ConfigCreate
|
func ConfigCreate(info *model.ConfigCreateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
spec := swarm.ConfigSpec{}
spec.Name = info.Name
spec.Data = []byte(info.Data)
spec.Labels = info.Labels.ToMap()
if info.Template.Name != "" {
spec.Templating = &swarm.Driver{
Name: info.Template.Name,
Options: info.Template.Options,
}
}
_, err = cli.ConfigCreate(ctx, spec)
return
})
}
|
go
|
func ConfigCreate(info *model.ConfigCreateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
spec := swarm.ConfigSpec{}
spec.Name = info.Name
spec.Data = []byte(info.Data)
spec.Labels = info.Labels.ToMap()
if info.Template.Name != "" {
spec.Templating = &swarm.Driver{
Name: info.Template.Name,
Options: info.Template.Options,
}
}
_, err = cli.ConfigCreate(ctx, spec)
return
})
}
|
[
"func",
"ConfigCreate",
"(",
"info",
"*",
"model",
".",
"ConfigCreateInfo",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"spec",
":=",
"swarm",
".",
"ConfigSpec",
"{",
"}",
"\n",
"spec",
".",
"Name",
"=",
"info",
".",
"Name",
"\n",
"spec",
".",
"Data",
"=",
"[",
"]",
"byte",
"(",
"info",
".",
"Data",
")",
"\n",
"spec",
".",
"Labels",
"=",
"info",
".",
"Labels",
".",
"ToMap",
"(",
")",
"\n",
"if",
"info",
".",
"Template",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"spec",
".",
"Templating",
"=",
"&",
"swarm",
".",
"Driver",
"{",
"Name",
":",
"info",
".",
"Template",
".",
"Name",
",",
"Options",
":",
"info",
".",
"Template",
".",
"Options",
",",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"cli",
".",
"ConfigCreate",
"(",
"ctx",
",",
"spec",
")",
"\n",
"return",
"\n",
"}",
")",
"\n",
"}"
] |
// ConfigCreate create a config.
|
[
"ConfigCreate",
"create",
"a",
"config",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/config.go#L38-L53
|
19,769
|
cuigh/swirl
|
biz/docker/config.go
|
ConfigUpdate
|
func ConfigUpdate(info *model.ConfigUpdateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var cfg swarm.Config
cfg, _, err = cli.ConfigInspectWithRaw(ctx, info.ID)
if err != nil {
return err
}
spec := cfg.Spec
// only the Labels field can be updated on API 1.30
//spec.Name = info.Name
//spec.Data = []byte(info.Data)
spec.Labels = info.Labels.ToMap()
return cli.ConfigUpdate(ctx, info.ID, version(info.Version), spec)
})
}
|
go
|
func ConfigUpdate(info *model.ConfigUpdateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var cfg swarm.Config
cfg, _, err = cli.ConfigInspectWithRaw(ctx, info.ID)
if err != nil {
return err
}
spec := cfg.Spec
// only the Labels field can be updated on API 1.30
//spec.Name = info.Name
//spec.Data = []byte(info.Data)
spec.Labels = info.Labels.ToMap()
return cli.ConfigUpdate(ctx, info.ID, version(info.Version), spec)
})
}
|
[
"func",
"ConfigUpdate",
"(",
"info",
"*",
"model",
".",
"ConfigUpdateInfo",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"var",
"cfg",
"swarm",
".",
"Config",
"\n",
"cfg",
",",
"_",
",",
"err",
"=",
"cli",
".",
"ConfigInspectWithRaw",
"(",
"ctx",
",",
"info",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"spec",
":=",
"cfg",
".",
"Spec",
"\n",
"// only the Labels field can be updated on API 1.30",
"//spec.Name = info.Name",
"//spec.Data = []byte(info.Data)",
"spec",
".",
"Labels",
"=",
"info",
".",
"Labels",
".",
"ToMap",
"(",
")",
"\n",
"return",
"cli",
".",
"ConfigUpdate",
"(",
"ctx",
",",
"info",
".",
"ID",
",",
"version",
"(",
"info",
".",
"Version",
")",
",",
"spec",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// ConfigUpdate update a config.
|
[
"ConfigUpdate",
"update",
"a",
"config",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/config.go#L56-L71
|
19,770
|
cuigh/swirl
|
biz/docker/config.go
|
ConfigInspect
|
func ConfigInspect(id string) (cfg swarm.Config, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
cfg, raw, err = cli.ConfigInspectWithRaw(ctx, id)
}
return
}
|
go
|
func ConfigInspect(id string) (cfg swarm.Config, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
cfg, raw, err = cli.ConfigInspectWithRaw(ctx, id)
}
return
}
|
[
"func",
"ConfigInspect",
"(",
"id",
"string",
")",
"(",
"cfg",
"swarm",
".",
"Config",
",",
"raw",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"(",
"ctx",
"context",
".",
"Context",
"\n",
"cli",
"*",
"client",
".",
"Client",
"\n",
")",
"\n",
"if",
"ctx",
",",
"cli",
",",
"err",
"=",
"mgr",
".",
"Client",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"cfg",
",",
"raw",
",",
"err",
"=",
"cli",
".",
"ConfigInspectWithRaw",
"(",
"ctx",
",",
"id",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// ConfigInspect returns config information with raw data.
|
[
"ConfigInspect",
"returns",
"config",
"information",
"with",
"raw",
"data",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/config.go#L74-L83
|
19,771
|
cuigh/swirl
|
biz/docker/config.go
|
ConfigRemove
|
func ConfigRemove(ids []string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
for _, id := range ids {
if err = cli.ConfigRemove(ctx, id); err != nil {
return
}
}
return
})
}
|
go
|
func ConfigRemove(ids []string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
for _, id := range ids {
if err = cli.ConfigRemove(ctx, id); err != nil {
return
}
}
return
})
}
|
[
"func",
"ConfigRemove",
"(",
"ids",
"[",
"]",
"string",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"for",
"_",
",",
"id",
":=",
"range",
"ids",
"{",
"if",
"err",
"=",
"cli",
".",
"ConfigRemove",
"(",
"ctx",
",",
"id",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}",
")",
"\n",
"}"
] |
// ConfigRemove remove a config.
|
[
"ConfigRemove",
"remove",
"a",
"config",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/config.go#L86-L95
|
19,772
|
cuigh/swirl
|
controller/home.go
|
Home
|
func Home() (c *HomeController) {
return &HomeController{
Index: homeIndex,
Login: homeLogin,
InitGet: homeInitGet,
InitPost: homeInitPost,
Error403: homeError403,
Error404: homeError404,
}
}
|
go
|
func Home() (c *HomeController) {
return &HomeController{
Index: homeIndex,
Login: homeLogin,
InitGet: homeInitGet,
InitPost: homeInitPost,
Error403: homeError403,
Error404: homeError404,
}
}
|
[
"func",
"Home",
"(",
")",
"(",
"c",
"*",
"HomeController",
")",
"{",
"return",
"&",
"HomeController",
"{",
"Index",
":",
"homeIndex",
",",
"Login",
":",
"homeLogin",
",",
"InitGet",
":",
"homeInitGet",
",",
"InitPost",
":",
"homeInitPost",
",",
"Error403",
":",
"homeError403",
",",
"Error404",
":",
"homeError404",
",",
"}",
"\n",
"}"
] |
// Home creates an instance of HomeController
|
[
"Home",
"creates",
"an",
"instance",
"of",
"HomeController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/home.go#L22-L31
|
19,773
|
cuigh/swirl
|
biz/docker/compose/convert_service.go
|
Services
|
func Services(
namespace Namespace,
config *composetypes.Config,
client *client.Client,
) (map[string]swarm.ServiceSpec, error) {
result := make(map[string]swarm.ServiceSpec)
services := config.Services
volumes := config.Volumes
networks := config.Networks
for _, service := range services {
secrets, err := convertServiceSecrets(client, namespace, service.Secrets, config.Secrets)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
configs, err := convertServiceConfigObjs(client, namespace, service, config.Configs)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
serviceSpec, err := Service(client.ClientVersion(), namespace, service, networks, volumes, secrets, configs)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
result[service.Name] = serviceSpec
}
return result, nil
}
|
go
|
func Services(
namespace Namespace,
config *composetypes.Config,
client *client.Client,
) (map[string]swarm.ServiceSpec, error) {
result := make(map[string]swarm.ServiceSpec)
services := config.Services
volumes := config.Volumes
networks := config.Networks
for _, service := range services {
secrets, err := convertServiceSecrets(client, namespace, service.Secrets, config.Secrets)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
configs, err := convertServiceConfigObjs(client, namespace, service, config.Configs)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
serviceSpec, err := Service(client.ClientVersion(), namespace, service, networks, volumes, secrets, configs)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
result[service.Name] = serviceSpec
}
return result, nil
}
|
[
"func",
"Services",
"(",
"namespace",
"Namespace",
",",
"config",
"*",
"composetypes",
".",
"Config",
",",
"client",
"*",
"client",
".",
"Client",
",",
")",
"(",
"map",
"[",
"string",
"]",
"swarm",
".",
"ServiceSpec",
",",
"error",
")",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"swarm",
".",
"ServiceSpec",
")",
"\n\n",
"services",
":=",
"config",
".",
"Services",
"\n",
"volumes",
":=",
"config",
".",
"Volumes",
"\n",
"networks",
":=",
"config",
".",
"Networks",
"\n\n",
"for",
"_",
",",
"service",
":=",
"range",
"services",
"{",
"secrets",
",",
"err",
":=",
"convertServiceSecrets",
"(",
"client",
",",
"namespace",
",",
"service",
".",
"Secrets",
",",
"config",
".",
"Secrets",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"service",
".",
"Name",
")",
"\n",
"}",
"\n",
"configs",
",",
"err",
":=",
"convertServiceConfigObjs",
"(",
"client",
",",
"namespace",
",",
"service",
",",
"config",
".",
"Configs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"service",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"serviceSpec",
",",
"err",
":=",
"Service",
"(",
"client",
".",
"ClientVersion",
"(",
")",
",",
"namespace",
",",
"service",
",",
"networks",
",",
"volumes",
",",
"secrets",
",",
"configs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"service",
".",
"Name",
")",
"\n",
"}",
"\n",
"result",
"[",
"service",
".",
"Name",
"]",
"=",
"serviceSpec",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// Services from compose-file types to engine API types
|
[
"Services",
"from",
"compose",
"-",
"file",
"types",
"to",
"engine",
"API",
"types"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/compose/convert_service.go#L28-L57
|
19,774
|
cuigh/swirl
|
security/perm.go
|
Checker
|
func Checker(user web.User, h web.HandlerInfo) bool {
if au, ok := user.(*model.AuthUser); ok {
return au.IsAllowed(h.Name())
}
return false
}
|
go
|
func Checker(user web.User, h web.HandlerInfo) bool {
if au, ok := user.(*model.AuthUser); ok {
return au.IsAllowed(h.Name())
}
return false
}
|
[
"func",
"Checker",
"(",
"user",
"web",
".",
"User",
",",
"h",
"web",
".",
"HandlerInfo",
")",
"bool",
"{",
"if",
"au",
",",
"ok",
":=",
"user",
".",
"(",
"*",
"model",
".",
"AuthUser",
")",
";",
"ok",
"{",
"return",
"au",
".",
"IsAllowed",
"(",
"h",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// Checker check permission of user
|
[
"Checker",
"check",
"permission",
"of",
"user"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/security/perm.go#L12-L17
|
19,775
|
cuigh/swirl
|
security/perm.go
|
Permiter
|
func Permiter(next web.HandlerFunc) web.HandlerFunc {
return func(ctx web.Context) error {
opt := ctx.Handler().Option("perm")
if opt != "" {
array := strings.Split(opt, ",")
err := biz.Perm.Check(ctx.User(), array[0], array[1], ctx.P(array[2]))
if err != nil {
return err
}
}
return next(ctx)
}
}
|
go
|
func Permiter(next web.HandlerFunc) web.HandlerFunc {
return func(ctx web.Context) error {
opt := ctx.Handler().Option("perm")
if opt != "" {
array := strings.Split(opt, ",")
err := biz.Perm.Check(ctx.User(), array[0], array[1], ctx.P(array[2]))
if err != nil {
return err
}
}
return next(ctx)
}
}
|
[
"func",
"Permiter",
"(",
"next",
"web",
".",
"HandlerFunc",
")",
"web",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"ctx",
"web",
".",
"Context",
")",
"error",
"{",
"opt",
":=",
"ctx",
".",
"Handler",
"(",
")",
".",
"Option",
"(",
"\"",
"\"",
")",
"\n",
"if",
"opt",
"!=",
"\"",
"\"",
"{",
"array",
":=",
"strings",
".",
"Split",
"(",
"opt",
",",
"\"",
"\"",
")",
"\n",
"err",
":=",
"biz",
".",
"Perm",
".",
"Check",
"(",
"ctx",
".",
"User",
"(",
")",
",",
"array",
"[",
"0",
"]",
",",
"array",
"[",
"1",
"]",
",",
"ctx",
".",
"P",
"(",
"array",
"[",
"2",
"]",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"next",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"}"
] |
// Permiter is a middleware for validate data permission.
|
[
"Permiter",
"is",
"a",
"middleware",
"for",
"validate",
"data",
"permission",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/security/perm.go#L20-L32
|
19,776
|
cuigh/swirl
|
dao/bolt/bolt.go
|
New
|
func New(addr string) (*Dao, error) {
if addr == "" {
addr = "/data/swirl"
}
db, err := bolt.Open(filepath.Join(addr, "swirl.db"), 0600, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to open bolt database")
}
d := &Dao{
logger: log.Get("bolt"),
db: db,
}
return d, nil
}
|
go
|
func New(addr string) (*Dao, error) {
if addr == "" {
addr = "/data/swirl"
}
db, err := bolt.Open(filepath.Join(addr, "swirl.db"), 0600, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to open bolt database")
}
d := &Dao{
logger: log.Get("bolt"),
db: db,
}
return d, nil
}
|
[
"func",
"New",
"(",
"addr",
"string",
")",
"(",
"*",
"Dao",
",",
"error",
")",
"{",
"if",
"addr",
"==",
"\"",
"\"",
"{",
"addr",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"db",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"filepath",
".",
"Join",
"(",
"addr",
",",
"\"",
"\"",
")",
",",
"0600",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"d",
":=",
"&",
"Dao",
"{",
"logger",
":",
"log",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"db",
":",
"db",
",",
"}",
"\n",
"return",
"d",
",",
"nil",
"\n",
"}"
] |
// New creates a Dao instance.
|
[
"New",
"creates",
"a",
"Dao",
"instance",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/dao/bolt/bolt.go#L26-L41
|
19,777
|
cuigh/swirl
|
controller/secret.go
|
Secret
|
func Secret() (c *SecretController) {
return &SecretController{
List: secretList,
Delete: secretDelete,
New: secretNew,
Create: secretCreate,
Edit: secretEdit,
Update: secretUpdate,
}
}
|
go
|
func Secret() (c *SecretController) {
return &SecretController{
List: secretList,
Delete: secretDelete,
New: secretNew,
Create: secretCreate,
Edit: secretEdit,
Update: secretUpdate,
}
}
|
[
"func",
"Secret",
"(",
")",
"(",
"c",
"*",
"SecretController",
")",
"{",
"return",
"&",
"SecretController",
"{",
"List",
":",
"secretList",
",",
"Delete",
":",
"secretDelete",
",",
"New",
":",
"secretNew",
",",
"Create",
":",
"secretCreate",
",",
"Edit",
":",
"secretEdit",
",",
"Update",
":",
"secretUpdate",
",",
"}",
"\n",
"}"
] |
// Secret creates an instance of SecretController
|
[
"Secret",
"creates",
"an",
"instance",
"of",
"SecretController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/secret.go#L24-L33
|
19,778
|
cuigh/swirl
|
model/pager.go
|
NewPager
|
func NewPager(uri string, count, size, page int) *Pager {
if page < 1 {
page = 1
}
u, _ := url.Parse(uri)
q := u.Query()
p := &Pager{
Count: count,
Size: size,
Page: page,
Previous: page - 1,
MaxPage: int(math.Ceil(float64(count) / float64(size))),
URL: func(page int) string {
if page < 2 {
q.Del("page")
} else {
q.Set("page", strconv.Itoa(page))
}
u.RawQuery = q.Encode()
return u.String()
},
}
if p.Page < p.MaxPage {
p.Next = page + 1
}
// calculate pages
if count == 0 {
p.Pages = []int{1}
} else if p.MaxPage <= 7 {
p.Pages = make([]int, p.MaxPage)
for i := 0; i < p.MaxPage; i++ {
p.Pages[i] = i + 1
}
} else if page <= 4 {
p.Pages = []int{1, 2, 3, 4, 5, 6, 0, p.MaxPage}
} else if page > (p.MaxPage - 4) {
p.Pages = []int{1, 0}
for i := p.MaxPage - 5; i <= p.MaxPage; i++ {
p.Pages = append(p.Pages, i)
}
} else {
p.Pages = []int{1, 0, page - 2, page - 1, page, page + 1, page + 2, 0, p.MaxPage}
}
return p
}
|
go
|
func NewPager(uri string, count, size, page int) *Pager {
if page < 1 {
page = 1
}
u, _ := url.Parse(uri)
q := u.Query()
p := &Pager{
Count: count,
Size: size,
Page: page,
Previous: page - 1,
MaxPage: int(math.Ceil(float64(count) / float64(size))),
URL: func(page int) string {
if page < 2 {
q.Del("page")
} else {
q.Set("page", strconv.Itoa(page))
}
u.RawQuery = q.Encode()
return u.String()
},
}
if p.Page < p.MaxPage {
p.Next = page + 1
}
// calculate pages
if count == 0 {
p.Pages = []int{1}
} else if p.MaxPage <= 7 {
p.Pages = make([]int, p.MaxPage)
for i := 0; i < p.MaxPage; i++ {
p.Pages[i] = i + 1
}
} else if page <= 4 {
p.Pages = []int{1, 2, 3, 4, 5, 6, 0, p.MaxPage}
} else if page > (p.MaxPage - 4) {
p.Pages = []int{1, 0}
for i := p.MaxPage - 5; i <= p.MaxPage; i++ {
p.Pages = append(p.Pages, i)
}
} else {
p.Pages = []int{1, 0, page - 2, page - 1, page, page + 1, page + 2, 0, p.MaxPage}
}
return p
}
|
[
"func",
"NewPager",
"(",
"uri",
"string",
",",
"count",
",",
"size",
",",
"page",
"int",
")",
"*",
"Pager",
"{",
"if",
"page",
"<",
"1",
"{",
"page",
"=",
"1",
"\n",
"}",
"\n\n",
"u",
",",
"_",
":=",
"url",
".",
"Parse",
"(",
"uri",
")",
"\n",
"q",
":=",
"u",
".",
"Query",
"(",
")",
"\n\n",
"p",
":=",
"&",
"Pager",
"{",
"Count",
":",
"count",
",",
"Size",
":",
"size",
",",
"Page",
":",
"page",
",",
"Previous",
":",
"page",
"-",
"1",
",",
"MaxPage",
":",
"int",
"(",
"math",
".",
"Ceil",
"(",
"float64",
"(",
"count",
")",
"/",
"float64",
"(",
"size",
")",
")",
")",
",",
"URL",
":",
"func",
"(",
"page",
"int",
")",
"string",
"{",
"if",
"page",
"<",
"2",
"{",
"q",
".",
"Del",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"q",
".",
"Set",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"page",
")",
")",
"\n",
"}",
"\n",
"u",
".",
"RawQuery",
"=",
"q",
".",
"Encode",
"(",
")",
"\n",
"return",
"u",
".",
"String",
"(",
")",
"\n",
"}",
",",
"}",
"\n",
"if",
"p",
".",
"Page",
"<",
"p",
".",
"MaxPage",
"{",
"p",
".",
"Next",
"=",
"page",
"+",
"1",
"\n",
"}",
"\n\n",
"// calculate pages",
"if",
"count",
"==",
"0",
"{",
"p",
".",
"Pages",
"=",
"[",
"]",
"int",
"{",
"1",
"}",
"\n",
"}",
"else",
"if",
"p",
".",
"MaxPage",
"<=",
"7",
"{",
"p",
".",
"Pages",
"=",
"make",
"(",
"[",
"]",
"int",
",",
"p",
".",
"MaxPage",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"p",
".",
"MaxPage",
";",
"i",
"++",
"{",
"p",
".",
"Pages",
"[",
"i",
"]",
"=",
"i",
"+",
"1",
"\n",
"}",
"\n",
"}",
"else",
"if",
"page",
"<=",
"4",
"{",
"p",
".",
"Pages",
"=",
"[",
"]",
"int",
"{",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
",",
"6",
",",
"0",
",",
"p",
".",
"MaxPage",
"}",
"\n",
"}",
"else",
"if",
"page",
">",
"(",
"p",
".",
"MaxPage",
"-",
"4",
")",
"{",
"p",
".",
"Pages",
"=",
"[",
"]",
"int",
"{",
"1",
",",
"0",
"}",
"\n",
"for",
"i",
":=",
"p",
".",
"MaxPage",
"-",
"5",
";",
"i",
"<=",
"p",
".",
"MaxPage",
";",
"i",
"++",
"{",
"p",
".",
"Pages",
"=",
"append",
"(",
"p",
".",
"Pages",
",",
"i",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Pages",
"=",
"[",
"]",
"int",
"{",
"1",
",",
"0",
",",
"page",
"-",
"2",
",",
"page",
"-",
"1",
",",
"page",
",",
"page",
"+",
"1",
",",
"page",
"+",
"2",
",",
"0",
",",
"p",
".",
"MaxPage",
"}",
"\n",
"}",
"\n\n",
"return",
"p",
"\n",
"}"
] |
// NewPager returns a Pager instance which displays max 7 pages.
|
[
"NewPager",
"returns",
"a",
"Pager",
"instance",
"which",
"displays",
"max",
"7",
"pages",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/model/pager.go#L25-L73
|
19,779
|
cuigh/swirl
|
biz/docker/node.go
|
NodeList
|
func NodeList() (infos []*model.NodeListInfo, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var nodes []swarm.Node
nodes, err = cli.NodeList(ctx, types.NodeListOptions{})
if err == nil {
sort.Slice(nodes, func(i, j int) bool {
return nodes[i].Description.Hostname < nodes[j].Description.Hostname
})
infos = make([]*model.NodeListInfo, len(nodes))
for i, n := range nodes {
infos[i] = model.NewNodeListInfo(n)
}
}
return
})
return
}
|
go
|
func NodeList() (infos []*model.NodeListInfo, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var nodes []swarm.Node
nodes, err = cli.NodeList(ctx, types.NodeListOptions{})
if err == nil {
sort.Slice(nodes, func(i, j int) bool {
return nodes[i].Description.Hostname < nodes[j].Description.Hostname
})
infos = make([]*model.NodeListInfo, len(nodes))
for i, n := range nodes {
infos[i] = model.NewNodeListInfo(n)
}
}
return
})
return
}
|
[
"func",
"NodeList",
"(",
")",
"(",
"infos",
"[",
"]",
"*",
"model",
".",
"NodeListInfo",
",",
"err",
"error",
")",
"{",
"err",
"=",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"var",
"nodes",
"[",
"]",
"swarm",
".",
"Node",
"\n",
"nodes",
",",
"err",
"=",
"cli",
".",
"NodeList",
"(",
"ctx",
",",
"types",
".",
"NodeListOptions",
"{",
"}",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"sort",
".",
"Slice",
"(",
"nodes",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"nodes",
"[",
"i",
"]",
".",
"Description",
".",
"Hostname",
"<",
"nodes",
"[",
"j",
"]",
".",
"Description",
".",
"Hostname",
"\n",
"}",
")",
"\n",
"infos",
"=",
"make",
"(",
"[",
"]",
"*",
"model",
".",
"NodeListInfo",
",",
"len",
"(",
"nodes",
")",
")",
"\n",
"for",
"i",
",",
"n",
":=",
"range",
"nodes",
"{",
"infos",
"[",
"i",
"]",
"=",
"model",
".",
"NewNodeListInfo",
"(",
"n",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// NodeList return all swarm nodes.
|
[
"NodeList",
"return",
"all",
"swarm",
"nodes",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/node.go#L14-L30
|
19,780
|
cuigh/swirl
|
biz/docker/node.go
|
NodeCount
|
func NodeCount() (count int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var nodes []swarm.Node
nodes, err = cli.NodeList(ctx, types.NodeListOptions{})
if err == nil {
count = len(nodes)
}
return
})
return
}
|
go
|
func NodeCount() (count int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var nodes []swarm.Node
nodes, err = cli.NodeList(ctx, types.NodeListOptions{})
if err == nil {
count = len(nodes)
}
return
})
return
}
|
[
"func",
"NodeCount",
"(",
")",
"(",
"count",
"int",
",",
"err",
"error",
")",
"{",
"err",
"=",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"var",
"nodes",
"[",
"]",
"swarm",
".",
"Node",
"\n",
"nodes",
",",
"err",
"=",
"cli",
".",
"NodeList",
"(",
"ctx",
",",
"types",
".",
"NodeListOptions",
"{",
"}",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"count",
"=",
"len",
"(",
"nodes",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// NodeCount return number of swarm nodes.
|
[
"NodeCount",
"return",
"number",
"of",
"swarm",
"nodes",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/node.go#L33-L43
|
19,781
|
cuigh/swirl
|
biz/docker/node.go
|
NodeRemove
|
func NodeRemove(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
return cli.NodeRemove(ctx, id, types.NodeRemoveOptions{})
})
}
|
go
|
func NodeRemove(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
return cli.NodeRemove(ctx, id, types.NodeRemoveOptions{})
})
}
|
[
"func",
"NodeRemove",
"(",
"id",
"string",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"return",
"cli",
".",
"NodeRemove",
"(",
"ctx",
",",
"id",
",",
"types",
".",
"NodeRemoveOptions",
"{",
"}",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// NodeRemove remove a swarm node from cluster.
|
[
"NodeRemove",
"remove",
"a",
"swarm",
"node",
"from",
"cluster",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/node.go#L46-L50
|
19,782
|
cuigh/swirl
|
biz/docker/node.go
|
NodeInspect
|
func NodeInspect(id string) (node swarm.Node, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
return cli.NodeInspectWithRaw(ctx, id)
}
return
}
|
go
|
func NodeInspect(id string) (node swarm.Node, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
return cli.NodeInspectWithRaw(ctx, id)
}
return
}
|
[
"func",
"NodeInspect",
"(",
"id",
"string",
")",
"(",
"node",
"swarm",
".",
"Node",
",",
"raw",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"(",
"ctx",
"context",
".",
"Context",
"\n",
"cli",
"*",
"client",
".",
"Client",
"\n",
")",
"\n",
"if",
"ctx",
",",
"cli",
",",
"err",
"=",
"mgr",
".",
"Client",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"cli",
".",
"NodeInspectWithRaw",
"(",
"ctx",
",",
"id",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// NodeInspect return node information.
|
[
"NodeInspect",
"return",
"node",
"information",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/node.go#L53-L62
|
19,783
|
cuigh/swirl
|
biz/docker/node.go
|
NodeUpdate
|
func NodeUpdate(id string, info *model.NodeUpdateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
spec := swarm.NodeSpec{
Role: info.Role,
Availability: info.Availability,
}
spec.Name = info.Name
spec.Labels = info.Labels.ToMap()
return cli.NodeUpdate(ctx, id, version(info.Version), spec)
})
}
|
go
|
func NodeUpdate(id string, info *model.NodeUpdateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
spec := swarm.NodeSpec{
Role: info.Role,
Availability: info.Availability,
}
spec.Name = info.Name
spec.Labels = info.Labels.ToMap()
return cli.NodeUpdate(ctx, id, version(info.Version), spec)
})
}
|
[
"func",
"NodeUpdate",
"(",
"id",
"string",
",",
"info",
"*",
"model",
".",
"NodeUpdateInfo",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"spec",
":=",
"swarm",
".",
"NodeSpec",
"{",
"Role",
":",
"info",
".",
"Role",
",",
"Availability",
":",
"info",
".",
"Availability",
",",
"}",
"\n",
"spec",
".",
"Name",
"=",
"info",
".",
"Name",
"\n",
"spec",
".",
"Labels",
"=",
"info",
".",
"Labels",
".",
"ToMap",
"(",
")",
"\n",
"return",
"cli",
".",
"NodeUpdate",
"(",
"ctx",
",",
"id",
",",
"version",
"(",
"info",
".",
"Version",
")",
",",
"spec",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// NodeUpdate update a node.
|
[
"NodeUpdate",
"update",
"a",
"node",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/node.go#L65-L75
|
19,784
|
cuigh/swirl
|
controller/service.go
|
Service
|
func Service() (c *ServiceController) {
return &ServiceController{
List: serviceList,
Detail: serviceDetail,
Raw: serviceRaw,
Logs: serviceLogs,
FetchLogs: serviceFetchLogs,
Delete: serviceDelete,
New: serviceNew,
Create: serviceCreate,
Edit: serviceEdit,
Update: serviceUpdate,
Scale: serviceScale,
Rollback: serviceRollback,
Restart: serviceRestart,
PermEdit: servicePermEdit,
PermUpdate: permUpdate("service", "name"),
Stats: serviceStats,
}
}
|
go
|
func Service() (c *ServiceController) {
return &ServiceController{
List: serviceList,
Detail: serviceDetail,
Raw: serviceRaw,
Logs: serviceLogs,
FetchLogs: serviceFetchLogs,
Delete: serviceDelete,
New: serviceNew,
Create: serviceCreate,
Edit: serviceEdit,
Update: serviceUpdate,
Scale: serviceScale,
Rollback: serviceRollback,
Restart: serviceRestart,
PermEdit: servicePermEdit,
PermUpdate: permUpdate("service", "name"),
Stats: serviceStats,
}
}
|
[
"func",
"Service",
"(",
")",
"(",
"c",
"*",
"ServiceController",
")",
"{",
"return",
"&",
"ServiceController",
"{",
"List",
":",
"serviceList",
",",
"Detail",
":",
"serviceDetail",
",",
"Raw",
":",
"serviceRaw",
",",
"Logs",
":",
"serviceLogs",
",",
"FetchLogs",
":",
"serviceFetchLogs",
",",
"Delete",
":",
"serviceDelete",
",",
"New",
":",
"serviceNew",
",",
"Create",
":",
"serviceCreate",
",",
"Edit",
":",
"serviceEdit",
",",
"Update",
":",
"serviceUpdate",
",",
"Scale",
":",
"serviceScale",
",",
"Rollback",
":",
"serviceRollback",
",",
"Restart",
":",
"serviceRestart",
",",
"PermEdit",
":",
"servicePermEdit",
",",
"PermUpdate",
":",
"permUpdate",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"Stats",
":",
"serviceStats",
",",
"}",
"\n",
"}"
] |
// Service creates an instance of ServiceController
|
[
"Service",
"creates",
"an",
"instance",
"of",
"ServiceController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/service.go#L39-L58
|
19,785
|
cuigh/swirl
|
biz/setting.go
|
Get
|
func (b *settingBiz) Get() (setting *model.Setting, err error) {
do(func(d dao.Interface) {
setting, err = d.SettingGet()
})
return
}
|
go
|
func (b *settingBiz) Get() (setting *model.Setting, err error) {
do(func(d dao.Interface) {
setting, err = d.SettingGet()
})
return
}
|
[
"func",
"(",
"b",
"*",
"settingBiz",
")",
"Get",
"(",
")",
"(",
"setting",
"*",
"model",
".",
"Setting",
",",
"err",
"error",
")",
"{",
"do",
"(",
"func",
"(",
"d",
"dao",
".",
"Interface",
")",
"{",
"setting",
",",
"err",
"=",
"d",
".",
"SettingGet",
"(",
")",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// Get returns settings of swirl. If not found, default settings will be returned.
|
[
"Get",
"returns",
"settings",
"of",
"swirl",
".",
"If",
"not",
"found",
"default",
"settings",
"will",
"be",
"returned",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/setting.go#L19-L24
|
19,786
|
cuigh/swirl
|
controller/network.go
|
Network
|
func Network() (c *NetworkController) {
return &NetworkController{
List: networkList,
New: networkNew,
Create: networkCreate,
Delete: networkDelete,
Disconnect: networkDisconnect,
Detail: networkDetail,
Raw: networkRaw,
}
}
|
go
|
func Network() (c *NetworkController) {
return &NetworkController{
List: networkList,
New: networkNew,
Create: networkCreate,
Delete: networkDelete,
Disconnect: networkDisconnect,
Detail: networkDetail,
Raw: networkRaw,
}
}
|
[
"func",
"Network",
"(",
")",
"(",
"c",
"*",
"NetworkController",
")",
"{",
"return",
"&",
"NetworkController",
"{",
"List",
":",
"networkList",
",",
"New",
":",
"networkNew",
",",
"Create",
":",
"networkCreate",
",",
"Delete",
":",
"networkDelete",
",",
"Disconnect",
":",
"networkDisconnect",
",",
"Detail",
":",
"networkDetail",
",",
"Raw",
":",
"networkRaw",
",",
"}",
"\n",
"}"
] |
// Network creates a NetworkController instance.
|
[
"Network",
"creates",
"a",
"NetworkController",
"instance",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/network.go#L23-L33
|
19,787
|
cuigh/swirl
|
biz/docker/volume.go
|
VolumeList
|
func VolumeList(name string, pageIndex, pageSize int) (volumes []*types.Volume, totalCount int, err error) {
var (
ctx context.Context
cli *client.Client
resp volume.VolumeListOKBody
)
ctx, cli, err = mgr.Client()
if err != nil {
return
}
f := filters.NewArgs()
//f.Add("dangling", "true")
//f.Add("driver", "xx")
if name != "" {
f.Add("name", name)
}
resp, err = cli.VolumeList(ctx, f)
if err != nil {
return
}
sort.Slice(resp.Volumes, func(i, j int) bool {
return resp.Volumes[i].Name < resp.Volumes[j].Name
})
totalCount = len(resp.Volumes)
start, end := misc.Page(totalCount, pageIndex, pageSize)
volumes = resp.Volumes[start:end]
return
}
|
go
|
func VolumeList(name string, pageIndex, pageSize int) (volumes []*types.Volume, totalCount int, err error) {
var (
ctx context.Context
cli *client.Client
resp volume.VolumeListOKBody
)
ctx, cli, err = mgr.Client()
if err != nil {
return
}
f := filters.NewArgs()
//f.Add("dangling", "true")
//f.Add("driver", "xx")
if name != "" {
f.Add("name", name)
}
resp, err = cli.VolumeList(ctx, f)
if err != nil {
return
}
sort.Slice(resp.Volumes, func(i, j int) bool {
return resp.Volumes[i].Name < resp.Volumes[j].Name
})
totalCount = len(resp.Volumes)
start, end := misc.Page(totalCount, pageIndex, pageSize)
volumes = resp.Volumes[start:end]
return
}
|
[
"func",
"VolumeList",
"(",
"name",
"string",
",",
"pageIndex",
",",
"pageSize",
"int",
")",
"(",
"volumes",
"[",
"]",
"*",
"types",
".",
"Volume",
",",
"totalCount",
"int",
",",
"err",
"error",
")",
"{",
"var",
"(",
"ctx",
"context",
".",
"Context",
"\n",
"cli",
"*",
"client",
".",
"Client",
"\n",
"resp",
"volume",
".",
"VolumeListOKBody",
"\n",
")",
"\n\n",
"ctx",
",",
"cli",
",",
"err",
"=",
"mgr",
".",
"Client",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"f",
":=",
"filters",
".",
"NewArgs",
"(",
")",
"\n",
"//f.Add(\"dangling\", \"true\")",
"//f.Add(\"driver\", \"xx\")",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"f",
".",
"Add",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"resp",
",",
"err",
"=",
"cli",
".",
"VolumeList",
"(",
"ctx",
",",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"sort",
".",
"Slice",
"(",
"resp",
".",
"Volumes",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"resp",
".",
"Volumes",
"[",
"i",
"]",
".",
"Name",
"<",
"resp",
".",
"Volumes",
"[",
"j",
"]",
".",
"Name",
"\n",
"}",
")",
"\n\n",
"totalCount",
"=",
"len",
"(",
"resp",
".",
"Volumes",
")",
"\n",
"start",
",",
"end",
":=",
"misc",
".",
"Page",
"(",
"totalCount",
",",
"pageIndex",
",",
"pageSize",
")",
"\n",
"volumes",
"=",
"resp",
".",
"Volumes",
"[",
"start",
":",
"end",
"]",
"\n",
"return",
"\n",
"}"
] |
// VolumeList return volumes on the host.
|
[
"VolumeList",
"return",
"volumes",
"on",
"the",
"host",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/volume.go#L16-L46
|
19,788
|
cuigh/swirl
|
biz/docker/volume.go
|
VolumeCreate
|
func VolumeCreate(info *model.VolumeCreateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
options := volume.VolumeCreateBody{
Name: info.Name,
DriverOpts: info.Options.ToMap(),
Labels: info.Labels.ToMap(),
}
if info.Driver == "other" {
options.Driver = info.CustomDriver
} else {
options.Driver = info.Driver
}
_, err = cli.VolumeCreate(ctx, options)
return
})
}
|
go
|
func VolumeCreate(info *model.VolumeCreateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
options := volume.VolumeCreateBody{
Name: info.Name,
DriverOpts: info.Options.ToMap(),
Labels: info.Labels.ToMap(),
}
if info.Driver == "other" {
options.Driver = info.CustomDriver
} else {
options.Driver = info.Driver
}
_, err = cli.VolumeCreate(ctx, options)
return
})
}
|
[
"func",
"VolumeCreate",
"(",
"info",
"*",
"model",
".",
"VolumeCreateInfo",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"options",
":=",
"volume",
".",
"VolumeCreateBody",
"{",
"Name",
":",
"info",
".",
"Name",
",",
"DriverOpts",
":",
"info",
".",
"Options",
".",
"ToMap",
"(",
")",
",",
"Labels",
":",
"info",
".",
"Labels",
".",
"ToMap",
"(",
")",
",",
"}",
"\n",
"if",
"info",
".",
"Driver",
"==",
"\"",
"\"",
"{",
"options",
".",
"Driver",
"=",
"info",
".",
"CustomDriver",
"\n",
"}",
"else",
"{",
"options",
".",
"Driver",
"=",
"info",
".",
"Driver",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"cli",
".",
"VolumeCreate",
"(",
"ctx",
",",
"options",
")",
"\n",
"return",
"\n",
"}",
")",
"\n",
"}"
] |
// VolumeCreate create a volume.
|
[
"VolumeCreate",
"create",
"a",
"volume",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/volume.go#L49-L65
|
19,789
|
cuigh/swirl
|
biz/docker/volume.go
|
VolumePrune
|
func VolumePrune() (report types.VolumesPruneReport, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
f := filters.NewArgs()
report, err = cli.VolumesPrune(ctx, f)
return
})
return
}
|
go
|
func VolumePrune() (report types.VolumesPruneReport, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
f := filters.NewArgs()
report, err = cli.VolumesPrune(ctx, f)
return
})
return
}
|
[
"func",
"VolumePrune",
"(",
")",
"(",
"report",
"types",
".",
"VolumesPruneReport",
",",
"err",
"error",
")",
"{",
"err",
"=",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"f",
":=",
"filters",
".",
"NewArgs",
"(",
")",
"\n",
"report",
",",
"err",
"=",
"cli",
".",
"VolumesPrune",
"(",
"ctx",
",",
"f",
")",
"\n",
"return",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// VolumePrune remove all unused volumes.
|
[
"VolumePrune",
"remove",
"all",
"unused",
"volumes",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/volume.go#L75-L82
|
19,790
|
cuigh/swirl
|
biz/docker/volume.go
|
VolumeInspectRaw
|
func VolumeInspectRaw(name string) (vol types.Volume, raw []byte, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) error {
vol, raw, err = cli.VolumeInspectWithRaw(ctx, name)
return err
})
return
}
|
go
|
func VolumeInspectRaw(name string) (vol types.Volume, raw []byte, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) error {
vol, raw, err = cli.VolumeInspectWithRaw(ctx, name)
return err
})
return
}
|
[
"func",
"VolumeInspectRaw",
"(",
"name",
"string",
")",
"(",
"vol",
"types",
".",
"Volume",
",",
"raw",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"err",
"=",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"error",
"{",
"vol",
",",
"raw",
",",
"err",
"=",
"cli",
".",
"VolumeInspectWithRaw",
"(",
"ctx",
",",
"name",
")",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// VolumeInspectRaw return volume raw information.
|
[
"VolumeInspectRaw",
"return",
"volume",
"raw",
"information",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/volume.go#L85-L91
|
19,791
|
cuigh/swirl
|
biz/docker/image.go
|
ImageList
|
func ImageList(name string, pageIndex, pageSize int) (images []*model.ImageListInfo, totalCount int, err error) {
ctx, cli, err := mgr.Client()
if err != nil {
return nil, 0, err
}
opts := types.ImageListOptions{}
if name != "" {
opts.Filters = filters.NewArgs()
opts.Filters.Add("reference", name)
}
summaries, err := cli.ImageList(ctx, opts)
if err != nil {
return nil, 0, err
}
//sort.Slice(images, func(i, j int) bool {
// return images[i].ID < images[j].ID
//})
totalCount = len(summaries)
start, end := misc.Page(totalCount, pageIndex, pageSize)
summaries = summaries[start:end]
if length := len(summaries); length > 0 {
images = make([]*model.ImageListInfo, length)
for i, summary := range summaries {
images[i] = model.NewImageListInfo(summary)
}
}
return
}
|
go
|
func ImageList(name string, pageIndex, pageSize int) (images []*model.ImageListInfo, totalCount int, err error) {
ctx, cli, err := mgr.Client()
if err != nil {
return nil, 0, err
}
opts := types.ImageListOptions{}
if name != "" {
opts.Filters = filters.NewArgs()
opts.Filters.Add("reference", name)
}
summaries, err := cli.ImageList(ctx, opts)
if err != nil {
return nil, 0, err
}
//sort.Slice(images, func(i, j int) bool {
// return images[i].ID < images[j].ID
//})
totalCount = len(summaries)
start, end := misc.Page(totalCount, pageIndex, pageSize)
summaries = summaries[start:end]
if length := len(summaries); length > 0 {
images = make([]*model.ImageListInfo, length)
for i, summary := range summaries {
images[i] = model.NewImageListInfo(summary)
}
}
return
}
|
[
"func",
"ImageList",
"(",
"name",
"string",
",",
"pageIndex",
",",
"pageSize",
"int",
")",
"(",
"images",
"[",
"]",
"*",
"model",
".",
"ImageListInfo",
",",
"totalCount",
"int",
",",
"err",
"error",
")",
"{",
"ctx",
",",
"cli",
",",
"err",
":=",
"mgr",
".",
"Client",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"opts",
":=",
"types",
".",
"ImageListOptions",
"{",
"}",
"\n",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"opts",
".",
"Filters",
"=",
"filters",
".",
"NewArgs",
"(",
")",
"\n",
"opts",
".",
"Filters",
".",
"Add",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"summaries",
",",
"err",
":=",
"cli",
".",
"ImageList",
"(",
"ctx",
",",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"//sort.Slice(images, func(i, j int) bool {",
"//\treturn images[i].ID < images[j].ID",
"//})",
"totalCount",
"=",
"len",
"(",
"summaries",
")",
"\n",
"start",
",",
"end",
":=",
"misc",
".",
"Page",
"(",
"totalCount",
",",
"pageIndex",
",",
"pageSize",
")",
"\n",
"summaries",
"=",
"summaries",
"[",
"start",
":",
"end",
"]",
"\n",
"if",
"length",
":=",
"len",
"(",
"summaries",
")",
";",
"length",
">",
"0",
"{",
"images",
"=",
"make",
"(",
"[",
"]",
"*",
"model",
".",
"ImageListInfo",
",",
"length",
")",
"\n",
"for",
"i",
",",
"summary",
":=",
"range",
"summaries",
"{",
"images",
"[",
"i",
"]",
"=",
"model",
".",
"NewImageListInfo",
"(",
"summary",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// ImageList return images on the host.
|
[
"ImageList",
"return",
"images",
"on",
"the",
"host",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/image.go#L15-L44
|
19,792
|
cuigh/swirl
|
biz/docker/image.go
|
ImageInspect
|
func ImageInspect(id string) (image types.ImageInspect, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
return cli.ImageInspectWithRaw(ctx, id)
}
return
}
|
go
|
func ImageInspect(id string) (image types.ImageInspect, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
return cli.ImageInspectWithRaw(ctx, id)
}
return
}
|
[
"func",
"ImageInspect",
"(",
"id",
"string",
")",
"(",
"image",
"types",
".",
"ImageInspect",
",",
"raw",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"(",
"ctx",
"context",
".",
"Context",
"\n",
"cli",
"*",
"client",
".",
"Client",
"\n",
")",
"\n",
"if",
"ctx",
",",
"cli",
",",
"err",
"=",
"mgr",
".",
"Client",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"cli",
".",
"ImageInspectWithRaw",
"(",
"ctx",
",",
"id",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// ImageInspect returns image information.
|
[
"ImageInspect",
"returns",
"image",
"information",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/image.go#L47-L56
|
19,793
|
cuigh/swirl
|
biz/docker/image.go
|
ImageRemove
|
func ImageRemove(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ImageRemoveOptions{}
_, err = cli.ImageRemove(ctx, id, opts)
return
})
}
|
go
|
func ImageRemove(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ImageRemoveOptions{}
_, err = cli.ImageRemove(ctx, id, opts)
return
})
}
|
[
"func",
"ImageRemove",
"(",
"id",
"string",
")",
"error",
"{",
"return",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"opts",
":=",
"types",
".",
"ImageRemoveOptions",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cli",
".",
"ImageRemove",
"(",
"ctx",
",",
"id",
",",
"opts",
")",
"\n",
"return",
"\n",
"}",
")",
"\n",
"}"
] |
// ImageRemove remove a image.
|
[
"ImageRemove",
"remove",
"a",
"image",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/image.go#L71-L77
|
19,794
|
cuigh/swirl
|
controller/template.go
|
Template
|
func Template() (c *TemplateController) {
return &TemplateController{
List: templateList,
New: templateNew,
Create: templateCreate,
Edit: templateEdit,
Update: templateUpdate,
Delete: templateDelete,
}
}
|
go
|
func Template() (c *TemplateController) {
return &TemplateController{
List: templateList,
New: templateNew,
Create: templateCreate,
Edit: templateEdit,
Update: templateUpdate,
Delete: templateDelete,
}
}
|
[
"func",
"Template",
"(",
")",
"(",
"c",
"*",
"TemplateController",
")",
"{",
"return",
"&",
"TemplateController",
"{",
"List",
":",
"templateList",
",",
"New",
":",
"templateNew",
",",
"Create",
":",
"templateCreate",
",",
"Edit",
":",
"templateEdit",
",",
"Update",
":",
"templateUpdate",
",",
"Delete",
":",
"templateDelete",
",",
"}",
"\n",
"}"
] |
// Template creates an instance of TemplateController
|
[
"Template",
"creates",
"an",
"instance",
"of",
"TemplateController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/template.go#L24-L33
|
19,795
|
cuigh/swirl
|
controller/node.go
|
Node
|
func Node() (c *NodeController) {
return &NodeController{
List: nodeList,
Detail: nodeDetail,
Raw: nodeRaw,
Delete: nodeDelete,
Edit: nodeEdit,
Update: nodeUpdate,
}
}
|
go
|
func Node() (c *NodeController) {
return &NodeController{
List: nodeList,
Detail: nodeDetail,
Raw: nodeRaw,
Delete: nodeDelete,
Edit: nodeEdit,
Update: nodeUpdate,
}
}
|
[
"func",
"Node",
"(",
")",
"(",
"c",
"*",
"NodeController",
")",
"{",
"return",
"&",
"NodeController",
"{",
"List",
":",
"nodeList",
",",
"Detail",
":",
"nodeDetail",
",",
"Raw",
":",
"nodeRaw",
",",
"Delete",
":",
"nodeDelete",
",",
"Edit",
":",
"nodeEdit",
",",
"Update",
":",
"nodeUpdate",
",",
"}",
"\n",
"}"
] |
// Node creates an instance of NodeController
|
[
"Node",
"creates",
"an",
"instance",
"of",
"NodeController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/node.go#L21-L30
|
19,796
|
cuigh/swirl
|
controller/role.go
|
Role
|
func Role() (c *RoleController) {
return &RoleController{
Index: roleIndex,
New: roleNew,
Create: roleCreate,
Delete: roleDelete,
Detail: roleDetail,
Edit: roleEdit,
Update: roleUpdate,
}
}
|
go
|
func Role() (c *RoleController) {
return &RoleController{
Index: roleIndex,
New: roleNew,
Create: roleCreate,
Delete: roleDelete,
Detail: roleDetail,
Edit: roleEdit,
Update: roleUpdate,
}
}
|
[
"func",
"Role",
"(",
")",
"(",
"c",
"*",
"RoleController",
")",
"{",
"return",
"&",
"RoleController",
"{",
"Index",
":",
"roleIndex",
",",
"New",
":",
"roleNew",
",",
"Create",
":",
"roleCreate",
",",
"Delete",
":",
"roleDelete",
",",
"Detail",
":",
"roleDetail",
",",
"Edit",
":",
"roleEdit",
",",
"Update",
":",
"roleUpdate",
",",
"}",
"\n",
"}"
] |
// Role creates an instance of RoleController
|
[
"Role",
"creates",
"an",
"instance",
"of",
"RoleController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/role.go#L23-L33
|
19,797
|
cuigh/swirl
|
controller/registry.go
|
Registry
|
func Registry() (c *RegistryController) {
return &RegistryController{
List: registryList,
Create: registryCreate,
Delete: registryDelete,
Update: registryUpdate,
}
}
|
go
|
func Registry() (c *RegistryController) {
return &RegistryController{
List: registryList,
Create: registryCreate,
Delete: registryDelete,
Update: registryUpdate,
}
}
|
[
"func",
"Registry",
"(",
")",
"(",
"c",
"*",
"RegistryController",
")",
"{",
"return",
"&",
"RegistryController",
"{",
"List",
":",
"registryList",
",",
"Create",
":",
"registryCreate",
",",
"Delete",
":",
"registryDelete",
",",
"Update",
":",
"registryUpdate",
",",
"}",
"\n",
"}"
] |
// Registry creates an instance of RegistryController
|
[
"Registry",
"creates",
"an",
"instance",
"of",
"RegistryController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/registry.go#L18-L25
|
19,798
|
cuigh/swirl
|
controller/profile.go
|
Profile
|
func Profile() (c *ProfileController) {
return &ProfileController{
Index: profileIndex,
ModifyInfo: profileModifyInfo,
Password: profilePassword,
ModifyPassword: profileModifyPassword,
}
}
|
go
|
func Profile() (c *ProfileController) {
return &ProfileController{
Index: profileIndex,
ModifyInfo: profileModifyInfo,
Password: profilePassword,
ModifyPassword: profileModifyPassword,
}
}
|
[
"func",
"Profile",
"(",
")",
"(",
"c",
"*",
"ProfileController",
")",
"{",
"return",
"&",
"ProfileController",
"{",
"Index",
":",
"profileIndex",
",",
"ModifyInfo",
":",
"profileModifyInfo",
",",
"Password",
":",
"profilePassword",
",",
"ModifyPassword",
":",
"profileModifyPassword",
",",
"}",
"\n",
"}"
] |
// Profile creates an instance of ProfileController
|
[
"Profile",
"creates",
"an",
"instance",
"of",
"ProfileController"
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/controller/profile.go#L18-L25
|
19,799
|
cuigh/swirl
|
biz/docker/secret.go
|
SecretList
|
func SecretList(name string, pageIndex, pageSize int) (secrets []swarm.Secret, totalCount int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.SecretListOptions{}
if name != "" {
opts.Filters = filters.NewArgs()
opts.Filters.Add("name", name)
}
secrets, err = cli.SecretList(ctx, opts)
if err == nil {
sort.Slice(secrets, func(i, j int) bool {
return secrets[i].Spec.Name < secrets[j].Spec.Name
})
totalCount = len(secrets)
start, end := misc.Page(totalCount, pageIndex, pageSize)
secrets = secrets[start:end]
}
return
})
return
}
|
go
|
func SecretList(name string, pageIndex, pageSize int) (secrets []swarm.Secret, totalCount int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.SecretListOptions{}
if name != "" {
opts.Filters = filters.NewArgs()
opts.Filters.Add("name", name)
}
secrets, err = cli.SecretList(ctx, opts)
if err == nil {
sort.Slice(secrets, func(i, j int) bool {
return secrets[i].Spec.Name < secrets[j].Spec.Name
})
totalCount = len(secrets)
start, end := misc.Page(totalCount, pageIndex, pageSize)
secrets = secrets[start:end]
}
return
})
return
}
|
[
"func",
"SecretList",
"(",
"name",
"string",
",",
"pageIndex",
",",
"pageSize",
"int",
")",
"(",
"secrets",
"[",
"]",
"swarm",
".",
"Secret",
",",
"totalCount",
"int",
",",
"err",
"error",
")",
"{",
"err",
"=",
"mgr",
".",
"Do",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"*",
"client",
".",
"Client",
")",
"(",
"err",
"error",
")",
"{",
"opts",
":=",
"types",
".",
"SecretListOptions",
"{",
"}",
"\n",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"opts",
".",
"Filters",
"=",
"filters",
".",
"NewArgs",
"(",
")",
"\n",
"opts",
".",
"Filters",
".",
"Add",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"secrets",
",",
"err",
"=",
"cli",
".",
"SecretList",
"(",
"ctx",
",",
"opts",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"sort",
".",
"Slice",
"(",
"secrets",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"secrets",
"[",
"i",
"]",
".",
"Spec",
".",
"Name",
"<",
"secrets",
"[",
"j",
"]",
".",
"Spec",
".",
"Name",
"\n",
"}",
")",
"\n",
"totalCount",
"=",
"len",
"(",
"secrets",
")",
"\n",
"start",
",",
"end",
":=",
"misc",
".",
"Page",
"(",
"totalCount",
",",
"pageIndex",
",",
"pageSize",
")",
"\n",
"secrets",
"=",
"secrets",
"[",
"start",
":",
"end",
"]",
"\n",
"}",
"\n",
"return",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// SecretList return all secrets.
|
[
"SecretList",
"return",
"all",
"secrets",
"."
] |
9028e8ad445a1e501a11e5bd13491c270911c151
|
https://github.com/cuigh/swirl/blob/9028e8ad445a1e501a11e5bd13491c270911c151/biz/docker/secret.go#L17-L36
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.