A Go package which reads structure data from CSV data using reflection

csvdta.go

package csvdata
// csvdata complements the csv package by allowing you to map a custom structure to
// the columns of data in a CSV file. The struct needs to be annotated so that each
// field can match a column in the data
//
//    type Person struct {
//       FirstName string `field:"First Name"`
//       Second_Name string
//       Age int
//    }
//
// The name of the column can be inferred from the field name; any underscores in the
// name are converted to spaces when comparing. Otherwise, you must provide a tag
// 'field' with the name of the column.
//
//     r := csv.NewReader(os.Stdin)
//     p := new (Person)
//     rs,_ := NewReaderIter(r,p)
//     for rs.Get() {
//        fmt.Println(p.FirstName,p.Second_Name,p.Age)
//     }
//     if rs.Error != nil {
//        fmt.Println("error",rs.Error)
//    }

import (
	"os"
	"reflect"
	"strconv"
	"strings"
)

// The data source is any object that has a Read method which can
// return a row as a slice of strings. This matches csv.Reader in particular.
type Reader interface {
	Read() ([]string, os.Error)
}

// Custom data types can be implemented by implementing Value; these
// methods must be defined on a pointer receiver.
// The interface is also used by flag package for a similar purpose.
type Value interface {
	String() string
	Set(string) bool
}

// ReadIter encapsulates an iterator over a Reader source that fills a
// pointer to a user struct with data.
type ReadIter struct {
	Reader       Reader
	Headers      []string
	Error        os.Error
	Line, Column int
	fields       []reflect.Value
	kinds        []int
	tags         []int
}

const (
	none_k = iota
	string_k
	int_k
	float_k
	uint_k
	value_k
)

// Creates a new iterator from a Reader source and a user-defined struct.
func NewReadIter(rdr Reader, ps interface{}) (this *ReadIter, err os.Error) {
	this = new(ReadIter)
	this.Line = 1
	this.Headers, err = rdr.Read()
	this.Reader = rdr
	if err != nil {
		this = nil
		return
	}
	st := reflect.TypeOf(ps).Elem()
	sv := reflect.ValueOf(ps).Elem()
	nf := st.NumField()
	this.kinds = make([]int, nf)
	this.tags = make([]int, nf)
	this.fields = make([]reflect.Value, nf)
	for i := 0; i < nf; i++ {
		f := st.Field(i)

		val := sv.Field(i)
		// get the corresponding field name and look it up in the headers
		tag := f.Tag.Get("field")
		if len(tag) == 0 {
			tag = f.Name
			if strings.Contains(tag, "_") {
				tag = strings.Replace(tag,"_"," ",-1)
			}
		}
		itag := -1
		for k, h := range this.Headers {
			if h == tag {
				itag = k
				break
			}
		}
		if itag == -1 {
			err = os.NewError("cannot find this field " + tag)
			this = nil
			return
		}
		kind := none_k
		Kind := f.Type.Kind()
		// this is necessary because Kind can't tell distinguish between a primitive type
		// and a type derived from it. We're looking for a Value interface defined on
		// the pointer to this value
		_, ok := val.Addr().Interface().(Value)
		if ok {
			val = val.Addr()
			kind = value_k
		} else {
			switch Kind {
			case reflect.Int, reflect.Int16, reflect.Int8, reflect.Int32, reflect.Int64:
				kind = int_k
			case reflect.Uint, reflect.Uint16, reflect.Uint8, reflect.Uint32, reflect.Uint64:
				kind = uint_k
			case reflect.Float32, reflect.Float64:
				kind = float_k
			case reflect.String:
				kind = string_k
			default:
				kind = value_k
				_, ok := val.Interface().(Value)
				if !ok {
					err = os.NewError("cannot convert this type ")
					this = nil
					return
				}
			}
		}
		this.kinds[i] = kind
		this.tags[i] = itag
		this.fields[i] = val
	}
	return
}

// The Get method reads the next row. If there was an error or EOF, it
// will return false.  Client code must then check that ReadIter.Error is
// not nil to distinguish between normal EOF and specific errors.
func (this *ReadIter) Get() bool {
	row, err := this.Reader.Read()
	this.Line = this.Line + 1
	if err != nil {
		if err != os.EOF {
			this.Error = err
		}
		return false
	}
	var ival int64
	var fval float64
	var uval uint64
	var v Value
	var ok bool

	for fi, ci := range this.tags {
		vals := row[ci] // string at column ci of current row
		f := this.fields[fi]
		switch this.kinds[fi] {
		case string_k:
			f.SetString(vals)
		case int_k:
			ival, err = strconv.Atoi64(vals)
			f.SetInt(ival)
		case uint_k:
			uval, err = strconv.Atoui64(vals)
			f.SetUint(uval)
		case float_k:
			fval, err = strconv.Atof64(vals)
			f.SetFloat(fval)
		case value_k:
			v, ok = f.Interface().(Value)
			if !ok {
				err = os.NewError("Not a Value object")
				break
			}
			v.Set(vals)
		}
		if err != nil {
			this.Column = ci + 1
			this.Error = err
			return false
		}
	}
	return true
}

testdate.go

package main
// invoke like so :  ./testdate -d 2009-01-01

import (
	"fmt"
	"flag"
	"csv"
	"strings"
	"time"
	"./csvdata"
)

type Person struct {
	Joined      *Date
	FirstName   string `field:"First Name"`
	Second_Name string
	Age         int
}

const isodate = "2006-01-02"

type Date struct {
	*time.Time
}

func (this *Date) String() string {
	return this.Format(isodate)
}

func (this *Date) Set(sval string) bool {
	t, e := time.Parse(isodate, sval)
	this.Time = t
	return e == nil
}

var testdata = `
Joined,"First Name",Second Name,Age
2009-10-03,John,Smith,67
2010-03-15,Jill,Tailor,54
`

func main() {
	// our Date satisfies the Value interface, so we can use it as a flag value
	date := Date{time.LocalTime()}
	flag.Var(&date, "d", "date to filter records")
	flag.Parse()
	// read from our string
	rdr := strings.NewReader(testdata)
	r := csv.NewReader(rdr)
	// make a pointer to our structure
	p := new(Person)
	p.Joined = new(Date)
	rs, _ := csvdata.NewReadIter(r, p)
	for rs.Get() {
		if date.Year == p.Joined.Year {
			fmt.Println(p)
		}
	}
	if rs.Error != nil {
		fmt.Println("error", rs.Error)
	}
}

testthousands.go

package main
// invoke like so :  ./testdate -d 2009-01-01

import (
	"fmt"
	"csv"
	"strings"
	"strconv"
	"./csvdata"
)

type Account struct {
	Name     string
	Received Float
	Spent    Float
}

type Float float64

func (this *Float) String() string {
	return strconv.Ftoa64(float64(*this), 'f', 10)
}

func (this *Float) Set(sval string) bool {
	sval = strings.Replace(sval,",","",-1)
	v, e := strconv.Atof64(sval)
	*this = Float(v)
	return e == nil
}

var testdata = `
Name,Received,Spent
Frodo,"3,200","4,444"
Bilbo,"4,100","23,000"
`

func main() {
	// read from our string
	rdr := strings.NewReader(testdata)
	r := csv.NewReader(rdr)
	// make a pointer to our structure
	p := new(Account)
	rs, e := csvdata.NewReadIter(r, p)
	if e != nil {
		fmt.Println("iter", e)
		return
	}
	for rs.Get() {
		fmt.Println(p)
	}
	if rs.Error != nil {
		fmt.Println("error", rs.Error, "at line", rs.Line, "and column", rs.Column)
	}
}