Trying to figure out this dang thing

Now for loading them

bolteasable.go

@@ -0,0 +1,189 @@
+package boltease
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+type any interface{}
+
+func (b *DB) Load(path []string, dest any) error {
+	destValue := reflect.ValueOf(dest)
+	fmt.Println("Loading:", path, destValue)
+	if destValue.Kind() != reflect.Pointer {
+		return errors.New("Destination must be a pointer")
+	}
+	d := reflect.Indirect(destValue)
+	fmt.Println(">> d.Kind() ->", d.Kind())
+	if d.Kind() != reflect.Struct {
+		fmt.Println(">> Kind != Struct; GetForInterface")
+		path, name := path[:len(path)-1], path[len(path)-1]
+		return b.GetForInterface(path, name, dest)
+	}
+
+	entityType := reflect.TypeOf(dest).Elem()
+	var ret error
+	for i := 0; i < entityType.NumField(); i++ {
+		structFld := entityType.Field(i)
+		fldName := FieldName(structFld)
+		fmt.Println("Loading Field:", fldName, "->", structFld.Type.Kind())
+		switch structFld.Type.Kind() {
+		case reflect.Pointer, reflect.Struct:
+			fmt.Println("Getting Pointer or Struct")
+			var wrk interface{}
+			var wrkV reflect.Value
+			if structFld.Type.Kind() == reflect.Pointer {
+				fmt.Println("  It's a pointer to something")
+				wrkV = reflect.New(structFld.Type).Elem()
+			} else {
+				fmt.Println("  It's a struct itself")
+				wrkV = reflect.New(reflect.TypeOf(structFld))
+			}
+			wrk = wrkV.Interface()
+			fmt.Println("-> Recurse (struct)", reflect.TypeOf(wrk))
+			err := b.Load(append(path, fldName), &wrk)
+			if err != nil {
+				fmt.Println("-> -> Error loading.", err.Error())
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+
+		case reflect.String:
+			fmt.Println("Getting String")
+			var wrk string
+			err := b.GetForInterface(path, fldName, &wrk)
+			if err != nil {
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+
+		case reflect.Bool:
+			fmt.Println("Getting Boolean")
+			var wrk bool
+			err := b.GetForInterface(path, fldName, &wrk)
+			if err != nil {
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			fmt.Println("Getting Integer")
+			var wrk int
+			err := b.GetForInterface(path, fldName, &wrk)
+			if err != nil {
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+		}
+
+		/*
+			setField := reflect.ValueOf(dest).Elem().Field(i)
+			value := entityType.Field(i)
+			fldName := FieldName(value)
+			if value.Type.Kind() == reflect.Struct {
+				b.LoadStruct(append(path, fldName), setField.Interface())
+			} else {
+				err := b.GetForInterface(path, fldName, &value)
+				if err != nil {
+					fmt.Println(err)
+					return err
+				}
+				fmt.Println("value:", value)
+			}
+		*/
+
+		/*
+			if value.Type.Kind() == reflect.Struct {
+				b.LoadStruct(append(path, fldName), setField.Interface())
+			} else {
+				v, err := b.GetForType(path, fldName, value)
+				if err != nil {
+					return err
+				}
+				setField.Set(reflect.ValueOf(v))
+			}
+		*/
+	}
+	return ret
+}
+
+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 FieldName(fld reflect.StructField) string {
+	nm := fld.Name
+	tag := fld.Tag.Get("boltease")
+	if tag != "" {
+		nm = tag
+	}
+	return nm
+}
+func FieldIgnored(fld reflect.StructField) bool {
+	return fld.Tag.Get("boltease") == "-"
+}
+
+func ReflectValueToInterface(val reflect.Value) interface{} {
+	switch val.Kind() {
+	case reflect.Pointer:
+		return ReflectValueToInterface(reflect.Indirect(val))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return val.Int()
+	case reflect.Bool:
+		return val.Bool()
+	case reflect.String:
+		return val.String()
+	default:
+		return val.Bytes()
+	}
+}

boltease.go

@@ -2,9 +2,9 @@ package boltease
 
 import (
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"os"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -103,16 +103,87 @@ func (b *DB) MkBucketPath(path []string) error {
 
 func (b *DB) Set(path []string, key string, val interface{}) error {
 	switch v := val.(type) {
+	case reflect.Value:
+		return b.Set(path, key, ReflectValueToInterface(v))
 	case string:
 		return b.SetString(path, key, v)
 	case int:
 		return b.SetInt(path, key, v)
+	case int8:
+		return b.SetInt(path, key, int(v))
+	case int16:
+		return b.SetInt(path, key, int(v))
+	case int32:
+		return b.SetInt(path, key, int(v))
+	case int64:
+		return b.SetInt(path, key, int(v))
 	case bool:
 		return b.SetBool(path, key, v)
 	case []byte:
 		return b.SetBytes(path, key, v)
+	default:
+		return fmt.Errorf("Unknown Data Type: %v", v)
 	}
-	return errors.New("Unknown Data Type")
+}
+func (b *DB) GetForInterface(path []string, key string, val interface{}) error {
+	var err error
+	switch v := val.(type) {
+	case *string:
+		*v, err = b.GetString(path, key)
+	case *int:
+		*v, err = b.GetInt(path, key)
+	case *int8:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int8(wrk)
+	case *int16:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int16(wrk)
+	case *int32:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int32(wrk)
+	case *int64:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int64(wrk)
+	case *bool:
+		*v, err = b.GetBool(path, key)
+	case *[]byte:
+		*v, err = b.GetBytes(path, key)
+	default:
+		return fmt.Errorf("Unknown Data Type: %v", v)
+	}
+	return err
+}
+func (b *DB) LoadInto(path []string, key string, into interface{}) error {
+	var err error
+	switch v := into.(type) {
+	case string:
+		i := new(string)
+		*i, err = b.GetString(path, key)
+		fmt.Printf("Loading String: %v\n", i)
+		into = i
+	case int, int8, int16, int32, int64:
+		i := new(int)
+		*i, err = b.GetInt(path, key)
+		fmt.Printf("Loading Int: %v\n", i)
+		into = i
+	case bool:
+		i := new(bool)
+		*i, err = b.GetBool(path, key)
+		fmt.Printf("Loading Bool: %v\n", i)
+		into = i
+	case []byte:
+		i := new([]byte)
+		*i, err = b.GetBytes(path, key)
+		fmt.Printf("Loading []byte: %v\n", i)
+		into = i
+	default:
+		return fmt.Errorf("Unknown Data Type: %v", v)
+	}
+	return err
 }
 
 func (b *DB) GetBytes(path []string, key string) ([]byte, error) {

example/.gitignore

@@ -0,0 +1,2 @@
+example
+example.db

example/main.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"git.bullercodeworks.com/brian/boltease"
+)
+
+func main() {
+	//example1()
+	//fmt.Println()
+	example2()
+}
+
+func example1() {
+	fmt.Println("# Example 1")
+	db, err := boltease.Create("example.db", 0600, nil)
+	if err != nil {
+		fmt.Printf("Error Opening File: %s\n", err.Error())
+		os.Exit(1)
+	}
+
+	fmt.Println("## Saving Struct")
+	err = db.Save(
+		[]string{"examples", "example1"},
+		ExampleType{
+			Name: "Example 1",
+			Age:  5,
+		})
+	if err != nil {
+		fmt.Printf("Error saving struct: %s\n", err.Error())
+		os.Exit(1)
+	}
+
+	fmt.Println("## Example 1-1: Simple")
+	var v string
+	err = db.GetForInterface([]string{"examples", "example1"}, "name", &v)
+	if err != nil {
+		fmt.Println("Error:", err.Error())
+	}
+	fmt.Println("Name:", v)
+	var age int
+	err = db.GetForInterface([]string{"examples", "example1"}, "age", &age)
+	if err != nil {
+		fmt.Println("Error:", err.Error())
+	}
+	fmt.Println("Age:", age)
+	fmt.Println("")
+
+	fmt.Println("## Example 1-2: LoadStruct, simple")
+	var name string
+	err = db.Load(
+		[]string{"examples", "example1", "name"},
+		&name,
+	)
+	fmt.Println("Name:", name)
+	if err != nil {
+		fmt.Println("Err:", err)
+	}
+	fmt.Println("")
+
+	fmt.Println("## Example 1-3: Struct")
+	fmt.Println("Loading into Struct")
+	newStruct := ExampleType{}
+	err = db.Load(
+		[]string{"examples", "example1"},
+		&newStruct,
+	)
+	fmt.Println(newStruct)
+}
+
+func example2() {
+	fmt.Println("# Example 2")
+	db, err := boltease.Create("example.db", 0600, nil)
+	if err != nil {
+		fmt.Printf("Error Opening File: %s\n", err.Error())
+		os.Exit(1)
+	}
+	fmt.Println("## Saving Struct")
+	num := 12345
+	err = db.Save(
+		[]string{"examples", "example2"},
+		&ExampleType2{
+			Name: "Example 2",
+			Age:  20,
+			SubTypePtr: &ExampleSubType{
+				SubName: "Example SubType Pointer",
+			},
+			SubType: ExampleSubType{
+				SubName: "Example SubType",
+			},
+			Number: &num,
+		})
+	if err != nil {
+		fmt.Printf("Error saving struct: %s\n", err.Error())
+		os.Exit(1)
+	}
+
+	newStruct := ExampleType2{}
+	err = db.Load([]string{"examples", "example2"}, &newStruct)
+	fmt.Println(newStruct)
+}
+
+type ExampleType struct {
+	Name string `boltease:"name"`
+	Age  int    `boltease:"age"`
+}
+
+func (e ExampleType) String() string {
+	r, _ := json.Marshal(e)
+	return string(r)
+}
+
+type ExampleType2 struct {
+	Name       string          `boltease:"name"`
+	Age        int             `boltease:"age"`
+	SubTypePtr *ExampleSubType `boltease:"subtypeptr"`
+	SubType    ExampleSubType  `boltease:"subtype"`
+	Number     *int            `boltease:"number"`
+}
+
+func (e ExampleType2) String() string {
+	r, _ := json.Marshal(e)
+	return string(r)
+}
+
+type ExampleSubType struct {
+	SubName string `boltease:"subname"`
+}
+
+func (e ExampleSubType) String() string {
+	r, _ := json.Marshal(e)
+	return string(r)
+}