_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17700 | preCmp | train | func preCmp(a, b string) int {
auint, auinterr := parseUint(a)
buint, buinterr := parseUint(b)
switch {
case auinterr == nil && buinterr == nil:
return uintCmp(auint, buint)
case auinterr == nil && buinterr != nil:
return -1
case auinterr != nil && buinterr == nil:
return +1
}
return strings.Compare(a, b)... | go | {
"resource": ""
} |
q17701 | MarshalLogObject | train | func (v *Plugin_Handshake_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Success != nil {
err = multierr.Append(err, enc.AddObject("success", v.Success))
}
return err
} | go | {
"resource": ""
} |
q17702 | String | train | func (v *ServiceGenerator_Generate_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Request != nil {
fields[i] = fmt.Sprintf("Request: %v", v.Request)
i++
}
return fmt.Sprintf("ServiceGenerator_Generate_Args{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q17703 | Equals | train | func (v *ServiceGenerator_Generate_Args) Equals(rhs *ServiceGenerator_Generate_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Request == nil && rhs.Request == nil) || (v.Request != nil && rhs.Request != nil && v.Request.Equals(rhs.Request))) {
return false
}
retu... | go | {
"resource": ""
} |
q17704 | MarshalLogObject | train | func (v *ServiceGenerator_Generate_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Request != nil {
err = multierr.Append(err, enc.AddObject("request", v.Request))
}
return err
} | go | {
"resource": ""
} |
q17705 | Equals | train | func (v *ServiceGenerator_Generate_Result) Equals(rhs *ServiceGenerator_Generate_Result) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
return false
}
... | go | {
"resource": ""
} |
q17706 | FormatAnnotations | train | func FormatAnnotations(anns []*Annotation) string {
if len(anns) == 0 {
return ""
}
as := make([]string, len(anns))
for i, ann := range anns {
as[i] = ann.String()
}
return "(" + strings.Join(as, ", ") + ")"
} | go | {
"resource": ""
} |
q17707 | generateTags | train | func generateTags(f *compile.FieldSpec) (string, error) {
tags, err := structtag.Parse("") // no tags
if err != nil {
return "", fmt.Errorf("failed to parse tag: %v", err)
}
// Default to the field name or label as the name used in the JSON
// representation.
if err := tags.Set(compileJSONTag(f, entityLabel(f)... | go | {
"resource": ""
} |
q17708 | getIncludedScope | train | func getIncludedScope(scope Scope, name string) (Scope, error) {
included, err := scope.LookupInclude(name)
if err != nil {
return nil, unrecognizedModuleError{Name: name, Reason: err}
}
return included, nil
} | go | {
"resource": ""
} |
q17709 | AddRootService | train | func (g *generateServiceBuilder) AddRootService(spec *compile.ServiceSpec) (api.ServiceID, error) {
id, err := g.addService(spec)
if err != nil {
return id, err
}
if _, alreadyAdded := g.rootServices[id]; !alreadyAdded {
g.RootServices = append(g.RootServices, id)
g.rootServices[id] = struct{}{}
}
return ... | go | {
"resource": ""
} |
q17710 | addModule | train | func (g *generateServiceBuilder) addModule(thriftPath string) (api.ModuleID, error) {
if id, ok := g.moduleIDs[thriftPath]; ok {
return id, nil
}
id := g.nextModuleID
g.nextModuleID++
g.moduleIDs[thriftPath] = id
importPath, err := g.importer.Package(thriftPath)
if err != nil {
return 0, err
}
dir, err ... | go | {
"resource": ""
} |
q17711 | NewClient | train | func NewClient(name string, c envelope.Client) envelope.Client {
return client{name: name, c: c}
} | go | {
"resource": ""
} |
q17712 | NewNamespace | train | func NewNamespace() Namespace {
return &namespace{
taken: make(map[string]struct{}),
gave: make(map[string][]string),
}
} | go | {
"resource": ""
} |
q17713 | fixedWidth | train | func fixedWidth(t wire.Type) int64 {
switch t {
case wire.TBool:
return 1
case wire.TI8:
return 1
case wire.TDouble:
return 8
case wire.TI16:
return 2
case wire.TI32:
return 4
case wire.TI64:
return 8
default:
return -1
}
} | go | {
"resource": ""
} |
q17714 | copyN | train | func (br *Reader) copyN(w io.Writer, off int64, n int64) (int64, error) {
src := io.NewSectionReader(br.reader, off, n)
copied, err := io.CopyN(w, src, n)
off += copied
if err == io.EOF {
// All EOFs are unexpected for the decoder
err = io.ErrUnexpectedEOF
}
return off, err
} | go | {
"resource": ""
} |
q17715 | ReadValue | train | func (br *Reader) ReadValue(t wire.Type, off int64) (wire.Value, int64, error) {
switch t {
case wire.TBool:
b, off, err := br.readByte(off)
if err != nil {
return wire.Value{}, off, err
}
if b != 0 && b != 1 {
return wire.Value{}, off, decodeErrorf(
"invalid value %q for bool field", b,
)
}
... | go | {
"resource": ""
} |
q17716 | DeterminePackageName | train | func DeterminePackageName(importPath string) string {
packageName := filepath.Base(importPath)
if strings.HasSuffix(packageName, "-go") {
packageName = packageName[:len(packageName)-3]
}
return strings.Map(func(c rune) rune {
switch {
case unicode.IsLetter(c), unicode.IsDigit(c):
return c
default:
re... | go | {
"resource": ""
} |
q17717 | compileEnum | train | func compileEnum(file string, src *ast.Enum) (*EnumSpec, error) {
enumNS := newNamespace(caseInsensitive)
prev := -1
var items []EnumItem
for _, astItem := range src.Items {
if err := enumNS.claim(astItem.Name, astItem.Line); err != nil {
return nil, compileError{
Target: src.Name + "." + astItem.Name,
... | go | {
"resource": ""
} |
q17718 | LookupItem | train | func (e *EnumSpec) LookupItem(name string) (*EnumItem, bool) {
for _, item := range e.Items {
if item.Name == name {
return &item, true
}
}
return nil, false
} | go | {
"resource": ""
} |
q17719 | compileBaseType | train | func compileBaseType(t ast.BaseType) (TypeSpec, error) {
annots, err := compileAnnotations(t.Annotations)
if err != nil {
return nil, err
}
switch t.ID {
case ast.BoolTypeID:
return &BoolSpec{Annotations: annots}, nil
case ast.I8TypeID:
return &I8Spec{Annotations: annots}, nil
case ast.I16TypeID:
return... | go | {
"resource": ""
} |
q17720 | Put | train | func (h Handler) Put(name string, service envelope.Handler) {
h.services[name] = service
} | go | {
"resource": ""
} |
q17721 | Handle | train | func (h Handler) Handle(name string, req wire.Value) (wire.Value, error) {
parts := strings.SplitN(name, ":", 2)
if len(parts) < 2 {
return wire.Value{}, envelope.ErrUnknownMethod(name)
}
service, ok := h.services[parts[0]]
if !ok {
return wire.Value{}, envelope.ErrUnknownMethod(name)
}
name = parts[1]
re... | go | {
"resource": ""
} |
q17722 | Handle | train | func (h PluginHandler) Handle(name string, reqValue wire.Value) (wire.Value, error) {
switch name {
case "goodbye":
var args Plugin_Goodbye_Args
if err := args.FromWire(reqValue); err != nil {
return wire.Value{}, err
}
result, err := Plugin_Goodbye_Helper.WrapResponse(
h.impl.Goodbye(),
)
if err... | go | {
"resource": ""
} |
q17723 | swapQuotes | train | func swapQuotes(in []byte) []byte {
// s/'/"/g, s/"/'/g
out := make([]byte, len(in))
for i, c := range in {
if c == '"' {
c = '\''
} else if c == '\'' {
c = '"'
}
out[i] = c
}
return out
} | go | {
"resource": ""
} |
q17724 | EvaluateValue | train | func EvaluateValue(v Value) error {
switch v.Type() {
case TBool, TI8, TDouble, TI16, TI32, TI64, TBinary:
return nil
case TStruct:
for _, f := range v.GetStruct().Fields {
if err := EvaluateValue(f.Value); err != nil {
return err
}
}
return nil
case TMap:
m := v.GetMap()
defer m.Close()
ret... | go | {
"resource": ""
} |
q17725 | Import | train | func (g *goFileGenerator) Import(path string) string {
if name, ok := g.imports[path]; ok {
return name
}
name := goast.DeterminePackageName(path)
// Find an import name that does not conflict with any known globals.
importedName := name
for i := 2; ; i++ {
if !g.isGlobalTaken(importedName) {
break
}
... | go | {
"resource": ""
} |
q17726 | FormatType | train | func (g *goFileGenerator) FormatType(t *api.Type) (string, error) {
switch {
case t.SimpleType != nil:
switch *t.SimpleType {
case api.SimpleTypeBool:
return "bool", nil
case api.SimpleTypeByte:
return "byte", nil
case api.SimpleTypeInt8:
return "int8", nil
case api.SimpleTypeInt16:
return "int1... | go | {
"resource": ""
} |
q17727 | Generate | train | func (g *goFileGenerator) Generate(filename, tmpl string, data interface{}) ([]byte, error) {
funcs := template.FuncMap{
"import": g.Import,
"formatType": g.FormatType,
}
for k, v := range g.templateFuncs {
funcs[k] = v
}
t, err := template.New(filename).Delims("<", ">").Funcs(funcs).Parse(tmpl)
if err... | go | {
"resource": ""
} |
q17728 | Get | train | func (v *Value) Get() interface{} {
switch v.typ {
case TBool:
return v.GetBool()
case TI8:
return v.GetI8()
case TDouble:
return v.GetDouble()
case TI16:
return v.GetI16()
case TI32:
return v.GetI32()
case TI64:
return v.GetI64()
case TBinary:
return v.GetBinary()
case TStruct:
return v.GetStr... | go | {
"resource": ""
} |
q17729 | NewValueBool | train | func NewValueBool(v bool) Value {
n := uint64(0)
if v {
n = 1
}
return Value{
typ: TBool,
tnumber: n,
}
} | go | {
"resource": ""
} |
q17730 | NewValueI8 | train | func NewValueI8(v int8) Value {
return Value{
typ: TI8,
tnumber: uint64(v),
}
} | go | {
"resource": ""
} |
q17731 | NewValueDouble | train | func NewValueDouble(v float64) Value {
return Value{
typ: TDouble,
tnumber: math.Float64bits(v),
}
} | go | {
"resource": ""
} |
q17732 | NewValueI16 | train | func NewValueI16(v int16) Value {
return Value{
typ: TI16,
tnumber: uint64(v),
}
} | go | {
"resource": ""
} |
q17733 | NewValueI32 | train | func NewValueI32(v int32) Value {
return Value{
typ: TI32,
tnumber: uint64(v),
}
} | go | {
"resource": ""
} |
q17734 | NewValueI64 | train | func NewValueI64(v int64) Value {
return Value{
typ: TI64,
tnumber: uint64(v),
}
} | go | {
"resource": ""
} |
q17735 | NewValueBinary | train | func NewValueBinary(v []byte) Value {
if v == nil {
v = _emptyByteSlice
}
return Value{
typ: TBinary,
tbinary: v,
}
} | go | {
"resource": ""
} |
q17736 | NewValueString | train | func NewValueString(v string) Value {
return Value{
typ: TBinary,
tbinary: unsafeStringToBytes(v),
}
} | go | {
"resource": ""
} |
q17737 | Write | train | func (w *Writer) Write(b []byte) error {
w.Lock()
defer w.Unlock()
// TODO(abg): Bounds check?
binary.BigEndian.PutUint32(w.buff[:], uint32(len(b)))
if _, err := w.w.Write(w.buff[:]); err != nil {
return err
}
if len(b) == 0 {
return nil
}
_, err := w.w.Write(b)
return err
} | go | {
"resource": ""
} |
q17738 | Close | train | func (w *Writer) Close() error {
if w.closed.Swap(true) {
return nil // already closed
}
if c, ok := w.w.(io.Closer); ok {
return c.Close()
}
return nil
} | go | {
"resource": ""
} |
q17739 | RegisterWriter | train | func RegisterWriter(name string, writer io.Writer) {
m.Lock()
Writers[name] = writer
m.Unlock()
} | go | {
"resource": ""
} |
q17740 | DefaultConfig | train | func DefaultConfig() *Config {
return &Config{
LoggerLevel: INFO,
LoggerFile: "",
EnableRsyslog: false,
RsyslogNetwork: "udp",
RsyslogAddr: "127.0.0.1:5140",
LogFormatText: false,
}
} | go | {
"resource": ""
} |
q17741 | Init | train | func Init(c Config) {
if c.LoggerLevel != "" {
config.LoggerLevel = c.LoggerLevel
}
if c.LoggerFile != "" {
config.LoggerFile = c.LoggerFile
config.Writers = append(config.Writers, "file")
}
if c.EnableRsyslog {
config.EnableRsyslog = c.EnableRsyslog
}
if c.RsyslogNetwork != "" {
config.RsyslogNetwo... | go | {
"resource": ""
} |
q17742 | NewLoggerExt | train | func NewLoggerExt(component string, appGUID string) lager.Logger {
var lagerLogLevel lager.LogLevel
switch strings.ToUpper(config.LoggerLevel) {
case DEBUG:
lagerLogLevel = lager.DEBUG
case INFO:
lagerLogLevel = lager.INFO
case WARN:
lagerLogLevel = lager.WARN
case ERROR:
lagerLogLevel = lager.ERROR
case... | go | {
"resource": ""
} |
q17743 | Dial | train | func Dial(component, appguid, network, raddr string) (*Writer, error) {
hostname, _ := os.Hostname()
// construct syslog header the same to rsyslog's,
// origin, node_id, app_guid, instance_id, loglevel
syslogHeader = fmt.Sprintf("%s %s %s %s %s", component, component, appguid, hostname, "all")
var conn net.... | go | {
"resource": ""
} |
q17744 | Write | train | func (r *Writer) Write(b []byte) (int, error) {
nl := ""
if len(b) == 0 || b[len(b)-1] != '\n' {
nl = "\n"
}
r.conn.SetWriteDeadline(time.Now().Add(1 * time.Second))
_, err := fmt.Fprintf(r.conn, " %s %s%s", syslogHeader, b, nl)
if err != nil {
return 0, err
}
return len(b), nil
} | go | {
"resource": ""
} |
q17745 | unixSyslog | train | func unixSyslog() (net.Conn, error) {
networks := []string{"unixgram", "unix"}
logPaths := []string{"/dev/log", "/var/run/syslog"}
var addr string
for _, n := range networks {
for _, p := range logPaths {
addr = p
if conn, err := net.Dial(n, addr); err == nil {
return conn, nil
}
}
}
return nil, ... | go | {
"resource": ""
} |
q17746 | NewLoggerExt | train | func NewLoggerExt(component string, isFormatText bool) Logger {
return &logger{
component: component,
task: component,
sinks: []Sink{},
data: openlogging.Tags{},
logFormatText: isFormatText,
}
} | go | {
"resource": ""
} |
q17747 | Session | train | func (l *logger) Session(task string, opts ...openlogging.Option) Logger {
opt := &openlogging.Options{}
for _, o := range opts {
o(opt)
}
sid := atomic.AddUint64(&l.nextSession, 1)
var sessionIDstr string
if l.sessionID != "" {
sessionIDstr = fmt.Sprintf("%s.%d", l.sessionID, sid)
} else {
sessionIDstr ... | go | {
"resource": ""
} |
q17748 | WithData | train | func (l *logger) WithData(data openlogging.Tags) Logger {
return &logger{
component: l.component,
task: l.task,
sinks: l.sinks,
sessionID: l.sessionID,
data: l.baseData(data),
}
} | go | {
"resource": ""
} |
q17749 | SetLogLevel | train | func (l *logger) SetLogLevel(level LogLevel) {
for _, itf := range l.sinks {
if s, ok := itf.(*writerSink); ok && s.name != "file" {
continue
}
if s, ok := itf.(*ReconfigurableSink); ok {
s.SetMinLevel(level)
}
}
} | go | {
"resource": ""
} |
q17750 | activeSinks | train | func (l *logger) activeSinks(loglevel LogLevel) []Sink {
ss := make([]Sink, len(l.sinks))
idx := 0
for _, itf := range l.sinks {
if s, ok := itf.(*writerSink); ok && loglevel < s.minLogLevel {
continue
}
if s, ok := itf.(*ReconfigurableSink); ok && loglevel < LogLevel(s.minLogLevel) {
continue
}
ss[i... | go | {
"resource": ""
} |
q17751 | FormatLogLevel | train | func FormatLogLevel(x LogLevel) string {
var level string
switch x {
case DEBUG:
level = "DEBUG"
case INFO:
level = "INFO"
case WARN:
level = "WARN"
case ERROR:
level = "ERROR"
case FATAL:
level = "FATAL"
}
return level
} | go | {
"resource": ""
} |
q17752 | MarshalJSON | train | func (x LogLevel) MarshalJSON() ([]byte, error) {
// var level string
var level = FormatLogLevel(x)
return json.Marshal(level)
} | go | {
"resource": ""
} |
q17753 | Log | train | func (sink *ReconfigurableSink) Log(level LogLevel, log []byte) {
minLogLevel := LogLevel(atomic.LoadInt32(&sink.minLogLevel))
if level < minLogLevel {
return
}
sink.sink.Log(level, log)
} | go | {
"resource": ""
} |
q17754 | getTimeStamp | train | func getTimeStamp() string {
now := time.Now().Format("2006.01.02.15.04.05.000")
timeSlot := strings.Replace(now, ".", "", -1)
return timeSlot
} | go | {
"resource": ""
} |
q17755 | CopyFile | train | func CopyFile(srcFile, destFile string) error {
file, err := os.Open(srcFile)
if err != nil {
return err
}
defer file.Close()
dest, err := os.Create(destFile)
if err != nil {
return err
}
defer dest.Close()
_, err = io.Copy(dest, file)
return err
} | go | {
"resource": ""
} |
q17756 | RunLogRotate | train | func RunLogRotate(logFilePath string, c *RotateConfig, logger lager.Logger) {
Logger = logger
if logFilePath == "" {
return
}
checkConfig(c)
if c == nil {
go func() {
for {
LogRotate(filepath.Dir(logFilePath), LogRotateSize, LogBackupCount)
time.Sleep(30 * time.Second)
}
}()
} else {
if c.Ro... | go | {
"resource": ""
} |
q17757 | checkConfig | train | func checkConfig(c *RotateConfig) {
if c.RollingPolicy == "" {
log.Println("RollingPolicy is empty, use default policy[size]")
c.RollingPolicy = RollingPolicySize
} else if c.RollingPolicy != "daily" && c.RollingPolicy != RollingPolicySize {
log.Printf("RollingPolicy is error, RollingPolicy=%s, use default poli... | go | {
"resource": ""
} |
q17758 | Close | train | func (d *DL) Close() error {
if d.handle != nil {
d.mu.Lock()
defer d.mu.Unlock()
if d.handle != nil {
mu.Lock()
defer mu.Unlock()
if C.dlclose(d.handle) != 0 {
return dlerror()
}
d.handle = nil
}
}
return nil
} | go | {
"resource": ""
} |
q17759 | AddSource | train | func (s *Staert) AddSource(src Source) {
s.sources = append(s.sources, src)
} | go | {
"resource": ""
} |
q17760 | LoadConfig | train | func (s *Staert) LoadConfig() (interface{}, error) {
for _, src := range s.sources {
// Type assertion
if flg, ok := src.(*flaeg.Flaeg); ok {
fCmd, err := flg.GetCommand()
if err != nil {
return nil, err
}
// if fleag sub-command
if s.command != fCmd {
// if parseAllSources
if fCmd.Meta... | go | {
"resource": ""
} |
q17761 | parseConfigAllSources | train | func (s *Staert) parseConfigAllSources(cmd *flaeg.Command) error {
for _, src := range s.sources {
_, err := src.Parse(cmd)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q17762 | NewKvSource | train | func NewKvSource(backend store.Backend, addrs []string, options *store.Config, prefix string) (*KvSource, error) {
kvStore, err := valkeyrie.NewStore(backend, addrs, options)
return &KvSource{Store: kvStore, Prefix: prefix}, err
} | go | {
"resource": ""
} |
q17763 | Parse | train | func (kv *KvSource) Parse(cmd *flaeg.Command) (*flaeg.Command, error) {
err := kv.LoadConfig(cmd.Config)
if err != nil {
return nil, err
}
return cmd, nil
} | go | {
"resource": ""
} |
q17764 | StoreConfig | train | func (kv *KvSource) StoreConfig(config interface{}) error {
kvMap := map[string]string{}
if err := collateKvRecursive(reflect.ValueOf(config), kvMap, kv.Prefix); err != nil {
return err
}
var keys []string
for key := range kvMap {
keys = append(keys, key)
}
sort.Strings(keys)
for _, k := range keys {
var ... | go | {
"resource": ""
} |
q17765 | ListRecursive | train | func (kv *KvSource) ListRecursive(key string, pairs map[string][]byte) error {
pairsN1, err := kv.List(key, nil)
if err == store.ErrKeyNotFound {
return nil
}
if err != nil {
return err
}
if len(pairsN1) == 0 {
pairLeaf, err := kv.Get(key, nil)
if err != nil {
return err
}
if pairLeaf == nil {
r... | go | {
"resource": ""
} |
q17766 | ListValuedPairWithPrefix | train | func (kv *KvSource) ListValuedPairWithPrefix(key string) (map[string][]byte, error) {
pairs := make(map[string][]byte)
pairsN1, err := kv.List(key, nil)
if err == store.ErrKeyNotFound {
return pairs, nil
}
if err != nil {
return pairs, err
}
for _, p := range pairsN1 {
if len(p.Value) > 0 {
pairs[p.Ke... | go | {
"resource": ""
} |
q17767 | NewServerCodecContext | train | func NewServerCodecContext(ctx context.Context, conn io.ReadWriteCloser, srv *rpc.Server) rpc.ServerCodec {
codec := NewServerCodec(conn, srv)
codec.(*serverCodec).ctx = ctx
return codec
} | go | {
"resource": ""
} |
q17768 | ServeConnContext | train | func ServeConnContext(ctx context.Context, conn io.ReadWriteCloser) {
rpc.ServeCodec(NewServerCodecContext(ctx, conn, nil))
} | go | {
"resource": ""
} |
q17769 | Batch | train | func (JSONRPC2) Batch(arg BatchArg, replies *[]*json.RawMessage) (err error) {
cli, srv := net.Pipe()
defer cli.Close()
go arg.srv.ServeCodec(NewServerCodecContext(arg.Context(), srv, arg.srv))
replyc := make(chan *json.RawMessage, len(arg.reqs))
donec := make(chan struct{}, 1)
go func() {
dec := json.NewDeco... | go | {
"resource": ""
} |
q17770 | Notify | train | func (c Client) Notify(serviceMethod string, args interface{}) error {
req := &rpc.Request{
ServiceMethod: serviceMethod,
Seq: seqNotify,
}
return c.codec.WriteRequest(req, args)
} | go | {
"resource": ""
} |
q17771 | NewClientWithCodec | train | func NewClientWithCodec(codec rpc.ClientCodec) *Client {
client := rpc.NewClientWithCodec(codec)
return &Client{client, codec}
} | go | {
"resource": ""
} |
q17772 | FromContext | train | func FromContext(c context.Context) *Goon {
return &Goon{
Context: c,
cache: make(map[string]interface{}),
KindNameResolver: DefaultKindName,
}
} | go | {
"resource": ""
} |
q17773 | Key | train | func (g *Goon) Key(src interface{}) *datastore.Key {
if k, err := g.KeyError(src); err == nil {
return k
}
return nil
} | go | {
"resource": ""
} |
q17774 | Kind | train | func (g *Goon) Kind(src interface{}) string {
if k, err := g.KeyError(src); err == nil {
return k.Kind()
}
return ""
} | go | {
"resource": ""
} |
q17775 | KeyError | train | func (g *Goon) KeyError(src interface{}) (*datastore.Key, error) {
key, _, err := g.getStructKey(src)
return key, err
} | go | {
"resource": ""
} |
q17776 | Put | train | func (g *Goon) Put(src interface{}) (*datastore.Key, error) {
ks, err := g.PutMulti([]interface{}{src})
if err != nil {
if me, ok := err.(appengine.MultiError); ok {
return nil, me[0]
}
return nil, err
}
return ks[0], nil
} | go | {
"resource": ""
} |
q17777 | FlushLocalCache | train | func (g *Goon) FlushLocalCache() {
g.cacheLock.Lock()
g.cache = make(map[string]interface{})
g.cacheLock.Unlock()
} | go | {
"resource": ""
} |
q17778 | Get | train | func (g *Goon) Get(dst interface{}) error {
set := reflect.ValueOf(dst)
if set.Kind() != reflect.Ptr {
return fmt.Errorf("goon: expected pointer to a struct, got %#v", dst)
}
if !set.CanSet() {
set = set.Elem()
}
dsts := []interface{}{dst}
if err := g.GetMulti(dsts); err != nil {
// Look for an embedded er... | go | {
"resource": ""
} |
q17779 | Delete | train | func (g *Goon) Delete(key *datastore.Key) error {
keys := []*datastore.Key{key}
err := g.DeleteMulti(keys)
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
} | go | {
"resource": ""
} |
q17780 | DeleteMulti | train | func (g *Goon) DeleteMulti(keys []*datastore.Key) error {
if len(keys) == 0 {
return nil
// not an error, and it was "successful", so return nil
}
memkeys := make([]string, len(keys))
g.cacheLock.Lock()
for i, k := range keys {
mk := MemcacheKey(k)
memkeys[i] = mk
if g.inTransaction {
g.txnCacheLock... | go | {
"resource": ""
} |
q17781 | serializeStruct | train | func serializeStruct(src interface{}) ([]byte, error) {
if src == nil {
return serializeProperties(nil, false)
}
if k := reflect.Indirect(reflect.ValueOf(src)).Type().Kind(); k != reflect.Struct {
return nil, fmt.Errorf("goon: Expected struct, got instead: %v", k)
}
var err error
var props []datastore.Proper... | go | {
"resource": ""
} |
q17782 | serializeProperties | train | func serializeProperties(props []datastore.Property, exists bool) ([]byte, error) {
// NOTE: We use a separate exists bool to support nil-props for existing structs
if !exists {
return []byte{0, 0, 0, 0}, nil
}
buf := getBuffer()
defer freeBuffer(buf)
// Serialize the entity header
header := serializeEntityH... | go | {
"resource": ""
} |
q17783 | deserializeStruct | train | func deserializeStruct(dst interface{}, b []byte) error {
if len(b) == 0 {
return fmt.Errorf("goon: Expected some data to deserialize, got none.")
}
if k := reflect.Indirect(reflect.ValueOf(dst)).Type().Kind(); k != reflect.Struct {
return fmt.Errorf("goon: Expected struct, got instead: %v", k)
}
// Deseriali... | go | {
"resource": ""
} |
q17784 | deserializeProperties | train | func deserializeProperties(dst interface{}, props []datastore.Property) error {
if k := reflect.Indirect(reflect.ValueOf(dst)).Type().Kind(); k != reflect.Struct {
return fmt.Errorf("goon: Expected struct, got instead: %v", k)
}
if pls, ok := dst.(datastore.PropertyLoadSaver); ok {
return pls.Load(props)
}
ret... | go | {
"resource": ""
} |
q17785 | getStructKey | train | func (g *Goon) getStructKey(src interface{}) (key *datastore.Key, hasStringId bool, err error) {
v := reflect.Indirect(reflect.ValueOf(src))
t := v.Type()
k := t.Kind()
if k != reflect.Struct {
err = fmt.Errorf("goon: Expected struct, got instead: %v", k)
return
}
var parent *datastore.Key
var stringID str... | go | {
"resource": ""
} |
q17786 | Count | train | func (g *Goon) Count(q *datastore.Query) (int, error) {
return q.Count(g.Context)
} | go | {
"resource": ""
} |
q17787 | Run | train | func (g *Goon) Run(q *datastore.Query) *Iterator {
return &Iterator{
g: g,
i: q.Run(g.Context),
}
} | go | {
"resource": ""
} |
q17788 | Draw | train | func (g *drawer) Draw(s string, size int, bg *color.RGBA) image.Image {
// draw the background
dst := image.NewRGBA(image.Rect(0, 0, size, size))
draw.Draw(dst, dst.Bounds(), &image.Uniform{bg}, image.ZP, draw.Src)
// draw the text
drawer := &font.Drawer{
Dst: dst,
Src: image.White,
Face: g.face,
}
// ... | go | {
"resource": ""
} |
q17789 | New | train | func New(fontFile string) *InitialsAvatar {
avatar := NewWithConfig(Config{
MaxItems: 1024, // default to 1024 items.
FontFile: fontFile,
})
return avatar
} | go | {
"resource": ""
} |
q17790 | NewWithConfig | train | func NewWithConfig(cfg Config) *InitialsAvatar {
var err error
avatar := new(InitialsAvatar)
avatar.drawer, err = newDrawer(cfg.FontFile, cfg.FontSize)
if err != nil {
panic(err.Error())
}
avatar.cache = lru.New(lru.Config{
MaxItems: cfg.MaxItems,
MaxBytes: cfg.MaxBytes,
})
return avatar
} | go | {
"resource": ""
} |
q17791 | DrawToBytes | train | func (a *InitialsAvatar) DrawToBytes(name string, size int, encoding ...string) ([]byte, error) {
if size <= 0 {
size = 48 // default size
}
name = strings.TrimSpace(name)
firstRune := []rune(name)[0]
if !isHan(firstRune) && !unicode.IsLetter(firstRune) {
return nil, ErrUnsupportChar
}
initials := getInitial... | go | {
"resource": ""
} |
q17792 | isHan | train | func isHan(r rune) bool {
if unicode.Is(unicode.Scripts["Han"], r) {
return true
}
return false
} | go | {
"resource": ""
} |
q17793 | parseRegistrant | train | func parseRegistrant(registrant Registrant, name, value string) Registrant {
keyName := FindKeyName(name)
switch keyName {
case "registrant_id":
registrant.ID = value
case "registrant_name":
registrant.Name = value
case "registrant_organization":
registrant.Organization = value
case "registrant_street":
r... | go | {
"resource": ""
} |
q17794 | IsNotFound | train | func IsNotFound(data string) bool {
notExistsKeys := []string{
"no found",
"no match",
"not found",
"not match",
"no entries found",
"no data found",
"not registered",
"not been registered",
"is free",
"not available for registration",
"object does not exist",
}
data = strings.ToLower(data)
f... | go | {
"resource": ""
} |
q17795 | IsLimitExceeded | train | func IsLimitExceeded(data string) bool {
data = strings.ToLower(data)
return strings.Contains(data, "limit exceeded")
} | go | {
"resource": ""
} |
q17796 | ClearName | train | func ClearName(key string) string {
if strings.Contains(key, "(") {
key = strings.Split(key, "(")[0]
}
key = strings.Replace(key, "-", " ", -1)
key = strings.Replace(key, "_", " ", -1)
key = strings.Replace(key, "/", " ", -1)
key = strings.Replace(key, "\\", " ", -1)
key = strings.Replace(key, "'", " ", -1)
... | go | {
"resource": ""
} |
q17797 | FindKeyName | train | func FindKeyName(key string) string {
key = ClearName(key)
if v, ok := keyRule[key]; ok {
return v
}
return ""
} | go | {
"resource": ""
} |
q17798 | RemoveDuplicateField | train | func RemoveDuplicateField(data string) string {
fs := []string{}
for _, v := range strings.Split(data, ",") {
if strings.TrimSpace(v) != "" {
fs = append(fs, v)
}
}
fields := xslice.Unique(fs)
result := strings.Join(fields.([]string), ",")
return result
} | go | {
"resource": ""
} |
q17799 | FixDomainStatus | train | func FixDomainStatus(state string) string {
states := strings.Split(state, ",")
for k, v := range states {
names := strings.Split(strings.TrimSpace(v), " ")
states[k] = names[0]
}
return strings.Join(states, ",")
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.