maputil

package
v1.9.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 26, 2023 License: MIT Imports: 20 Imported by: 22

Documentation

Overview

Utilities for converting, manipulating, and iterating over maps

Index

Examples

Constants

This section is empty.

Variables

View Source 
var MapXmlRootTagName = `data`
View Source 
var MapXmlStructTagName = `xml`
View Source 
var SkipDescendants = errors.New("skip descendants")
View Source 
var UnmarshalStructTag string = `maputil`

Functions

func Append 

func Append(maps ...map[string]interface{}) map[string]interface{}

func Apply 

func Apply(input interface{}, fn ApplyFunc) map[string]interface{}

Recursively walk the given map, calling the ApplyFunc for each leaf value. If the second return value from the function is true, that value in the struct will be replaced with the first return value. If false, the value will be left as-is.

func ApplyStruct 

func ApplyStruct(input interface{}, fn ApplyFunc) map[string]interface{}

The same as Apply(), but will descend into structs.

func Autotype 

func Autotype(input interface{}) map[string]interface{}

Recursively walk the given map, performing automatic type conversion on all leaf nodes.

func CoalesceMap 

func CoalesceMap(data map[string]interface{}, fieldJoiner string) (map[string]interface{}, error)

Take a deeply-nested map and return a flat (non-nested) map with keys whose intermediate tiers are joined with fieldJoiner

func CoalesceMapTyped 

func CoalesceMapTyped(data map[string]interface{}, fieldJoiner string, typePrefixSeparator string) (map[string]interface{}, []error)

Take a deeply-nested map and return a flat (non-nested) map with keys whose intermediate tiers are joined with fieldJoiner Additionally, values will be converted to strings and keys will be prefixed with the datatype of the value

func Compact 

func Compact(input map[string]interface{}) (map[string]interface{}, error)

Recursively remove all zero and empty values from the given map.

func DeepCopy 

func DeepCopy(input interface{}) map[string]interface{}

Perform a deep copy of the given map.

func DeepCopyStruct 

func DeepCopyStruct(input interface{}) map[string]interface{}

Perform a deep copy of the given map or struct, returning a map.

func DeepGet 

func DeepGet(data interface{}, path []string, fallbacks ...interface{}) interface{}

func DeepGetBool 

func DeepGetBool(data interface{}, path []string) bool

func DeepGetString 

func DeepGetString(data interface{}, path []string) string

func DeepJoin 

func DeepJoin(input interface{}, innerJoiner string, outerJoiner string, nestedSeparator string) string

Join the given map, using innerJoiner to join keys and values, and outerJoiner to join the resulting key-value lines.

func DeepSet 

func DeepSet(data interface{}, path []string, value interface{}) interface{}

func Delete 

func Delete(data interface{}, key interface{}) error

Delete a key to a given value in the given map.

func DiffuseMap 

func DiffuseMap(data map[string]interface{}, fieldJoiner string) (map[string]interface{}, error)

Take a flat (non-nested) map keyed with fields joined on fieldJoiner and return a deeply-nested map

func DiffuseMapTyped 

func DiffuseMapTyped(data map[string]interface{}, fieldJoiner string, typePrefixSeparator string) (map[string]interface{}, []error)

Take a flat (non-nested) map keyed with fields joined on fieldJoiner and return a deeply-nested map

func Fprintf 

func Fprintf(w io.Writer, format string, data ...interface{})

Same as Sprintf, but writes output to the given writer.

func Get 

func Get(data interface{}, key string, fallback ...interface{}) interface{}

func Join 

func Join(input interface{}, innerJoiner string, outerJoiner string) string

Join the given map, using innerJoiner to join keys and values, and outerJoiner to join the resulting key-value lines.

func Keys 

func Keys(input interface{}) []interface{}

Return an interface slice of the keys of the given map.

func MapValues 

func MapValues(input interface{}) []interface{}

Return the values from the given map.

func Merge 

func Merge(first interface{}, second interface{}, options ...MergeOption) (map[string]interface{}, error)

Recursively merge the contents of the second map into the first one and return the result.

func Pluck 

func Pluck(sliceOfMaps interface{}, key []string) []interface{}

func Printf 

func Printf(format string, data ...interface{})

Same as Sprintf, but prints its output to standard output.

Example (DeeplyNestedKeys) 
Printf("Hello ${details.0.value|guest}! Your IP is: ${details.1.value|(unknown)}", map[string]interface{}{
	`details`: []map[string]interface{}{
		{
			`key`:   `username`,
			`value`: `friend`,
		}, {
			`key`:   `ipaddress`,
			`value`: `127.0.0.1`,
		},
	},
})

Output:

