_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
}
return true
} | 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
}
return true
} | 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))); err != nil {
return "", fmt.Errorf("failed to set tag: %v", err)
}
// Process go.tags and overwrite JSON tag if specified in Thrift
// annotation.
if goAnnotation := f.Annotations[goTagKey]; goAnnotation != "" {
goTags, err := structtag.Parse(goAnnotation)
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)
}
}
}
return fmt.Sprintf("`%s`", tags.String()), nil
} | 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 id, err
} | 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 := g.importer.RelativePackage(thriftPath)
if err != nil {
return 0, err
}
g.Modules[id] = &api.Module{
ImportPath: importPath,
Directory: dir,
ThriftFilePath: thriftPath,
}
return id, nil
} | 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,
)
}
return wire.NewValueBool(b == 1), off, nil
case wire.TI8:
b, off, err := br.readByte(off)
return wire.NewValueI8(int8(b)), off, err
case wire.TDouble:
value, off, err := br.readInt64(off)
d := math.Float64frombits(uint64(value))
return wire.NewValueDouble(d), off, err
case wire.TI16:
n, off, err := br.readInt16(off)
return wire.NewValueI16(n), off, err
case wire.TI32:
n, off, err := br.readInt32(off)
return wire.NewValueI32(n), off, err
case wire.TI64:
n, off, err := br.readInt64(off)
return wire.NewValueI64(n), off, err
case wire.TBinary:
v, off, err := br.readBytes(off)
return wire.NewValueBinary(v), off, err
case 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(off)
return wire.NewValueList(l), off, err
default:
return wire.Value{}, off, decodeErrorf("unknown ttype %v", t)
}
} | 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:
return '_'
}
}, packageName)
} | 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,
Line: astItem.Line,
Reason: err,
}
}
value := prev + 1
if astItem.Value != nil {
value = *astItem.Value
}
prev = value
itemAnnotations, err := compileAnnotations(astItem.Annotations)
if err != nil {
return nil, compileError{
Target: src.Name + "." + astItem.Name,
Line: astItem.Line,
Reason: err,
}
}
// TODO bounds check for value
item := EnumItem{
Name: astItem.Name,
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{
Name: src.Name,
File: file,
Doc: src.Doc,
Items: items,
Annotations: annotations,
}, nil
} | 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 &I16Spec{Annotations: annots}, nil
case ast.I32TypeID:
return &I32Spec{Annotations: annots}, nil
case ast.I64TypeID:
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))
}
} | 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]
return service.Handle(name, req)
} | 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 != nil {
return wire.Value{}, err
}
return result.ToWire()
case "handshake":
var args Plugin_Handshake_Args
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)
}
} | 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()
return m.ForEach(func(item MapItem) error {
if err := EvaluateValue(item.Key); err != nil {
return err
}
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())
}
} | 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
}
importedName = fmt.Sprintf("%s%d", name, i)
}
g.imports[path] = importedName
g.globals[importedName] = struct{}{}
return importedName
} | 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 "int16", nil
case api.SimpleTypeInt32:
return "int32", nil
case api.SimpleTypeInt64:
return "int64", nil
case api.SimpleTypeFloat64:
return "float64", nil
case api.SimpleTypeString:
return "string", nil
case api.SimpleTypeStructEmpty:
return "struct{}", nil
default:
return "", fmt.Errorf("unknown simple type: %v", *t.SimpleType)
}
case t.SliceType != nil:
v, err := g.FormatType(t.SliceType)
return "[]" + v, err
case t.KeyValueSliceType != nil:
k, err := g.FormatType(t.KeyValueSliceType.Left)
if err != nil {
return "", err
}
v, err := g.FormatType(t.KeyValueSliceType.Right)
return fmt.Sprintf("[]struct{Key %v; Value %v}", k, v), err
case t.MapType != nil:
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.ReferenceType.Name, nil
}
importName := g.Import(t.ReferenceType.ImportPath)
return importName + "." + t.ReferenceType.Name, nil
case t.PointerType != nil:
v, err := g.FormatType(t.PointerType)
return "*" + v, err
default:
return "", fmt.Errorf("unknown type: %v", t)
}
} | 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 != nil {
return nil, fmt.Errorf("failed to parse template %q: %v", filename, err)
}
var buff bytes.Buffer
if err := t.Execute(&buff, data); err != nil {
return nil, err
}
fset := token.NewFileSet()
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 function")
}
importPaths := make([]string, 0, len(g.imports))
for path := range g.imports {
importPaths = append(importPaths, path)
}
sort.Strings(importPaths)
for _, path := range importPaths {
astutil.AddNamedImport(fset, f, g.imports[path], path)
}
buff = bytes.Buffer{}
if err := format.Node(&buff, fset, f); err != nil {
return nil, err // TODO wrap error
}
return buff.Bytes(), nil
} | 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.GetStruct()
case TMap:
return v.GetMap()
case TSet, TList:
return v.GetList()
default:
panic(fmt.Sprintf("Unknown value type %v", v.typ))
}
} | 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.RsyslogNetwork = c.RsyslogNetwork
}
if c.RsyslogAddr != "" {
config.RsyslogAddr = c.RsyslogAddr
}
if len(c.Writers) == 0 {
config.Writers = append(config.Writers, "stdout")
} else {
config.Writers = c.Writers
}
config.LogFormatText = c.LogFormatText
RegisterWriter("stdout", os.Stdout)
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")
}
RegisterWriter("file", file)
}
}
} | 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 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.NewReconfigurableSink(lager.NewWriterSink(sink, writer, lager.DEBUG), lagerLogLevel)
logger.RegisterSink(sink)
}
return logger
} | 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.Conn
var err error
if network == "" {
conn, err = unixSyslog()
} else {
conn, err = net.Dial(network, raddr)
}
return &Writer{
conn: conn,
}, err
} | 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, errors.New("Could not connect to local syslog socket")
} | 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 = 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),
}
} | 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[idx] = itf
idx++
}
return ss[:idx]
} | 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.RollingPolicy == RollingPolicySize {
go func() {
for {
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))
}
}()
}
}
} | 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 policy[size].", c.RollingPolicy)
c.RollingPolicy = RollingPolicySize
}
if c.LogRotateDate <= 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
}
} | 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.Metadata["parseAllSources"] == "true" {
fCmdConfigType := reflect.TypeOf(fCmd.Config)
sCmdConfigType := reflect.TypeOf(s.command.Config)
if fCmdConfigType != sCmdConfigType {
return nil, fmt.Errorf("command %s : Config type doesn't match with 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)
return s.command.Config, err
} | 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 writeOptions *store.WriteOptions
// is it a directory ?
if strings.HasSuffix(k, "/") {
writeOptions = &store.WriteOptions{
IsDir: true,
}
}
if err := kv.Put(k, []byte(kvMap[k]), writeOptions); err != nil {
return err
}
}
return nil
} | 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 {
return nil
}
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
} | 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.Key] = p.Value
}
}
return pairs, nil
} | 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.NewDecoder(cli)
*replies = make([]*json.RawMessage, 0, len(arg.reqs))
for reply := range replyc {
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 arg.reqs {
if req == nil || json.Unmarshal(*req, &testreq) != nil {
replyc <- &jErrRequest
} else {
if testreq.ID != nil {
replyc <- nil
}
if _, err = cli.Write(append(*req, '\n')); err != nil {
break
}
}
}
close(replyc)
<-donec
return err
} | 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 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
} | 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.Lock()
g.toDelete[mk] = true
g.txnCacheLock.Unlock()
} else {
delete(g.cache, mk)
}
}
g.cacheLock.Unlock()
// Memcache needs to be updated after the datastore to prevent a common race condition,
// where a concurrent request will fetch the not-yet-updated data from the datastore
// and populate memcache with it.
if g.inTransaction {
g.txnCacheLock.Lock()
for _, mk := range memkeys {
g.toDeleteMC[mk] = true
}
g.txnCacheLock.Unlock()
} else {
defer memcache.DeleteMulti(g.Context, memkeys)
}
mu := new(sync.Mutex)
multiErr, any := make(appengine.MultiError, len(keys)), false
goroutines := (len(keys)-1)/deleteMultiLimit + 1
var wg sync.WaitGroup
wg.Add(goroutines)
for i := 0; i < goroutines; i++ {
go 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.Unlock()
merr, ok := dmerr.(appengine.MultiError)
if !ok {
g.error(dmerr)
for j := lo; j < hi; j++ {
multiErr[j] = dmerr
}
return
}
copy(multiErr[lo:hi], merr)
}
}(i)
}
wg.Wait()
if any {
return realError(multiErr)
}
return nil
} | 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.Property
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)
} | 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 := serializeEntityHeader(len(props), entityExists)
headerBytes := make([]byte, 4)
binary.LittleEndian.PutUint32(headerBytes, header)
buf.Write(headerBytes)
// 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
} | 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)
}
// Deserialize the 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++ {
if err := deserializeProperty(buf, &props[i]); err != nil {
return err
}
}
return deserializeProperties(dst, props)
} | 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)
}
return datastore.LoadStruct(dst, props)
} | 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 string
var intID int64
var kind string
for i := 0; i < v.NumField(); i++ {
tf := t.Field(i)
vf := v.Field(i)
tag := tf.Tag.Get("goon")
tagValues := strings.Split(tag, ",")
if len(tagValues) > 0 {
tagValue := tagValues[0]
if tagValue == "id" {
switch vf.Kind() {
case reflect.Int64:
if intID != 0 || stringID != "" {
err = fmt.Errorf("goon: Only one field may be marked id")
return
}
intID = vf.Int()
case reflect.String:
if intID != 0 || stringID != "" {
err = fmt.Errorf("goon: Only one field may be marked id")
return
}
stringID = vf.String()
hasStringId = true
default:
err = fmt.Errorf("goon: ID field must be int64 or string in %v", t.Name())
return
}
} else if tagValue == "kind" {
if vf.Kind() == reflect.String {
if kind != "" {
err = fmt.Errorf("goon: Only one field may be marked kind")
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.Errorf("goon: Only one field may be marked parent")
return
}
parent = vf.Convert(dskeyType).Interface().(*datastore.Key)
}
}
}
}
// if kind has not been manually set, fetch it from src's type
if kind == "" {
kind = g.KindNameResolver(src)
}
key = datastore.NewKey(g.Context, kind, stringID, intID, parent)
return
} | 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,
}
// font index
fi := g.font.Index([]rune(s)[0])
// glyph example: http://www.freetype.org/freetype2/docs/tutorial/metrics.png
var gbuf truetype.GlyphBuf
var err error
fsize := fixed.Int26_6(g.fontSize * g.dpi * (64.0 / 72.0))
err = gbuf.Load(g.font, fsize, fi, font.HintingFull)
if err != nil {
// fixme
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: fixed.I(y),
}
drawer.DrawString(s)
return dst
} | 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 := getInitials(name)
bgcolor := getColorByName(name)
// get from cache
v, ok := a.cache.GetBytes(lru.Key(initials))
if ok {
return v, nil
}
m := a.drawer.Draw(initials, size, bgcolor)
// encode the image
var buf bytes.Buffer
enc := "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.SetBytes(lru.Key(initials), buf.Bytes())
return buf.Bytes(), nil
} | 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":
registrant.Street = value
case "registrant_city":
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 = value
case "registrant_fax":
registrant.Fax = value
case "registrant_fax_ext":
registrant.FaxExt = value
case "registrant_email":
registrant.Email = strings.ToLower(value)
}
return registrant
} | 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)
for _, v := range notExistsKeys {
if strings.Contains(data, v) {
return true
}
}
return false
} | 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)
key = strings.Replace(key, ".", " ", -1)
key = strings.TrimSpace(key)
key = strings.ToLower(key)
return key
} | 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.