set

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// Once a BoundMapping has been created you can swap out the value it mutates
	// by calling Rebind.  This yields better performance in tight loops where
	// you intend to mutate many instances of the same type.

	m := &set.Mapper{}

	type S struct {
		Str string
		Num int
	}

	values := []map[string]interface{}{
		{"Str": "First", "Num": 1},
		{"Str": "Second", "Num": 2},
		{"Str": "Third", "Num": 3},
	}
	slice := make([]S, 3)

	b, _ := m.Bind(&slice[0]) // We can bind on the first value to get a BoundMapping
	for k := range slice {
		b.Rebind(&slice[k]) // The BoundMapping now affects slice[k]
		for key, value := range values[k] {
			_ = b.Set(key, value) // error ignored for brevity
		}
	}

	fmt.Println(slice[0].Num, slice[0].Str)
	fmt.Println(slice[1].Num, slice[1].Str)
	fmt.Println(slice[2].Num, slice[2].Str)

}

Output:

1 First
2 Second
3 Third

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// BoundMapping.Rebind panics if the new instance is not the same type.

	m := &set.Mapper{}

	type S struct {
		Str string
	}
	type Different struct {
		Str string
	}

	defer func() {
		if r := recover(); r != nil {
			fmt.Println(r)
		}
	}()

	var s S
	var d Different

	b, _ := m.Bind(&s)
	b.Rebind(&d)

}

Output:

mismatching types during Rebind; have *set_test.S and got *set_test.Different

package main

import (
	"fmt"
	"reflect"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// As a convenience BoundMapping.Rebind can be called with an instance of reflect.Value
	// if-and-only-if the reflect.Value is holding a type compatible with the BoundMapping.

	m := &set.Mapper{}

	type S struct {
		Str string
		Num int
	}
	var s S

	// Errors ignored for brevity.
	b, _ := m.Bind(&s)
	_ = b.Set("Num", 42) // b.Set errors ignored for brevity
	_ = b.Set("Str", "Hello")

	rv := reflect.New(reflect.TypeOf(s)) // reflect.New creates a *S which is the type
	b.Rebind(rv)                         // originally bound.  Therefore b.Rebind(rv) is valid.
	_ = b.Set("Num", 100)
	_ = b.Set("Str", "reflect.Value!")
	r := rv.Elem().Interface().(S)

	fmt.Println(s.Str, s.Num)
	fmt.Println(r.Str, r.Num)

}

Output:

Hello 42
reflect.Value! 100

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates a simple flat struct of primitives.
	type S struct {
		Num int
		Str string
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{}
	b, _ := m.Bind(&s) // err ignored for brevity

	// b.Set errors ignored for brevity
	_ = b.Set("Str", 3.14) // 3.14 coerced to "3.14"
	_ = b.Set("Num", "42") // "42" coerced to 42

	fmt.Println(s.Num, s.Str)
}

Output:

42 3.14

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how to access fields in an elevated embedded struct.
	// Elevated types can be embedded without their type name becoming part of the field name.
	type Embed struct {
		V int
	}
	type S struct {
		Num int
		Str string
		Embed
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{
		Elevated: set.NewTypeList(Embed{}), // Elevate embedded fields of type Embed
		Join:     ".",                      // Nested and embedded fields join with DOT
	}
	b, _ := m.Bind(&s) // err ignored for brevity

	// b.Set errors ignored for brevity
	_ = b.Set("Str", 3.14) // 3.14 coerced to "3.14"
	_ = b.Set("Num", "42") // "42" coerced to 42
	_ = b.Set("V", 3.14)   // 3.14 coerced to 3

	fmt.Println(s.Num, s.Str, s.V)
}

Output:

42 3.14 3

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how to access fields in an embedded struct.
	// Notice in this example the field is named Embed.V -- the struct type name
	// becomes part of the mapping name.
	type Embed struct {
		V int
	}
	type S struct {
		Num int
		Str string
		Embed
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{
		Join: ".", // Nested and embedded fields join with DOT
	}
	b, _ := m.Bind(&s) // err ignored for brevity

	// b.Set errors ignored for brevity
	_ = b.Set("Str", 3.14)     // 3.14 coerced to "3.14"
	_ = b.Set("Num", "42")     // "42" coerced to 42
	_ = b.Set("Embed.V", 3.14) // 3.14 coerced to 3

	fmt.Println(s.Num, s.Str, s.V)
}

Output:

42 3.14 3

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how nested structs are accessible via their mapped names.
	type Nest struct {
		V int
	}
	type S struct {
		Num int
		Str string
		Foo Nest
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{
		Join: ".", // Nested and embedded fields join with DOT
	}
	b, _ := m.Bind(&s) // err ignored for brevity

	// b.Set errors ignored for brevity
	_ = b.Set("Str", 3.14)   // 3.14 coerced to "3.14"
	_ = b.Set("Num", "42")   // "42" coerced to 42
	_ = b.Set("Foo.V", 3.14) // 3.14 coerced to 3

	fmt.Println(s.Num, s.Str, s.Foo.V)
}

