encoding

Documentation

Overview

Package encoding provides generic abstractions for decoding common formats

Example

type Person struct {
	FirstName string `json:"firstName"`
	LastName  string `json:"lastName"`
	Age       int    `json:"age"`
}

decoder := NewJSONWriterDecoder[Person]("Person", func(p *Person) error {
	if p.FirstName == "" {
		return ErrFailedCheck
	}
	return nil
})

samplePerson := &Person{FirstName: "Tony", LastName: "Stark", Age: 53}

buf := new(bytes.Buffer)
_ = json.NewEncoder(buf).Encode(samplePerson)

_, _ = decoder.ReadFrom(buf)
p, err := decoder.Decode()
if err != nil {
	panic(err)
}
decodedPerson, ok := p.(*Person)
if !ok {
	panic("invalid type")
}

fmt.Printf("%s %s %d", decodedPerson.FirstName, decodedPerson.LastName, decodedPerson.Age)

Output:

Tony Stark 53

Index

• Constants
• Variables
• type AsyncDecoder
  • func NewAsyncDecoder(decs ...WriterDecoder) *AsyncDecoder
  • func (d *AsyncDecoder) Decode() (any, error)
  • func (d *AsyncDecoder) DecodeFrom(r io.Reader) (any, error)
  • func (d *AsyncDecoder) FileType() string
  • func (d *AsyncDecoder) WithDecoders(decs ...WriterDecoder) *AsyncDecoder
• type JSONWriterDecoder
  • func NewJSONWriterDecoder[T any](fileType string, check func(*T) error) *JSONWriterDecoder[T]
  • func (d *JSONWriterDecoder[T]) Decode() (any, error)
  • func (d *JSONWriterDecoder[T]) DecodeFrom(r io.Reader) (any, error)
  • func (d *JSONWriterDecoder[T]) FileType() string
• type WriterDecoder
• type YAMLWriterDecoder
  • func NewYAMLWriterDecoder[T any](fileType string, check func(*T) error) *YAMLWriterDecoder[T]
  • func (d *YAMLWriterDecoder[T]) Decode() (any, error)
  • func (d *YAMLWriterDecoder[T]) DecodeFrom(r io.Reader) (any, error)
  • func (d *YAMLWriterDecoder[T]) FileType() string

Examples

• Package

Constants

const GenericFileType string = "Generic"

GenericFileType files that cannot be decoded by any provided decoders

Variables

var ErrEncoding = errors.New("encoding error")

ErrEncoding any errors decoding/encoding

var ErrFailedCheck = errors.New("object field check failed")

ErrFailedCheck use for simple validation to differentiate field values for formatting

var ErrIO = errors.New("input/output error")

ErrIO any errors from reading/writing

Types

type AsyncDecoder

type AsyncDecoder struct {
	bytes.Buffer
	// contains filtered or unexported fields
}

AsyncDecoder generic implementation

func NewAsyncDecoder

func NewAsyncDecoder(decs ...WriterDecoder) *AsyncDecoder

NewAsyncDecoder provide decoders to run

func (*AsyncDecoder) Decode

func (d *AsyncDecoder) Decode() (any, error)

Decode attempt to decode across all decoders, first to succeed without error wins

func (*AsyncDecoder) DecodeFrom

func (d *AsyncDecoder) DecodeFrom(r io.Reader) (any, error)

DecodeFrom see Decode

func (*AsyncDecoder) FileType

func (d *AsyncDecoder) FileType() string

FileType MUST be run after Decode to get the filetype, otherwise it will return '?'

func (*AsyncDecoder) WithDecoders

func (d *AsyncDecoder) WithDecoders(decs ...WriterDecoder) *AsyncDecoder

WithDecoders set decoders, will overwrite any provided in NewAsyncDecoder

type JSONWriterDecoder

type JSONWriterDecoder[T any] struct {
	bytes.Buffer
	// contains filtered or unexported fields
}

JSONWriterDecoder decodes JSON and runs a provided check function

func NewJSONWriterDecoder

func NewJSONWriterDecoder[T any](fileType string, check func(*T) error) *JSONWriterDecoder[T]

NewJSONWriterDecoder generic implementation, use to create a specific implementation

func (*JSONWriterDecoder[T]) Decode

func (d *JSONWriterDecoder[T]) Decode() (any, error)

Decode run the decoding and check function

func (*JSONWriterDecoder[T]) DecodeFrom

func (d *JSONWriterDecoder[T]) DecodeFrom(r io.Reader) (any, error)

DecodeFrom see Decode

func (*JSONWriterDecoder[T]) FileType

func (d *JSONWriterDecoder[T]) FileType() string

FileType plain text file type

type WriterDecoder

type WriterDecoder interface {
	io.Writer
	Decode() (any, error)
	DecodeFrom(r io.Reader) (any, error)
	FileType() string
}

WriterDecoder can be implemented for custom decoders

type YAMLWriterDecoder

type YAMLWriterDecoder[T any] struct {
	bytes.Buffer
	// contains filtered or unexported fields
}

YAMLWriterDecoder see JSONWriterDecoder, this implementation is the same but for YAML

func NewYAMLWriterDecoder

func NewYAMLWriterDecoder[T any](fileType string, check func(*T) error) *YAMLWriterDecoder[T]

NewYAMLWriterDecoder use to create a yaml decoder

func (*YAMLWriterDecoder[T]) Decode

func (d *YAMLWriterDecoder[T]) Decode() (any, error)

Decode run the decoding and check function

func (*YAMLWriterDecoder[T]) DecodeFrom

func (d *YAMLWriterDecoder[T]) DecodeFrom(r io.Reader) (any, error)

DecodeFrom see Decode

func (*YAMLWriterDecoder[T]) FileType

func (d *YAMLWriterDecoder[T]) FileType() string

FileType plain text provided file type after decoding