mergo

Documentation

Overview

Package mergo merges same-type structs and maps by setting default values in zero-value fields.

Mergo won't merge unexported (private) fields but will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

Usage

From my own work-in-progress project:

type networkConfig struct {
	Protocol string
	Address string
	ServerType string `json: "server_type"`
	Port uint16
}

type FssnConfig struct {
	Network networkConfig
}

var fssnDefault = FssnConfig {
	networkConfig {
		"tcp",
		"127.0.0.1",
		"http",
		31560,
	},
}

// Inside a function [...]

if err := mergo.Merge(&config, fssnDefault); err != nil {
	log.Fatal(err)
}

// More code [...]

Index

• Variables
• func Map(dst, src interface{}, opts ...func(*Config)) error
• func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error
• func Merge(dst, src interface{}, opts ...func(*Config)) error
• func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error
• func WithAppendSlice(config *Config)
• func WithOverride(config *Config)
• func WithTransformers(transformers Transformers) func(*Config)
• type Config
• type Transformers

Variables

var (
	ErrNilArguments                = errors.New("src and dst must not be nil")
	ErrDifferentArgumentsTypes     = errors.New("src and dst must be of same type")
	ErrNotSupported                = errors.New("only structs and maps are supported")
	ErrExpectedMapAsDestination    = errors.New("dst was expected to be a map")
	ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")
)

Errors reported by Mergo when it finds invalid arguments.

Functions

func Map

func Map(dst, src interface{}, opts ...func(*Config)) error

Map sets fields' values in dst from src. src can be a map with string keys or a struct. dst must be the opposite: if src is a map, dst must be a valid pointer to struct. If src is a struct, dst must be map[string]interface{}. It won't merge unexported (private) fields and will do recursively any exported field. If dst is a map, keys will be src fields' names in lower camel case. Missing key in src that doesn't match a field in dst will be skipped. This doesn't apply if dst is a map. This is separated method from Merge because it is cleaner and it keeps sane semantics: merging equal types, mapping different (restricted) types.

func MapWithOverwrite

func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error

MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by non-empty src attribute values. Deprecated: Use Map(…) with WithOverride

func Merge

func Merge(dst, src interface{}, opts ...func(*Config)) error

Merge will fill any empty for value type attributes on the dst struct using corresponding src attributes if they themselves are not empty. dst and src must be valid same-type structs and dst must be a pointer to struct. It won't merge unexported (private) fields and will do recursively any exported field.

func MergeWithOverwrite

func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error

MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overriden by non-empty src attribute values. Deprecated: use Merge(…) with WithOverride

func WithAppendSlice

func WithAppendSlice(config *Config)

WithAppendSlice will make merge append slices instead of overwriting it

func WithOverride

func WithOverride(config *Config)

WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.

func WithTransformers

func WithTransformers(transformers Transformers) func(*Config)

WithTransformers adds transformers to merge, allowing to customize the merging of some types.

Types

type Config

type Config struct {
	Overwrite    bool
	AppendSlice  bool
	Transformers Transformers
}

type Transformers

type Transformers interface {
	Transformer(reflect.Type) func(dst, src reflect.Value) error
}