Output:

42 3.14 3

package main

import (
	"fmt"
	"reflect"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// As a convenience Mapper.Bind will accept a reflect.Value to perform the binding.
	type S struct {
		Num int
		Str string
	}
	var s, t, u S

	// Create a mapper.
	m := &set.Mapper{}
	b, _ := m.Bind(reflect.ValueOf(&s)) // err ignored for brevity

	// b.Set errors ignored for brevity
	_ = b.Set("Str", 3.14)
	_ = b.Set("Num", "42")

	b.Rebind(reflect.ValueOf(&t))
	_ = b.Set("Str", -3.14)
	_ = b.Set("Num", "24")

	// Even though the BoundMapping was created with reflect.Value it will still accept *S directly.
	b.Rebind(&u)
	_ = b.Set("Str", "Works!")
	_ = b.Set("Num", uint(100))

	fmt.Println("s", s.Num, s.Str)
	fmt.Println("t", t.Num, t.Str)
	fmt.Println("u", u.Num, u.Str)
}

Output:

s 42 3.14
t 24 -3.14
u 100 Works!

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates a simple flat struct of primitives.
	type S struct {
		Num int
		Str string
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{}
	p, _ := m.Prepare(&s) // err ignored for brevity

	// PreparedBindings require a call to Plan indicating field order.
	_ = p.Plan("Str", "Num") // err ignored for brevity

	_ = p.Set(3.14) // 3.14 coerced to "3.14"
	_ = p.Set("42") // "42" coerced to 42

	fmt.Println(s.Num, s.Str)
}

Output:

42 3.14

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how to access fields in an elevated embedded struct.
	// Elevated types can be embedded without their type name becoming part of the field name.
	type Embed struct {
		V int
	}
	type S struct {
		Num int
		Str string
		Embed
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{
		Elevated: set.NewTypeList(Embed{}), // Elevate embedded fields of type Embed
		Join:     ".",                      // Nested and embedded fields join with DOT
	}
	p, _ := m.Prepare(&s) // err ignored for brevity

	// PreparedBindings require a call to Plan indicating field order.
	_ = p.Plan("Str", "Num", "V") // err ignored for brevity

	_ = p.Set(3.14) // 3.14 coerced to "3.14"
	_ = p.Set("42") // "42" coerced to 42
	_ = p.Set(3.14) // 3.14 coerced to 3

	fmt.Println(s.Num, s.Str, s.V)
}

Output:

42 3.14 3

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how to access fields in an embedded struct.
	// Notice in this example the field is named Embed.V -- the struct type name
	// becomes part of the mapping name.
	type Embed struct {
		V int
	}
	type S struct {
		Num int
		Str string
		Embed
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{
		Join: ".", // Nested and embedded fields join with DOT
	}
	p, _ := m.Prepare(&s) // err ignored for brevity

	// PreparedBindings require a call to Plan indicating field order.
	_ = p.Plan("Str", "Num", "Embed.V") // err ignored for brevity

	_ = p.Set(3.14) // 3.14 coerced to "3.14"
	_ = p.Set("42") // "42" coerced to 42
	_ = p.Set(3.14) // 3.14 coerced to 3

	fmt.Println(s.Num, s.Str, s.V)
}

Output:

42 3.14 3

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how nested structs are accessible via their mapped names.
	type Nest struct {
		V int
	}
	type S struct {
		Num int
		Str string
		Foo Nest
	}
	var s S

	// Create a mapper.
	m := &set.Mapper{
		Join: ".", // Nested and embedded fields join with DOT
	}
	p, _ := m.Prepare(&s) // err ignored for brevity

	// PreparedBindings require a call to Plan indicating field order.
	_ = p.Plan("Str", "Num", "Foo.V") // err ignored for brevity

	_ = p.Set(3.14) // 3.14 coerced to "3.14"
	_ = p.Set("42") // "42" coerced to 42
	_ = p.Set(3.14) // 3.14 coerced to 3

	fmt.Println(s.Num, s.Str, s.Foo.V)
}

Output:

42 3.14 3

package main

import (
	"fmt"
	"reflect"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// As a convenience Mapper.Prepare will accept a reflect.Value to perform the binding.
	type S struct {
		Num int
		Str string
	}
	var s, t, u S

	// Create a mapper.
	m := &set.Mapper{}
	p, _ := m.Prepare(reflect.ValueOf(&s)) // err ignored for brevity
	_ = p.Plan("Str", "Num")               // err ignored for brevity

	_ = p.Set(3.14)
	_ = p.Set("42")

	p.Rebind(reflect.ValueOf(&t))
	_ = p.Set(-3.14)
	_ = p.Set("24")

	// Even though the PreparedMapping was created with reflect.Value it will still accept *S directly.
	p.Rebind(&u)
	_ = p.Set("Works!")
	_ = p.Set(uint(100))

	fmt.Println("s", s.Num, s.Str)
	fmt.Println("t", t.Num, t.Str)
	fmt.Println("u", u.Num, u.Str)
}

