// OutWithTags is exactly like In, except it tags the value of the predicate
// traversed with the tags provided.
328847
func (p *Path) OutWithTags(tags []string, via ...interface{}) *Path {
	np := p.clone()
	np.stack = append(np.stack, outMorphism(tags, via...))
	return np
}
552832
func fieldByTag(x interface{}, tag string) string {
	tagm := tags(x)
	v := reflect.ValueOf(x)
	if v.Kind() == reflect.Ptr {
		v = v.Elem()
	}
	if i, ok := tagm[tag]; ok {
		return v.Field(i).Interface().(string)
	}
	return ""
}
708655
func (r *Reader) ReadBytesWithoutTag() (b []byte) {
	l := r.readLength()
	b = make([]byte, l)
	if _, err := r.Read(b); err != nil {
		panic(err)
	}
	r.readByte()
	if !r.Simple {
		setReaderRef(r, b)
	}
	return
}
224654
func (s *stat) Tags() map[string]string {
	m := make(map[string]string, len(s.tags))
	for k, v := range s.tags {
		m[k] = v
	}
	return m
}
1124384
func WithTags(ctx context.Context, tags []string) context.Context {
	stats, ok := FromContext(ctx)
	if !ok {
		return ctx
	}
	return WithStats(ctx, &taggedStats{tags, stats})
}
1090284
func (mv *Validator) WithTag(tag string) *Validator {
	v := mv.copy()
	v.SetTag(tag)
	return v
}
288245
func (s *WriteSegmentRequest) SetTags(v map[string]*string) *WriteSegmentRequest {
	s.Tags = v
	return s
}
1347973
func (s *EventFilter) SetTags(v []map[string]*string) *EventFilter {
	s.Tags = v
	return s
}
1046397
func ListTags() (tags []string, err error) {
	var task = "Get release tags"

	// Get all release tags.
	stdout, err := git.RunCommand("tag", "--list", "v*.*.*")
	if err != nil {
		return nil, errs.NewError(task, err)
	}

	// Parse the output to get sortable versions.
	var vers []*version.Version
	scanner := bufio.NewScanner(stdout)
	for scanner.Scan() {
		line := scanner.Text()
		if line == "" {
			continue
		}
		line = line[1:] // strip "v"
		ver, _ := version.Parse(line)
		vers = append(vers, ver)
	}
	if err := scanner.Err(); err != nil {
		return nil, errs.NewError(task, err)
	}

	// Sort the versions.
	sort.Sort(version.Versions(vers))

	// Convert versions back to tag names and return.
	tgs := make([]string, 0, len(vers))
	for _, ver := range vers {
		tgs = append(tgs, "v"+ver.String())
	}
	return tgs, nil
}
633616
func (s *Resource) SetTags(v map[string]*string) *Resource {
	s.Tags = v
	return s
}
479918
func NewWithTags(dsn string, tags map[string]string) (*Client, error) {
	client := newClient(tags)
	return client, client.SetDSN(dsn)
}
572793
func (a MultiStatsClient) WithTags(tags ...string) StatsClient {
	other := make(MultiStatsClient, len(a))
	for i := range a {
		other[i] = a[i].WithTags(tags...)
	}
	return other
}
827302
func (s *Expression) SetTags(v *TagValues) *Expression {
	s.Tags = v
	return s
}
1147140
func (s *Services) WithTag(tag string) ([]Service, error) {
	result := []Service{}
	for _, services := range *s {
		for i := range services {
			service := services[i]
			for _, t := range service.Tags {
				if strings.EqualFold(tag, t) {
					result = append(result, service)
					break
				}
			}
		}
	}

	if len(result) > 0 {
		return result, nil
	}

	return nil, fmt.Errorf("no services with tag %s", tag)
}
310526
func Tags(tags map[string]string) SpanOption {
	return func(t *Tracer, s *spanImpl) {
		for k, v := range tags {
			s.Tags[k] = v
		}
	}
}
718590
func (t *Tracer) Tags() []opentracing.Tag {
	tags := make([]opentracing.Tag, len(t.tags))
	for i, tag := range t.tags {
		tags[i] = opentracing.Tag{Key: tag.key, Value: tag.value}
	}
	return tags
}
590657
func (s *GetFunctionDefinitionOutput) SetTags(v map[string]*string) *GetFunctionDefinitionOutput {
	s.Tags = v
	return s
}