type Collision … // TakeLhs always returns the left value in a collision. func TakeLhs(lhs, rhs interface{ … } // TakeRhs always returns the right hand side in a collision. func TakeRhs(lhs, rhs interface{ … } type Builder … // NewBuilder creates a new Builder with a unique Scope. func NewBuilder() *Builder { … } func (b *Builder) Scope() Scope { … } // Rescope changes the builder's scope to a new unique Scope. // // Any Maps created using the previous scope need to be Cloned // before any operation. // // This makes the old internals of the Builder eligible to be GC'ed. func (b *Builder) Rescope() { … } // Empty is the empty map. func (b *Builder) Empty() Map { … } // InsertWith inserts a new association from k to v into the Map m to create a new map // in the current scope and handle collisions using the collision function c. // // This is roughly corresponds to updating a map[uint64]interface{} by: // // if _, ok := m[k]; ok { m[k] = c(m[k], v} else { m[k] = v} // // An insertion or update happened whenever Insert(m, ...) != m . func (b *Builder) InsertWith(c Collision, m Map, k uint64, v interface{ … } // Inserts a new association from key to value into the Map m to create // a new map in the current scope. // // If there was a previous value mapped by key, keep the previously mapped value. // This is roughly corresponds to updating a map[uint64]interface{} by: // // if _, ok := m[k]; ok { m[k] = val } // // This is equivalent to b.Merge(m, b.Create({k: v})). func (b *Builder) Insert(m Map, k uint64, v interface{ … } // Updates a (key, value) in the map. This is roughly corresponds to // updating a map[uint64]interface{} by: // // m[key] = val func (b *Builder) Update(m Map, key uint64, val interface{ … } // Merge two maps lhs and rhs to create a new map in the current scope. // // Whenever there is a key in both maps (a collision), the resulting value mapped by // the key will be `c(lhs[key], rhs[key])`. func (b *Builder) MergeWith(c Collision, lhs, rhs Map) Map { … } // Merge two maps lhs and rhs to create a new map in the current scope. // // Whenever there is a key in both maps (a collision), the resulting value mapped by // the key will be the value in lhs `b.Collision(lhs[key], rhs[key])`. func (b *Builder) Merge(lhs, rhs Map) Map { … } // Clone returns a Map that contains the same (key, value) elements // within b.Scope(), i.e. return m if m.Scope() == b.Scope() or return // a deep copy of m within b.Scope() otherwise. func (b *Builder) Clone(m Map) Map { … } func (b *Builder) clone(n node) node { … } // Remove a key from a Map m and return the resulting Map. func (b *Builder) Remove(m Map, k uint64) Map { … } // Intersect Maps lhs and rhs and returns a map with all of the keys in // both lhs and rhs and the value comes from lhs, i.e. // // {(k, lhs[k]) | k in lhs, k in rhs}. func (b *Builder) Intersect(lhs, rhs Map) Map { … } // IntersectWith take lhs and rhs and returns the intersection // with the value coming from the collision function, i.e. // // {(k, c(lhs[k], rhs[k]) ) | k in lhs, k in rhs}. // // The elements of the resulting map are always { <k, c(lhs[k], rhs[k]) > } // for each key k that a key in both lhs and rhs. func (b *Builder) IntersectWith(c Collision, lhs, rhs Map) Map { … } type MutMap … // MutEmpty is an empty MutMap for a builder. func (b *Builder) MutEmpty() MutMap { … } // Insert an element into the map using the collision function for the builder. // Returns true if the element was inserted. func (mm *MutMap) Insert(k uint64, v interface{ … } // Updates an element in the map. Returns true if the map was updated. func (mm *MutMap) Update(k uint64, v interface{ … } // Removes a key from the map. Returns true if the element was removed. func (mm *MutMap) Remove(k uint64) bool { … } // Merge another map into the current one using the collision function // for the builder. Returns true if the map changed. func (mm *MutMap) Merge(other Map) bool { … } // Intersect another map into the current one using the collision function // for the builder. Returns true if the map changed. func (mm *MutMap) Intersect(other Map) bool { … } func (b *Builder) Create(m map[uint64]interface{ … } // Merge another map into the current one using the collision function // for the builder. Returns true if the map changed. func (mm *MutMap) MergeWith(c Collision, other Map) bool { … } // creates a map for a collection of leaf nodes. func (b *Builder) create(leaves []*leaf) node { … } // mkLeaf returns the hash-consed representative of (k, v) in the current scope. func (b *Builder) mkLeaf(k key, v interface{ … } // mkBranch returns the hash-consed representative of the tuple // // (prefix, branch, left, right) // // in the current scope. func (b *Builder) mkBranch(p prefix, bp bitpos, left node, right node) *branch { … } // join two maps with prefixes p0 and p1 that are *known* to disagree. func (b *Builder) join(p0 prefix, t0 node, p1 prefix, t1 node) *branch { … } // collide two leaves with the same key to create a leaf // with the collided value. func (b *Builder) collide(c Collision, left, right *leaf) *leaf { … } // inserts a leaf l into a map m and returns the resulting map. // When lhs is true, l is the left hand side in a collision. // Both l and m are in the current scope. func (b *Builder) insert(c Collision, m node, l *leaf, lhs bool) node { … } // merge two maps in the current scope. func (b *Builder) merge(c Collision, lhs, rhs node) node { … } func (b *Builder) remove(m node, k key) node { … } func (b *Builder) intersect(c Collision, l, r node) node { … }
Codebase Browser
gotools