class Puppet::RbTreeMap

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

A RbTreeMap is a map that is stored in sorted order based on the order of its keys. This ordering is determined by applying the function <=> to compare the keys. No duplicate values for keys are allowed, so duplicate values are overwritten.

A major advantage of RBTreeMap over a Hash is the fact that keys are stored in order and can thus be iterated over in order. This is useful for many datasets.

The implementation is adapted from Robert Sedgewick’s Left Leaning Red-Black Tree implementation, which can be found at www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java

Most methods have O(log n) complexity.

Attributes

length[R]

size[R]

Public Class Methods

new() click to toggle source

Create and initialize a new empty TreeMap.

# File lib/puppet/rb_tree_map.rb, line 41
def initialize
  @root = nil
  @size = 0
end

Public Instance Methods

[](key)

Alias for: get

[]=(key, value)

Alias for: push

delete(key) click to toggle source

Deletes the item and key if it’s found, and returns the item. Returns nil if key is not present.

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.delete("MA") #=> "Massachusetts"

# File lib/puppet/rb_tree_map.rb, line 121
def delete(key)
  result = nil
  if @root
    return unless has_key? key
    @root, result = delete_recursive(@root, key)
    @root.color = :black if @root
    @size -= 1
  end
  result
end

delete_max() click to toggle source

Deletes the item with the largest key and returns the item. Returns nil if key is not present.

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.delete_max #=> "Georgia"
map.size #=> 1

# File lib/puppet/rb_tree_map.rb, line 167
def delete_max
  result = nil
  if @root
    @root, result = delete_max_recursive(@root)
    @root.color = :black if @root
    @size -= 1
  end
  result
end

delete_min() click to toggle source

Deletes the item with the smallest key and returns the item. Returns nil if key is not present.

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.delete_min #=> "Massachusetts"
map.size #=> 1

# File lib/puppet/rb_tree_map.rb, line 147
def delete_min
  result = nil
  if @root
    @root, result = delete_min_recursive(@root)
    @root.color = :black if @root
    @size -= 1
  end
  result
end

each(&blk) click to toggle source

Yields [key, value] pairs in order by key.

# File lib/puppet/rb_tree_map.rb, line 178
def each(&blk)
  recursive_yield(@root, &blk)
end

empty?() click to toggle source

Returns true if the tree is empty, false otherwise

# File lib/puppet/rb_tree_map.rb, line 133
def empty?
  @root.nil?
end

first() click to toggle source

# File lib/puppet/rb_tree_map.rb, line 182
def first
  return nil unless @root
  node = min_recursive(@root)
  [node.key, node.value]
end

get(key) click to toggle source

Return the item associated with the key, or nil if none found.

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.get("GA") #=> "Georgia"

# File lib/puppet/rb_tree_map.rb, line 81
def get(key)
  node = get_recursive(@root, key)
  node ? node.value : nil
  node.value if node
end

Also aliased as: []

has_key?(key) click to toggle source

Return true if key is found in the TreeMap, false otherwise

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.has_key?("GA") #=> true
map.has_key?("DE") #=> false

# File lib/puppet/rb_tree_map.rb, line 69
def has_key?(key)
  !get_recursive(@root, key).nil?
end

last() click to toggle source

# File lib/puppet/rb_tree_map.rb, line 188
def last
  return nil unless @root
  node = max_recursive(@root)
  [node.key, node.value]
end

max_key() click to toggle source

Return the largest key in the map.

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.max_key #=> "MA"

# File lib/puppet/rb_tree_map.rb, line 108
def max_key
  @root.nil? ? nil : max_recursive(@root).key
end

min_key() click to toggle source

Return the smallest key in the map.

Complexity: O(log n)

map = Containers::TreeMap.new
map.push("MA", "Massachusetts")
map.push("GA", "Georgia")
map.min_key #=> "GA"

# File lib/puppet/rb_tree_map.rb, line 96
def min_key
  @root.nil? ? nil : min_recursive(@root).key
end

push(key, value) click to toggle source

Insert an item with an associated key into the TreeMap, and returns the item inserted

Complexity: O(log n)

map = Containers::TreeMap.new map.push(“MA”, “Massachusetts”) #=> “Massachusetts” map.get(“MA”) #=> “Massachusetts”

# File lib/puppet/rb_tree_map.rb, line 53
def push(key, value)
  @root = insert(@root, key, value)
  @root.color = :black
  value
end

Also aliased as: []=

to_hash() click to toggle source

# File lib/puppet/rb_tree_map.rb, line 194
def to_hash
  @root ? @root.to_hash : {}
end