// gtk_text_tag_event
518906
func newTextTag(tag *C.GtkTextTag) *TextTag { // TODO
	return &TextTag{
		GTextTag: tag,
		GObject:  glib.ObjectFromNative(unsafe.Pointer(tag)),
	}
}
427258
func (f *Field) AddTag(tag string) FieldInterface {
	f.tag[tag] = struct{}{}
	return f
}
690211
func (w *mlWriter) OpenTag(tag []string) error {
	w.activatePlugin(tag[0])
	w.writeIndent(true)
	if err := w.activePlugin().OpenTag(tag); err != nil {
		return err
	}
	w.writeNewline()
	w.indent++
	return nil
}
889626
func (r *PURuntime) Tag(key string) (string, bool) {
	r.Lock()
	defer r.Unlock()

	tag, ok := r.tags.Get(key)
	return tag, ok
}
812757
func tagsToMapCloudWatchEvents(ts []*events.Tag) map[string]string {
	result := make(map[string]string)
	for _, t := range ts {
		if !tagIgnoredCloudWatchEvents(t) {
			result[*t.Key] = *t.Value
		}
	}

	return result
}
1221529
func (m *Message) AddTag(tag ...string) error {
	if len(m.tags) >= MaxNumberOfTags {
		return fmt.Errorf("cannot add any new tags. Message tag limit (%b) reached", MaxNumberOfTags)
	}

	m.tags = append(m.tags, tag...)
	return nil
}
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
}
1089617
func (c *Client) Event(e *Event) error {
	if c == nil {
		return fmt.Errorf("Client is nil")
	}
	stat, err := e.Encode(c.Tags...)
	if err != nil {
		return err
	}
	return c.sendMsg([]byte(stat))
}
1162079
func (client *Client) SetTagsContext(t map[string]string) {
	client.mu.Lock()
	defer client.mu.Unlock()
	client.context.setTags(t)
}
1265943
func (c *TasksCountCall) Tags(tags ...string) *TasksCountCall {
	c.urlParams_.SetMulti("tags", append([]string{}, tags...))
	return c
}
659535
func NewText(tags core.TagSlice) (*Text, error) {
	text := new(Text)

	// set default
	text.RelativeXScale = 1.0
	text.StyleName = "STANDARD"
	text.ExtrusionDirection = core.Point{X: 0.0, Y: 0.0, Z: 1.0}

	text.InitBaseEntityParser()
	text.Update(map[int]core.TypeParser{
		1:  core.NewStringTypeParserToVar(&text.Value),
		7:  core.NewStringTypeParserToVar(&text.StyleName),
		10: core.NewFloatTypeParserToVar(&text.FirstAlignmentPoint.X),
		20: core.NewFloatTypeParserToVar(&text.FirstAlignmentPoint.Y),
		30: core.NewFloatTypeParserToVar(&text.FirstAlignmentPoint.Z),
		39: core.NewFloatTypeParserToVar(&text.Thickness),
		40: core.NewFloatTypeParserToVar(&text.Height),
		41: core.NewFloatTypeParserToVar(&text.RelativeXScale),
		50: core.NewFloatTypeParserToVar(&text.Rotation),
		51: core.NewFloatTypeParserToVar(&text.ObliqueAngle),
		71: core.NewIntTypeParser(func(flags int) {
			text.MirroredX = flags&backwardTextBit != 0
			text.MirroredY = flags&upsideDownTextBit != 0
		}),
		72: core.NewIntTypeParser(func(value int) {
			text.HorizontalJustification = HorizontalTextJustification(value)
		}),
		73: core.NewIntTypeParser(func(value int) {
			text.VerticalJustification = VerticalTextJustification(value)
		}),
		11:  core.NewFloatTypeParserToVar(&text.SecondAlignmentPoint.X),
		21:  core.NewFloatTypeParserToVar(&text.SecondAlignmentPoint.Y),
		31:  core.NewFloatTypeParserToVar(&text.SecondAlignmentPoint.Z),
		210: core.NewFloatTypeParserToVar(&text.ExtrusionDirection.X),
		220: core.NewFloatTypeParserToVar(&text.ExtrusionDirection.Y),
		230: core.NewFloatTypeParserToVar(&text.ExtrusionDirection.Z),
	})

	err := text.Parse(tags)
	return text, err
}
43277
func (g *GitHttp) event(e Event) {
	if g.EventHandler != nil {
		g.EventHandler(e)
	} else {
		fmt.Printf("EVENT: %q\n", e)
	}
}
429985
func (tn *tagNode) Tag() []string {
	out := make([]string, len(tn.tag))
	copy(out, tn.tag)
	return out
}
643302
func (blk *TagBlock) TagKeyElem(key []byte) TagKeyElem {
	var elem TagBlockKeyElem
	if !blk.DecodeTagKeyElem(key, &elem) {
		return nil
	}
	return &elem
}
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
}
754500
func tag(s interface{}, field string, tag string) (string, bool) {
	st := reflect.TypeOf(s)

	if st.Kind() == reflect.Ptr {
		st = st.Elem()
	}

	for i := 0; i <= st.NumField()-1; i++ {
		f := st.Field(i)

		if f.Name == field {
			if value, ok := f.Tag.Lookup(tag); ok {
				return value, true
			}
		}
	}

	return "", false
}
1273529
func t(tags []string) string {
	for i, v := range tags {
		tags[i] = strings.Replace(v, ":", "=", 1)
	}
	t := ""
	if len(tags) > 0 {
		t = "" + strings.Join(tags, ",")
	}
	return t
}