Output:

s 42 3.14
t 24 -3.14
u 100 Works!

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// Once a PreparedMapping has been created you can swap out the value it mutates
	// by calling Rebind.  This yields better performance in tight loops where
	// you intend to mutate many instances of the same type.

	m := &set.Mapper{}

	type S struct {
		Str string
		Num int
	}

	values := [][]interface{}{
		{"First", 1},
		{"Second", 2},
		{"Third", 3},
	}
	slice := make([]S, 3)

	p, _ := m.Prepare(&slice[0]) // We can prepare on the first value to get a PreparedMapping

	// We must call Plan with our intended field access order.
	_ = p.Plan("Str", "Num")

	for k := range slice {
		p.Rebind(&slice[k]) // The PreparedMapping now affects slice[k]
		for _, value := range values[k] {
			_ = p.Set(value) // error ignored for brevity
		}
	}

	fmt.Println(slice[0].Num, slice[0].Str)
	fmt.Println(slice[1].Num, slice[1].Str)
	fmt.Println(slice[2].Num, slice[2].Str)

}

Output:

1 First
2 Second
3 Third

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// PreparedMapping.Rebind panics if the new instance is not the same type.

	m := &set.Mapper{}

	type S struct {
		Str string
	}
	type Different struct {
		Str string
	}

	defer func() {
		if r := recover(); r != nil {
			fmt.Println(r)
		}
	}()

	var s S
	var d Different

	p, _ := m.Prepare(&s)
	p.Rebind(&d)

}

Output:

mismatching types during Rebind; have *set_test.S and got *set_test.Different

package main

import (
	"fmt"
	"reflect"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// As a convenience PreparedMapping.Rebind can be called with an instance of reflect.Value
	// if-and-only-if the reflect.Value is holding a type compatible with the PreparedMapping.

	m := &set.Mapper{}

	type S struct {
		Str string
		Num int
	}
	var s S

	// Errors ignored for brevity.
	p, _ := m.Prepare(&s)
	_ = p.Plan("Num", "Str")

	_ = p.Set(42)
	_ = p.Set("Hello")

	rv := reflect.New(reflect.TypeOf(s)) // reflect.New creates a *S which is the type
	p.Rebind(rv)                         // originally bound.  Therefore b.Rebind(rv) is valid.
	_ = p.Set(100)
	_ = p.Set("reflect.Value!")
	r := rv.Elem().Interface().(S)

	fmt.Println(s.Str, s.Num)
	fmt.Println(r.Str, r.Num)

}

Output:

Hello 42
reflect.Value! 100

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// Once a Value has been created you can swap out the value it mutates
	// by calling Rebind.  This yields better performance in tight loops where
	// you intend to mutate many instances of the same type.

	values := []string{"3.14", "false", "true", "5"}
	slice := make([]int, 4)

	v := set.V(&slice[0])
	for k, str := range values {
		v.Rebind(&slice[k])
		if err := v.To(str); err != nil {
			fmt.Println(err)
			return
		}
	}
	fmt.Println(slice)

}

Output:

[3 0 1 5]

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// Value.Rebind panics if the new instance is not the same type.

	defer func() {
		if r := recover(); r != nil {
			fmt.Println(r)
		}
	}()

	var a int
	var b string

	v := set.V(&a)
	v.Rebind(&b)

}

Output:

mismatching types during Rebind; have *int and got *string

package main

import (
	"fmt"
	"reflect"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// As a convenience Value.Rebind will accept reflect.Value
	// if-and-only-if the reflect.Value is holding a type compatible
	// with the Value.

	var a, b int

	v, rv := set.V(&a), reflect.ValueOf(&b)

	if err := v.To("42"); err != nil {
		fmt.Println(err)
		return
	}

	v.Rebind(rv)
	if err := v.To("24"); err != nil {
		fmt.Println(err)
		return
	}

	fmt.Printf("a=%v b=%v", a, b)

}

Output:

a=42 b=24

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// As a convenience Value.Rebind will accept another Value
	// as long as the internal types are compatible.

	var a, b int

	av, bv := set.V(&a), set.V(&b)

	if err := av.To("42"); err != nil {
		fmt.Println(err)
		return
	}

	av.Rebind(bv)
	if err := av.To("24"); err != nil {
		fmt.Println(err)
		return
	}

	fmt.Printf("a=%v b=%v", a, b)

}

