kind

Documentation

Index

• Variables
• func Call(value reflect.Value, method string, v ...reflect.Value) []reflect.Value
• func Pointer(value reflect.Value) reflect.Value
• type Data
• type Decoder
• type Encoder
• type Handler
  • func NewHandler(encode func(Encoder, reflect.Value) error, ...) Handler
• type Map
  • func (m *Map) Alias(kind int, t reflect.Type)
  • func (m *Map) Load(v interface{}) (int, reflect.Type)
  • func (m *Map) Run(v, i interface{}, value reflect.Value) (bool, error)
  • func (m *Map) Store(kind int, t reflect.Type, handler Handler)

Variables

var Bin = NewHandler(
	func(encoder Encoder, value reflect.Value) error {
		ptr := reflect.New(realType(value.Type()))
		ptr.Elem().Set(value)

		return encoder.Encode(ptr)
	},
	func(decoder Decoder, value reflect.Value) error {
		ptr := reflect.New(realType(value.Type()))

		if err := decoder.Decode(ptr.Elem()); err != nil {
			return err
		}

		value.Set(ptr.Elem())
		return nil
	},
)

var EncodingBinary = NewHandler(
	func(encoder Encoder, value reflect.Value) error {
		out := Call(value, "MarshalBinary")
		if !out[1].IsNil() {
			return out[1].Interface().(error)
		}

		return encoder.Encode(out[0].Interface().([]byte))
	},
	func(decoder Decoder, value reflect.Value) error {
		var data []byte

		if err := decoder.Decode(&data); err != nil {
			return err
		}

		if len(data) == 0 {
			return nil
		}

		out := Call(value, "UnmarshalBinary", reflect.ValueOf(data))
		if !out[0].IsNil() {
			return out[0].Interface().(error)
		}

		return nil
	},
)

var EncodingText = NewHandler(
	func(encoder Encoder, value reflect.Value) error {
		out := Call(value, "MarshalText")
		if !out[1].IsNil() {
			return out[1].Interface().(error)
		}

		if err := encoder.Encode(out[0].Len()); err != nil {
			return err
		}

		return encoder.Encode(out[0].Interface().([]byte))
	},
	func(decoder Decoder, value reflect.Value) error {
		var data []byte

		if err := decoder.Decode(&data); err != nil {
			return err
		}

		out := Call(value, "UnmarshalText", reflect.ValueOf(data))
		if !out[0].IsNil() {
			return out[0].Interface().(error)
		}

		return nil
	},
)

var Gob = NewHandler(
	func(encoder Encoder, value reflect.Value) error {
		i := Call(value, "GobEncode")
		if !i[1].IsNil() {
			return i[1].Interface().(error)
		}

		return encoder.Encode(i[0].Interface().([]byte))
	},
	func(decoder Decoder, value reflect.Value) error {
		var data []byte

		if err := decoder.Decode(&data); err != nil {
			return err
		}

		if i := Call(value, "GobDecode", reflect.ValueOf(data)); !i[0].IsNil() {
			return i[0].Interface().(error)
		}

		return nil
	},
)

Functions

func Call

func Call(value reflect.Value, method string, v ...reflect.Value) []reflect.Value

Call tries to call normal value and then pointer.

func Pointer

func Pointer(value reflect.Value) reflect.Value

Pointer transforms value T into *T with reflection.

Types

type Data

type Data struct {
	Kind    int
	Type    reflect.Type
	Handler Handler
}

type Decoder

type Decoder interface {
	Decode(interface{}) error
}

type Encoder

type Encoder interface {
	Encode(interface{}) error
}

type Handler

type Handler interface {
	Encode(Encoder, reflect.Value) error
	Decode(Decoder, reflect.Value) error
}

func NewHandler

func NewHandler(encode func(Encoder, reflect.Value) error, decode func(Decoder, reflect.Value) error) Handler

type Map

type Map struct {
	// contains filtered or unexported fields
}

func (*Map) Alias

func (m *Map) Alias(kind int, t reflect.Type)

func (*Map) Load

func (m *Map) Load(v interface{}) (int, reflect.Type)

func (*Map) Run

func (m *Map) Run(v, i interface{}, value reflect.Value) (bool, error)

func (*Map) Store

func (m *Map) Store(kind int, t reflect.Type, handler Handler)