Class: ThreadSafe::Cache

### Home Classes Methods

### In Files

- lib/thread_safe/cache.rb

### Parent

ConcurrentCacheBackend

### Methods

- ::new
- #[]
- #each_key
- #each_value
- #empty?
- #fetch
- #fetch_or_store
- #get
- #index
- #key
- #keys
- #marshal_dump
- #marshal_load
- #put_if_absent
- #size
- #value?
- #values

### Class/Module Index

Quicksearch

- ThreadSafe
- ThreadSafe::Array
- ThreadSafe::AtomicReferenceCacheBackend
- ThreadSafe::AtomicReferenceCacheBackend::Node
- ThreadSafe::AtomicReferenceCacheBackend::Table
- ThreadSafe::Cache
- ThreadSafe::Hash
- ThreadSafe::MriCacheBackend
- ThreadSafe::NonConcurrentCacheBackend
- ThreadSafe::SynchronizedCacheBackend
- ThreadSafe::Util
- ThreadSafe::Util::Adder
- ThreadSafe::Util::CheapLockable
- ThreadSafe::Util::PowerOfTwoTuple
- ThreadSafe::Util::Striped64
- ThreadSafe::Util::Striped64::Cell
- ThreadSafe::Util::Volatile
- ThreadSafe::Util::VolatileTuple
- SynchronizedDelegator
- Threadsafe

No matching classes.

# ThreadSafe::Cache

### Constants

KEY_ERROR

### Public Class Methods

new(options = nil, &block) click to toggle source

    # File lib/thread_safe/cache.rb, line 26
    def initialize(options = nil, &block)
      if options.kind_of?(::Hash)
        validate_options_hash!(options)
      else
        options = nil
      end

      super(options)
      @default_proc = block
    end

### Public Instance Methods

[](key) click to toggle source

    # File lib/thread_safe/cache.rb, line 37
    def [](key)
      if value = super # non-falsy value is an existing mapping, return it right away
        value
      # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
      # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
      # would be returned)
      # note: nil == value check is not technically necessary
      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
        @default_proc.call(self, key)
      else
        value
      end
    end

Also aliased as: get
each_key() click to toggle source

    # File lib/thread_safe/cache.rb, line 100
    def each_key
      each_pair {|k, v| yield k}
    end

each_value() click to toggle source

    # File lib/thread_safe/cache.rb, line 104
    def each_value
      each_pair {|k, v| yield v}
    end

empty?() click to toggle source

    # File lib/thread_safe/cache.rb, line 114
    def empty?
      each_pair {|k, v| return false}
      true
    end

fetch(key, default_value = NULL) click to toggle source

    # File lib/thread_safe/cache.rb, line 54
    def fetch(key, default_value = NULL)
      if NULL != (value = get_or_default(key, NULL))
        value
      elsif block_given?
        yield key
      elsif NULL != default_value
        default_value
      else
        raise_fetch_no_key
      end
    end

fetch_or_store(key, default_value = NULL) click to toggle source

    # File lib/thread_safe/cache.rb, line 66
    def fetch_or_store(key, default_value = NULL)
      fetch(key) do
        put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
      end
    end

get(key) click to toggle source
Alias for: []
index(value) click to toggle source
Alias for: key
key(value) click to toggle source

    # File lib/thread_safe/cache.rb, line 108
    def key(value)
      each_pair {|k, v| return k if v == value}
      nil
    end

Also aliased as: index
keys() click to toggle source

    # File lib/thread_safe/cache.rb, line 88
    def keys
      arr = []
      each_pair {|k, v| arr << k}
      arr
    end

marshal_dump() click to toggle source

    # File lib/thread_safe/cache.rb, line 125
    def marshal_dump
      raise TypeError, "can't dump hash with default proc" if @default_proc
      h = {}
      each_pair {|k, v| h[k] = v}
      h
    end

marshal_load(hash) click to toggle source

    # File lib/thread_safe/cache.rb, line 132
    def marshal_load(hash)
      initialize
      populate_from(hash)
    end

put_if_absent(key, value) click to toggle source

    # File lib/thread_safe/cache.rb, line 72
    def put_if_absent(key, value)
      computed = false
      result = compute_if_absent(key) do
        computed = true
        value
      end
      computed ? nil : result
    end

size() click to toggle source

    # File lib/thread_safe/cache.rb, line 119
    def size
      count = 0
      each_pair {|k, v| count += 1}
      count
    end

value?(value) click to toggle source

    # File lib/thread_safe/cache.rb, line 81
    def value?(value)
      each_value do |v|
        return true if value.equal?(v)
      end
      false
    end

values() click to toggle source

    # File lib/thread_safe/cache.rb, line 94
    def values
      arr = []
      each_pair {|k, v| arr << v}
      arr
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.