Hello friend! Your IP is: 127.0.0.1
Example (SuppliedWithData) 
Printf("Hello ${username|guest}! Your IP is: ${ipaddress|(unknown)}", map[string]interface{}{
	`username`:  `friend`,
	`ipaddress`: `127.0.0.1`,
})

Output:

Hello friend! Your IP is: 127.0.0.1
Example (UsingDefaultValues) 
Printf("Hello ${username|guest}! Your IP is: ${ipaddress|(unknown)}")

Output:

Hello guest! Your IP is: (unknown)

func Set 

func Set(data interface{}, key interface{}, value interface{}) error

Set a key to a given value in the given map, reflect.Map Value, or slice/array.

func Split 

func Split(input string, innerJoiner string, outerJoiner string) map[string]interface{}

Split the given string, first on outerJoiner to form key-value lines, then each line on innerJoiner. Populates a map and returns the result.

func Sprintf 

func Sprintf(format string, data ...interface{}) string

Format the given string in the same manner as fmt.Sprintf, except data items that are maps or Map objects will be expanded using special patterns in the format string. Deeply-nested map values can be referenced using a format string "${path.to.value}". Missing keys will return an empty string, or a fallback value may be provided like so: "${path.to.value|fallback}". The value may also specify a standard fmt.Sprintf pattern with "${path.to.value:%02d}" (or "${path.to.value|fallback:%02d}" for fallback values.) Finally, a special case for time.Time values allows for the format string to be passed to time.Format: "${path.to.time:%January 2, 2006 (3:04pm)}".

func StringKeys 

func StringKeys(input interface{}) []string

Return a slice of strings representing the keys of the given map.

func Stringify 

func Stringify(input map[string]interface{}) map[string]string

Take the input map and convert all values to strings.

func StructFromMap 

func StructFromMap(input map[string]interface{}, populate interface{}) error

Same as TaggedStructFromMapFunc, but no value conversion and uses the "maputil" struct tag.

func TaggedStructFromMap 

func TaggedStructFromMap(input interface{}, populate interface{}, tagname string) error

Same as TaggedStructFromMapFunc, but does not perform any value conversion.

func TaggedStructFromMapFunc 

func TaggedStructFromMapFunc(input interface{}, populate interface{}, tagname string, converter ConversionFunc) error

Take an input map, and populate the struct instance pointed to by "populate". Use the values of the tagname tag to inform which map keys should be used to fill struct fields, and if a Conversion function is given, that function will be used to allow values to be converted in preparation for becoming struct field values.

func Walk 

func Walk(input interface{}, walkFn WalkFunc) error

Recursively walk through the given map, calling walkFn for each intermediate and leaf value.

func WalkStruct 

func WalkStruct(input interface{}, walkFn WalkFunc) error

Recursively walk through the given map, calling walkFn for each intermediate and leaf value. This form behaves identically to Walk(), except that it will also recurse into structs, calling walkFn for all intermediate structs and fields.

Types

type ApplyFunc 

type ApplyFunc func(key []string, value interface{}) (interface{}, bool)

type ConversionFunc 

type ConversionFunc func(from reflect.Type, to reflect.Type, data interface{}) (interface{}, error)

type Item 

type Item struct {
	Key   interface{}
	Value interface{}
	K     string
	V     typeutil.Variant
	// contains filtered or unexported fields
}

func (*Item) Set 

func (self *Item) Set(value interface{}) error

type ItemFunc 

type ItemFunc func(key string, value typeutil.Variant) error

type IterOptions 

type IterOptions struct {
	TagName  string
	SortKeys bool
}

type KeyTransformFunc 

type KeyTransformFunc func(string) string

type Map 

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

A Map object (or "M" object) is a utility struct that makes it straightforward to work with interface data types that contain map-like data (has a reflect.Kind equal to reflect.Map).

func M 

func M(data interface{}) *Map

Create a new Variant map object from the given value (which should be a map of some kind).

func (*Map) Auto 

func (self *Map) Auto(key string, fallbacks ...interface{}) interface{}

Return the value at key as an automatically converted value.

func (*Map) Bool 

func (self *Map) Bool(key string) bool

Return the value at key as a bool.

func (*Map) Bytes 

func (self *Map) Bytes(key string) []byte

Return the value at key as a byte slice.

func (*Map) Duration 

func (self *Map) Duration(key string, fallbacks ...interface{}) time.Duration

Return the value at key interpreted as a Duration.

func (*Map) Each 

func (self *Map) Each(fn ItemFunc, tagName ...string) error

Iterate through each item in the map.

func (*Map) Err 

func (self *Map) Err(key string) error

Return the value at key as an error, or nil if the value is not an error.

func (*Map) Float 

