class Concurrent::Collection::NonConcurrentMapBackend
@!visibility private
def [](key)
def [](key) @backend[key] end
def []=(key, value)
def []=(key, value) @backend[key] = value end
def clear
def clear @backend.clear self end
def compute(key)
def compute(key) store_computed_value(key, yield(get_or_default(key, nil))) end
def compute_if_absent(key)
def compute_if_absent(key) if NULL != (stored_value = @backend.fetch(key, NULL)) stored_value else @backend[key] = yield end end
def compute_if_present(key)
def compute_if_present(key) if NULL != (stored_value = @backend.fetch(key, NULL)) store_computed_value(key, yield(stored_value)) end end
def delete(key)
def delete(key) @backend.delete(key) end
def delete_pair(key, value)
def delete_pair(key, value) if pair?(key, value) @backend.delete(key) true else false end end
def dupped_backend
def dupped_backend @backend.dup end
def each_pair
def each_pair dupped_backend.each_pair do |k, v| yield k, v end self end
def get_and_set(key, value)
def get_and_set(key, value) stored_value = get_or_default(key, nil) @backend[key] = value stored_value end
def get_or_default(key, default_value)
def get_or_default(key, default_value) @backend.fetch(key, default_value) end
def initialize(options = nil, &default_proc)
SynchronizedMapBackend which uses a non-reentrant mutex for performance
directly without calling each other. This is important because of the
WARNING: all public methods of the class must operate on the @backend
def initialize(options = nil, &default_proc) validate_options_hash!(options) if options.kind_of?(::Hash) set_backend(default_proc) @default_proc = default_proc end
def initialize_copy(other)
def initialize_copy(other) super set_backend(@default_proc) self end
def key?(key)
def key?(key) @backend.key?(key) end
def merge_pair(key, value)
def merge_pair(key, value) if NULL == (stored_value = @backend.fetch(key, NULL)) @backend[key] = value else store_computed_value(key, yield(stored_value)) end end
def pair?(key, expected_value)
def pair?(key, expected_value) NULL != (stored_value = @backend.fetch(key, NULL)) && expected_value.equal?(stored_value) end
def replace_if_exists(key, new_value)
def replace_if_exists(key, new_value) if NULL != (stored_value = @backend.fetch(key, NULL)) @backend[key] = new_value stored_value end end
def replace_pair(key, old_value, new_value)
def replace_pair(key, old_value, new_value) if pair?(key, old_value) @backend[key] = new_value true else false end end
def set_backend(default_proc)
def set_backend(default_proc) if default_proc @backend = ::Hash.new { |_h, key| default_proc.call(self, key) } else @backend = {} end end
def size
def size @backend.size end
def store_computed_value(key, new_value)
def store_computed_value(key, new_value) if new_value.nil? @backend.delete(key) nil else @backend[key] = new_value end end