package tcontainer

Import Path
	github.com/trivago/tgo/tcontainer (on go.dev)

Dependency Relation
	imports 10 packages, and imported by 3 packages

Involved Source Files

	      arrays.go
	      bytepool.go
	      marshalmap.go
	      trie.go
Package-Level Type Names (total 7, in which 6 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type BytePool (struct)
		BytePool is a fragmentation friendly way to allocated byte slices.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			hugeSlab byteSlab
			largeSlab byteSlab
			mediumSlab byteSlab
			smallSlab byteSlab
			tinySlab byteSlab
		Methods (only one, which is exported)
			(*T) Get(size int) []byte
				Get returns a slice allocated to a normalized size.
				Sizes are organized in evenly sized buckets so that fragmentation is kept low.

		As Outputs Of (at least 2, both are exported)
			func NewBytePool() BytePool
			func NewBytePoolWithSize(n int) BytePool

	 type Float32Slice ([]T)
		Float32Slice is a typedef to allow sortable float32 slices

		Methods (total 6, all are exported)
			( T) IsSorted() bool
				IsSorted is a shortcut for sort.IsSorted(s)

			( T) Len() int
			( T) Less(i, j int) bool
			( T) Set(v float32)
				Set sets all values in this slice to the given value

			( T) Sort()
				Sort is a shortcut for sort.Sort(s)

			( T) Swap(i, j int)
		Implements (at least one exported)
			 T : sort.Interface

	 type Int64Slice ([]T)
		Int64Slice is a typedef to allow sortable int64 slices

		Methods (total 6, all are exported)
			( T) IsSorted() bool
				IsSorted is a shortcut for sort.IsSorted(s)

			( T) Len() int
			( T) Less(i, j int) bool
			( T) Set(v int64)
				Set sets all values in this slice to the given value

			( T) Sort()
				Sort is a shortcut for sort.Sort(s)

			( T) Swap(i, j int)
		Implements (at least one exported)
			 T : sort.Interface

	 type MarshalMap (map)
		MarshalMap is a wrapper type to attach converter methods to maps normally
		returned by marshalling methods, i.e. key/value parsers.
		All methods that do a conversion will return an error if the value stored
		behind key is not of the expected type or if the key is not existing in the
		map.

		Methods (total 24, in which 22 are exported)
			( T) Array(key string) ([]interface{}, error)
				Array returns a value at key that is expected to be a []interface{}

			( T) Bool(key string) (bool, error)
				Bool returns a value at key that is expected to be a boolean

			( T) Bytes(key string) ([]byte, error)
				Bytes returns a value at key that is expected to be a []byte

			( T) Clone() MarshalMap
				Clone creates a copy of the given MarshalMap.

			( T) Delete(key string)
				Delete a value from a given path.
				The path must point to a map key. Deleting from arrays is not supported.

			( T) Duration(key string) (time.Duration, error)
				Duration returns a value at key that is expected to be a string

			( T) Float(key string) (float64, error)
				Float returns a value at key that is expected to be a float64 or compatible
				float value.

			( T) Int(key string) (int64, error)
				Int returns a value at key that is expected to be an int64 or compatible
				integer value.

			( T) Int64Array(key string) ([]int64, error)
				Int64Array returns a value at key that is expected to be a []int64
				This function supports conversion (by copy) from
				 * []interface{}

			( T) Int64Slice(key string) ([]int64, error)
				Int64Slice is an alias for Int64Array

			( T) Map(key string) (map[interface{}]interface{}, error)
				Map returns a value at key that is expected to be a
				map[interface{}]interface{}.

			( T) MarshalMap(key string) (MarshalMap, error)
				MarshalMap returns a value at key that is expected to be another MarshalMap
				This function supports conversion (by copy) from
				 * map[interface{}]interface{}

			( T) Set(key string, val interface{})
				Set a value for a given path.
				The path must point to a map key. Setting array elements is not supported.

			( T) Slice(key string) ([]interface{}, error)
				Slice is an alias for Array

			( T) String(key string) (string, error)
				String returns a value at key that is expected to be a string

			( T) StringArray(key string) ([]string, error)
				StringArray returns a value at key that is expected to be a []string
				This function supports conversion (by copy) from
				 * []interface{}

			( T) StringArrayMap(key string) (map[string][]string, error)
				StringArrayMap returns a value at key that is expected to be a
				map[string][]string. This function supports conversion (by copy) from
				 * map[interface{}][]interface{}
				 * map[interface{}]interface{}
				 * map[string]interface{}

			( T) StringMap(key string) (map[string]string, error)
				StringMap returns a value at key that is expected to be a map[string]string.
				This function supports conversion (by copy) from
				 * map[interface{}]interface{}
				 * map[string]interface{}

			( T) StringSlice(key string) ([]string, error)
				StringSlice is an alias for StringArray

			( T) StringSliceMap(key string) (map[string][]string, error)
				StringSliceMap is an alias for StringArrayMap

			( T) Uint(key string) (uint64, error)
				Uint returns a value at key that is expected to be an uint64 or compatible
				integer value.

			( T) Value(key string) (val interface{}, exists bool)
				Value returns a value from a given value path.
				Fields can be accessed by their name. Nested fields can be accessed by using
				"/" as a separator. Arrays can be addressed using the standard array
				notation "[<index>]".
				Examples:
				"key"         -> mmap["key"]              single value
				"key1/key2"   -> mmap["key1"]["key2"]     nested map
				"key1[0]"     -> mmap["key1"][0]          nested array
				"key1[0]key2" -> mmap["key1"][0]["key2"]  nested array, nested map

			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) resolvePath(k string, v interface{}, action func(p, k reflect.Value, v interface{})) bool
			( T) resolvePathKey(key string) (int, int)
		As Outputs Of (at least 4, all are exported)
			func ConvertToMarshalMap(value interface{}, formatKey func(string) string) (MarshalMap, error)
			func NewMarshalMap() MarshalMap
			func MarshalMap.Clone() MarshalMap
			func MarshalMap.MarshalMap(key string) (MarshalMap, error)

	 type TrieNode (struct)
		TrieNode represents a single node inside a trie.
		Each node can contain a payload which can be retrieved after a successfull
		match. In addition to that PathLen will contain the length of the match.

		Fields (total 5, in which 2 are exported)
			PathLen int
			Payload interface{}
			/* 3 unexporteds ... *//* 3 unexporteds: */
			children []*TrieNode
			longestPath int
			suffix []byte
		Methods (total 7, in which 4 are exported)
			(*T) Add(data []byte, payload interface{}) *TrieNode
				Add adds a new data path to the trie.
				The TrieNode returned is the (new) root node so you should always reassign
				the root with the return value of Add.

			(*T) ForEach(callback func(*TrieNode))
				ForEach applies a function to each node in the tree including and below the
				passed node.

			(*T) Match(data []byte) *TrieNode
				Match compares the trie to the given data stream.
				Match returns true if data can be completely matched to the trie.

			(*T) MatchStart(data []byte) *TrieNode
				MatchStart compares the trie to the beginning of the given data stream.
				MatchStart returns true if the beginning of data can be matched to the trie.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) addNewChild(data []byte, payload interface{}, pathLen int)
			(*T) addPath(data []byte, payload interface{}, pathLen int, parent *TrieNode) *TrieNode
			(*T) replace(oldChild *TrieNode, newChild *TrieNode)
		As Outputs Of (at least 5, in which 4 are exported)
			func NewTrie(data []byte, payload interface{}) *TrieNode
			func (*TrieNode).Add(data []byte, payload interface{}) *TrieNode
			func (*TrieNode).Match(data []byte) *TrieNode
			func (*TrieNode).MatchStart(data []byte) *TrieNode
			/* at least one unexported ... *//* at least one unexported: */
			func (*TrieNode).addPath(data []byte, payload interface{}, pathLen int, parent *TrieNode) *TrieNode
		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func (*TrieNode).addPath(data []byte, payload interface{}, pathLen int, parent *TrieNode) *TrieNode
			func (*TrieNode).replace(oldChild *TrieNode, newChild *TrieNode)
			func (*TrieNode).replace(oldChild *TrieNode, newChild *TrieNode)

	 type Uint64Slice ([]T)
		Uint64Slice is a typedef to allow sortable uint64 slices

		Methods (total 6, all are exported)
			( T) IsSorted() bool
				IsSorted is a shortcut for sort.IsSorted(s)

			( T) Len() int
			( T) Less(i, j int) bool
			( T) Set(v uint64)
				Set sets all values in this slice to the given value

			( T) Sort()
				Sort is a shortcut for sort.Sort(s)

			( T) Swap(i, j int)
		Implements (at least one exported)
			 T : sort.Interface

	/* one unexported ... *//* one unexported: */
	 type byteSlab (struct)

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			basePtr *uintptr
			buffer []byte
			bufferSize uintptr
			nextPtr *uintptr
			stride uintptr
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) getSlice(size int) (chunk []byte)
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newByteSlab(size, count int) byteSlab