Output:

a=42 b=24

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// Value wraps around scalars or slices and the To method performs type coercion.
	//
	// When calling set.V(a) `a` must represent an addressable or writable value similarly
	// to invoking deserializers like json.Unmarshal([]byte, a).

	// Fails because not addressable
	var b bool
	err := set.V(b).To("true") // Should have been &b -- address of b
	fmt.Println(err)

	// Succeed because we pass addresses of destinations.
	var s string
	var n int
	var u8 uint8

	err = set.V(&s).To(3.14)
	fmt.Println("s", s, err)

	err = set.V(&n).To("42")
	fmt.Println("n", n, err)

	err = set.V(&u8).To("27")
	fmt.Println("u8", u8, err)

	// When passing the address of a nil ptr it will be created.
	var nptr *int                // nptr == nil
	err = set.V(&nptr).To("100") // nptr != nil now
	fmt.Println("nptr", *nptr, err)

	// If a pointer already points at something you can pass it directly.
	sptr := &s // sptr != nil and points at s
	err = set.V(sptr).To("Something")
	fmt.Println("sptr", *sptr, err, "s", s)

	// new(T) works the same as sptr above.
	f32 := new(float32)
	err = set.V(f32).To("3")
	fmt.Println("f32", *f32, err)

}

Output:

set: Value.To: read only value: bool is not writable: hint=[call to set.V(bool) should have been set.V(*bool)]
s 3.14 <nil>
n 42 <nil>
u8 27 <nil>
nptr 100 <nil>
sptr Something <nil> s Something
f32 3 <nil>

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how scalars are coerced to slices.
	// Given
	// 	↪ var t []T    // A target slice
	// 	↪ var s S      // A scalar value
	// Then
	//	↪ _ = set.V(&t).To(s)
	// Yields
	//	↪ t == []T{ s } // A slice with a single element

	var n []int
	var s []string

	err := set.V(&n).To("9")
	fmt.Println("n", n, err)

	err = set.V(&s).To(1234)
	fmt.Println("s", s, err)

	// When the incoming value can not be type coerced the slice will be an empty slice.
	err = set.V(&n).To("Hello")
	fmt.Println("n", n == nil, err == nil)

}

Output:

n [9] <nil>
s [1234] <nil>
n true false

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how slices are coerced to scalars.
	// Given
	// 	↪ var t T    // A target scalar
	// 	↪ var s []S  // A slice value
	// Then
	//	↪ _ = set.V(&t).To(s)
	// Yields
	//	↪ t == s[ len(s) -1 ]    // t is set to last value in slice

	var n int
	var s string

	err := set.V(&n).To([]interface{}{9, "3.14", false, "next value wins", "9999"})
	fmt.Println("n", n, err)

	err = set.V(&s).To([]interface{}{9, "3.14", false, "next value wins", "I win!"})
	fmt.Println("s", s, err)

	// When the incoming slice can not be type coerced the scalar will be zero value.
	err = set.V(&n).To([]interface{}{9, "3.14", false, "next value wins", "9999", "Fred"})
	fmt.Println("n", n == 0, err == nil)

	// When the incoming slice is nil or empty the scalar will be zero value.
	err = set.V(&s).To([]int(nil)) // Sets s to "" -- empty string!
	fmt.Println("s", s, err)

}

Output:

n 9999 <nil>
s I win! <nil>
n true false
s  <nil>

package main

import (
	"fmt"

	"github.com/nofeaturesonlybugs/set"
)

func main() {
	// This example demonstrates how slices are coerced to slices.
	// Given
	// 	↪ var t []T  // A target slice
	// 	↪ var s []S  // A slice value
	// Then
	//	↪ _ = set.V(&t).To(s)
	// Yields
	//	↪ t == s // t is a slice equal in length to s with elements type coerced to T
	// However
	//	↪ t is a copy of s

	var n []int
	var s []string

	values := []interface{}{9, "3.14", false, "9999"}

	err := set.V(&n).To(values)
	fmt.Println("n", n, err)

	err = set.V(&s).To(values)
	fmt.Println("s", s, err)

	// If any element can not be coerced the target (or dest) will be zero value slice.
	values = append(values, "Hello") // "Hello" can not be coereced to int
	err = set.V(&n).To(values)
	fmt.Println("n", n == nil, err == nil)

	// When dealing with slices the target (or dest) is always a copy.
	m := []int{2, 4, 6, 8}
	err = set.V(&n).To(m) // Even though m and n are same type n will be a copy
	fmt.Println("n", n, err)
	m[1] = -4 // Change element in m
	fmt.Println("m", m, "n", n)

}

Output:

n [9 3 0 9999] <nil>
s [9 3.14 false 9999] <nil>
n true false
n [2 4 6 8] <nil>
m [2 -4 6 8] n [2 4 6 8]