// add single inheritance
// inheritance is implemented as composition
// spec : http://docs.raml.org/specs/1.0/#raml-10-spec-inheritance-and-specialization
960250
func (sd *structDef) addSingleInheritance(apiDef *raml.APIDefinition, strType string) {
	// check if parent is user defined type
	if _, ok := apiDef.Types[strType]; ok {
		strType = strings.Title(strType)
	}

	fd := fieldDef{
		Name:          strType,
		IsComposition: true,
	}
	sd.Fields[strType] = fd

}
370451
func (service *BaseService) AddInstanceMethods(obj interface{}, option ...Options) Service {
	service.methodManager.AddInstanceMethods(obj, option...)
	return service
}
945512
func (f *FieldSetType) AddClass(class string) *FieldSetType {
	f.class[class] = struct{}{}
	return f
}
507220
func (p Params) Add(k, v string) {
	if param, ok := p[k]; ok {
		switch param.(type) {
		case string:
			param = []string{param.(string), v}
		case []string:
			param = append(param.([]string), v)
		}
		p[k] = param
	} else {
		p[k] = v
	}
}
751013
func (s *Stack) Add(m ...Middleware) {
	for _, mdw := range m {
		s.Stack = s.Stack.Append(alice.Constructor(mdw))
	}
}
495828
func (s *SingleStack) Add(fx func(interface{})) int {
	return s.FunctionStack.Add(func(f ...interface{}) {
		if len(f) <= 0 {
			fx(nil)
			return
		}

		fx(f[0])
	})
}
1112317
func (attrs *attributes) Add(attrType asn1.ObjectIdentifier, value interface{}) {
	attrs.types = append(attrs.types, attrType)
	attrs.values = append(attrs.values, value)
}
1170100
func AddCommonInitialism(ss ...string) {
	mu.Lock()
	defer mu.Unlock()
	for _, s := range ss {
		commonInitialismMap[s] = struct{}{}
	}
	commonInitialisms = keys(commonInitialismMap)
	commonInitialism = mustDoubleArray(newDoubleArray(commonInitialisms))
	longestLen = longestLength(commonInitialisms)
	shortestLen = shortestLength(commonInitialisms, longestLen)
}
896123
func (s *SequenceRenderer) Add(r ...Renderable) {
	for _, rm := range r {
		if rx, ok := rm.(ReactiveRenderable); ok {
			rx.Bind(s, true)
		}
		s.stack = append(s.stack, rm)
	}
}
650135
func (e *GT) Add(a, b *GT) *GT {
	if e.p == nil {
		e.p = &gfP12{}
	}
	e.p.Mul(a.p, b.p)
	return e
}
260536
func (doc *PluginDocument) InheritMetadata(parentDoc PluginDocument) {
	if doc.InheritedMetadata == nil {
		doc.InheritedMetadata = make(map[string]DefinitionList)
	}

	// Inherit the parent's direct metadata fields, but exclude locally defined params
	doc.InheritedMetadata[parentDoc.PackageName+"."+parentDoc.PluginName] =
		parentDoc.Metadata.subtractList(doc.Metadata)

	// Inherit the parent's inherited metadata fields, but exclude locally defined params
	for parentName, metadataSet := range parentDoc.InheritedMetadata {
		doc.InheritedMetadata[parentName] = metadataSet.subtractList(doc.Metadata)
	}
}
979042
func (ns *Namespace) Add(a, b interface{}) (interface{}, error) {
	return _math.DoArithmetic(a, b, '+')
}
189207
func (h *Plus) Add(v []byte) {
	x := h.hash(v)
	if h.sparse {
		h.tmpSet.add(h.encodeHash(x))

		if uint32(len(h.tmpSet))*100 > h.m {
			h.mergeSparse()
			if uint32(h.sparseList.Len()) > h.m {
				h.toNormal()
			}
		}
	} else {
		i := bextr(x, 64-h.p, h.p) // {x63,...,x64-p}
		w := x<<h.p | 1<<(h.p-1)   // {x63-p,...,x0}

		rho := uint8(bits.LeadingZeros64(w)) + 1
		if rho > h.denseList[i] {
			h.denseList[i] = rho
		}
	}
}
157367
func (p *parser) addAlternate() {
	// The | parts inside a Testgroup group go directly to the group

	if p.group.t == ntTestgroup || p.group.t == ntTestref {
		p.group.addChild(p.concatenation.reverseLeft())
	} else {
		p.alternation.addChild(p.concatenation.reverseLeft())
	}

	p.concatenation = newRegexNode(ntConcatenate, p.options)
}
681423
func (p *basePlan) AddParent(parent Plan) {
	p.parents = append(p.parents, parent)
}
1067437
func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&TestType{},
		&TestTypeList{},
	)

	scheme.AddKnownTypes(SchemeGroupVersion)
	return nil
}
1148265
func (a *AnimationSystem) Add(basic *ecs.BasicEntity, anim *AnimationComponent, render *RenderComponent) {
	if a.entities == nil {
		a.entities = make(map[uint64]animationEntity)
	}
	a.entities[basic.ID()] = animationEntity{anim, render}
}