Class: Concurrent::Promises::AbstractEventFuture

Inherits:
Synchronization::Object show all
Includes:
ThrottleIntegration
Defined in:
lib/concurrent/edge/promises.rb,
lib/concurrent/edge/throttle.rb

Overview

Common ancestor of Event and Future classes, many shared methods are defined here.

Direct Known Subclasses

Event, Future

Defined Under Namespace

Modules: ThrottleIntegration

Constant Summary

Instance Method Summary (collapse)

Instance Method Details

- (undocumented) add_callback_notify_blocked(promise, index)

@!visibility private



742
743
744
 
# File 'lib/concurrent/edge/promises.rb', line 742

def add_callback_notify_blocked(promise, index)
  add_callback :callback_notify_blocked, promise, index
end

- (Future) chain(*args, &task)

Shortcut of #chain_on with default :io executor supplied.

Returns:

See Also:



605
606
607
 
# File 'lib/concurrent/edge/promises.rb', line 605

def chain(*args, &task)
  chain_on @DefaultExecutor, *args, &task
end

- (Future) an_event.chain_on(executor, *args) {|*args| ... } - (Future) a_future.chain_on(executor, *args) {|fulfilled, value, reason, *args| ... }

Chains the task to be executed asynchronously on executor after it is resolved.

Overloads:

  • - (Future) an_event.chain_on(executor, *args) {|*args| ... }

    Yields:

    • (*args) —

      to the task.

  • - (Future) a_future.chain_on(executor, *args) {|fulfilled, value, reason, *args| ... }

    Yields:

    • (fulfilled, value, reason, *args) —

      to the task.

    Yield Parameters:

    • fulfilled (true, false)
    • value (Object)
    • reason (Exception)

Parameters:

  • executor (Executor, :io, :fast) —

    Instance of an executor or a name of the global executor. The task is executed on it, default executor remains unchanged.

  • args (Object) —

    arguments which are passed to the task when it's executed. (It might be prepended with other arguments, see the @yeild section).

Yield Returns:

  • will become result of the returned Future. Its returned value becomes Future#value fulfilling it, raised exception becomes Future#reason rejecting it.

Returns:



623
624
625
 
# File 'lib/concurrent/edge/promises.rb', line 623

def chain_on(executor, *args, &task)
  ChainPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
end

- (self) chain_resolvable(resolvable) Also known as: tangle

Resolves the resolvable when receiver is resolved.

Parameters:

Returns:

  • (self) 


638
639
640
 
# File 'lib/concurrent/edge/promises.rb', line 638

def chain_resolvable(resolvable)
  on_resolution! { resolvable.resolve_with internal_state }
end

- (Promises::Future, Promises::Event) chain_throttled_by(throttle, *args, &block) Originally defined in module ThrottleIntegration

Behaves as Concurrent::Promises::AbstractEventFuture#chain but the it is throttled.

Returns:

See Also:

- (Executor) default_executor

Returns default executor.

Returns:

  • (Executor) —

    default executor

See Also:



599
600
601
 
# File 'lib/concurrent/edge/promises.rb', line 599

def default_executor
  @DefaultExecutor
end

- (self) on_resolution(*args, &callback)

Shortcut of #on_resolution_using with default :io executor supplied.

Returns:

  • (self)

See Also:



646
647
648
 
# File 'lib/concurrent/edge/promises.rb', line 646

def on_resolution(*args, &callback)
  on_resolution_using @DefaultExecutor, *args, &callback
end

- (self) an_event.on_resolution!(*args) {|*args| ... } - (self) a_future.on_resolution!(*args) {|fulfilled, value, reason, *args| ... }

Stores the callback to be executed synchronously on resolving thread after it is resolved.

Overloads:

  • - (self) an_event.on_resolution!(*args) {|*args| ... }

    Yields:

    • (*args) —

      to the callback.

  • - (self) a_future.on_resolution!(*args) {|fulfilled, value, reason, *args| ... }

    Yields:

    • (fulfilled, value, reason, *args) —

      to the callback.

    Yield Parameters:

    • fulfilled (true, false)
    • value (Object)
    • reason (Exception)

Parameters:

  • args (Object) —

    arguments which are passed to the task when it's executed. (It might be prepended with other arguments, see the @yeild section).

Yield Returns:

  • is forgotten.

