{{$typesPackage := .TypesPackage}}

// {{.Name}}

type {{.Name}} struct {
	s   {{$typesPackage}}Set
	cs  chunks.ChunkStore
	ref *ref.Ref
}

func New{{.Name}}(cs chunks.ChunkStore) {{.Name}} {
	return {{.Name}}{ {{$typesPackage}}NewTypedSet(cs, __typeFor{{.Name}}), cs, &ref.Ref{}}
}

{{if .CanUseDef}}
	type {{.Name}}Def map[{{defType .ElemType}}]bool

	func (def {{.Name}}Def) New(cs chunks.ChunkStore) {{.Name}} {
		l := make([]{{$typesPackage}}Value, len(def))
		i := 0
		for d, _ := range def  {
			l[i] = {{defToValue "d" .ElemType}}
			i++
		}
		return {{.Name}}{ {{$typesPackage}}NewTypedSet(cs, __typeFor{{.Name}}, l...), cs, &ref.Ref{}}
	}

	func (s {{.Name}}) Def() {{.Name}}Def {
		def := make(map[{{defType .ElemType}}]bool, s.Len())
		s.s.Iter(func(v {{$typesPackage}}Value) bool {
			def[{{valueToDef "v" .ElemType}}] = true
			return false
		})
		return def
	}
{{end}}

func (s {{.Name}}) Equals(other {{$typesPackage}}Value) bool {
	return other != nil && __typeFor{{.Name}}.Equals(other.Type()) && s.Ref() == other.Ref()
}

func (s {{.Name}}) Ref() ref.Ref {
	return {{$typesPackage}}EnsureRef(s.ref, s)
}

func (s {{.Name}}) Chunks() (chunks []ref.Ref) {
	chunks = append(chunks, s.Type().Chunks()...)
	chunks = append(chunks, s.s.Chunks()...)
	return
}

func (s {{.Name}}) ChildValues() []{{$typesPackage}}Value {
	return append([]{{$typesPackage}}Value{}, s.s.ChildValues()...)
}

// A Noms Value that describes {{.Name}}.
var __typeFor{{.Name}} {{$typesPackage}}Type

func (m {{.Name}}) Type() {{$typesPackage}}Type {
	return __typeFor{{.Name}}
}

func init() {
	__typeFor{{.Name}} = {{toTypesType .Type .FileID .PackageName}}
	{{$typesPackage}}RegisterValue(__typeFor{{.Name}}, builderFor{{.Name}}, readerFor{{.Name}})
}

func builderFor{{.Name}}(cs chunks.ChunkStore, v {{$typesPackage}}Value) {{$typesPackage}}Value {
	return {{.Name}}{v.({{$typesPackage}}Set), cs, &ref.Ref{}}
}

func readerFor{{.Name}}(v {{$typesPackage}}Value) {{$typesPackage}}Value {
	return v.({{.Name}}).s
}

func (s {{.Name}}) Empty() bool {
	return s.s.Empty()
}

func (s {{.Name}}) Len() uint64 {
	return s.s.Len()
}

func (s {{.Name}}) Has(p {{userType .ElemType}}) bool {
	return s.s.Has({{userToValue "p" .ElemType}})
}

type {{.Name}}IterCallback func(p {{userType .ElemType}}) (stop bool)

func (s {{.Name}}) Iter(cb {{.Name}}IterCallback) {
	s.s.Iter(func(v {{$typesPackage}}Value) bool {
		return cb({{valueToUser "v" .ElemType}})
	})
}

type {{.Name}}IterAllCallback func(p {{userType .ElemType}})

func (s {{.Name}}) IterAll(cb {{.Name}}IterAllCallback) {
	s.s.IterAll(func(v {{$typesPackage}}Value) {
		cb({{valueToUser "v" .ElemType}})
	})
}

func (s {{.Name}}) IterAllP(concurrency int, cb {{.Name}}IterAllCallback) {
	s.s.IterAllP(concurrency, func(v {{$typesPackage}}Value) {
		cb({{valueToUser "v" .ElemType}})
	})
}

type {{.Name}}FilterCallback func(p {{userType .ElemType}}) (keep bool)

func (s {{.Name}}) Filter(cb {{.Name}}FilterCallback) {{.Name}} {
	out := s.s.Filter(func(v {{$typesPackage}}Value) bool {
		return cb({{valueToUser "v" .ElemType}})
	})
	return {{.Name}}{out, s.cs, &ref.Ref{}}
}

func (s {{.Name}}) Insert(p ...{{userType .ElemType}}) {{.Name}} {
	return {{.Name}}{s.s.Insert(s.fromElemSlice(p)...), s.cs, &ref.Ref{}}
}

func (s {{.Name}}) Remove(p ...{{userType .ElemType}}) {{.Name}} {
	return {{.Name}}{s.s.Remove(s.fromElemSlice(p)...), s.cs, &ref.Ref{}}
}

func (s {{.Name}}) Union(others ...{{.Name}}) {{.Name}} {
	return {{.Name}}{s.s.Union(s.fromStructSlice(others)...), s.cs, &ref.Ref{}}
}

func (s {{.Name}}) Subtract(others ...{{.Name}}) {{.Name}} {
	return {{.Name}}{s.s.Subtract(s.fromStructSlice(others)...), s.cs, &ref.Ref{}}
}

func (s {{.Name}}) First() {{userType .ElemType}} {
	return {{valueToUser "s.s.First()" .ElemType}}
}

func (s {{.Name}}) fromStructSlice(p []{{.Name}}) []{{$typesPackage}}Set {
	r := make([]{{$typesPackage}}Set, len(p))
	for i, v := range p {
		r[i] = v.s
	}
	return r
}

func (s {{.Name}}) fromElemSlice(p []{{userType .ElemType}}) []{{$typesPackage}}Value {
	r := make([]{{$typesPackage}}Value, len(p))
	for i, v := range p {
		r[i] = {{userToValue "v" .ElemType}}
	}
	return r
}