Working on a rewrite based on JSON unmarshaling

bolteasable.go

@@ -4,9 +4,50 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"sort"
+	"sync"
+	"unicode"
+	"unicode/utf8"
 )
 
-type any interface{}
+type any = interface{}
+
+func (b *DB) Save(path []string, src any) error {
+	t := reflect.TypeOf(src)
+	if t.Kind() == reflect.Pointer {
+		// Save the actual struct
+		elem := reflect.ValueOf(src).Elem()
+		return b.Save(path, elem.Interface())
+	}
+
+	if t.Kind() == reflect.Struct {
+		fields := reflect.VisibleFields(t)
+		r := reflect.ValueOf(src)
+		for _, fld := range fields {
+			f := r.FieldByName(fld.Name)
+			if (f.Kind() == reflect.Struct || f.Kind() == reflect.Pointer) && f != src {
+				if f.CanInterface() {
+					err := b.Save(append(path, FieldName(fld)), f.Interface())
+					if err != nil {
+						return err
+					}
+				} else {
+					err := b.Save(append(path, FieldName(fld)), reflect.Indirect(f))
+					if err != nil {
+						return err
+					}
+				}
+			} else {
+				if err := b.Set(path, FieldName(fld), f); err != nil {
+					return err
+				}
+			}
+		}
+	} else {
+		return b.Set(path[:len(path)-1], path[len(path)-1], src)
+	}
+	return nil
+}
 
 func (b *DB) Load(path []string, dest any) error {
 	destValue := reflect.ValueOf(dest)
@@ -17,12 +58,20 @@ func (b *DB) Load(path []string, dest any) error {
 	d := reflect.Indirect(destValue)
 	fmt.Println(">> d.Kind() ->", d.Kind())
 	if d.Kind() != reflect.Struct {
+		if b.CanGetForInterface(d) {
 			fmt.Println(">> Kind != Struct; GetForInterface")
 			path, name := path[:len(path)-1], path[len(path)-1]
 			return b.GetForInterface(path, name, dest)
+		} else {
+			fmt.Println(">> Reflect Indirect(d) Elem")
+			dest = reflect.Indirect(d).Elem()
+			fmt.Println(">> Dest set")
+		}
 	}
 
 	entityType := reflect.TypeOf(dest).Elem()
+	fmt.Println(">> entityType.Kind() ->", entityType.Kind())
+
 	var ret error
 	for i := 0; i < entityType.NumField(); i++ {
 		structFld := entityType.Field(i)
@@ -124,39 +173,11 @@ func (b *DB) Load(path []string, dest any) error {
 	return ret
 }
 
-func (b *DB) Save(path []string, src any) error {
+func (b *DB) loadObject(path []string, v reflect.Value) error {
-	t := reflect.TypeOf(src)
+	var fields structFields
-	if t.Kind() == reflect.Pointer {
+	switch v.Kind() {
-		// Save the actual struct
+	case reflect.Struct:
-		elem := reflect.ValueOf(src).Elem()
+		fields = cachedTypeFields(t)
-		return b.Save(path, elem.Interface())
-	}
-
-	if t.Kind() == reflect.Struct {
-		fields := reflect.VisibleFields(t)
-		r := reflect.ValueOf(src)
-		for _, fld := range fields {
-			f := r.FieldByName(fld.Name)
-			if (f.Kind() == reflect.Struct || f.Kind() == reflect.Pointer) && f != src {
-				if f.CanInterface() {
-					err := b.Save(append(path, FieldName(fld)), f.Interface())
-					if err != nil {
-						return err
-					}
-				} else {
-					err := b.Save(append(path, FieldName(fld)), reflect.Indirect(f))
-					if err != nil {
-						return err
-					}
-				}
-			} else {
-				if err := b.Set(path, FieldName(fld), f); err != nil {
-					return err
-				}
-			}
-		}
-	} else {
-		return b.Set(path[:len(path)-1], path[len(path)-1], src)
 	}
 	return nil
 }
@@ -187,3 +208,255 @@ func ReflectValueToInterface(val reflect.Value) interface{} {
 		return val.Bytes()
 	}
 }
+
+// A field represents a single field found in a struct.
+type field struct {
+	name      string
+	nameBytes []byte // []byte(name)
+
+	tag       bool
+	index     []int
+	typ       reflect.Type
+	omitEmpty bool
+}
+
+// byIndex sorts fields by index sequence
+type byIndex []field
+
+func (x byIndex) Len() int      { return len(x) }
+func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x byIndex) Less(i, j int) bool {
+	for k, xik := range x[i].index {
+		if k >= len(x[j].index) {
+			return false
+		}
+		if xik != x[j].index[k] {
+			return xik < x[j].index[k]
+		}
+	}
+	return len(x[i].index) < len(x[j].index)
+}
+
+type structFields struct {
+	list         []field
+	byExactName  map[string]*field
+	byFoldedName map[string]*field
+}
+
+// typeFields returns a list of fields that JSON should recognize for the given type.
+// The algorithm is breadth-first search over the set of structs to include - the top struct
+// and then any reachable anonymous structs.
+func typeFields(t reflect.Type) structFields {
+	// Anonymous fields to explore at the current level and the next
+	current := []field{}
+	next := []field{{typ: t}}
+
+	// Count of queued names for current level and the next.
+	var count, nextCount map[reflect.Type]int
+
+	// Types already visited at an earlier level.
+	visited := map[reflect.Type]bool{}
+
+	// Fields found.
+	var fields []field
+
+	for len(next) > 0 {
+		current, next = next, current[:0]
+		count, nextCount = nextCount, map[reflect.Type]int{}
+
+		for _, f := range current {
+			if visited[f.typ] {
+				continue
+			}
+			visited[f.typ] = true
+			// Scan f.typ for fields to include.
+			for i := 0; i < f.typ.NumField(); i++ {
+				sf := f.typ.Field(i)
+				if sf.Anonymous {
+					t := sf.Type
+					if t.Kind() == reflect.Pointer {
+						t = t.Elem()
+					}
+					if !sf.IsExported() && t.Kind() != reflect.Struct {
+						// Ignore embedded fields of unexported non-struct types.
+						continue
+					}
+					// Do not ignore embedded fields of unexported struct types
+					// /since they may have exported fields.
+				} else if !sf.IsExported() {
+					// Ignore unexported non-embedded fields.
+					continue
+				}
+				tag := sf.Tag.Get("boltease")
+				if tag == "-" {
+					continue
+				}
+				name, opts := parseTag(tag)
+				if !isValidTag(name) {
+					name = ""
+				}
+				index := make([]int, len(f.index)+1)
+				copy(index, f.index)
+				index[len(f.index)] = i
+
+				ft := sf.Type
+				if ft.Name() == "" && ft.Kind() == reflect.Pointer {
+					// Follow pointer.
+					ft = ft.Elem()
+				}
+
+				// Record found field and index sequence.
+				if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
+					tagged := name != ""
+					if name == "" {
+						name = sf.Name
+					}
+					field := field{
+						name:      name,
+						tag:       tagged,
+						index:     index,
+						typ:       ft,
+						omitEmpty: opts.Contains("omitempty"),
+					}
+					field.nameBytes = []byte(field.name)
+					fields = append(fields, field)
+					if count[f.typ] > 1 {
+						// If there were multiple instances, add a second,
+						// so thta the annihilation code will see a duplicate.
+						// it only cares about the distinction between 1 or 2,
+						// so don't bother generating any more copies.
+						fields = append(fields, fields[len(fields)-1])
+					}
+					continue
+				}
+				// Record new anonymous struct to explore in next round.
+				nextCount[ft]++
+				if nextCount[ft] == 1 {
+					next = append(next, field{name: ft.Name(), index: index, typ: ft})
+				}
+			}
+		}
+	}
+
+	sort.Slice(fields, func(i, j int) bool {
+		x := fields
+		// sort field by name, breaking ties with depth, then
+		// breaking ties with "name came from boltease tag", then
+		// breaking ties with index sequence
+		if x[i].name != x[j].name {
+			return x[i].name < x[j].name
+		}
+		if len(x[i].index) != len(x[j].index) {
+			return len(x[i].index) < len(x[j].index)
+		}
+		if x[i].tag != x[j].tag {
+			return x[i].tag
+		}
+		return byIndex(x).Less(i, j)
+	})
+
+	// Delete all fields that are hidden by the Go rules for embedded fields,
+	// except that fields with boltease tags are promoted.
+	//
+	// The fields are sorted in primary order of name, secondary order
+	// of field index length. Loop over names; for each name, delete
+	// hidden fields by choosing the one dominant field that survives.
+	out := fields[:0]
+	for advance, i := 0, 0; i < len(fields); i += advance {
+		// One iteration per name.
+		// Find the sequence of fields with th ename of this first field.
+		fi := fields[i]
+		name := fi.name
+		for advance = 1; i+advance < len(fields); advance++ {
+			fj := fields[i+advance]
+			if fj.name != name {
+				break
+			}
+		}
+		if advance == 1 { // Only one field with this name
+			out = append(out, fi)
+			continue
+		}
+		dominant, ok := dominantField(fields[i : i+advance])
+		if ok {
+			out = append(out, dominant)
+		}
+	}
+
+	fields = out
+	sort.Sort(byIndex(fields))
+
+	exactNameIndex := make(map[string]*field, len(fields))
+	foldedNameIndex := make(map[string]*field, len(fields))
+	for i, field := range fields {
+		exactNameIndex[field.name] = &fields[i]
+		// For historical reasons, first folded match takes precedence.
+		if _, ok := foldedNameIndex[string(foldName(field.nameBytes))]; !ok {
+			foldedNameIndex[string(foldName(field.nameBytes))] = &fields[i]
+		}
+	}
+	return structFields{fields, exactNameIndex, foldedNameIndex}
+}
+
+// dominantField looks through the fields, all of which are known to have the
+// same name, to find the single field that dominates the others using Go's
+// embedding rules, modified by the presence of boltease tags. if there are
+// multiple top-level fields, the boolean will be false: This condition is an
+// error in Go and we skip all fields.
+func dominantField(fields []field) (field, bool) {
+	// The fields are sorted in increasing index-length order, then by presence of tag.
+	// That means that the first field is the dominant one. We need only check
+	// for error cases: two fields at top level, either both tagged or neither tagged.
+	if len(fields) > 1 && len(fields[0].index) == len(fields[1].index) && fields[0].tag == fields[1].tag {
+		return field{}, false
+	}
+	return fields[0], true
+}
+
+var fieldCache sync.Map // map[reflect.Type]structFields
+
+func cachedTypeFields(t reflect.Type) structFields {
+	if f, ok := fieldCache.Load(t); ok {
+		return f.(structFields)
+	}
+	f, _ := fieldCache.LoadOrStore(t, typeFields(t))
+	return f.(structFields)
+}
+
+// foldName returns a folded string such that foldName(x) == foldName(y)
+// is identical to bytes.EqualFold(x, y).
+func foldName(in []byte) []byte {
+	// This is inlinable to take advantage of "function outlining".
+	var arr [32768]byte // The max size of a bolt key
+	return appendFoldedName(arr[:0], in)
+}
+
+func appendFoldedName(out, in []byte) []byte {
+	for i := 0; i < len(in); {
+		// Handle single-byte ASCII.
+		if c := in[i]; c < utf8.RuneSelf {
+			if 'a' <= c && c <= 'z' {
+				c -= 'a' - 'A'
+			}
+			out = append(out, c)
+			i++
+			continue
+		}
+		// Handle multi-byt eUnicode.
+		r, n := utf8.DecodeRune(in[i:])
+		out = utf8.AppendRune(out, foldRune(r))
+		i += n
+	}
+	return out
+}
+
+// foldRune returns the smallest rune for all runes in the same fold set.
+func foldRune(r rune) rune {
+	for {
+		r2 := unicode.SimpleFold(r)
+		if r2 <= r {
+			return r2
+		}
+		r = r2
+	}
+}

boltease.go

@@ -122,7 +122,15 @@ func (b *DB) Set(path []string, key string, val interface{}) error {
 	case []byte:
 		return b.SetBytes(path, key, v)
 	default:
-		return fmt.Errorf("Unknown Data Type: %v", v)
+		return fmt.Errorf("Set: Unknown Data Type: %v", v)
+	}
+}
+func (b *DB) CanGetForInterface(val interface{}) bool {
+	switch val.(type) {
+	case *string, *int, *int8, *int16, *int32, *int64, *bool, *[]byte:
+		return true
+	default:
+		return false
 	}
 }
 func (b *DB) GetForInterface(path []string, key string, val interface{}) error {
@@ -153,7 +161,7 @@ func (b *DB) GetForInterface(path []string, key string, val interface{}) error {
 	case *[]byte:
 		*v, err = b.GetBytes(path, key)
 	default:
-		return fmt.Errorf("Unknown Data Type: %v", v)
+		return fmt.Errorf("GetForInterface: Unknown Data Type: %v", v)
 	}
 	return err
 }

tags.go

@@ -0,0 +1,52 @@
+package boltease
+
+import (
+	"strings"
+	"unicode"
+)
+
+func isValidTag(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, c := range s {
+		switch {
+		case strings.ContainsRune("!#$%&()*+-./:;<=>?@[]^_{|}~ ", c):
+			// Backslash and quote chars are reserved, but
+			// otherwise any punctuation chars are allowed
+			// in a tag name.
+		case !unicode.IsLetter(c) && !unicode.IsDigit(c):
+			return false
+		}
+	}
+	return true
+}
+
+// tagOptions is the string following a comma in a struct field's "boltease"
+// tag, or the empty string. It does not include the leading comma
+type tagOptions string
+
+// parseTag splits a struct field's boltease tag into it sname and
+// comma-separated options.
+func parseTag(tag string) (string, tagOptions) {
+	tag, opt, _ := strings.Cut(tag, ",")
+	return tag, tagOptions(opt)
+}
+
+// Contains reports whether a comma-separated list of options
+// contains a particular substr flag. Substr must be surrounded by a
+// string boundary or commas.
+func (o tagOptions) Contains(optionName string) bool {
+	if len(o) == 0 {
+		return false
+	}
+	s := string(o)
+	for s != "" {
+		var name string
+		name, s, _ = strings.Cut(s, ",")
+		if name == optionName {
+			return true
+		}
+	}
+	return false
+}