Package-Level Functions (total 10, in which 6 are exported)

	 func ConvertToMarshalMap(value interface{}, formatKey func(string) string) (MarshalMap, error)
		ConvertToMarshalMap tries to convert a compatible map type to a marshal map.
		Compatible types are map[interface{}]interface{}, map[string]interface{} and of
		course MarshalMap. The same rules as for ConvertValueToMarshalMap apply.

	 func NewBytePool() BytePool
		NewBytePool creates a new BytePool with each slab using 1 MB of storage.
		The pool contains 5 slabs of different sizes: 64B, 512B, 1KB, 10KB and 100KB.
		Allocations above 100KB will be allocated directly.

	 func NewBytePoolWithSize(n int) BytePool
		NewBytePoolWithSize creates a new BytePool with each slab size using n MB of
		storage. See NewBytePool() for slab size details.

	 func NewMarshalMap() MarshalMap
		NewMarshalMap creates a new marshal map (string -> interface{})

	 func NewTrie(data []byte, payload interface{}) *TrieNode
		NewTrie creates a new root TrieNode

	 func TryConvertToMarshalMap(value interface{}, formatKey func(string) string) interface{}
		TryConvertToMarshalMap converts collections to MarshalMap if possible.
		This is a deep conversion, i.e. each element in the collection will be
		traversed. You can pass a formatKey function that will be applied to all
		string keys that are detected.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 func castToInt64Array(key string, value interface{}) ([]int64, error)
	 func castToStringArray(key string, value interface{}) ([]string, error)
	 func cloneMap(mapValue reflect.Value) reflect.Value
	 func newByteSlab(size, count int) byteSlab
Package-Level Constants (total 13, in which 3 are exported)

	const MarshalMapArrayBegin = 91
		MarshalMapArrayBegin defines the rune starting array index notation

	const MarshalMapArrayEnd = 93
		MarshalMapArrayEnd defines the rune ending array index notation

	const MarshalMapSeparator = 47
		MarshalMapSeparator defines the rune used for path separation

	/* 10 unexporteds ... *//* 10 unexporteds: */
	const huge = 102400
	const hugeCount = 10 // ~1 MB
	const large = 10240
	const largeCount = 102 // ~1 MB
	const medium = 1024
	const mediumCount = 1024 // 1 MB
	const small = 512
	const smallCount = 2048 // 1 MB
	const tiny = 64
	const tinyCount = 16384 // 1 MB

The pages are generated with Golds v0.3.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.