add next and scan reading mode

Author: Stefan Tudose

convert.go

@@ -0,0 +1,94 @@
+package csvdecoder
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// convertAssignValues copies to dest the value in src, converting it if possible.
+// An error is returned if the conversion is not possible.
+// dest is expected to be a non-nil pointer type.
+func convertAssignValue(dest interface{}, src string) error {
+	dpv := reflect.ValueOf(dest)
+	if dpv.Kind() != reflect.Ptr {
+		return errNotPtr
+	}
+	if dpv.IsNil() {
+		return errNilPtr
+	}
+
+	if src == "" {
+		// zero values should leave the dest untouched
+		return nil
+	}
+
+	// check if the destination implements the Decoder interface
+	if decoder, ok := dest.(Decoder); ok {
+		return decoder.DecodeRecord(src)
+	}
+
+	var sv reflect.Value
+
+	// simple cases without reflect
+	switch d := dest.(type) {
+	case *string:
+		*d = src
+		return nil
+	case *[]byte:
+		*d = []byte(src)
+		return nil
+	case *bool:
+		bv, err := strconv.ParseBool(src)
+		if err == nil {
+			*d = bv
+		}
+		return err
+	case *interface{}:
+		*d = sv.Interface()
+		return nil
+	}
+
+	// cases with reflect
+	sv = reflect.ValueOf(src)
+	dv := reflect.Indirect(dpv)
+
+	if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
+		dv.Set(sv)
+		return nil
+	}
+
+	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
+		dv.Set(sv.Convert(dv.Type()))
+		return nil
+	}
+
+	switch dv.Kind() {
+	case reflect.Ptr:
+		dv.Set(reflect.New(dv.Type().Elem()))
+		return convertAssignValue(dv.Interface(), src)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		i64, err := strconv.ParseInt(src, 10, dv.Type().Bits())
+		if err != nil {
+			return err
+		}
+		dv.SetInt(i64)
+		return nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		u64, err := strconv.ParseUint(src, 10, dv.Type().Bits())
+		if err != nil {
+			return err
+		}
+		dv.SetUint(u64)
+		return nil
+	case reflect.Float32, reflect.Float64:
+		f64, err := strconv.ParseFloat(src, dv.Type().Bits())
+		if err != nil {
+			return err
+		}
+		dv.SetFloat(f64)
+		return nil
+	}
+
+	return fmt.Errorf("unsupported Scan, storing type %T into type %T", src, dest)
+}

errors.go

@@ -0,0 +1,13 @@
+package csvdecoder
+
+import (
+	"errors"
+)
+
+var (
+	// ErrEOF is thrown if the EOF is reached by the Next method.
+	ErrEOF = errors.New("end of file reached")
+
+	errNilPtr = errors.New("destination is a nil pointer")
+	errNotPtr = errors.New("destination not a pointer")
+)

main/main.go

@@ -21,10 +21,9 @@ type ExampleStringArrayRow struct {
 }
 
 type ExampleSimpleRow struct {
-	Name   string
-	Age    int
-	Gender string
-	Real   bool
+	Name string
+	Age  int
+	Real bool
 }
 
 type ExampleIntArrayRow struct {
@@ -67,26 +66,25 @@ type TestExampleDeserializerRow struct {
 
 func main() {
 	fmt.Println("running")
-	file, err := os.Open("/Users/stefan.tudose/private/gitrepos/csvdecoder/example_simple.csvdecoder")
+	file, err := os.Open("/Users/stefan.tudose/private/gitrepos/csvdecoder/test/example_simple.csv")
 	if err != nil {
 		panic(err)
 	}
 	defer file.Close()
 
-	parser, err := csvdecoder.NewParser(file)
+	parser, err := csvdecoder.NewParser(file, &csvdecoder.ParserConfig{IgnoreHeaders: true})
 	if err != nil {
 		panic(err)
 	}
 
-	for {
+	for parser.Nexty() {
 		data := ExampleSimpleRow{}
-		eof, err := parser.Next(&data)
-		if eof {
-			return
-		}
-		if err != nil {
+		if err := parser.Scan(&data.Name, &data.Age, &data.Real); err != nil {
 			panic(err)
 		}
 		fmt.Println(data)
 	}
+	if err = parser.Err(); err != nil {
+		panic(err)
+	}
 }

parser.go

@@ -12,8 +12,10 @@ import (
 )
 
 type Parser struct {
-	Reader *csv.Reader
-	config *ParserConfig
+	Reader           *csv.Reader
+	config           *ParserConfig
+	currentRowValues []string
+	lastErr          error
 }
 
 // ParserConfig has information for parser
@@ -168,3 +170,61 @@ func (p *Parser) Next(data interface{}) (eof bool, err error) {
 
 	return false, nil
 }
+
+// Scan copies the values in the current row into the values pointed
+// at by dest. The number of values in dest can be different than the
+// number of values. In this case Scan will only fill the available
+// values.
+//
+// Scan converts columns read from the database into the following
+// common types:
+//
+//    *string
+//    *[]byte
+//    *int, *int8, *int16, *int32, *int64
+//    *uint, *uint8, *uint16, *uint32, *uint64
+//    *bool
+//    *float32, *float64
+//    *interface{}
+//    any type implementing Decoder
+//
+func (p *Parser) Scan(dest ...interface{}) error {
+	if p.currentRowValues == nil {
+		return errors.New("Scan called without calling Next")
+	}
+	for i, val := range p.currentRowValues {
+		err := convertAssignValue(dest[i], val)
+		if err != nil {
+			return fmt.Errorf(`Scan error on value index %d: %v`, i, err)
+		}
+	}
+	return nil
+}
+
+// Next prepares the next result row for reading with the Scan method. It
+// returns nil on success, or false if there is no next result row or an error
+// happened while preparing it. Err should be consulted to distinguish between
+// the two cases.
+//
+// Every call to Scan, even the first one, must be preceded by a call to Next.
+func (p *Parser) Nexty() bool {
+	var err error
+	p.currentRowValues, err = p.Reader.Read()
+	if err != nil {
+		if err.Error() == "EOF" {
+			p.lastErr = ErrEOF
+			return false
+		}
+		p.lastErr = fmt.Errorf("error while reading: %w", err)
+		return false
+	}
+	return true
+}
+
+// Err returns the error, if any, that was encountered during iteration.
+func (p *Parser) Err() error {
+	if p.lastErr != nil && p.lastErr != ErrEOF {
+		return p.lastErr
+	}
+	return nil
+}