// Tags routes tags commands to their specific function
497731
func Tags(argv []string) error {
	usage := `
Valid commands for tags:

tags:list        list tags for an app
tags:set         set tags for an app
tags:unset       unset tags for an app

Use 'deis help [command]' to learn more.
`

	switch argv[0] {
	case "tags:list":
		return tagsList(argv)
	case "tags:set":
		return tagsSet(argv)
	case "tags:unset":
		return tagsUnset(argv)
	default:
		if printHelp(argv, usage) {
			return nil
		}

		if argv[0] == "tags" {
			argv[0] = "tags:list"
			return tagsList(argv)
		}

		PrintUsage()
		return nil
	}
}
1203655
func Tags(tags map[string]string) TracerOption {
	return func(o *tracerOptions) {
		for k, v := range tags {
			o.tags[k] = v
		}
	}
}
1119368
func (ext *Extractor) Tags() []string {
	num := int(C.mitie_get_num_possible_ner_tags(ext.ner))
	tags := make([]string, num, num)
	for i := 0; i < num; i++ {
		tags[i] = ext.tagString(i)
	}
	return tags
}
1197354
func tagsFromMapRDS(m map[string]interface{}) []*rds.Tag {
	result := make([]*rds.Tag, 0, len(m))
	for k, v := range m {
		t := &rds.Tag{
			Key:   aws.String(k),
			Value: aws.String(v.(string)),
		}
		if !tagIgnoredRDS(t) {
			result = append(result, t)
		}
	}

	return result
}
607228
func (r *RepositoryService) ListTags(repo string, auth Authenticator) (TagMap, error) {
	path := fmt.Sprintf("repositories/%s/tags", repo)
	req, err := r.client.newRequest("GET", path, auth, nil)
	if err != nil {
		return nil, err
	}

	tags := TagMap{}
	_, err = r.client.do(req, &tags)
	if err != nil {
		return nil, err
	}

	return tags, nil
}
922406
func (as AnnotatedSentence) Tags() []POSTag {
	retVal := make([]POSTag, len(as))
	for i, a := range as {
		retVal[i] = a.POSTag
	}
	return retVal
}
310526
func Tags(tags map[string]string) SpanOption {
	return func(t *Tracer, s *spanImpl) {
		for k, v := range tags {
			s.Tags[k] = v
		}
	}
}
1095392
func ServerTags(tags map[string]string) ServerOption {
	return func(h *serverHandler) {
		h.defaultTags = tags
	}
}
251865
func tagsFromMapEFS(m map[string]interface{}) []*efs.Tag {
	var result []*efs.Tag
	for k, v := range m {
		t := &efs.Tag{
			Key:   aws.String(k),
			Value: aws.String(v.(string)),
		}
		if !tagIgnoredEFS(t) {
			result = append(result, t)
		}
	}

	return result
}
822778
func (j *Job) Tags() map[string]string {
	if j.Formation == nil {
		return nil
	}
	return j.Formation.Tags[j.Type]
}
328847
func (p *Path) OutWithTags(tags []string, via ...interface{}) *Path {
	np := p.clone()
	np.stack = append(np.stack, outMorphism(tags, via...))
	return np
}
235042
func Tags(obj interface{}, key string) (map[string]string, error) {
	return tags(obj, key, false)
}
944974
func (c *TasksRequestsCall) Tags(tags ...string) *TasksRequestsCall {
	c.urlParams_.SetMulti("tags", append([]string{}, tags...))
	return c
}
528549
func (s *Sentry) Tag(key, value string) {
	s.Lock()
	s.client.Tags[key] = value
	s.Unlock()
}
429985
func (tn *tagNode) Tag() []string {
	out := make([]string, len(tn.tag))
	copy(out, tn.tag)
	return out
}
658669
func (c *Config) ListTags() string {
	var tags []string

	for k, v := range c.Tags {
		tags = append(tags, fmt.Sprintf("%s=%s", k, v))
	}

	sort.Strings(tags)

	return strings.Join(tags, " ")
}
168217
func (packet *Packet) AddTags(tags map[string]string) {
	for k, v := range tags {
		packet.Tags = append(packet.Tags, Tag{k, v})
	}
}