Class: Memoizable::Memory

Inherits:
Object
  • Object
show all
Defined in:
lib/memoizable/memory.rb

Overview

Storage for memoized methods

Instance Method Summary collapse

Constructor Details

#initialize(memory) ⇒ undefined

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Initialize the memory storage for memoized methods

Parameters:

  • memory (Hash) 


13
14
15
16
17
 
# File 'lib/memoizable/memory.rb', line 13

def initialize(memory)
  @memory = memory
  @monitor = Monitor.new
  freeze
end

Instance Method Details

#[](name) ⇒ Object

Get the value from memory

Examples:


memory = Memoizable::Memory.new(foo: 1)
memory[:foo]  # => 1

Parameters:

  • name (Symbol)

Returns:

  • (Object) 


31
32
33
34
35
 
# File 'lib/memoizable/memory.rb', line 31

def [](name)
  fetch(name) do
    raise NameError, "No method #{name} is memoized"
  end
end

#clear ⇒ self

Remove all values from memory

Examples:

memory = Memoizable::Memory.new(foo: 1)
memory.clear  # => memory

Returns:

  • (self) 


138
139
140
141
142
143
 
# File 'lib/memoizable/memory.rb', line 138

def clear
  @monitor.synchronize do
    @memory.clear
  end
  self
end

#delete(name) ⇒ Object

Remove a specific value from memory

Examples:

memory = Memoizable::Memory.new(foo: 1)
memory.delete(:foo)

Parameters:

  • name (Symbol)

Returns:

  • (Object) 


123
124
125
126
127
 
# File 'lib/memoizable/memory.rb', line 123

def delete(name)
  @monitor.synchronize do
    @memory.delete(name)
  end
end

#fetch(name, default = (no_default = true), &block) ⇒ Object

Fetch the value from memory, or store it if it does not exist

Examples:

memory = Memoizable::Memory.new(foo: 1)
memory.fetch(:foo) { 2 }  # => 1
memory.fetch(:bar) { 2 }  # => 2
memory[:bar]              # => 2
memory.fetch(:baz, 3)     # => 3

Parameters:

  • name (Symbol)
  • default (Object) (defaults to: (no_default = true)) —

    optional default value to return if the key is not found

Yield Returns:

  • (Object) —

    the value to memoize

Returns:

  • (Object) 


77
78
79
80
81
82
83
84
85
 
# File 'lib/memoizable/memory.rb', line 77

def fetch(name, default = (no_default = true), &block)
  @memory.fetch(name) do       # check for the key
    @monitor.synchronize do    # acquire a lock if the key is not found
      @memory.fetch(name) do   # recheck under lock
        @memory[name] = resolve_fetch_value(name, no_default, default, &block)
      end
    end
  end
end

#marshal_dump ⇒ Hash

A hook that allows Marshal to dump the object

Examples:

memory = Memoizable::Memory.new(foo: 1)
Marshal.dump(memory)
# => "\x04\bU:\x17Memoizable::Memory{\x06:\bfooi\x06"

Returns:

  • (Hash) —

    A hash used to populate the internal memory



156
157
158
 
# File 'lib/memoizable/memory.rb', line 156

def marshal_dump
  @memory
end

#marshal_load(hash) ⇒ undefined

A hook that allows Marshal to load the object

Examples:

memory = Memoizable::Memory.new(foo: 1)
Marshal.load(Marshal.dump(memory))
# => #<Memoizable::Memory:0x007f9c2a8b6b20 @memory={:foo=>1}>

Parameters:

  • hash (Hash) —

    A hash used to populate the internal memory

Returns:

  • (undefined) 


173
174
175
 
# File 'lib/memoizable/memory.rb', line 173

def marshal_load(hash)
  initialize(hash)
end

#store(name, value) ⇒ undefined

Store the value in memory

Examples:

memory = Memoizable::Memory.new(foo: 1)
memory.store(:foo, 2)
memory[:foo]  # => 2

Parameters:

  • name (Symbol)
  • value (Object)

Returns:

  • (undefined) 


50
51
52
53
54
55
56
 
# File 'lib/memoizable/memory.rb', line 50

def store(name, value)
  @monitor.synchronize do
    raise ArgumentError, "The method #{name} is already memoized" if @memory.key?(name)

    @memory[name] = value
  end
end