class Audrey::Node::Hash

Audrey::Node::Hash

Public Class Methods

new_object() click to toggle source
# File lib/audrey.rb, line 903
def self.new_object
        return({})
end

Public Instance Methods

[](key) click to toggle source
# File lib/audrey.rb, line 914
def [](key)
        # $tm.hrm
        # puts "@pk: #{@pk}"
        # puts "key: #{key}"
        
        read_check()
        hsh = @engine.row_hash_by_key(@pk, key)
        
        # if we got a hash
        if hsh
                return @db.object_from_row(hsh)
                
        # else return nil
        else
                return nil
        end
end
[]=(key, child) click to toggle source
# File lib/audrey.rb, line 939
def []=(key, child)
        write_check()
        
        # test for checks outside of a transaction
        @db.checks_outside_transaction @aclass
        
        @engine.hash_element_delete @pk, key
        save_child child, 'key'=>key.to_s
        return child
end
attach_to(hsh) click to toggle source
# File lib/audrey.rb, line 1047
def attach_to(hsh)
        # hold on to original values
        orgs = hsh.clone
        
        # audrey()
        def hsh.audrey(p_node = nil)
                if p_node
                        @audrey_node = p_node
                end
                
                # return
                return @audrey_node
        end
        
        # []
        def hsh.[](key)
                return @audrey_node[key]
        end
        
        # []=
        def hsh.[]=(key, child)
                return @audrey_node[key] = child
        end
        
        # each
        def hsh.each()
                if block_given?
                        @audrey_node.each do |k, v|
                                yield k, v
                        end
                else
                        return @audrey_node.each
                end
        end
        
        # length
        def hsh.length()
                return @audrey_node.length
        end
        
        # keys
        def hsh.keys()
                return @audrey_node.keys
        end
        
        # values
        def hsh.values()
                return @audrey_node.values
        end
        
        # delete
        def hsh.delete(*opts)
                return @audrey_node.delete(*opts)
        end
        
        # clear
        def hsh.clear()
                return @audrey_node.clear()
        end
        
        # has_key?
        def hsh.has_key?(key)
                return @audrey_node.has_key?(key)
        end
        
        # any?
        def hsh.any?()
                return @audrey_node.any?
        end
        
        # ==
        def hsh.==(*opts)
                return @audrey_node.==(*opts)
        end
        
        # <=
        def hsh.<=(*opts)
                return @audrey_node.<=(*opts)
        end
        
        # >=
        def hsh.>=(*opts)
                return @audrey_node.>=(*opts)
        end
        
        # ===
        def hsh.===(*opts)
                return @audrey_node.===(*opts)
        end
        
        # initial call to audrey object
        hsh.audrey self
        
        # save child elements
        orgs.each do |k, v|
                hsh[k] = v
        end
end
delete(key) click to toggle source
# File lib/audrey.rb, line 1016
def delete(key)
        write_check()
        record = @engine.hash_element_delete(@pk, key)
        
        # if record, return node, else return nil
        if record
                return @db.object_from_row(record)
        else
                return nil
        end
end
each() { |key, object| ... } click to toggle source
# File lib/audrey.rb, line 989
def each
        read_check()
        rv = nil
        
        # loop through records
        @engine.hash_each(@pk) do |key, row|
                object = @db.object_from_row(row)
                
                if block_given?
                        yield key, object
                else
                        rv ||= []
                        rv.push [key, object]
                end
        end
        
        # return
        return rv
end
has_key?(key) click to toggle source
# File lib/audrey.rb, line 1035
def has_key?(key)
        read_check()
        return @engine.hash_has_key?(@pk, key)
end
keys() click to toggle source
# File lib/audrey.rb, line 957
def keys
        read_check()
        return @engine.hash_keys(@pk)
end
values() click to toggle source
# File lib/audrey.rb, line 969
def values
        read_check()
        rv = []
        
        # loop through records
        @engine.hash_each(@pk) do |key, row|
                rv.push @db.object_from_row(row)
        end
        
        # return
        return rv
end