Class: Concurrent::LazyRegister

Inherits:
Synchronization::Object show all
Defined in:
lib/concurrent-ruby-edge/concurrent/lazy_register.rb

Overview

Note:

Edge Features are under active development and may change frequently.

  • Deprecations are not added before incompatible changes.
  • Edge version: major is always 0, minor bump means incompatible change, patch bump means compatible change.
  • Edge features may also lack tests and documentation.
  • Features developed in concurrent-ruby-edge are expected to move to concurrent-ruby when finalised.

Hash-like collection that store lazy evaluated values.

Examples:

register = Concurrent::LazyRegister.new
#=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
register[:key]
#=> nil
register.add(:key) { Concurrent::Actor.spawn!(Actor::AdHoc, :ping) { -> message { message } } }
#=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
register[:key]
#=> #<Concurrent::Actor::Reference /ping (Concurrent::Actor::AdHoc)>

Instance Method Summary collapse

Constructor Details

#initializeLazyRegister

Returns a new instance of LazyRegister



25
26
27
28
# File 'lib/concurrent-ruby-edge/concurrent/lazy_register.rb', line 25

def initialize
  super
  self.data = {}
end

Instance Method Details

#[](key) ⇒ Object

Element reference. Retrieves the value object corresponding to the key object. Returns nil if the key is not found. Raises an exception if the stored item raised an exception when the block was evaluated.

Parameters:

  • key (Object)

Returns:

  • (Object)

    value stored for the key or nil if the key is not found

Raises:

  • Exception when the initialization block fails



38
39
40
41
# File 'lib/concurrent-ruby-edge/concurrent/lazy_register.rb', line 38

def [](key)
  delay = data[key]
  delay ? delay.value! : nil
end

#register(key) { ... } ⇒ LazyRegister Also known as: add, store

Element assignment. Associates the value given by value with the key given by key.

Parameters:

  • key (Object)

Yields:

  • the object to store under the key

Returns:



61
62
63
64
65
# File 'lib/concurrent-ruby-edge/concurrent/lazy_register.rb', line 61

def register(key, &block)
  delay = Delay.new(executor: :immediate, &block)
  update_data { |h| h.merge(key => delay) }
  self
end

#registered?(key) ⇒ true, false Also known as: key?, has_key?

Returns true if the given key is present.

Parameters:

  • key (Object)

Returns:

  • (true, false)

    if the key is registered



47
48
49
# File 'lib/concurrent-ruby-edge/concurrent/lazy_register.rb', line 47

def registered?(key)
  data.key?(key)
end

#unregister(key) ⇒ LazyRegister Also known as: remove, delete

Un-registers the object under key, realized or not.

Parameters:

  • key (Object)

Returns:



75
76
77
78
# File 'lib/concurrent-ruby-edge/concurrent/lazy_register.rb', line 75

def unregister(key)
  update_data { |h| h.dup.tap { |j| j.delete(key) } }
  self
end