Documentation ¶
Overview ¶
Package attribute is focused on enabling efficient handling and tracking of attribute usage.
Index ¶
- func CheckType(value interface{}) bool
- func Equal(this, that interface{}) bool
- type Bag
- type Expression
- type List
- type MutableBag
- func (mb *MutableBag) Contains(key string) bool
- func (mb *MutableBag) Delete(name string)
- func (mb *MutableBag) Done()
- func (mb *MutableBag) Get(name string) (interface{}, bool)
- func (mb *MutableBag) Merge(bag *MutableBag)
- func (mb *MutableBag) Names() []string
- func (mb *MutableBag) ReferenceTracker() ReferenceTracker
- func (mb *MutableBag) Reset()
- func (mb *MutableBag) Set(name string, value interface{})
- func (mb *MutableBag) String() string
- type Presence
- type Reference
- type ReferenceTracker
- type ReferencedAttributeSnapshot
- type StringMap
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Bag ¶
type Bag interface { fmt.Stringer // Get returns an attribute value. Get(name string) (value interface{}, found bool) // Names returns the names of all the attributes known to this bag. Names() []string // Contains returns true if this bag contains the specified key. Contains(key string) bool // Done indicates the bag can be reclaimed. Done() // ReferenceTracker keeps track of bag accesses (optionally) ReferenceTracker() ReferenceTracker }
Bag is a generic mechanism to access a set of attributes.
The type of an attribute value is guaranteed to be one of the following: - int64 - string - float64 - bool - time.Time - time.Duration - []byte (backed by a byte array) - attribute.StringMap (backed by a map[string]string)
Attribute value types are physical representation of the semantic attribute types. For example, IP addresses are represented as []byte.
The following types are not fully implemented at the surface level: - *attribute.List (note the pointer, backed by []interface{})
type Expression ¶
type Expression interface { // Evaluate evaluates this compiled expression against the attribute bag. Evaluate(attributes Bag) (interface{}, error) // EvaluateBoolean evaluates this compiled expression against the attribute bag and returns the result as boolean. // panics if the expression does not return a boolean. EvaluateBoolean(attributes Bag) (bool, error) // EvaluateString evaluates this compiled expression against the attribute bag and returns the result as string. // panics if the expression does not return a string. EvaluateString(attributes Bag) (string, error) // EvaluateDouble evaluates this compiled expression against the attribute bag and returns the result as float64. // panics if the expression does not return a float64. EvaluateDouble(attribute Bag) (float64, error) // EvaluateInteger evaluates this compiled expression against the attribute bag and returns the result as int64. // panics if the expression does not return a int64. EvaluateInteger(attribute Bag) (int64, error) }
Expression represents a precompiled expression that can be immediately evaluated. It holds no cache and does not listen to any events. If the configuration changes, the CompiledExpression needs to be discarded and created again.
type List ¶
type List struct {
// contains filtered or unexported fields
}
List wraps a list of values and optionally reference counts it
func NewListForTesting ¶
NewListForTesting should only be used for testing.
type MutableBag ¶
type MutableBag struct {
// contains filtered or unexported fields
}
MutableBag is a generic mechanism to read and write a set of attributes.
Bags can be chained together in a parent/child relationship. A child bag represents a delta over a parent. By default a child looks identical to the parent. But as mutations occur to the child, the two start to diverge. Resetting a child makes it look identical to its parent again.
func GetMutableBag ¶
func GetMutableBag(parent Bag) *MutableBag
GetMutableBag returns an initialized bag.
Bags can be chained in a parent/child relationship. You can pass nil if the bag has no parent.
When you are done using the mutable bag, call the Done method to recycle it.
func GetMutableBagForTesting ¶
func GetMutableBagForTesting(values map[string]interface{}) *MutableBag
GetMutableBagForTesting returns a Mutable bag based on the specified map Use this function only for testing purposes.
func (*MutableBag) Contains ¶
func (mb *MutableBag) Contains(key string) bool
Contains returns true if the key is present in the bag.
func (*MutableBag) Delete ¶
func (mb *MutableBag) Delete(name string)
Delete removes a named item from the local state. The item may still be present higher in the hierarchy
func (*MutableBag) Get ¶
func (mb *MutableBag) Get(name string) (interface{}, bool)
Get returns an attribute value.
func (*MutableBag) Merge ¶
func (mb *MutableBag) Merge(bag *MutableBag)
Merge combines an array of bags into the current bag. If the current bag already defines a particular attribute, it keeps its value and is not overwritten.
Note that this does a 'shallow' merge. Only the value defined explicitly in the mutable bags themselves, and not in any of their parents, are considered.
func (*MutableBag) Names ¶
func (mb *MutableBag) Names() []string
Names returns the names of all the attributes known to this bag.
func (*MutableBag) ReferenceTracker ¶
func (mb *MutableBag) ReferenceTracker() ReferenceTracker
ReferenceTracker keeps track of bag accesses (optionally)
func (*MutableBag) Set ¶
func (mb *MutableBag) Set(name string, value interface{})
Set creates an override for a named attribute.
func (*MutableBag) String ¶
func (mb *MutableBag) String() string
String prints out the attributes from the parent bag, then walks through the local changes and prints them as well.
type ReferenceTracker ¶
type ReferenceTracker interface { // MapReference records access of a string map record. MapReference(name, key string, condition Presence) // Reference records access of an attribute by name. Reference(name string, condition Presence) // Clear the list of referenced attributes being tracked by this bag Clear() // Restore the list of referenced attributes being tracked by this bag Restore(snap ReferencedAttributeSnapshot) // Snapshot grabs a snapshot of the currently referenced attributes Snapshot() ReferencedAttributeSnapshot }
ReferenceTracker for an attribute bag
type ReferencedAttributeSnapshot ¶
type ReferencedAttributeSnapshot struct { // ReferenceAttrs is a collection of references to attributes ReferencedAttrs map[Reference]Presence }
ReferencedAttributeSnapshot keeps track of the attribute reference state for a mutable bag. You can snapshot the referenced attributes with SnapshotReferencedAttributes and later reinstall them with RestoreReferencedAttributes. Note that a snapshot can only be used once, the RestoreReferencedAttributes call is destructive.
type StringMap ¶
type StringMap struct {
// contains filtered or unexported fields
}
StringMap wraps a map[string]string and optionally reference counts it
func NewStringMap ¶
NewStringMap instantiates a new string map. The stringmap takes ownership of the provided map.
func WrapStringMap ¶
WrapStringMap wraps a string map value without reference tracking.