lib/ref/abstract_reference_value_map.rb
module Ref
# Abstract base class for WeakValueMap and SoftValueMap.
#
# The classes behave similar to Hashes, but the values in the map are not strong references
# and can be reclaimed by the garbage collector at any time. When a value is reclaimed, the
# map entry will be removed.
class AbstractReferenceValueMap
class << self
def reference_class=(klass) #:nodoc:
@reference_class = klass
end
def reference_class #:nodoc:
raise NotImplementedError.new("#{name} is an abstract class and cannot be instantiated") unless @reference_class
@reference_class
end
end
# Create a new map. Values added to the map will be cleaned up by the garbage
# collector if there are no other reference except in the map.
def initialize
@references = {}
@references_to_keys_map = {}
@lock = Monitor.new
@reference_cleanup = lambda{|object_id| remove_reference_to(object_id)}
end
# Get a value from the map by key. If the value has been reclaimed by the garbage
# collector, this will return nil.
def [](key)
@lock.synchronize do
ref = @references[key]
value = ref.object if ref
value
end
end
alias_method :get, :[]
# Add a key/value to the map.
def []=(key, value)
ObjectSpace.define_finalizer(value, @reference_cleanup)
key = key.dup if key.is_a?(String)
@lock.synchronize do
@references[key] = self.class.reference_class.new(value)
keys_for_id = @references_to_keys_map[value.__id__]
unless keys_for_id
keys_for_id = []
@references_to_keys_map[value.__id__] = keys_for_id
end
keys_for_id << key
end
value
end
alias_method :put, :[]=
# Remove the entry associated with the key from the map.
def delete(key)
ref = @references.delete(key)
if ref
keys_to_id = @references_to_keys_map[ref.referenced_object_id]
if keys_to_id
keys_to_id.delete(key)
@references_to_keys_map.delete(ref.referenced_object_id) if keys_to_id.empty?
end
ref.object
else
nil
end
end
# Get the list of all values that have not yet been garbage collected.
def values
vals = []
each{|k,v| vals << v}
vals
end
# Turn the map into an arry of [key, value] entries
def to_a
array = []
each{|k,v| array << [k, v]}
array
end
# Returns a hash containing the names and values for the struct’s members.
def to_h
hash = {}
each{|k,v| hash[k] = v}
hash
end
# Iterate through all the key/value pairs in the map that have not been reclaimed
# by the garbage collector.
def each
@references.each do |key, ref|
value = ref.object
yield(key, value) if value
end
end
# Clear the map of all key/value pairs.
def clear
@lock.synchronize do
@references.clear
@references_to_keys_map.clear
end
end
# Returns a new struct containing the contents of `other` and the contents
# of `self`. If no block is specified, the value for entries with duplicate
# keys will be that of `other`. Otherwise the value for each duplicate key
# is determined by calling the block with the key, its value in `self` and
# its value in `other`.
def merge(other_hash, &block)
to_h.merge(other_hash, &block).reduce(self.class.new) do |map, pair|
map[pair.first] = pair.last
map
end
end
# Merge the values from another hash into this map.
def merge!(other_hash)
@lock.synchronize do
other_hash.each { |key, value| self[key] = value }
end
end
# The number of entries in the map
def size
@references.count do |_, ref|
ref.object
end
end
alias_method :length, :size
# True if there are entries that exist in the map
def empty?
@references.each do |_, ref|
return false if ref.object
end
true
end
def inspect
live_entries = {}
each do |key, value|
live_entries[key] = value
end
live_entries.inspect
end
private
def remove_reference_to(object_id)
@lock.synchronize do
keys = @references_to_keys_map[object_id]
if keys
keys.each do |key|
@references.delete(key)
end
@references_to_keys_map.delete(object_id)
end
end
end
end
end