_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q19700 | Private | train | func (f *Field) Private() bool {
return strings.ToLower(f.name[0:1]) == f.name[0:1]
} | go | {
"resource": ""
} |
q19701 | Fields | train | 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 | {
"resource": ""
} |
q19702 | deriveSort | train | func deriveSort(list []*MyStruct) []*MyStruct {
sort.Slice(list, func(i, j int) bool { return deriveCompare_(list[i], list[j]) < 0 })
return list
} | go | {
"resource": ""
} |
q19703 | IsError | train | 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 | {
"resource": ""
} |
q19704 | Zero | train | 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 | {
"resource": ""
} |
q19705 | deriveTraverse | train | 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 | {
"resource": ""
} |
q19706 | eq | train | 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 | {
"resource": ""
} |
q19707 | New | train | 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 | {
"resource": ""
} |
q19708 | deriveMem | train | 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 | {
"resource": ""
} |
q19709 | NewPlugins | train | func NewPlugins(ps []Plugin, autoname bool, dedup bool) Plugins {
sortPlugins(ps)
return &plugins{
plugins: ps,
autoname: autoname,
dedup: dedup,
}
} | go | {
"resource": ""
} |
q19710 | deriveKeys | train | func deriveKeys(m map[string]int) []string {
keys := make([]string, 0, len(m))
for key := range m {
keys = append(keys, key)
}
return keys
} | go | {
"resource": ""
} |
q19711 | deriveMins | train | 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 | {
"resource": ""
} |
q19712 | New | train | 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 | {
"resource": ""
} |
q19713 | deriveDo | train | 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 | {
"resource": ""
} |
q19714 | deriveUnique | train | 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 | {
"resource": ""
} |
q19715 | deriveHash_s | train | func deriveHash_s(object string) uint64 {
var h uint64
for _, c := range object {
h = 31*h + uint64(c)
}
return h
} | go | {
"resource": ""
} |
q19716 | deriveCompose | train | 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 | {
"resource": ""
} |
q19717 | getInputTypes | train | 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 | {
"resource": ""
} |
q19718 | HasUndefined | train | 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 | {
"resource": ""
} |
q19719 | New | train | 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 | {
"resource": ""
} |
q19720 | generateEqual | train | 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 | {
"resource": ""
} |
q19721 | deriveToError | train | 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 | {
"resource": ""
} |
q19722 | deriveCompose | train | 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 | {
"resource": ""
} |
q19723 | deriveSet | train | func deriveSet(list []int) map[int]struct{} {
set := make(map[int]struct{}, len(list))
for _, v := range list {
set[v] = struct{}{}
}
return set
} | go | {
"resource": ""
} |
q19724 | deriveHash_ | train | func deriveHash_(object string) uint64 {
var h uint64
for _, c := range object {
h = 31*h + uint64(c)
}
return h
} | go | {
"resource": ""
} |
q19725 | deriveHash_1 | train | 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 | {
"resource": ""
} |
q19726 | deriveUnion | train | func deriveUnion(this, that []*Person) []*Person {
for i, v := range that {
if !deriveContains(this, v) {
this = append(this, that[i])
}
}
return this
} | go | {
"resource": ""
} |
q19727 | New | train | 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 | {
"resource": ""
} |
q19728 | deriveIntersect | train | 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 | {
"resource": ""
} |
q19729 | deriveGoString | train | 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 | {
"resource": ""
} |
q19730 | derivePipeline | train | 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 | {
"resource": ""
} |
q19731 | deriveJoin | train | 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 | {
"resource": ""
} |
q19732 | deriveFmap | train | 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 | {
"resource": ""
} |
q19733 | Register | train | func (m *Mux) Register(method string, path string, handler http.Handler) *Route {
return m.register(method, path, handler)
} | go | {
"resource": ""
} |
q19734 | GetFunc | train | func (m *Mux) GetFunc(path string, handler http.HandlerFunc) *Route {
return m.register("GET", path, handler)
} | go | {
"resource": ""
} |
q19735 | Handle | train | func (m *Mux) Handle(path string, handler http.Handler) {
for _, mt := range method {
m.register(mt, path, handler)
}
} | go | {
"resource": ""
} |
q19736 | Options | train | func (m *Mux) Options(path string, handler http.Handler) *Route {
return m.register("OPTIONS", path, handler)
} | go | {
"resource": ""
} |
q19737 | register | train | 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 | {
"resource": ""
} |
q19738 | SubRoute | train | 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 | {
"resource": ""
} |
q19739 | save | train | 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 | {
"resource": ""
} |
q19740 | Match | train | func (r *Route) Match(req *http.Request) bool {
ok, _ := r.matchAndParse(req)
return ok
} | go | {
"resource": ""
} |
q19741 | matchAndParse | train | 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 | {
"resource": ""
} |
q19742 | New | train | 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 | {
"resource": ""
} |
q19743 | RegisterValidatorFunc | train | 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 | {
"resource": ""
} |
q19744 | RegisterValidator | train | func (m *Mux) RegisterValidator(name string, validator Validator) {
if m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = validator
} | go | {
"resource": ""
} |
q19745 | Prefix | train | func (m *Mux) Prefix(p string) *Mux {
m.prefix = strings.TrimSuffix(p, "/")
return m
} | go | {
"resource": ""
} |
q19746 | DefaultServe | train | 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 | {
"resource": ""
} |
q19747 | ServeHTTP | train | 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 | {
"resource": ""
} |
q19748 | staticRoute | train | 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 | {
"resource": ""
} |
q19749 | HandleNotFound | train | 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 | {
"resource": ""
} |
q19750 | cleanURL | train | func cleanURL(url *string) {
ulen := len((*url))
if ulen > 1 {
if (*url)[ulen-1:] == "/" {
*url = (*url)[:ulen-1]
cleanURL(url)
}
}
} | go | {
"resource": ""
} |
q19751 | GetRequestRoute | train | 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 | {
"resource": ""
} |
q19752 | HostApis | train | func HostApis() ([]*HostApiInfo, error) {
hosts, _, err := hostsAndDevices()
if err != nil {
return nil, err
}
return hosts, nil
} | go | {
"resource": ""
} |
q19753 | HostApi | train | 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 | {
"resource": ""
} |
q19754 | DefaultHostApi | train | 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 | {
"resource": ""
} |
q19755 | Devices | train | func Devices() ([]*DeviceInfo, error) {
_, devs, err := hostsAndDevices()
if err != nil {
return nil, err
}
return devs, nil
} | go | {
"resource": ""
} |
q19756 | DefaultInputDevice | train | 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 | {
"resource": ""
} |
q19757 | DefaultOutputDevice | train | 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 | {
"resource": ""
} |
q19758 | IsFormatSupported | train | 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 | {
"resource": ""
} |
q19759 | PutInt32 | train | 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 | {
"resource": ""
} |
q19760 | OpenStream | train | 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 | {
"resource": ""
} |
q19761 | Close | train | 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 | {
"resource": ""
} |
q19762 | Info | train | 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 | {
"resource": ""
} |
q19763 | Time | train | func (s *Stream) Time() time.Duration {
return duration(C.Pa_GetStreamTime(s.paStream))
} | go | {
"resource": ""
} |
q19764 | AvailableToRead | train | 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 | {
"resource": ""
} |
q19765 | AvailableToWrite | train | 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 | {
"resource": ""
} |
q19766 | Read | train | 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 | {
"resource": ""
} |
q19767 | Write | train | 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 | {
"resource": ""
} |
q19768 | ConfigCreate | train | 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 | {
"resource": ""
} |
q19769 | ConfigUpdate | train | 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 | {
"resource": ""
} |
q19770 | ConfigInspect | train | 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 | {
"resource": ""
} |
q19771 | ConfigRemove | train | 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 | {
"resource": ""
} |
q19772 | Home | train | func Home() (c *HomeController) {
return &HomeController{
Index: homeIndex,
Login: homeLogin,
InitGet: homeInitGet,
InitPost: homeInitPost,
Error403: homeError403,
Error404: homeError404,
}
} | go | {
"resource": ""
} |
q19773 | Services | train | 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 | {
"resource": ""
} |
q19774 | Checker | train | func Checker(user web.User, h web.HandlerInfo) bool {
if au, ok := user.(*model.AuthUser); ok {
return au.IsAllowed(h.Name())
}
return false
} | go | {
"resource": ""
} |
q19775 | Permiter | train | 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 | {
"resource": ""
} |
q19776 | New | train | 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 | {
"resource": ""
} |
q19777 | Secret | train | func Secret() (c *SecretController) {
return &SecretController{
List: secretList,
Delete: secretDelete,
New: secretNew,
Create: secretCreate,
Edit: secretEdit,
Update: secretUpdate,
}
} | go | {
"resource": ""
} |
q19778 | NewPager | train | 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 | {
"resource": ""
} |
q19779 | NodeList | train | 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 | {
"resource": ""
} |
q19780 | NodeCount | train | 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 | {
"resource": ""
} |
q19781 | NodeRemove | train | 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 | {
"resource": ""
} |
q19782 | NodeInspect | train | 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 | {
"resource": ""
} |
q19783 | NodeUpdate | train | 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 | {
"resource": ""
} |
q19784 | Service | train | 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 | {
"resource": ""
} |
q19785 | Get | train | func (b *settingBiz) Get() (setting *model.Setting, err error) {
do(func(d dao.Interface) {
setting, err = d.SettingGet()
})
return
} | go | {
"resource": ""
} |
q19786 | Network | train | func Network() (c *NetworkController) {
return &NetworkController{
List: networkList,
New: networkNew,
Create: networkCreate,
Delete: networkDelete,
Disconnect: networkDisconnect,
Detail: networkDetail,
Raw: networkRaw,
}
} | go | {
"resource": ""
} |
q19787 | VolumeList | train | 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 | {
"resource": ""
} |
q19788 | VolumeCreate | train | 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 | {
"resource": ""
} |
q19789 | VolumePrune | train | 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 | {
"resource": ""
} |
q19790 | VolumeInspectRaw | train | 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 | {
"resource": ""
} |
q19791 | ImageList | train | 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 | {
"resource": ""
} |
q19792 | ImageInspect | train | 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 | {
"resource": ""
} |
q19793 | ImageRemove | train | 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 | {
"resource": ""
} |
q19794 | Template | train | func Template() (c *TemplateController) {
return &TemplateController{
List: templateList,
New: templateNew,
Create: templateCreate,
Edit: templateEdit,
Update: templateUpdate,
Delete: templateDelete,
}
} | go | {
"resource": ""
} |
q19795 | Node | train | func Node() (c *NodeController) {
return &NodeController{
List: nodeList,
Detail: nodeDetail,
Raw: nodeRaw,
Delete: nodeDelete,
Edit: nodeEdit,
Update: nodeUpdate,
}
} | go | {
"resource": ""
} |
q19796 | Role | train | func Role() (c *RoleController) {
return &RoleController{
Index: roleIndex,
New: roleNew,
Create: roleCreate,
Delete: roleDelete,
Detail: roleDetail,
Edit: roleEdit,
Update: roleUpdate,
}
} | go | {
"resource": ""
} |
q19797 | Registry | train | func Registry() (c *RegistryController) {
return &RegistryController{
List: registryList,
Create: registryCreate,
Delete: registryDelete,
Update: registryUpdate,
}
} | go | {
"resource": ""
} |
q19798 | Profile | train | func Profile() (c *ProfileController) {
return &ProfileController{
Index: profileIndex,
ModifyInfo: profileModifyInfo,
Password: profilePassword,
ModifyPassword: profileModifyPassword,
}
} | go | {
"resource": ""
} |
q19799 | SecretList | train | 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 | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.