go-superstruct

superstruct.go (3957B)

---

 // Package superstruct uses reflection to merge multiple structs into one.
 //
 // The resulting struct's fields cannot be accessed without reflection.
 //
 // The intended use of this package is to quickly whack together structures for
 // json.Marshal. As json.Marshal uses reflection under the hood, a superstruct
 // can be passed to it like any other struct.
 package superstruct // import "hhvn.uk/go-superstruct"
 
 import (
 	"fmt"
 	"sort"
 	"errors"
 	"strings"
 	"reflect"
 )
 
 var (
 	ErrNotStruct = errors.New("not a structure")
 )
 
 func getStruct(v reflect.Value) (reflect.Value, error) {
 	for (v.Kind() == reflect.Pointer || v.Kind() == reflect.Interface) {
 		v = v.Elem()
 	}
 
 	if v.Kind() == reflect.Struct {
 		return v, nil
 	} else {
 		return v, ErrNotStruct
 	}
 }
 
 func copyWalk(vdst, src reflect.Value) {
 	dst := vdst.Elem()
 
 	switch dst.Kind() {
 	case reflect.Bool:    fallthrough
 	case reflect.Int:     fallthrough
 	case reflect.Int8:    fallthrough
 	case reflect.Int16:   fallthrough
 	case reflect.Int32:   fallthrough
 	case reflect.Int64:   fallthrough
 	case reflect.Uint:    fallthrough
 	case reflect.Uint8:   fallthrough
 	case reflect.Uint16:  fallthrough
 	case reflect.Uint32:  fallthrough
 	case reflect.Uint64:  fallthrough
 	case reflect.Float32: fallthrough
 	case reflect.Float64: fallthrough
 	case reflect.Array:   fallthrough
 	case reflect.Slice:
 		dst.Set(src)
 
 	case reflect.String:
 		dst.SetString(src.String())
 
 	case reflect.Map:
 		keys := src.MapKeys()
 		dst.Set(reflect.MakeMapWithSize(dst.Type(), len(keys)))
 
 		for _, k := range keys {
 			dst.SetMapIndex(k, src.MapIndex(k))
 		}
 
 	case reflect.Struct:
 		for _, f := range reflect.VisibleFields(src.Type()) {
 			switch dst.FieldByName(f.Name).Kind() {
 			case reflect.Pointer: fallthrough
 			case reflect.Interface:
 				d := dst.FieldByName(f.Name)
 				s := src.FieldByName(f.Name)
 				d.Set(s)
 			default:
 				d := dst.FieldByName(f.Name).Addr()
 				s := src.FieldByName(f.Name)
 				copyWalk(d, s)
 			}
 		}
 	}
 }
 
 func do(cp bool, in... interface{}) (interface{}, error) {
 	v := make([]reflect.Value, len(in))
 	for i := range in {
 		var err error
 		v[i], err = getStruct(reflect.ValueOf(in[i]))
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	t := make([]reflect.Type, len(in))
 	for i := range in {
 		t[i] = v[i].Type()
 	}
 
 	f := make([][]reflect.StructField, len(in))
 	for i := range in {
 		f[i] = reflect.VisibleFields(t[i])
 	}
 
 	fm := make(map[string]reflect.StructField)
 
 	for i := range in {
 		for _, v := range f[i] {
 			fm[v.Name] = v
 		}
 	}
 
 	fs := make([]reflect.StructField, len(fm))
 	
 	i := 0
 	for _, v := range fm {
 		fs[i] = v
 		i++
 	}
 	
 	rv := reflect.New(reflect.StructOf(fs))
 
 	if cp {
 		for i := range in {
 			copyWalk(rv, v[i])
 		}
 	}
 
 	return rv.Elem().Interface(), nil
 }
 
 // Create combines multiple structs into a single struct and returns it ready to use.
 func Create(i... interface{}) (interface{}, error) {
 	return do(false, i...)
 }
 
 // CreateAndCopy also combines multiple structs into a single struct,
 // but copies the values in for you. The fields from structs passed later
 // take precedence over those passed earlier.
 func CreateAndCopy(i... interface{}) (interface{}, error) {
 	return do(true, i...)
 }
 
 // SortedStructString produces a string representation of the fields and values
 // of a struct. Each field is printed on its own line. Lines are sorted with
 // sort.Strings()
 //
 // The main use for this function is in creating a deterministic output for the
 // test and example included with this package, though it is exported anyway
 // for convenience.
 func SortedStructString(s interface{}) string {
 	var lines []string
 
 	vs := reflect.ValueOf(s)
 
 	for _, v := range reflect.VisibleFields(vs.Type()) {
 		f := vs.FieldByName(v.Name)
 		if f.Kind() == reflect.Pointer || f.Kind() == reflect.Interface {
 			f = f.Elem()
 		}
 		lines = append(lines, fmt.Sprintf("%v: %+v", v.Name, f.Interface()))
 	}
 
 	sort.Strings(lines)
 
 	return strings.Join(lines, "\n")
 }