Class: Concurrent::Promises::ResolvableEvent

Inherits:

Event

• Object
• Synchronization::Object
• AbstractEventFuture
• Event
• Concurrent::Promises::ResolvableEvent

Includes:

Resolvable

Defined in:

lib/concurrent-ruby/concurrent/promises.rb

Overview

A Event which can be resolved by user.

Instance Method Summary

• #resolve(raise_on_reassign = true, reserved = false) ⇒ self, false

  Makes the event resolved, which triggers all dependent futures.

• #wait(timeout = nil, resolve_on_timeout = false) ⇒ self, true, false

  Behaves as AbstractEventFuture#wait but has one additional optional argument resolve_on_timeout.

• #with_hidden_resolvable ⇒ Event

  Creates new event wrapping receiver, effectively hiding the resolve method.

• #release ⇒ true, false included from Resolvable

  On successful release of the reservation.

• #reserve ⇒ true, false included from Resolvable

  Reserves the event or future, if reserved others are prevented from resolving it.

Instance Method Details

#resolve(raise_on_reassign = true, reserved = false) ⇒ self, false

Makes the event resolved, which triggers all dependent futures.

Parameters:

• raise_on_reassign (Boolean) (defaults to: true) —

  should method raise exception if already resolved

• reserved (true, false) (defaults to: false) —

  Set to true if the resolvable is Concurrent::Promises::Resolvable#reserved by you, marks resolution of reserved resolvable events and futures explicitly. Advanced feature, ignore unless you use Concurrent::Promises::Resolvable#reserve from edge.

Returns:

• (self, false) —

  false is returner when raise_on_reassign is false and the receiver is already resolved.

# File 'lib/concurrent-ruby/concurrent/promises.rb', line 1313

def resolve(raise_on_reassign = true, reserved = false)
  resolve_with RESOLVED, raise_on_reassign, reserved
end

#wait(timeout = nil, resolve_on_timeout = false) ⇒ self, true, false

Behaves as AbstractEventFuture#wait but has one additional optional argument resolve_on_timeout.

Parameters:

• resolve_on_timeout (true, false) (defaults to: false) —

  If it times out and the argument is true it will also resolve the event.

Returns:

• (self, true, false)

See Also:

• AbstractEventFuture#wait

# File 'lib/concurrent-ruby/concurrent/promises.rb', line 1331

def wait(timeout = nil, resolve_on_timeout = false)
  super(timeout) or if resolve_on_timeout
                      # if it fails to resolve it was resolved in the meantime
                      # so return true as if there was no timeout
                      !resolve(false)
                    else
                      false
                    end
end

#with_hidden_resolvable ⇒ Event

Creates new event wrapping receiver, effectively hiding the resolve method.

Returns:

• (Event)

# File 'lib/concurrent-ruby/concurrent/promises.rb', line 1320

def with_hidden_resolvable
  @with_hidden_resolvable ||= EventWrapperPromise.new_blocked_by1(self, @DefaultExecutor).event
end

#release ⇒ true, false Originally defined in module Resolvable

Returns on successful release of the reservation.

Returns:

• (true, false) —

  on successful release of the reservation

#reserve ⇒ true, false Originally defined in module Resolvable

Reserves the event or future, if reserved others are prevented from resolving it. Advanced feature. Be careful about the order of reservation to avoid deadlocks, the method blocks if the future or event is already reserved until it is released or resolved.

Examples:

f = Concurrent::Promises.resolvable_future
reserved = f.reserve
Thread.new { f.resolve true, :val, nil } # fails
f.resolve true, :val, nil, true if reserved # must be called only if reserved

Returns:

• (true, false) —

  on successful reservation