id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c17700 |
return -1
case auinterr != nil && buinterr == nil:
return +1
}
return strings.Compare(a, b)
} | |
c17701 |
err = multierr.Append(err, enc.AddObject("success", v.Success))
}
return err
} | |
c17702 | }
return fmt.Sprintf("ServiceGenerator_Generate_Args{%v}", strings.Join(fields[:i], ", "))
} | |
c17703 | == nil) || (v.Request != nil && rhs.Request != nil && v.Request.Equals(rhs.Request))) {
return false
}
return true
} | |
c17704 | {
err = multierr.Append(err, enc.AddObject("request", v.Request))
}
return err
} | |
c17705 | rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
return false
}
return true
} | |
c17706 | as := make([]string, len(anns))
for i, ann := range anns {
as[i] = ann.String()
}
return "(" + strings.Join(as, ", ") + ")"
} | |
c17707 | if err != nil {
return "", fmt.Errorf("failed to parse tags %q: %v", goAnnotation, err)
}
for _, t := range goTags.Tags() {
if t.Key == jsonTagKey {
t = compileJSONTag(f, t.Name, t.Options...)
}
if err := tags.Set(t); err != nil {
return "", fmt.Errorf("failed to set tag: %v", err)
}
}
}... | |
c17708 | nil, unrecognizedModuleError{Name: name, Reason: err}
}
return included, nil
} | |
c17709 | g.rootServices[id]; !alreadyAdded {
g.RootServices = append(g.RootServices, id)
g.rootServices[id] = struct{}{}
}
return id, err
} | |
c17710 |
importPath, err := g.importer.Package(thriftPath)
if err != nil {
return 0, err
}
dir, err := g.importer.RelativePackage(thriftPath)
if err != nil {
return 0, err
}
g.Modules[id] = &api.Module{
ImportPath: importPath,
Directory: dir,
ThriftFilePath: thriftPath,
}
return id, nil
} | |
c17711 | envelope.Client {
return client{name: name, c: c}
} | |
c17712 |
gave: make(map[string][]string),
}
} | |
c17713 |
case wire.TDouble:
return 8
case wire.TI16:
return 2
case wire.TI32:
return 4
case wire.TI64:
return 8
default:
return -1
}
} | |
c17714 |
// All EOFs are unexpected for the decoder
err = io.ErrUnexpectedEOF
}
return off, err
} | |
c17715 | wire.TStruct:
s, off, err := br.readStruct(off)
return wire.NewValueStruct(s), off, err
case wire.TMap:
m, off, err := br.readMap(off)
return wire.NewValueMap(m), off, err
case wire.TSet:
s, off, err := br.readSet(off)
return wire.NewValueSet(s), off, err
case wire.TList:
l, off, err := br.readList... | |
c17716 | case unicode.IsLetter(c), unicode.IsDigit(c):
return c
default:
return '_'
}
}, packageName)
} | |
c17717 | Value: int32(value),
Doc: astItem.Doc,
Annotations: itemAnnotations,
}
items = append(items, item)
}
annotations, err := compileAnnotations(src.Annotations)
if err != nil {
return nil, compileError{
Target: src.Name,
Line: src.Line,
Reason: err,
}
}
return &EnumSpec{
Na... | |
c17718 | item.Name == name {
return &item, true
}
}
return nil, false
} | |
c17719 |
return &I64Spec{Annotations: annots}, nil
case ast.DoubleTypeID:
return &DoubleSpec{Annotations: annots}, nil
case ast.StringTypeID:
return &StringSpec{Annotations: annots}, nil
case ast.BinaryTypeID:
return &BinarySpec{Annotations: annots}, nil
default:
panic(fmt.Sprintf("unknown base type %v", t))
}
} | |
c17720 | envelope.Handler) {
h.services[name] = service
} | |
c17721 | envelope.ErrUnknownMethod(name)
}
service, ok := h.services[parts[0]]
if !ok {
return wire.Value{}, envelope.ErrUnknownMethod(name)
}
name = parts[1]
return service.Handle(name, req)
} | |
c17722 | if err := args.FromWire(reqValue); err != nil {
return wire.Value{}, err
}
result, err := Plugin_Handshake_Helper.WrapResponse(
h.impl.Handshake(args.Request),
)
if err != nil {
return wire.Value{}, err
}
return result.ToWire()
default:
return wire.Value{}, envelope.ErrUnknownMethod(name)
... | |
c17723 | c = '\''
} else if c == '\'' {
c = '"'
}
out[i] = c
}
return out
} | |
c17724 | return EvaluateValue(item.Value)
})
case TSet:
s := v.GetSet()
defer s.Close()
return s.ForEach(EvaluateValue)
case TList:
l := v.GetList()
defer l.Close()
return l.ForEach(EvaluateValue)
default:
return fmt.Errorf("unknown type %s", v.Type())
}
} | |
c17725 | with any known globals.
importedName := name
for i := 2; ; i++ {
if !g.isGlobalTaken(importedName) {
break
}
importedName = fmt.Sprintf("%s%d", name, i)
}
g.imports[path] = importedName
g.globals[importedName] = struct{}{}
return importedName
} | |
c17726 | k, err := g.FormatType(t.MapType.Left)
if err != nil {
return "", err
}
v, err := g.FormatType(t.MapType.Right)
return fmt.Sprintf("map[%v]%v", k, v), err
case t.ReferenceType != nil:
if g.importPath == t.ReferenceType.ImportPath {
// Target is in the same package. No need to import.
return t.Ref... | |
c17727 |
f, err := parser.ParseFile(fset, filename, buff.Bytes(), parser.ParseComments)
if err != nil {
return nil, fmt.Errorf("failed to parse generated code: %v:\n%s", err, buff.String())
}
if len(f.Imports) > 0 {
return nil, fmt.Errorf(
"plain imports are not allowed with GoFileFromTemplate: use the import funct... | |
c17728 | return v.GetBinary()
case TStruct:
return v.GetStruct()
case TMap:
return v.GetMap()
case TSet, TList:
return v.GetList()
default:
panic(fmt.Sprintf("Unknown value type %v", v.typ))
}
} | |
c17729 | if v {
n = 1
}
return Value{
typ: TBool,
tnumber: n,
}
} | |
c17730 |
tnumber: uint64(v),
}
} | |
c17731 |
tnumber: math.Float64bits(v),
}
} | |
c17732 | Value{
typ: TI16,
tnumber: uint64(v),
}
} | |
c17733 | Value{
typ: TI32,
tnumber: uint64(v),
}
} | |
c17734 | Value{
typ: TI64,
tnumber: uint64(v),
}
} | |
c17735 | Value{
typ: TBinary,
tbinary: v,
}
} | |
c17736 |
tbinary: unsafeStringToBytes(v),
}
} | |
c17737 | nil {
return err
}
if len(b) == 0 {
return nil
}
_, err := w.w.Write(b)
return err
} | |
c17738 | ok := w.w.(io.Closer); ok {
return c.Close()
}
return nil
} | |
c17739 | Writers[name] = writer
m.Unlock()
} | |
c17740 | "",
EnableRsyslog: false,
RsyslogNetwork: "udp",
RsyslogAddr: "127.0.0.1:5140",
LogFormatText: false,
}
} | |
c17741 | var file io.Writer
var err error
if config.LoggerFile != "" {
file, err = os.OpenFile(config.LoggerFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
if err != nil {
panic(err)
}
}
for _, sink := range config.Writers {
if sink == "file" {
if file == nil {
log.Panic("Must set file path")
}
Re... | |
c17742 | FATAL:
lagerLogLevel = lager.FATAL
default:
panic(fmt.Errorf("unknown logger level: %s", config.LoggerLevel))
}
logger := lager.NewLoggerExt(component, config.LogFormatText)
for _, sink := range config.Writers {
writer, ok := Writers[sink]
if !ok {
log.Panic("Unknow writer: ", sink)
}
sink := lager... | |
c17743 |
var conn net.Conn
var err error
if network == "" {
conn, err = unixSyslog()
} else {
conn, err = net.Dial(network, raddr)
}
return &Writer{
conn: conn,
}, err
} | |
c17744 | %s %s%s", syslogHeader, b, nl)
if err != nil {
return 0, err
}
return len(b), nil
} | |
c17745 | n := range networks {
for _, p := range logPaths {
addr = p
if conn, err := net.Dial(n, addr); err == nil {
return conn, nil
}
}
}
return nil, errors.New("Could not connect to local syslog socket")
} | |
c17746 | component,
task: component,
sinks: []Sink{},
data: openlogging.Tags{},
logFormatText: isFormatText,
}
} | |
c17747 | if l.sessionID != "" {
sessionIDstr = fmt.Sprintf("%s.%d", l.sessionID, sid)
} else {
sessionIDstr = fmt.Sprintf("%d", sid)
}
return &logger{
component: l.component,
task: fmt.Sprintf("%s.%s", l.task, task),
sinks: l.sinks,
sessionID: sessionIDstr,
data: l.baseData(opt.Tags),
}
} | |
c17748 |
sessionID: l.sessionID,
data: l.baseData(data),
}
} | |
c17749 | && s.name != "file" {
continue
}
if s, ok := itf.(*ReconfigurableSink); ok {
s.SetMinLevel(level)
}
}
} | |
c17750 | ok := itf.(*ReconfigurableSink); ok && loglevel < LogLevel(s.minLogLevel) {
continue
}
ss[idx] = itf
idx++
}
return ss[:idx]
} | |
c17751 | ERROR:
level = "ERROR"
case FATAL:
level = "FATAL"
}
return level
} | |
c17752 | var level string
var level = FormatLogLevel(x)
return json.Marshal(level)
} | |
c17753 | if level < minLogLevel {
return
}
sink.sink.Log(level, log)
} | |
c17754 |
timeSlot := strings.Replace(now, ".", "", -1)
return timeSlot
} | |
c17755 | return err
}
defer dest.Close()
_, err = io.Copy(dest, file)
return err
} | |
c17756 | LogRotate(filepath.Dir(logFilePath), c.LogRotateSize, c.LogBackupCount)
time.Sleep(30 * time.Second)
}
}()
} else {
go func() {
for {
LogRotate(filepath.Dir(logFilePath), 0, c.LogBackupCount)
time.Sleep(24 * time.Hour * time.Duration(c.LogRotateDate))
}
}()
}
}
} | |
c17757 | <= 0 || c.LogRotateDate > 10 {
c.LogRotateDate = LogRotateDate
}
if c.LogRotateSize <= 0 || c.LogRotateSize > 50 {
c.LogRotateSize = LogRotateSize
}
if c.LogBackupCount < 0 || c.LogBackupCount > 100 {
c.LogBackupCount = LogBackupCount
}
} | |
c17758 | nil {
mu.Lock()
defer mu.Unlock()
if C.dlclose(d.handle) != 0 {
return dlerror()
}
d.handle = nil
}
}
return nil
} | |
c17759 | append(s.sources, src)
} | |
c17760 | root command config type. Expected %s got %s",
fCmd.Name, sCmdConfigType.Name(), fCmdConfigType.Name())
}
s.command = fCmd
} else {
// (not parseAllSources)
s.command, err = flg.Parse(fCmd)
return s.command.Config, err
}
}
}
}
err := s.parseConfigAllSources(s.command)
re... | |
c17761 | err := src.Parse(cmd)
if err != nil {
return err
}
}
return nil
} | |
c17762 | (*KvSource, error) {
kvStore, err := valkeyrie.NewStore(backend, addrs, options)
return &KvSource{Store: kvStore, Prefix: prefix}, err
} | |
c17763 | {
err := kv.LoadConfig(cmd.Config)
if err != nil {
return nil, err
}
return cmd, nil
} | |
c17764 | "/") {
writeOptions = &store.WriteOptions{
IsDir: true,
}
}
if err := kv.Put(k, []byte(kvMap[k]), writeOptions); err != nil {
return err
}
}
return nil
} | |
c17765 |
}
pairs[pairLeaf.Key] = pairLeaf.Value
return nil
}
for _, p := range pairsN1 {
if p.Key != key {
err := kv.ListRecursive(p.Key, pairs)
if err != nil {
return err
}
}
}
return nil
} | |
c17766 | nil {
return pairs, err
}
for _, p := range pairsN1 {
if len(p.Value) > 0 {
pairs[p.Key] = p.Value
}
}
return pairs, nil
} | |
c17767 | codec := NewServerCodec(conn, srv)
codec.(*serverCodec).ctx = ctx
return codec
} | |
c17768 | rpc.ServeCodec(NewServerCodecContext(ctx, conn, nil))
} | |
c17769 | if reply != nil {
*replies = append(*replies, reply)
} else {
*replies = append(*replies, new(json.RawMessage))
if dec.Decode((*replies)[len(*replies)-1]) != nil {
(*replies)[len(*replies)-1] = &jErrRequest
}
}
}
donec <- struct{}{}
}()
var testreq serverRequest
for _, req := range ... | |
c17770 | seqNotify,
}
return c.codec.WriteRequest(req, args)
} | |
c17771 | rpc.NewClientWithCodec(codec)
return &Client{client, codec}
} | |
c17772 | make(map[string]interface{}),
KindNameResolver: DefaultKindName,
}
} | |
c17773 | {
if k, err := g.KeyError(src); err == nil {
return k
}
return nil
} | |
c17774 | err == nil {
return k.Kind()
}
return ""
} | |
c17775 | error) {
key, _, err := g.getStructKey(src)
return key, err
} | |
c17776 | me, ok := err.(appengine.MultiError); ok {
return nil, me[0]
}
return nil, err
}
return ks[0], nil
} | |
c17777 |
g.cache = make(map[string]interface{})
g.cacheLock.Unlock()
} | |
c17778 | }
dsts := []interface{}{dst}
if err := g.GetMulti(dsts); err != nil {
// Look for an embedded error if it's multi
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
// Not multi, normal error
return err
}
set.Set(reflect.Indirect(reflect.ValueOf(dsts[0])))
return nil
} | |
c17779 | err.(appengine.MultiError); ok {
return me[0]
}
return err
} | |
c17780 | func(i int) {
defer wg.Done()
lo := i * deleteMultiLimit
hi := (i + 1) * deleteMultiLimit
if hi > len(keys) {
hi = len(keys)
}
dmerr := datastore.DeleteMulti(g.Context, keys[lo:hi])
if dmerr != nil {
mu.Lock()
any = true // this flag tells DeleteMulti to return multiErr later
mu.Un... | |
c17781 |
if pls, ok := src.(datastore.PropertyLoadSaver); ok {
props, err = pls.Save()
} else {
props, err = datastore.SaveStruct(src)
}
if err != nil {
return nil, err
}
return serializeProperties(props, true)
} | |
c17782 |
// Serialize the properties
for i := range props {
if err := serializeProperty(buf, &props[i]); err != nil {
return nil, err
}
}
output := make([]byte, buf.Len())
copy(output, buf.Bytes())
return output, nil
} | |
c17783 | header
header := binary.LittleEndian.Uint32(b[:4])
propCount, flags := deserializeEntityHeader(header)
if flags&entityExists == 0 {
return datastore.ErrNoSuchEntity
}
// Deserialize the properties
buf := bytes.NewBuffer(b[4:])
props := make([]datastore.Property, propCount)
for i := 0; i < propCount; i++ {
... | |
c17784 | ok := dst.(datastore.PropertyLoadSaver); ok {
return pls.Load(props)
}
return datastore.LoadStruct(dst, props)
} | |
c17785 | return
}
kind = vf.String()
if kind == "" && len(tagValues) > 1 && tagValues[1] != "" {
kind = tagValues[1]
}
}
} else if tagValue == "parent" {
dskeyType := reflect.TypeOf(&datastore.Key{})
if vf.Type().ConvertibleTo(dskeyType) {
if parent != nil {
err = fmt.Er... | |
c17786 | return q.Count(g.Context)
} | |
c17787 |
g: g,
i: q.Run(g.Context),
}
} | |
c17788 | drawer.DrawString("")
return dst
}
// center
dY := int((size - int(gbuf.Bounds.Max.Y-gbuf.Bounds.Min.Y)>>6) / 2)
dX := int((size - int(gbuf.Bounds.Max.X-gbuf.Bounds.Min.X)>>6) / 2)
y := int(gbuf.Bounds.Max.Y>>6) + dY
x := 0 - int(gbuf.Bounds.Min.X>>6) + dX
drawer.Dot = fixed.Point26_6{
X: fixed.I(x),
Y... | |
c17789 |
MaxItems: 1024, // default to 1024 items.
FontFile: fontFile,
})
return avatar
} | |
c17790 |
if err != nil {
panic(err.Error())
}
avatar.cache = lru.New(lru.Config{
MaxItems: cfg.MaxItems,
MaxBytes: cfg.MaxBytes,
})
return avatar
} | |
c17791 | := "png"
if len(encoding) > 0 {
enc = encoding[0]
}
switch enc {
case "jpeg":
err := jpeg.Encode(&buf, m, nil)
if err != nil {
return nil, err
}
case "png":
err := png.Encode(&buf, m)
if err != nil {
return nil, err
}
default:
return nil, ErrUnsupportedEncoding
}
// set cache
a.cache.Se... | |
c17792 | return true
}
return false
} | |
c17793 | registrant.City = value
case "registrant_state_province":
registrant.Province = value
case "registrant_postal_code":
registrant.PostalCode = value
case "registrant_country":
registrant.Country = value
case "registrant_phone":
registrant.Phone = value
case "registrant_phone_ext":
registrant.PhoneExt = va... | |
c17794 | "object does not exist",
}
data = strings.ToLower(data)
for _, v := range notExistsKeys {
if strings.Contains(data, v) {
return true
}
}
return false
} | |
c17795 | strings.ToLower(data)
return strings.Contains(data, "limit exceeded")
} | |
c17796 | ", -1)
key = strings.Replace(key, "'", " ", -1)
key = strings.Replace(key, ".", " ", -1)
key = strings.TrimSpace(key)
key = strings.ToLower(key)
return key
} | |
c17797 | := keyRule[key]; ok {
return v
}
return ""
} | |
c17798 |
}
fields := xslice.Unique(fs)
result := strings.Join(fields.([]string), ",")
return result
} | |
c17799 | " ")
states[k] = names[0]
}
return strings.Join(states, ",")
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.