func (self *Map) Float(key string, fallbacks ...interface{}) float64

Return the value at key as a float.

func (*Map) Fprintf 

func (self *Map) Fprintf(w io.Writer, format string)

Uses the extended Fprintf in this package, passing this map as the data used in the given format string.

func (*Map) Get 

func (self *Map) Get(key string, fallbacks ...interface{}) typeutil.Variant

Retrieve a value from the Map by the given dot.separated key, or return a fallback value. Return values are a typeutil.Variant, which can be easily coerced into various types.

func (*Map) Int 

func (self *Map) Int(key string, fallbacks ...interface{}) int64

Return the value at key as an integer.

func (*Map) IsZero 

func (self *Map) IsZero(key string) bool

Return whether the value at the given key is that type's zero value.

func (*Map) Iter 

func (self *Map) Iter(opts ...IterOptions) <-chan Item

func (*Map) Keys 

func (self *Map) Keys(tagName ...string) []interface{}

Return the keys in this Map object. You may specify the name of a struct tag on the underlying object to use for generating key names.

func (*Map) Len 

func (self *Map) Len() int

Return the length of the Map.

func (*Map) Map 

func (self *Map) Map(key string, tagName ...string) map[typeutil.Variant]typeutil.Variant

Return the value at key as a Map. If the resulting value is nil or not a map type, a null Map will be returned. All values retrieved from a null Map will return that type's zero value.

func (*Map) MapNative 

func (self *Map) MapNative(tagName ...string) map[string]interface{}

Return the value as a map[string]interface{} {

func (*Map) MarshalJSON 

func (self *Map) MarshalJSON() ([]byte, error)

func (*Map) MarshalXML 

func (self *Map) MarshalXML(e *xml.Encoder, start xml.StartElement) error

Marshals the current data into XML. Nested maps are output as nested elements. Map values that are scalars (strings, numbers, bools, dates/times) will appear as attributes on the parent element.

func (*Map) Set 

func (self *Map) Set(key string, value interface{}) typeutil.Variant

Set a value in the Map at the given dot.separated key to a value.

func (*Map) SetIfZero 

func (self *Map) SetIfZero(key string, value interface{}) (typeutil.Variant, bool)

Set a value in the Map at the given dot.separated key to a value, but only if the current value at that key is that type's zero value.

func (*Map) SetMarshalXmlGeneric 

func (self *Map) SetMarshalXmlGeneric(yes bool)

func (*Map) SetMarshalXmlKeyFunc 

func (self *Map) SetMarshalXmlKeyFunc(fn KeyTransformFunc)

Set a function that will be used to generate XML tag names when calling MarshalXML. This works for all keys, including ones that appear inside of maps.

func (*Map) SetRootTagName 

func (self *Map) SetRootTagName(root string)

set the name of the root XML tag, used by MarshalXML.

func (*Map) SetValueIfNonZero 

func (self *Map) SetValueIfNonZero(key string, value interface{}) (typeutil.Variant, bool)

Set a value in the Map at the given dot.separated key to a value, but only if the new value is not a zero value.

func (*Map) Slice 

func (self *Map) Slice(key string) []typeutil.Variant

Return the value at key as a slice. Scalar values will be returned as a slice containing only that value.

func (*Map) Sprintf 

func (self *Map) Sprintf(format string) string

Uses the extended Sprintf in this package, passing this map as the data used in the given format string.

func (*Map) String 

func (self *Map) String(key string, fallbacks ...interface{}) string

Return the value at key as a string.

func (*Map) StringKeys 

func (self *Map) StringKeys(tagName ...string) []string

A string slice version of Keys()

func (*Map) Strings 

func (self *Map) Strings(key string) []string

Same as Slice(), but returns a []string

func (*Map) Tag 

func (self *Map) Tag(key string) *Map

Specify which struct tag to honor for generating field names when then underlying data is a struct.

func (*Map) Time 

func (self *Map) Time(key string, fallbacks ...interface{}) time.Time

Return the value at key interpreted as a Time.

func (*Map) UnmarshalJSON 

func (self *Map) UnmarshalJSON(data []byte) error

func (*Map) Value 

func (self *Map) Value() interface{}

Return the underlying value the M-object was created with.

func (*Map) Walk 

func (self *Map) Walk(fn WalkFunc) error

A recursive walk form of Each()

type MergeOption 

type MergeOption int
const (
	AppendValues MergeOption = iota
)

type MergeOptions 

type MergeOptions []MergeOption

func (MergeOptions) Has 

func (self MergeOptions) Has(option MergeOption) bool

type WalkFunc 

type WalkFunc func(value interface{}, path []string, isLeaf bool) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.