Returns:

  • (self) 


664
665
666
 
# File 'lib/concurrent/edge/promises.rb', line 664

def on_resolution!(*args, &callback)
  add_callback :callback_on_resolution, args, callback
end

- (self) an_event.on_resolution_using(executor, *args) {|*args| ... } - (self) a_future.on_resolution_using(executor, *args) {|fulfilled, value, reason, *args| ... }

Stores the callback to be executed asynchronously on executor after it is resolved.

Overloads:

  • - (self) an_event.on_resolution_using(executor, *args) {|*args| ... }

    Yields:

    • (*args) —

      to the callback.

  • - (self) a_future.on_resolution_using(executor, *args) {|fulfilled, value, reason, *args| ... }

    Yields:

    • (fulfilled, value, reason, *args) —

      to the callback.

    Yield Parameters:

    • fulfilled (true, false)
    • value (Object)
    • reason (Exception)

Parameters:

  • executor (Executor, :io, :fast) —

    Instance of an executor or a name of the global executor. The task is executed on it, default executor remains unchanged.

  • args (Object) —

    arguments which are passed to the task when it's executed. (It might be prepended with other arguments, see the @yeild section).

Yield Returns:

  • is forgotten.

Returns:

  • (self) 


682
683
684
 
# File 'lib/concurrent/edge/promises.rb', line 682

def on_resolution_using(executor, *args, &callback)
  add_callback :async_callback_on_resolution, executor, args, callback
end

- (Boolean) pending?(state = internal_state)

Is it in pending state?

Returns:

  • (Boolean) 


558
559
560
 
# File 'lib/concurrent/edge/promises.rb', line 558

def pending?(state = internal_state)
  !state.resolved?
end

- (Boolean) resolved?(state = internal_state)

Is it in resolved state?

Returns:

  • (Boolean) 


564
565
566
 
# File 'lib/concurrent/edge/promises.rb', line 564

def resolved?(state = internal_state)
  state.resolved?
end

- (:pending, :resolved) an_event.state - (:pending, :fulfilled, :rejected) a_future.state

Returns its state.

Overloads:

  • - (:pending, :resolved) an_event.state

    Returns:

    • (:pending, :resolved)
  • - (:pending, :fulfilled, :rejected) a_future.state

    Both :fulfilled, :rejected implies :resolved.

    Returns:

    • (:pending, :fulfilled, :rejected)

Returns:

  • (Symbol) 


552
553
554
 
# File 'lib/concurrent/edge/promises.rb', line 552

def state
  internal_state.to_sym
end

- (undocumented) throttled_by(throttle, &throttled_futures) Originally defined in module ThrottleIntegration

- (String) to_s Also known as: inspect

Returns Short string representation.

Returns:

  • (String) —

    Short string representation.



628
629
630
 
# File 'lib/concurrent/edge/promises.rb', line 628

def to_s
  format '<#%s:0x%x %s>', self.class, object_id << 1, state
end

- (self) touch

Propagates touch. Requests all the delayed futures, which it depends on, to be executed. This method is called by any other method requiring resolved state, like #wait.

Returns:

  • (self) 


571
572
573
574
 
# File 'lib/concurrent/edge/promises.rb', line 571

def touch
  @Promise.touch
  self
end

- (Future, true, false) wait(timeout = nil)

Note:

This function potentially blocks current thread until the Future is resolved. Be careful it can deadlock. Try to chain instead.

Wait (block the Thread) until receiver is #resolved?. Calls #touch.

Parameters:

  • timeout (Numeric) (defaults to: nil) —

    the maximum time in second to wait.

Returns:

  • (Future, true, false) —

    self implies timeout was not used, true implies timeout was used and it was resolved, false implies it was not resolved within timeout.



587
588
589
590
 
# File 'lib/concurrent/edge/promises.rb', line 587

def wait(timeout = nil)
  result = wait_until_resolved(timeout)
  timeout ? result : self
end

- (AbstractEventFuture) with_default_executor(executor)

This method is abstract.

Crates new object with same class with the executor set as its new default executor. Any futures depending on it will use the new default executor.

Returns:

Raises:

  • (NotImplementedError)

See Also:



692
693
694
 
# File 'lib/concurrent/edge/promises.rb', line 692

def with_default_executor(executor)
  raise NotImplementedError
end