maps

func Conflicts ¶

func Conflicts(v1, v2 interface{}) bool

Conflicts returns true if trees share common key paths, but the values at those paths are not equal. i.e. if the two maps were merged, no values would be overwritten conflicts == !contains(v1, v2) && !excludes(v1, v2) conflicts == !contains(merge(v1, v2), v1)

func Contains ¶

func Contains(v1, v2 interface{}, options ...ContainsOption) bool

Contains tests whether v1 "contains" v2. The notion of containment is based on postgres' JSONB containment operators.

A map v1 "contains" another map v2 if v1 has contains all the keys in v2, and if the values in v2 are contained by the corresponding values in v1.

{"color":"red"} contains {}
{"color":"red"} contains {"color":"red"}
{"color":"red","flavor":"beef"} contains {"color":"red"}
{"labels":{"color":"red","flavor":"beef"}} contains {"labels":{"flavor":"beef"}}
{"tags":["red","green","blue"]} contains {"tags":["red","green"]}

A scalar value v1 contains value v2 if they are equal.

5 contains 5
"red" contains "red"

A slice v1 contains a slice v2 if all the values in v2 are contained by at least one value in v1:

["red","green"] contains ["red"]
["red"] contains ["red","red","red"]
// In this case, the single value in v1 contains each of the values
// in v2, so v1 contains v2
[{"type":"car","color":"red","wheels":4}] contains [{"type":"car"},{"color","red"},{"wheels":4}]

A slice v1 also can contain a *scalar* value v2:

["red"] contains "red"

A struct v1 contains a struct v2 if they are deeply equal (using reflect.DeepEquals)

func Empty ¶

func Empty(v interface{}) bool

Empty returns true if v is nil, empty, or a zero value.

If v is a pointer, it is empty if the pointer is nil or invalid, but not empty if it points to a value, even if that value is zero. For example:

Empty(0)  // true
i := 0
Empty(&i) // false
Empty(Widget{}) // true, zero value
Empty(&Widget{}) // false, non-nil pointer

Maps, slices, arrays, and channels are considered empty if their length is zero.

Strings are empty if they contain nothing but whitespace.

func Equivalent ¶ added in v4.1.0

func Equivalent(v1, v2 interface{}, options ...ContainsOption) bool

Equivalent checks if v1 and v2 are approximately deeply equal to each other. It takes the same comparison options as Contains. It is equivalent to:

Equivalent(v1, v2) == Contains(v1, v2) && Contains(v2, v1)

ContainsOptions which only work in one direction, like StringContains, will always treat v2 as a pattern or rule to match v1 against. For example:

b := Equivalent("thefox", "fox", StringContains())

b is true because "thefox" contains "fox", even though the inverse is not true

func Get ¶

func Get(v interface{}, path string, opts ...NormalizeOption) (interface{}, error)

Get extracts the value at path from v. Path is in the form:

response.things[2].color.red

You can use `merry` to test the types of return errors:

_, err := maps.Get("","")
if merry.Is(err, maps.PathNotFoundError) {
  ...

Returns PathNotFoundError if the next key in the path is not found.

Returns PathNotMapError if evaluating a key against a value which is not a map (e.g. a slice or a primitive value, against which we can't evaluate a key name).

Returns IndexOutOfBoundsError if evaluating a slice index against a slice value, and the index is out of bounds.

Returns PathNotSliceError if evaluating a slice index against a value which isn't a slice.

func Keys ¶

func Keys(m map[string]interface{}) (keys []string)

Keys returns a slice of the keys in the map

func Merge ¶

func Merge(v1, v2 interface{}, opts ...NormalizeOption) interface{}

Merge returns a new map, which is the deep merge of the normalized values of v1 and v2.

Values in v2 override values in v1.

Slices are merged simply by adding any v2 values which aren't already in v1's slice. This won't do anything fancy with slices that have duplicate values. Order is ignored. E.g.:

[5, 6, 7] + [5, 5, 5, 4] = [5, 6, 7, 4]

The return value is a copy. v1 and v2 are not modified.

func Normalize ¶

func Normalize(v1 interface{}, opts ...NormalizeOption) (interface{}, error)

Normalize recursively converts v1 into a tree of maps, slices, and primitives. The types in the result will be the types the json package uses for unmarshalling into interface{}. The rules are:

1. All maps with string keys will be converted into map[string]interface{} 2. All slices will be converted to []interface{} 3. All primitive numeric types will be converted into float64 4. string, bool, and nil are unmodified 5. All other values will be converted into the above types by doing a json.Marshal and Unmarshal

Values in v1 will be modified in place if possible

func NormalizeWithOptions ¶

func NormalizeWithOptions(v interface{}, opt NormalizeOptions) (interface{}, error)

NormalizeWithOptions does the same as Normalize, but with options.

func Transform ¶

func Transform(v interface{}, transformer func(in interface{}) (interface{}, error), opts ...NormalizeOption) (interface{}, error)

Transform applies a transformation function to each value in tree. Values are normalized before being passed to the transformer function. Any maps and slices are passed to the transform function as the whole value first, then each child value of the map/slice is passed to the transform function.

The value returned by the transformer will replace the original value.

If the transform function returns a non-primitive value, it will recurse into the new value.

If the transformer function returns the error ErrStop, the process will abort with no error.