1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
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
|
