Class: Celluloid::Promise::DeferredPromise

Inherits:
Promise
  • Object
show all
Defined in:
lib/celluloid-promise/q.rb

Overview

A new promise instance is created when a deferred instance is created and can be retrieved by calling deferred.promise

Instance Method Summary collapse

Constructor Details

#initialize(defer, reactor) ⇒ DeferredPromise

Returns a new instance of DeferredPromise.

Raises:

  • (ArgumentError) 


31
32
33
34
35
36
37
 
# File 'lib/celluloid-promise/q.rb', line 31

def initialize(defer, reactor)
  raise ArgumentError unless defer.is_a?(Deferred)
  super()
  
  @defer = defer
  @reactor = reactor
end

Instance Method Details

#then(callback = nil, errback = nil, &blk) ⇒ Promise

regardless of when the promise was or will be resolved / rejected, calls one of the success or error callbacks asynchronously as soon as the result is available. The callbacks are called with a single argument, the result or rejection reason.

Parameters:

  • callbacks (Proc, Proc, &blk) —

    success, error, success_block

Returns:

  • (Promise) —

    Returns an unresolved promise for chaining



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/celluloid-promise/q.rb', line 46

def then(callback = nil, errback = nil, &blk)
  result = ::Celluloid::Actor[:Q].defer(@reactor)
  
  callback ||= blk
  
  wrappedCallback = proc { |val|
    begin
      if callback.nil?
        result.resolve(val)
      else
        result.resolve(callback.call(val))
      end
    rescue => e
      #warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"

      result.reject(e);
    end
  }
  
  wrappedErrback = proc { |reason|
    begin
      if errback.nil?
        result.resolve(ResolvedPromise.new(@reactor, reason, true))
      else
        result.resolve(errback.call(reason))
      end
    rescue => e
      #warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"

      result.reject(e);
    end
  }
  
  #

  # Schedule as we are touching shared state

  #  Everything else is locally scoped

  #

  @reactor.async.perform do
    pending_array = pending
    
    if pending_array.nil?
      value.then(wrappedCallback, wrappedErrback)
    else
      pending_array << [wrappedCallback, wrappedErrback]
    end
  end
  
  result.promise
end