schema

in := `{
		"name": "id",
		"type": "string",
		"format": "default",
		"constraints": {
			"required": true,
			"minLen": "5",
			"maxLen": "10",
			"pattern": ".*11$",
			"enum":["1234511"]
		}
	}`
var field Field
json.Unmarshal([]byte(in), &field)
v, err := field.Cast("1234511")
if err != nil {
	panic(err)
}
fmt.Println(v)

Output:

1234511

// Lets assume we have a schema ...
s := Schema{Fields: []Field{{Name: "Name", Type: StringType}, {Name: "Age", Type: IntegerType, Constraints: Constraints{Unique: true}}}}
// And a Table.
t := table.FromSlices([]string{"Name", "Age"}, [][]string{
	{"Foo", "42"},
	{"Bar", "43"}})
// And we would like to process the column Age using Go types. First we need to create a
// slice to hold the column contents.
var ages []float64
// Extract the column.
col, _ := t.ReadColumn("Age")
// And profit!
s.CastColumn(col, "Age", &ages)
fmt.Print(ages)

Output:

[42 43]

// Lets assume we have a schema ...
s := Schema{Fields: []Field{{Name: "Name", Type: StringType}, {Name: "Age", Type: IntegerType}}}

// And a Table.
t := table.FromSlices([]string{"Name", "Age"}, [][]string{
	{"Foo", "42"},
	{"Bar", "43"}})

// And we would like to process them using Go types. First we need to create a struct to
// hold the content of each row.
// The tag tableheader maps the field to the schema. If no tag is set the name of the field
// has to be the same like inside the schema.
type person struct {
	MyName string `tableheader:"Name"`
	Age    int
}

// Now it is a matter of iterate over the table and Cast each row.
iter, _ := t.Iter()
for iter.Next() {
	var p person
	s.CastRow(iter.Row(), &p)
	fmt.Printf("%+v\n", p)
}

Output:

{MyName:Foo Age:42}
{MyName:Bar Age:43}

// Lets assume we have a schema ...
s := Schema{Fields: []Field{{Name: "Name", Type: StringType}, {Name: "Age", Type: IntegerType, Constraints: Constraints{Unique: true}}}}

// And a Table.
t := table.FromSlices([]string{"Name", "Age"}, [][]string{
	{"Foo", "42"},
	{"Bar", "43"}})

// And we would like to process them using Go types. First we need to create a struct to
// hold the content of each row.
// The tag tableheader maps the field to the schema. If no tag is set the name of the field
// has to be the same like inside the schema.
type person struct {
	MyName string `tableheader:"Name"`
	Age    int
}
var people []person
s.CastTable(t, &people)
fmt.Print(people)

Output:

[{Foo 42} {Bar 43}]

// Lets assume we have a schema.
s := Schema{Fields: []Field{{Name: "Name", Type: StringType}, {Name: "Age", Type: IntegerType}}}

// And would like to create a CSV out of this list. The tag tableheader maps
// the field to the schema name. If no tag is set the name of the field
// has to be the same like inside the schema.
people := []struct {
	MyName string `tableheader:"Name"`
	Age    int
}{{"Foo", 42}, {"Bar", 43}}

// First create the writer and write the header.
w := table.NewStringWriter()
w.Write([]string{"Name", "Age"})

// Then write the list
for _, person := range people {
	row, _ := s.UncastRow(person)
	w.Write(row)
}
w.Flush()
fmt.Print(w.String())

Output:

Name,Age
Foo,42
Bar,43

// Lets assume we have a schema.
s := Schema{Fields: []Field{{Name: "Name", Type: StringType}, {Name: "Age", Type: IntegerType}}}

// And would like to create a CSV out of this list. The tag tableheader maps
// the field to the schema name. If no tag is set the name of the field
// has to be the same like inside the schema.
people := []struct {
	MyName string `tableheader:"Name"`
	Age    int
}{{"Foo", 42}, {"Bar", 43}}

// Then uncast the people slice into a slice of rows.
rows, _ := s.UncastTable(people)

// Now, simply write it down.
w := table.NewStringWriter()
w.Write([]string{"Name", "Age"})
w.WriteAll(rows)
w.Flush()
fmt.Print(w.String())

Output:

Name,Age
Foo,42
Bar,43