class Concurrent::Promises::BlockedPromise

@abstract

Public Class Methods

add_delayed(delayed1, delayed2) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1642
def self.add_delayed(delayed1, delayed2)
  if delayed1 && delayed2
    delayed1.push delayed2
    delayed1
  else
    delayed1 || delayed2
  end
end
new(delayed, blockers_count, future) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1651
def initialize(delayed, blockers_count, future)
  super(future)
  @Delayed   = delayed
  @Countdown = AtomicFixnum.new blockers_count
end
new_blocked_by(blockers, *args, &block) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1635
def self.new_blocked_by(blockers, *args, &block)
  delayed = blockers.reduce(nil) { |d, f| add_delayed d, f.promise.delayed_because }
  promise = new(delayed, blockers.size, *args, &block)
  blockers.each_with_index { |f, i| f.add_callback_notify_blocked promise, i }
  promise
end
new_blocked_by1(blocker, *args, &block) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1613
def self.new_blocked_by1(blocker, *args, &block)
  blocker_delayed = blocker.promise.delayed_because
  promise         = new(blocker_delayed, 1, *args, &block)
  blocker.add_callback_notify_blocked promise, 0
  promise
end
new_blocked_by2(blocker1, blocker2, *args, &block) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1620
def self.new_blocked_by2(blocker1, blocker2, *args, &block)
  blocker_delayed1 = blocker1.promise.delayed_because
  blocker_delayed2 = blocker2.promise.delayed_because
  delayed          = if blocker_delayed1 && blocker_delayed2
                       # TODO (pitr-ch 23-Dec-2016): use arrays when we know it will not grow (only flat adds delay)
                       LockFreeStack.of2(blocker_delayed1, blocker_delayed2)
                     else
                       blocker_delayed1 || blocker_delayed2
                     end
  promise          = new(delayed, 2, *args, &block)
  blocker1.add_callback_notify_blocked promise, 0
  blocker2.add_callback_notify_blocked promise, 1
  promise
end

Private Class Methods

new(future) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1543
def initialize(future)
  super()
  @Future = future
end

Public Instance Methods

blocked_by() click to toggle source

for inspection only

# File lib/concurrent-ruby/concurrent/promises.rb, line 1673
def blocked_by
  blocked_by = []
  ObjectSpace.each_object(AbstractEventFuture) { |o| blocked_by.push o if o.blocks.include? self }
  blocked_by
end
delayed_because() click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1664
def delayed_because
  @Delayed
end
on_blocker_resolution(future, index) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1657
def on_blocker_resolution(future, index)
  countdown  = process_on_blocker_resolution(future, index)
  resolvable = resolvable?(countdown, future, index)

  on_resolvable(future, index) if resolvable
end
touch() click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1668
def touch
  clear_and_propagate_touch
end

Private Instance Methods

clear_and_propagate_touch(stack_or_element = @Delayed) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1681
def clear_and_propagate_touch(stack_or_element = @Delayed)
  return if stack_or_element.nil?

  if stack_or_element.is_a? LockFreeStack
    stack_or_element.clear_each { |element| clear_and_propagate_touch element }
  else
    stack_or_element.touch unless stack_or_element.nil? # if still present
  end
end
on_resolvable(resolved_future, index) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1700
def on_resolvable(resolved_future, index)
  raise NotImplementedError
end
process_on_blocker_resolution(future, index) click to toggle source
# File lib/concurrent-ruby/concurrent/promises.rb, line 1696
def process_on_blocker_resolution(future, index)
  @Countdown.decrement
end
resolvable?(countdown, future, index) click to toggle source

@return [true,false] if resolvable

# File lib/concurrent-ruby/concurrent/promises.rb, line 1692
def resolvable?(countdown, future, index)
  countdown.zero?
end