Class: Concurrent::LazyRegister — Concurrent Ruby

# Class: Concurrent::LazyRegister

Inherits:
  Synchronization::Object
  - Object
  - Synchronization::Object
  - Concurrent::LazyRegister
  show all

Defined in:
  lib-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

- #[](key) ⇒ Object

  Element reference.

- #initialize ⇒ LazyRegister constructor

  A new instance of LazyRegister.

- #register(key) { ... } ⇒ LazyRegister (also: #add, #store)

  Element assignment.

- #registered?(key) ⇒ true, false (also: #key?, #has_key?)

  Returns true if the given key is present.

- #unregister(key) ⇒ LazyRegister (also: #remove, #delete)

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

## Constructor Details

### #initialize ⇒ `LazyRegister`

Returns a new instance of LazyRegister

    25
    26
    27
    28
    # File 'lib-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-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:

- (`LazyRegister`) —

  self

    61
    62
    63
    64
    65
    # File 'lib-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-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:

- (`LazyRegister`) —

  self

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

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