v0.0.161

wmo/reflection.go

@@ -1,6 +1,7 @@
 package wmo
 
 import (
+	"errors"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/reflectext"
 	"reflect"
@@ -14,7 +15,6 @@ func (c *Coll[TData]) EnsureInitializedReflection(v TData) {
 	}
 
 	rval := reflect.ValueOf(v)
-
 	for rval.Type().Kind() == reflect.Pointer {
 		rval = rval.Elem()
 	}
@@ -69,50 +69,65 @@ func (c *Coll[TData]) initFields(prefix string, rval reflect.Value, m map[string
 			continue
 		}
 
+		bsontags := make([]string, 0)
 		bsonkey, found := rsfield.Tag.Lookup("bson")
 		if !found {
 			continue
 		}
 		if strings.Contains(bsonkey, ",") {
 			bsonkey = bsonkey[:strings.Index(bsonkey, ",")]
+			bsontags = strings.Split(bsonkey[strings.Index(bsonkey, ",")+1:], ",")
 		}
 		if bsonkey == "-" {
 			continue
 		}
 
+		if bsonkey == "" {
+			bsonkey = rsfield.Name
+		}
+
 		fullKey := prefix + bsonkey
 
 		newIdxArr := langext.ArrCopy(idxarr)
 		newIdxArr = append(newIdxArr, i)
 
-		if rvfield.Type().Kind() == reflect.Pointer {
+		if langext.InArray("inline", bsontags) && rvfield.Kind() == reflect.Struct {
 
-			m[fullKey] = fullTypeRef{
-				IsPointer:      true,
-				RealType:       rvfield.Type(),
-				Kind:           rvfield.Type().Elem().Kind(),
-				Type:           rvfield.Type().Elem(),
-				UnderlyingType: reflectext.Underlying(rvfield.Type().Elem()),
-				Name:           rsfield.Name,
-				Index:          newIdxArr,
-			}
+			// pass-through field
+			c.initFields(prefix, rvfield, m, newIdxArr)
 
 		} else {
 
-			m[fullKey] = fullTypeRef{
-				IsPointer:      false,
-				RealType:       rvfield.Type(),
-				Kind:           rvfield.Type().Kind(),
-				Type:           rvfield.Type(),
-				UnderlyingType: reflectext.Underlying(rvfield.Type()),
-				Name:           rsfield.Name,
-				Index:          newIdxArr,
+			if rvfield.Type().Kind() == reflect.Pointer {
+
+				m[fullKey] = fullTypeRef{
+					IsPointer:      true,
+					RealType:       rvfield.Type(),
+					Kind:           rvfield.Type().Elem().Kind(),
+					Type:           rvfield.Type().Elem(),
+					UnderlyingType: reflectext.Underlying(rvfield.Type().Elem()),
+					Name:           rsfield.Name,
+					Index:          newIdxArr,
+				}
+
+			} else {
+
+				m[fullKey] = fullTypeRef{
+					IsPointer:      false,
+					RealType:       rvfield.Type(),
+					Kind:           rvfield.Type().Kind(),
+					Type:           rvfield.Type(),
+					UnderlyingType: reflectext.Underlying(rvfield.Type()),
+					Name:           rsfield.Name,
+					Index:          newIdxArr,
+				}
+
 			}
 
-		}
+			if rvfield.Kind() == reflect.Struct {
+				c.initFields(fullKey+".", rvfield, m, newIdxArr)
+			}
 
-		if rvfield.Kind() == reflect.Struct {
-			c.initFields(fullKey+".", rvfield, m, newIdxArr)
 		}
 
 	}
@@ -121,7 +136,10 @@ func (c *Coll[TData]) initFields(prefix string, rval reflect.Value, m map[string
 
 func (c *Coll[TData]) getTokenValueAsMongoType(value string, fieldName string) (any, error) {
 
-	fref := c.dataTypeMap[fieldName]
+	fref, err := c.getFieldType(fieldName)
+	if err != nil {
+		return nil, err
+	}
 
 	pss := reflectext.PrimitiveStringSerializer{}
 
@@ -131,7 +149,10 @@ func (c *Coll[TData]) getTokenValueAsMongoType(value string, fieldName string) (
 
 func (c *Coll[TData]) getFieldValueAsTokenString(entity TData, fieldName string) (string, error) {
 
-	realValue := c.getFieldValue(entity, fieldName)
+	realValue, err := c.getFieldValue(entity, fieldName)
+	if err != nil {
+		return "", err
+	}
 
 	pss := reflectext.PrimitiveStringSerializer{}
 
@@ -139,12 +160,56 @@ func (c *Coll[TData]) getFieldValueAsTokenString(entity TData, fieldName string)
 
 }
 
-func (c *Coll[TData]) getFieldType(fieldName string) fullTypeRef {
-	return c.dataTypeMap[fieldName]
+func (c *Coll[TData]) getFieldType(fieldName string) (fullTypeRef, error) {
+	if c.isInterfaceDataType {
+
+		for _, m := range c.implDataTypeMap {
+			if r, ok := m[fieldName]; ok {
+				return r, nil
+			}
+		}
+
+		return fullTypeRef{}, errors.New("unknown field: '" + fieldName + "' (in any impl)")
+
+	} else {
+
+		if r, ok := c.dataTypeMap[fieldName]; ok {
+			return r, nil
+		} else {
+			return fullTypeRef{}, errors.New("unknown field: '" + fieldName + "'")
+		}
+
+	}
+
 }
 
-func (c *Coll[TData]) getFieldValue(data TData, fieldName string) any {
-	fref := c.dataTypeMap[fieldName]
-	rval := reflect.ValueOf(data)
-	return rval.FieldByIndex(fref.Index).Interface()
+func (c *Coll[TData]) getFieldValue(data TData, fieldName string) (any, error) {
+	if c.isInterfaceDataType {
+
+		rval := reflect.ValueOf(data)
+		for rval.Type().Kind() == reflect.Pointer {
+			rval = rval.Elem()
+		}
+
+		if m, ok := c.implDataTypeMap[rval.Type()]; ok {
+			if fref, ok := m[fieldName]; ok {
+				rval := reflect.ValueOf(data)
+				return rval.FieldByIndex(fref.Index).Interface(), nil
+			} else {
+				return nil, errors.New("unknown bson field '" + fieldName + "' in type '" + rval.Type().String() + "'")
+			}
+		} else {
+			return nil, errors.New("unknown TData type: '" + rval.Type().String() + "'")
+		}
+
+	} else {
+
+		if fref, ok := c.dataTypeMap[fieldName]; ok {
+			rval := reflect.ValueOf(data)
+			return rval.FieldByIndex(fref.Index).Interface(), nil
+		} else {
+			return nil, errors.New("unknown bson field '" + fieldName + "'")
+		}
+
+	}
 }