encoding

type Encoder ¶

type Encoder interface {
	// Encode writes a serialized representation of v to w.
	Encode(w io.Writer, v any) error

	// Decode reads from r and decodes into v.
	Decode(r io.Reader, v any) error
}

Encoder encodes values to a writer and decodes values from a reader.

Encoder is intentionally minimal so multiple concrete encodings (JSON/YAML/TOML/protobuf/gob, etc.) can be used interchangeably.

Encode contract ¶

Encode must serialize v to w. Implementations may require that v satisfies additional interfaces or is of a particular shape (for example a protobuf encoder may require v to implement google.golang.org/protobuf/proto.Message).

Decode contract ¶

Decode must read from r and populate v. In most cases v is expected to be a pointer to the target value so the decoder can mutate it (e.g. *MyStruct). Implementations may return an error if v is not a supported type (for example encoding/errors.ErrInvalidType).

Implementations should return any underlying I/O errors and any parse/unmarshal errors produced by their respective codecs.

type Map ¶

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

Map provides lookup and registration of encoders by kind.

This type is a thin convenience around a string-keyed map and is commonly used with configuration to select an encoder at runtime.

Map is not concurrency-safe. If you mutate it via Register, do so during initialization.

func NewMap(params MapParams) *Map

func (f *Map) Get(kind string) Encoder

func (f *Map) Keys() []string

func (f *Map) Register(kind string, enc Encoder)

type MapParams ¶

type MapParams struct {
	di.In

	// JSON is the JSON encoder implementation registered under kind "json".
	JSON *json.Encoder

	// HJSON is the HJSON encoder implementation registered under kind "hjson".
	HJSON *hjson.Encoder

	// YAML is the YAML encoder implementation registered under kinds "yaml" and "yml".
	YAML *yaml.Encoder

	// TOML is the TOML encoder implementation registered under kind "toml".
	TOML *toml.Encoder

	// ProtoBinary is the protobuf binary encoder implementation registered under common binary kinds
	// (e.g. "proto", "protobuf", "pb", etc.).
	ProtoBinary *proto.Binary

	// ProtoText is the protobuf text encoder implementation registered under common text kinds
	// (e.g. "prototext", "prototxt", "pbtxt").
	ProtoText *proto.Text

	// ProtoJSON is the protobuf JSON encoder implementation registered under common JSON kinds
	// (e.g. "protojson", "pbjson").
	ProtoJSON *proto.JSON

	// GOB is the gob encoder implementation registered under kind "gob".
	GOB *gob.Encoder

	// Bytes is the passthrough encoder for io.ReaderFrom/io.WriterTo payloads, registered under kinds
	// like "plain", "octet-stream", and "markdown".
	Bytes *bytes.Encoder
}

MapParams defines the dependencies used to construct an encoding Map.

It is intended for dependency injection (Fx/Dig). The default wiring is provided by `encoding.Module`.