// New creates a new stringset with the specified strings in it
481893
func New(strings ...string) StringSet {
	set := make(map[string]struct{}, len(strings))
	for _, str := range strings {
		set[str] = struct{}{}
	}
	return set
}
735614
func StringsSet(in []string) map[string]struct{} {
	if in == nil {
		return nil
	}
	out := make(map[string]struct{})
	for _, v := range in {
		out[v] = struct{}{}
	}
	return out
}
462742
func New(items ...interface{}) *Set {
	s := &Set{}
	s.m = make(map[interface{}]struct{})

	// Ensure interface compliance
	var _ Interface = s

	s.Add(items...)
	return s
}
663668
func New(src string) *Lexer {
	l := &Lexer{
		input: src,
	}
	// step to the first character in order to be ready
	l.readChar()
	return l
}
662112
func New(c rest.Interface) *Clientset {
	var cs Clientset
	cs.project = projectinternalversion.New(c)

	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
	return &cs
}
611016
func (g *Generator) New() (string, error) {
	if err := g.check(); err != nil {
		return "", err
	}
	f := strconv.Itoa(int(g.timestampGet()))
	s := g.macAddrFormat(g.macAddrGet())
	t := g.rHexString()
	s = s[len(s)-4:]
	id := fmt.Sprintf("%s%s%s", f, s, t)

	return id, nil
}
1286830
func New(c rest.Interface) *Clientset {
	var cs Clientset
	cs.samplecontrollerV1alpha1 = samplecontrollerv1alpha1.New(c)

	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
	return &cs
}
764992
func (set StringSet) Clone() StringSet {
	clonedSet := NewStringSet()
	for elem := range set {
		clonedSet.Add(elem)
	}
	return clonedSet
}
509282
func (g *Group) New(typ Code) *Statement {
	s := New(typ)
	g.items = append(g.items, s)
	return s
}
622866
func New(message string, field string, kind Kind) Error {
	return Error{message, field, 0, kind}
}
741456
func NewKeySet(keys ...Key) KeySet {
	set := make(KeySet)
	for _, key := range keys {
		set.Add(key)
	}

	return set
}
810182
func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
1238137
func New(c rest.Interface) *Clientset {
	var cs Clientset
	cs.argoprojV1alpha1 = argoprojv1alpha1.New(c)

	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
	return &cs
}
331404
func New(c Config) (*Foo, error) {
	//ensure proper initialization of Foo
	foo := &Foo{
		c:    c,
		bar:  42 + c.Zip,
		bazz: 21 + c.Zop,
	}

	return foo, nil
}
118249
func New(possible []string, subsetSize []int) *ClosestMatch {
	cm := new(ClosestMatch)
	cm.SubstringSizes = subsetSize
	cm.SubstringToID = make(map[string]map[uint32]struct{})
	cm.ID = make(map[uint32]IDInfo)
	for i, s := range possible {
		substrings := cm.splitWord(strings.ToLower(s))
		cm.ID[uint32(i)] = IDInfo{Key: s, NumSubstrings: len(substrings)}
		for substring := range substrings {
			if _, ok := cm.SubstringToID[substring]; !ok {
				cm.SubstringToID[substring] = make(map[uint32]struct{})
			}
			cm.SubstringToID[substring][uint32(i)] = struct{}{}
		}
	}

	return cm
}
1236700
func New(f string) (*Strftime, error) {
	var wl appenderList
	if err := compile(&wl, f); err != nil {
		return nil, errors.Wrap(err, `failed to compile format`)
	}
	return &Strftime{
		pattern:  f,
		compiled: wl,
	}, nil
}
570038
func (r *resourceRecordSets) New(name string, rrdatas []string, ttl int64, rrstype rrstype.RrsType) dnsprovider.ResourceRecordSet {
	if len(rrdatas) > 1 {
		return nil
	}

	return &resourceRecordSet{
		name:       name,
		data:       rrdatas[0],
		ttl:        int(ttl),
		recordType: rrstype,
	}
}