Method: Kernel#await_fastest

Defined in:

lib/all/kernel.rb

#await_fastest(evaluation0, evaluation1, *more_evaluations, opts = {}) ⇒ Concurrently::Proc::Evaluation (private)

Waits for the first in a list of evaluations to be concluded.

Examples:

evaluation0 = concurrently{ wait 2 }
evaluation1 = concurrently{ wait 1 }

await_fastest(evaluation0, evaluation1) # => evaluation1

Waiting with a timeout

evaluation0 = concurrently{ wait 2 }
evaluation1 = concurrently{ wait 1 }

await_fastest(evaluation0, evaluation1, within: 0.1)
# => raises a TimeoutError after 0.1 seconds

Waiting with a timeout and a timeout result

evaluation0 = concurrently{ wait 2 }
evaluation1 = concurrently{ wait 1 }

await_fastest(evaluation0, evaluation1, within: 0.1, timeout_result: false)
# => returns false after 0.1 seconds

Parameters:

• evaluation0 (Concurrently::Proc::Evaluation)
• evaluation1 (Concurrently::Proc::Evaluation)
• *more_evaluations (Concurrently::Proc::Evaluation)
• opts (Hash) (defaults to: {})

Options Hash (opts):

• :within (Numeric) —

  maximum time to wait (defaults to: Float::INFINITY)

• :timeout_result (Object) —

  result to return in case of an exceeded waiting time (defaults to raising Concurrently::Evaluation::TimeoutError)

Returns:

• (Concurrently::Proc::Evaluation) —

  the evaluation been concluded first

Raises:

• (Concurrently::Evaluation::TimeoutError) —

  if a given maximum waiting time is exceeded and no custom timeout result is given.

Since:

• 1.1.0

# File 'lib/all/kernel.rb', line 238

private def await_fastest(eval0, eval1, *evaluations)
  opts = (evaluations.last.is_a? Hash) ? evaluations.pop : {}
  evaluations.unshift eval0, eval1

  if concluded = evaluations.find(&:concluded?)
    concluded
  else
    begin
      curr_eval = Concurrently::Evaluation.current
      evaluations.each{ |e| e.instance_eval{ @awaiting_result.store curr_eval, self } }
      await_resume! opts
    ensure
      evaluations.each{ |e| e.instance_eval{ @awaiting_result.delete curr_eval } }
    end
  end
end