mirror of
https://github.com/dolthub/dolt.git
synced 2026-05-01 11:49:54 -05:00
Erik Arvidsson
16353f38f8
This makes the new typed serialization the default (the old serialization is not used but the code has not been cleaned up yet). Some things are no working in the new world: Chunking - The compound list is not working correctly any more. The Chunks method is having issues because it assumed things based on the old implicit chunking. Commit - uses a `Set(Commit)` which means that the parent commit is embedded. We need to change that to be `Set(Ref(Commit))` so that the parent commit is referenced instead.
146 lines
3.2 KiB
Cheetah
146 lines
3.2 KiB
Cheetah
// {{.Name}}
|
|
|
|
type {{.Name}} struct {
|
|
s types.Set
|
|
ref *ref.Ref
|
|
}
|
|
|
|
func New{{.Name}}() {{.Name}} {
|
|
return {{.Name}}{types.NewSet(), &ref.Ref{}}
|
|
}
|
|
|
|
{{if .CanUseDef}}
|
|
type {{.Name}}Def map[{{defType .ElemType}}]bool
|
|
|
|
func (def {{.Name}}Def) New() {{.Name}} {
|
|
l := make([]types.Value, len(def))
|
|
i := 0
|
|
for d, _ := range def {
|
|
l[i] = {{defToValue "d" .ElemType}}
|
|
i++
|
|
}
|
|
return {{.Name}}{types.NewSet(l...), &ref.Ref{}}
|
|
}
|
|
|
|
func (s {{.Name}}) Def() {{.Name}}Def {
|
|
def := make(map[{{defType .ElemType}}]bool, s.Len())
|
|
s.s.Iter(func(v types.Value) bool {
|
|
def[{{valueToDef "v" .ElemType}}] = true
|
|
return false
|
|
})
|
|
return def
|
|
}
|
|
{{end}}
|
|
|
|
func {{.Name}}FromVal(val types.Value) {{.Name}} {
|
|
// TODO: Do we still need FromVal?
|
|
if val, ok := val.({{.Name}}); ok {
|
|
return val
|
|
}
|
|
return {{.Name}}{val.(types.Set), &ref.Ref{}}
|
|
}
|
|
|
|
func (s {{.Name}}) NomsValue() types.Value {
|
|
// TODO: Remove this
|
|
return s
|
|
}
|
|
|
|
func (s {{.Name}}) InternalImplementation() types.Set {
|
|
return s.s
|
|
}
|
|
|
|
func (s {{.Name}}) Equals(other types.Value) bool {
|
|
if other, ok := other.({{.Name}}); ok {
|
|
return s.Ref() == other.Ref()
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (s {{.Name}}) Ref() ref.Ref {
|
|
return types.EnsureRef(s.ref, s)
|
|
}
|
|
|
|
func (s {{.Name}}) Chunks() (futures []types.Future) {
|
|
futures = append(futures, s.TypeRef().Chunks()...)
|
|
futures = append(futures, s.s.Chunks()...)
|
|
return
|
|
}
|
|
|
|
{{template "type_ref.tmpl" .}}
|
|
|
|
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 types.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 types.Value) {
|
|
cb({{valueToUser "v" .ElemType}})
|
|
})
|
|
}
|
|
|
|
type {{.Name}}FilterCallback func(p {{userType .ElemType}}) (keep bool)
|
|
|
|
func (s {{.Name}}) Filter(cb {{.Name}}FilterCallback) {{.Name}} {
|
|
ns := New{{.Name}}()
|
|
s.IterAll(func(v {{userType .ElemType}}) {
|
|
if cb(v) {
|
|
ns = ns.Insert(v)
|
|
}
|
|
})
|
|
return ns
|
|
}
|
|
|
|
func (s {{.Name}}) Insert(p ...{{userType .ElemType}}) {{.Name}} {
|
|
return {{.Name}}{s.s.Insert(s.fromElemSlice(p)...), &ref.Ref{}}
|
|
}
|
|
|
|
func (s {{.Name}}) Remove(p ...{{userType .ElemType}}) {{.Name}} {
|
|
return {{.Name}}{s.s.Remove(s.fromElemSlice(p)...), &ref.Ref{}}
|
|
}
|
|
|
|
func (s {{.Name}}) Union(others ...{{.Name}}) {{.Name}} {
|
|
return {{.Name}}{s.s.Union(s.fromStructSlice(others)...), &ref.Ref{}}
|
|
}
|
|
|
|
func (s {{.Name}}) Subtract(others ...{{.Name}}) {{.Name}} {
|
|
return {{.Name}}{s.s.Subtract(s.fromStructSlice(others)...), &ref.Ref{}}
|
|
}
|
|
|
|
func (s {{.Name}}) Any() {{userType .ElemType}} {
|
|
return {{valueToUser "s.s.Any()" .ElemType}}
|
|
}
|
|
|
|
func (s {{.Name}}) fromStructSlice(p []{{.Name}}) []types.Set {
|
|
r := make([]types.Set, len(p))
|
|
for i, v := range p {
|
|
r[i] = v.s
|
|
}
|
|
return r
|
|
}
|
|
|
|
func (s {{.Name}}) fromElemSlice(p []{{userType .ElemType}}) []types.Value {
|
|
r := make([]types.Value, len(p))
|
|
for i, v := range p {
|
|
r[i] = {{userToValue "v" .ElemType}}
|
|
}
|
|
return r
|
|
}
|