// combineProperties returns new properties all values from a and b. uses more specific value
// for duplicate keys.
541831
func combineProperties(a, b *Properties) *Properties {
	r := &Properties{values: make(map[key]attr)}
	for k, v := range a.values {
		r.values[k] = v
	}
	r.updateMissing(b)
	return r
}
1164379
func MergeKeyValSet(setKeyVals, entryKeyVals []KeyVal) []KeyVal {
	retList := keyValCopy(setKeyVals)
	seenKeywords := []Keyword{}
	for i := range retList {
		word := retList[i].Keyword()
		for _, kv := range HasKeyword(entryKeyVals, word) {
			// match on the keyword prefix and suffix here
			if kv.Keyword() == word {
				retList[i] = kv
			}
		}
		seenKeywords = append(seenKeywords, word)
	}
	for i := range entryKeyVals {
		if !InKeywordSlice(entryKeyVals[i].Keyword(), seenKeywords) {
			retList = append(retList, entryKeyVals[i])
		}
	}
	return retList
}
346256
func (s *PerformanceMetrics) SetProperties(v map[string]*string) *PerformanceMetrics {
	s.Properties = v
	return s
}
16449
func ChildProperties(Properties map[string]interface{}) []raml.Property {
	props := make([]raml.Property, 0)

	for propName, propInterface := range Properties {
		props = append(props, raml.ToProperty(propName, propInterface))
	}

	return props
}
1251470
func CopyProperties(source, target interface{}) error {
	if source == nil || target == nil {
		return nil
	}

	return copier.Copy(target, source)

}
444411
public static Properties combineProperties(Properties... properties) {
    Properties combinedProperties = new Properties();
    for (Properties props : properties) {
      combinedProperties.putAll(props);
    }
    return combinedProperties;
  }
455914
func NewProperties(parameters *TestParameters) *Properties {
	if parameters == nil {
		parameters = DefaultTestParameters()
	}
	return &Properties{
		parameters: parameters,
		props:      make(map[string]Prop, 0),
		propNames:  make([]string, 0),
	}
}
1064269
func (fc *FeatureCollection) FillProperties() {
	properties := make(map[string]bool)

	// Loop 1: construct a set (actually a map)
	for _, feature := range fc.Features {
		for key := range feature.Properties {
			if _, ok := properties[key]; !ok {
				properties[key] = true
			}
		}
	}

	// Loop 2: make sure each feature has each property from the set
	for _, feature := range fc.Features {
		for key := range properties {
			if _, ok := feature.Properties[key]; !ok {
				feature.Properties[key] = nil
			}
		}
	}
}
618441
func (obj *GenericObject) SetProperties(ctx context.Context, prop *GenericObjectProperties) error {
	err := obj.rpc(ctx, "SetProperties", nil, prop)
	return err 
}
1082734
func Combine(a, b AABB) AABB {
	return AABB{
		vect.Min(a.Lower, b.Lower),
		vect.Max(a.Upper, b.Upper),
	}
}
791761
func merge(appliabels ...[]appliable) []appliable {
	all := []appliable{}

	for _, appl := range appliabels {
		all = append(all, appl...)
	}

	return all
}
462423
func (c *TasksConfig) Combine(configs ...TasksConfig) {
	if c.DefaultTasks.Tasks == nil {
		c.DefaultTasks.Tasks = make(map[string]v0.SingleDefaultTaskConfig)
	}

	var pluginsFromConfigs []v0.SinglePluginConfig
	for _, cfg := range configs {
		// DefaultTask resolvers are appended and uniquified
		c.DefaultTasks.DefaultResolvers = pluginsinternal.Uniquify(append(c.DefaultTasks.DefaultResolvers, cfg.DefaultTasks.DefaultResolvers...))

		// DefaultTask tasks key/values are simply copied (and overwritten with last writer wins for any duplicate keys)
		for k, v := range cfg.DefaultTasks.Tasks {
			c.DefaultTasks.Tasks[k] = v
		}

		// Plugin resolvers are appended and uniquified
		c.Plugins.DefaultResolvers = pluginsinternal.Uniquify(append(c.Plugins.DefaultResolvers, cfg.Plugins.DefaultResolvers...))

		// Append provided plugins to "pluginsFromConfigs" list
		pluginsFromConfigs = append(pluginsFromConfigs, cfg.Plugins.Plugins...)
	}

	// determine all of the provided plugins that specify overrides
	pluginsFromConfigsWithOverride := matchingPluginConfigs(pluginsFromConfigs, func(in v0.SinglePluginConfig) bool { return in.Override })

	// remove any of the original plugins that match override locators (because they will be overridden)
	var originalConfigsWithoutOverridenPlugins []v0.SinglePluginConfig
	for _, originalCfg := range c.Plugins.Plugins {
		locatorCfg := LocatorConfig(originalCfg.Locator)
		if locatorParam, err := locatorCfg.ToParam(); err == nil {
			// if locator can be parsed and matches a plugin for which an override was specified, omit it (it will be overridden)
			if _, ok := pluginsFromConfigsWithOverride[locatorParam.GroupAndProductString()]; ok {
				continue
			}
		}
		// plugin was not overridden or locator could not be parsed: keep it
		originalConfigsWithoutOverridenPlugins = append(originalConfigsWithoutOverridenPlugins, originalCfg)
	}

	// update plugins list. Any of the original plugins that match an override from an input plugin will be removed.
	// Note that no deduplication/override processing is done for the provided configurations -- if the input
	// configurations specifies duplicate plugins, that will be handled later when determining plugin compatibility.
	c.Plugins.Plugins = append(originalConfigsWithoutOverridenPlugins, pluginsFromConfigs...)
}
951307
func NewProperty(parent *Properties) *Property {
	property := &Property{parent: parent, Group: &Group{}, Contract: &Contract{}}
	property.Init()
	return property
}
1368614
func (c *Component) AddProperty(key string, val string) {
	c.Properties[key] = val
}
182869
func (b *SampleJSONBuilder) Properties() []*SamplePropertyInfo {
	return []*SamplePropertyInfo{
		b.B,
		b.C,
		b.D,
		b.E,
	}
}
1131895
func (b *SampleJSONBuilder) Properties() []*SamplePropertyInfo {
	return []*SamplePropertyInfo{
		b.A,
		b.B,
		b.C,
		b.D,
		b.F,
		b.G,
	}
}
1093502
func (h *Histo) Combine(other []byte) error {
	otherHistogram := tdigest.NewMerging(100, false)
	if err := otherHistogram.GobDecode(other); err != nil {
		return err
	}
	h.Value.Merge(otherHistogram)
	return nil
}