Class: Concurrent::Promises::ResolvableEvent

Inherits:
Event show all
Includes:
Resolvable
Defined in:
lib/concurrent-ruby/concurrent/promises.rb

Overview

A Event which can be resolved by user.

Instance Method Summary collapse

Instance Method Details

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

Makes the event resolved, which triggers all dependent futures.

Parameters:

Returns:

  • (self, false)

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



1313
1314
1315
# 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:



1331
1332
1333
1334
1335
1336
1337
1338
1339
# 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_resolvableEvent

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

Returns:



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

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

#releasetrue, false Originally defined in module Resolvable

Returns on successful release of the reservation.

Returns:

  • (true, false)

    on successful release of the reservation

#reservetrue, 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