// AddTag adds a no-value parameter (e.g.: checked, disabled) to the field.
427258
func (f *Field) AddTag(tag string) FieldInterface {
	f.tag[tag] = struct{}{}
	return f
}
1215138
func (s *AnalyticsFilter) SetTag(v *Tag) *AnalyticsFilter {
	s.Tag = v
	return s
}
421877
func (f FormFor) InputTag(field string, opts tags.Options) *tags.Tag {
	f.buildOptions(field, opts)
	f.addFormatTag(field, opts)
	return f.Form.InputTag(opts)
}
1221149
func (g *Group) Tag(items map[string]string) *Statement {
	// notest
	// don't think this can ever be used in valid code?
	s := Tag(items)
	g.items = append(g.items, s)
	return s
}
412772
func (s *TaggedResource) SetTag(v *Tag) *TaggedResource {
	s.Tag = v
	return s
}
130352
func (r *Route) Tag(value interface{}) *Route {
	if len(r.routes) > 0 {
		// this route is a composite one (a path with multiple methods)
		for _, route := range r.routes {
			route.Tag(value)
		}
		return r
	}
	if r.tags == nil {
		r.tags = []interface{}{}
	}
	r.tags = append(r.tags, value)
	return r
}
564088
func (f Form) CheckboxTag(opts tags.Options) *tags.Tag {
	return divWrapper(opts, func(o tags.Options) tags.Body {
		return f.Form.CheckboxTag(o)
	})
}
703441
func (f FormFor) HiddenTag(field string, opts tags.Options) *tags.Tag {
	f.buildOptions(field, opts)
	return f.Form.HiddenTag(opts)
}
1251466
func JavascriptTag(opts Options) *Tag {
	if opts["src"] != nil {
		delete(opts, "body")
	}

	return New("script", opts)
}
522963
func (s *Span) SetTag(key string, value interface{}) opentracing.Span {
	if s.Tags == nil {
		s.Tags = map[string]string{}
	}
	var val string

	// TODO mutex
	switch v := value.(type) {
	case string:
		val = v
	case fmt.Stringer:
		val = v.String()
	default:
		// TODO maybe just ban non-strings?
		val = fmt.Sprintf("%#v", value)
	}
	s.Tags[key] = val
	return s
}
552393
func RegisterTag(name string, parserFn TagParser) error {
	_, existing := tags[name]
	if existing {
		return errors.Errorf("tag with name '%s' is already registered", name)
	}
	tags[name] = &tag{
		name:   name,
		parser: parserFn,
	}
	return nil
}
528549
func (s *Sentry) Tag(key, value string) {
	s.Lock()
	s.client.Tags[key] = value
	s.Unlock()
}
381674
func (mr *MockRuntimeReaderMockRecorder) Tag(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockRuntimeReader)(nil).Tag), arg0)
}
443795
func (t *Tags) Add(tag string) error {
	ts := *t
	trim := strings.TrimSpace(tag)
	if trim == "" {
		return e.New(e.ErrEmptyString)
	}
	if err := CheckTag(trim); err != nil {
		return e.Forward(err)
	}
	i := sort.SearchStrings(ts, trim)
	if i >= ts.Len() || ts[i] != trim { // Not found
		//ts = append(ts, trim)
		//sort.Strings(ts)
		ts = append(ts[:i], append(Tags{trim}, ts[i:]...)...)
	} else {
		return e.New(ErrTagExist)
	}
	*t = ts
	return nil
}
1027818
func StatusCodeTag(code int) errors.TagValue {
	return errors.TagValue{Key: statusCodeTagKey, Value: code}
}
825585
func (s *PartOfSpeechTag) SetTag(v string) *PartOfSpeechTag {
	s.Tag = &v
	return s
}
594471
func (a *Annotator) Tag(tags ...TagValueGenerator) *Annotator {
	if a == nil {
		return a
	}
	tagMap := make(map[TagKey]interface{}, len(tags))
	for _, t := range tags {
		v := t.GenerateErrorTagValue()
		tagMap[v.Key] = v.Value
	}
	if len(tagMap) > 0 {
		if a.ctx.tags == nil {
			a.ctx.tags = tagMap
		} else {
			for k, v := range tagMap {
				a.ctx.tags[k] = v
			}
		}
	}
	return a
}