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