go-emarshal

emarshal.go (4161B)

---

 // Package emarshal makes (un)marshalling embedded types easy.
 //
 // The embedded types should each specify a marshalling and unmarshalling
 // method. The are then accessed by the Marshal and Unmarshal functions in this
 // package.
 //
 // The intended use case (as seen in the example) is for these functions to be
 // run by the MarshalJSON/UnmarshalJSON (or equivalent for other encodings)
 // methods on the parent type.
 package emarshal // import "hhvn.uk/go-emarshal"
 
 import (
 	"fmt"
 	"errors"
 	"reflect"
 
 	"hhvn.uk/go-superstruct"
 )
 
 var (
 	ErrNotPointer = errors.New("value is not pointer")
 	ErrBadMarshal = errors.New("bad marshaller")
 	ErrBadUnmarshal = errors.New("bad unmarshaller")
 )
 
 // MarshalFunc is a function that can be passed to Marshal().
 type MarshalFunc func(any) ([]byte, error)
 
 // EMarshalMethod documents the signature of an EMarshal... method
 type EMarshalMethod func() (any, error)
 
 // Marshal returns an encoded form of in.
 //
 // The encoded form is made by running all methods with the prefix "EMarshal"
 // of in, and then combining these values into a single struct and encoding it
 // with fn.
 //
 // The signature of a such a method is documented by EMarshalMethod.
 func Marshal(in any, fn MarshalFunc) ([]byte, error) {
 	t  := reflect.TypeOf(in)
 	tn := t.Name()
 	
 	mm := getMethods(t, "EMarshal")
 
 	rs := make([]any, len(mm))
 
 	for i, m := range mm {
 		mn := m.Name
 		man, _, mrn, mrt := methodInfo(m)
 
 		switch {
 		case man != 0:
 			return nil, methodErr(tn, mn, ErrBadMarshal,
 				fmt.Sprintf("expected 0 arguments, not %d", man))
 		case mrn != 2:
 			return nil, methodErr(tn, mn, ErrBadMarshal,
 				fmt.Sprintf("expected 2 return values, not %d", mrn))
 		case mrt[0].Kind() != reflect.Interface:
 			return nil, methodErr(tn, mn, ErrBadMarshal,
 				"2nd return value is not an interface")
 		case !isErr(mrt[1]):
 			return nil, methodErr(tn, mn, ErrBadMarshal,
 				"2nd return value is not an error")
 		}
 
 		r := m.Func.Call([]reflect.Value{reflect.ValueOf(in)})
 		
 		err, ok := r[1].Interface().(error)
 		if ok { // ok is only true when err is not nil
 			return nil, err
 		}
 
 		rs[i] = r[0].Interface()
 	}
 
 	s, err := superstruct.CreateAndCopy(rs...)
 	if err != nil {
 		return nil, err
 	}
 
 	return fn(s)
 }
 
 // UnmarshalFunc is a function that can be passed to Unmarshal().
 type UnmarshalFunc func([]byte, any) error
 
 // Unpack is the function that is passed to an EUnmarshalMethod.
 type Unpack func(any) error
 
 // EUnmarshalMethod documents the signature of an EUnmarshal... method
 type EUnmarshalMethod func(Unpack) error
 
 // Unmarshal decodes a byte slice into the value pointed to by in.
 //
 // It does this by running all the methods with the prefix "EUnmarshal" of in.
 // The methods are passed an anonymous function that will unpack the data into
 // a chosen variable using fn.
 //
 // The signature of a such a method is documented by EUnmarshalMethod.
 func Unmarshal(in any, b []byte, fn UnmarshalFunc) error {
 	t  := reflect.TypeOf(in)
 
 	if t.Kind() != reflect.Interface && t.Kind() != reflect.Pointer {
 		return fmt.Errorf("unmarshal: 1st %w", ErrNotPointer)
 	}
 
 	tn := t.Elem().Name()
 
 	mm := getMethods(t, "EUnmarshal")
 
 	unpacker := func(a any) error {
 		return fn(b, a)
 	}
 
 	for _, m := range mm {
 		mn := m.Name
 		man, mat, mrn, mrt := methodInfo(m)
 
 		switch {
 		case man != 1:
 			return methodErr(tn, mn, ErrBadUnmarshal,
 				fmt.Sprintf("expected 1 argument, not %d", man))
 		case mat[0].Kind() != reflect.Func:
 			return methodErr(tn, mn, ErrBadUnmarshal,
 				"argument is not a function")
 		case mrn != 1:
 			return methodErr(tn, mn, ErrBadUnmarshal,
 				fmt.Sprintf("expected 1 return not %d", mrn))
 		case !isErr(mrt[0]):
 			return methodErr(tn, mn, ErrBadUnmarshal,
 				"return value is not an error")
 		}
 
 		fan, fat, frn, frt := funcInfo(mat[0])
 
 		if fan != 1 || frn != 1 || fat[0].Kind() != reflect.Interface || !isErr(frt[0]) {
 			return methodErr(tn, mn, ErrBadMarshal,
 				"first argument is not an Unpack function")
 		}
 
 		r := m.Func.Call([]reflect.Value{
 			reflect.ValueOf(in),
 			reflect.ValueOf(unpacker),
 		})
 
 		err, ok := r[0].Interface().(error)
 		if ok {
 			return err
 		}
 	}
 
 	return nil
 }