wip: unmarshaler

default_record_handler.go

@@ -0,0 +1,66 @@
+package gocsvparser
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type defaultRecordHandlerMode int
+
+const (
+	single defaultRecordHandlerMode = 1
+	slice  defaultRecordHandlerMode = 2
+)
+
+type defaultRecordHandler struct {
+	structType     reflect.Type
+	mode           defaultRecordHandlerMode
+	slice          reflect.Value
+	fieldByName    map[string]FieldsHandlerByName
+	fieldByIndices map[int]FieldsHandlerByIndices
+	fieldsHandlers []FieldsHandler
+}
+
+type defaultFieldsHandlerByName struct {
+}
+
+func newDefaultRecordHandler(v interface{}) (*defaultRecordHandler, error) {
+	val := reflect.ValueOf(v)
+	if val.Kind() == reflect.Pointer {
+		val = val.Elem()
+
+		recordHandler := &defaultRecordHandler{}
+		switch val.Kind() {
+		case reflect.Slice:
+			recordHandler.mode = slice
+			typ := val.Type().Elem()
+			if typ.Kind() == reflect.Struct {
+				recordHandler.slice = val
+				recordHandler.structType = typ
+			}
+		case reflect.Struct:
+			recordHandler.mode = single
+		}
+	}
+
+	return nil, fmt.Errorf("invalid value %v", val)
+}
+
+func (dr *defaultRecordHandler) buildFieldsHandler() {
+
+}
+
+func (df *defaultFieldsHandlerByName) FieldsName() string {
+	//TODO: implementation
+	return ""
+}
+
+func (df *defaultFieldsHandlerByName) NumFields() int {
+	//TODO: implementation
+	return 0
+}
+
+func (df *defaultFieldsHandlerByName) Fields(fields ...string) error {
+	//TODO: implementation
+	return nil
+}

unmarshal.go

@@ -4,9 +4,30 @@ import (
 	"encoding/csv"
 )
 
+type FieldsHandlerByName interface {
+	FieldsName() string
+	FieldsHandler
+}
+
+type FieldsHandlerByIndices interface {
+	FieldsIndices() []int
+	FieldByIndex(index int, field string) error
+	FieldsHandler
+}
+
+type FieldsHandler interface {
+	Fields(fields ...string) error
+	NumFields() int
+}
+
+type RecordHandler interface {
+	FieldsHandlers() []FieldsHandler
+}
+
 type Unmarshaler struct {
 	header        []string
 	reader        *csv.Reader
+	recordHandler RecordHandler
 }
 
 func NewUnmarshaler() *Unmarshaler {
@@ -27,6 +48,11 @@ func (u *Unmarshaler) WithHeader(header []string) *Unmarshaler {
 	return u
 }
 
+func (u *Unmarshaler) WithRecordHandler(handler RecordHandler) *Unmarshaler {
+	u.recordHandler = handler
+	return u
+}
+
 func (u *Unmarshaler) Unmarshal(data []byte, v interface{}) error {
 	//TODO: implementation
 	return nil
@@ -35,3 +61,20 @@ func (u *Unmarshaler) Unmarshal(data []byte, v interface{}) error {
 func Unmarshal(data []byte, v interface{}) error {
 	return NewUnmarshaler().Unmarshal(data, v)
 }
+
+// func Read(i interface{}) {
+// 	var val reflect.Value
+
+// 	val = reflect.ValueOf(i)
+// 	if val.Kind() == reflect.Pointer {
+// 		val = val.Elem()
+
+// 		if val.Kind() == reflect.Slice {
+// 			val = val.Elem()
+
+// 			if val.Kind() == reflect.Struct {
+// 				fields := reflect.VisibleFields(val.Type())
+// 			}
+// 		}
+// 	}
+// }

unmarshal_test.go

@@ -0,0 +1,69 @@
+package gocsvparser
+
+import (
+	"reflect"
+	"testing"
+)
+
+type Coba struct {
+	Name    string `csv:"name"`
+	Address string `csv:"address,omitempty"`
+	Mile    int64  `csv:"mile"`
+	anon
+}
+
+type anon struct {
+	FieldX  int64 `csv:"x"`
+	OutputY int64 `csv:"y"`
+}
+
+func TestRead(t *testing.T) {
+	var coba []Coba
+
+	Read(&coba, t)
+
+	t.Logf("outside %+v", coba)
+
+	// type args struct {
+	// 	i interface{}
+	// }
+	// tests := []struct {
+	// 	name string
+	// 	args args
+	// }{
+	// 	// TODO: Add test cases.
+	// }
+	// for _, tt := range tests {
+	// 	t.Run(tt.name, func(t *testing.T) {
+	// 		Read(tt.args.i)
+	// 	})
+	// }
+}
+
+func Read(i interface{}, t *testing.T) {
+	var val reflect.Value
+
+	val = reflect.ValueOf(i)
+	if val.Kind() == reflect.Pointer {
+		val = val.Elem()
+
+		if val.Kind() == reflect.Slice {
+			vslice := val
+			typ := val.Type().Elem()
+
+			if typ.Kind() == reflect.Struct {
+				for _, x := range reflect.VisibleFields(typ) {
+					t.Logf("test: %+v", x)
+				}
+
+				nv := reflect.New(typ).Elem()
+				nv.FieldByName("Name").SetString("hello")
+				nv.FieldByName("Mile").SetInt(72)
+				// vslice = reflect.Append(vslice, nv)
+				vslice.Set(reflect.Append(vslice, nv))
+
+				t.Logf("inside: %+v", vslice)
+			}
+		}
+	}
+}