Fixed bug causing custom types of simple integer and string types to not work correctly in automap decoding

Author: zegl

auto_map_array_test.go

@@ -1,6 +1,7 @@
 package goriak
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -94,3 +95,39 @@ func TestAutoMapByteSlice(t *testing.T) {
 		t.Error("Wrong Val")
 	}
 }
+
+func TestCustomTypeUint8(t *testing.T) {
+	type CustomNumber uint8
+	type CustomString string
+	type CustomSlice []uint8
+	type tt struct {
+		Num CustomNumber
+		Str CustomString
+		Sli CustomSlice
+	}
+
+	input := tt{
+		Num: 50,
+		Str: "Hello",
+		Sli: CustomSlice{1, 2, 3, 4, 5},
+	}
+
+	res, err := bucket().Set(input).Run(con())
+	if err != nil {
+		t.Error(err)
+	}
+
+	var output tt
+
+	_, err = bucket().Get(res.Key, &output).Run(con())
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !reflect.DeepEqual(input, output) {
+		t.Logf("%+v", input)
+		t.Logf("%+v", output)
+	}
+
+	t.Logf("%+v", output)
+}

auto_map_decode.go

@@ -298,7 +298,6 @@ func transRiakToSlice(sliceValue reflect.Value, registerName string, data *riak.
 
 				// Override the Slice from "Userland"
 				sliceValue.Set(finalSliceValue)
-
 			}
 
 			return nil
@@ -317,58 +316,72 @@ func bytesToValue(input []byte, outputType reflect.Type) (reflect.Value, error)
 
 	outputKind := outputType.Kind()
 
+	// The final type (can be a custom type for example)
+	newWithSameType := reflect.New(outputType).Elem()
+
 	switch outputKind {
 	case reflect.String:
-		return reflect.ValueOf(string(input)), nil
+		newWithSameType.SetString(string(input))
+		return newWithSameType, nil
 
 	case reflect.Int:
 		if i, err := strconv.ParseInt(string(input), 10, 0); err == nil {
-			return reflect.ValueOf(int(i)), nil
+			newWithSameType.SetInt(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Int8:
 		if i, err := strconv.ParseInt(string(input), 10, 8); err == nil {
-			return reflect.ValueOf(int8(i)), nil
+			newWithSameType.SetInt(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Int16:
 		if i, err := strconv.ParseInt(string(input), 10, 16); err == nil {
-			return reflect.ValueOf(int16(i)), nil
+			newWithSameType.SetInt(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Int32:
 		if i, err := strconv.ParseInt(string(input), 10, 32); err == nil {
-			return reflect.ValueOf(int32(i)), nil
+			newWithSameType.SetInt(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Int64:
 		if i, err := strconv.ParseInt(string(input), 10, 64); err == nil {
-			return reflect.ValueOf(int64(i)), nil
+			newWithSameType.SetInt(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Uint:
 		if i, err := strconv.ParseUint(string(input), 10, 0); err == nil {
-			return reflect.ValueOf(uint(i)), nil
+			newWithSameType.SetUint(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Uint8:
 		if i, err := strconv.ParseUint(string(input), 10, 8); err == nil {
-			return reflect.ValueOf(uint8(i)), nil
+			newWithSameType.SetUint(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Uint16:
 		if i, err := strconv.ParseUint(string(input), 10, 16); err == nil {
-			return reflect.ValueOf(uint16(i)), nil
+			newWithSameType.SetUint(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Uint32:
 		if i, err := strconv.ParseUint(string(input), 10, 32); err == nil {
-			return reflect.ValueOf(uint32(i)), nil
+			newWithSameType.SetUint(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Uint64:
 		if i, err := strconv.ParseUint(string(input), 10, 64); err == nil {
-			return reflect.ValueOf(uint64(i)), nil
+			newWithSameType.SetUint(i)
+			return newWithSameType, nil
 		}
 
 	case reflect.Slice: