// ToNames returns the name in an arry of HandlerName.
512226
func (hns HandlerNames) ToNames() []string {
	var names = make([]string, len(hns))
	for i, hn := range hns {
		names[i] = hn.Name
	}
	return names
}
916771
func HandlerName(entry *logrus.Entry, _ *CustomFormatter) (interface{}, error) {
	if value, ok := entry.Data["name"]; ok {
		return value.(string), nil
	}
	return "", nil
}
617571
func (sel *selector) names() string {
	bf := new(bytes.Buffer)

	switch parent := sel.parent.(type) {
	case nil, *atRule:
		for _, name := range strings.Split(sel.name, comma) {
			if bf.Len() > 0 {
				bf.WriteString(comma)
			}

			bf.WriteString(strings.TrimSpace(name))
		}
	case *selector:
		for _, parentS := range strings.Split(parent.names(), comma) {
			for _, s := range strings.Split(sel.name, comma) {
				if bf.Len() > 0 {
					bf.WriteString(comma)
				}

				s = strings.TrimSpace(s)

				if strings.Index(s, ampersand) != -1 {
					bf.WriteString(strings.Replace(s, ampersand, parentS, -1))
				} else {
					bf.WriteString(parentS)
					bf.WriteString(space)
					bf.WriteString(s)
				}
			}
		}
	}

	return bf.String()
}
1123203
func (a *API) OperationNames() []string {
	i, names := 0, make([]string, len(a.Operations))
	for n := range a.Operations {
		names[i] = n
		i++
	}
	sort.Strings(names)
	return names
}
721811
func (r *HandlerRegistry) Handler(cname string) *Handler {
	r.mutex.Lock()
	h := r.handlers[cname]
	r.mutex.Unlock()
	return h
}
256717
func names(m map[string]*jsonschema.Schema) []string {
	ret := make([]string, 0, len(m))
	for n := range m {
		ret = append(ret, n)
	}
	sort.Strings(ret)
	return ret
}
970818
func (c *Command) NameAndAliases() string {
	return strings.Join(append([]string{c.Name()}, c.Aliases...), ", ")
}
1067903
func (c *Config) AggregatorNames() []string {
	var name []string
	for _, aggregator := range c.Aggregators {
		name = append(name, aggregator.Config.Name)
	}
	return name
}
204102
func ToName(serviceName string, methodName string) string {
	return fmt.Sprintf("%s::%s", serviceName, methodName)
}
879646
func (r Event_Log) GetAllEventNames(objectName *string) (resp []string, err error) {
	params := []interface{}{
		objectName,
	}
	err = r.Session.DoRequest("SoftLayer_Event_Log", "getAllEventNames", params, &r.Options, &resp)
	return
}
225841
func Named(query string, arg interface{}) (string, []interface{}, error) {
	return bindNamedMapper(QUESTION, query, arg, mapper())
}
1082198
func (mg MutexGroup) Names() []string {
	r := make([]string, len(mg))
	for i, flag := range mg {
		r[i] = flag.Name()
	}
	return r
}
1182334
func Names() []string {
	// TODO eliminate duplicates
	var names []string
	for _, f := range factories {
		names = append(names, f.Names()...)
	}
	return names
}
1126957
func (r *QueryResults) SortedNames() []string {
	names := r.Names()
	sort.Strings(names)
	return names
}
245666
func (l paramsList) Names() []string {
	var names []string
	for _, item := range l {
		names = append(names, item.Name)
	}
	return names
}
959541
func (b *Builder) ResourceNames(resource string, names ...string) *Builder {
	for _, name := range names {
		// See if this input string is of type/name format
		tuple, ok, err := splitResourceTypeName(name)
		if err != nil {
			b.errs = append(b.errs, err)
			return b
		}

		if ok {
			b.resourceTuples = append(b.resourceTuples, tuple)
			continue
		}
		if len(resource) == 0 {
			b.errs = append(b.errs, fmt.Errorf("the argument %q must be RESOURCE/NAME", name))
			continue
		}

		// Use the given default type to create a resource tuple
		b.resourceTuples = append(b.resourceTuples, resourceTuple{Resource: resource, Name: name})
	}
	return b
}
1022087
func (exs Examples) Names() []string {
	names := make([]string, 0, len(exs))
	for k := range exs {
		names = append(names, k)
	}

	sort.Strings(names)
	return names
}