datawire_mdk 2.0.5

data/lib/mdk_runtime/promise.rb

@@ -0,0 +1,814 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_runtime; MdkRuntime; end
+module MdkRuntime
+def self.promise; Promise; end
+module Promise
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_runtime',)
+require_relative '../quark/error' # 0 ('quark',) ('mdk_runtime',)
+require_relative '../quark' # 0 () ('mdk_runtime',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_runtime',)
+require_relative 'actors' # 1 () ()
+
+
+##
+# Resolve a Promise with a result.
+
+def self._fullfilPromise(promise, value)
+    
+    if (::Quark.quark.reflect.QuarkClass.ERROR.hasInstance(value))
+        promise._reject(::DatawireQuarkCore.cast(value) { ::Quark.quark.error.Error })
+    else
+        promise._resolve(value)
+    end
+
+
+    nil
+end
+
+def self._ChainPromise; ChainPromise; end
+class ChainPromise < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_next
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise__ChainPromise_ref: -> { nil }
+
+
+
+    def initialize(next_)
+        
+        self.__init_fields__
+        (self)._next = next_
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        
+        ::Quark.mdk_runtime.promise._fullfilPromise((self)._next, arg)
+        return nil
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise._ChainPromise"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_next"))
+            return (self)._next
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_next"))
+            (self)._next = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.Promise }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._next = nil
+
+        nil
+    end
+
+
+end
+ChainPromise.unlazy_statics
+
+def self._CallbackEvent; CallbackEvent; end
+class CallbackEvent < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_callable, :_next, :_value
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise__CallbackEvent_ref: -> { nil }
+
+
+
+    def initialize(callable, next_, value)
+        
+        self.__init_fields__
+        (self)._callable = callable
+        (self)._next = next_
+        (self)._value = value
+
+        nil
+    end
+
+
+
+
+    def deliver()
+        
+        result = ((self)._callable).call((self)._value)
+        if (::Quark.quark.reflect.QuarkClass.get("mdk_runtime.promise.Promise").hasInstance(result))
+            toChain = ::DatawireQuarkCore.cast(result) { ::Quark.mdk_runtime.promise.Promise }
+            toChain.andFinally(::Quark.mdk_runtime.promise._ChainPromise.new((self)._next))
+        else
+            ::Quark.mdk_runtime.promise._fullfilPromise((self)._next, result)
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise._CallbackEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_callable"))
+            return (self)._callable
+        end
+        if ((name) == ("_next"))
+            return (self)._next
+        end
+        if ((name) == ("_value"))
+            return (self)._value
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_callable"))
+            (self)._callable = ::DatawireQuarkCore.cast(value) { ::Quark.quark.UnaryCallable }
+        end
+        if ((name) == ("_next"))
+            (self)._next = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.Promise }
+        end
+        if ((name) == ("_value"))
+            (self)._value = value
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._callable = nil
+        self._next = nil
+        self._value = nil
+
+        nil
+    end
+
+
+end
+CallbackEvent.unlazy_statics
+
+def self._Callback; Callback; end
+class Callback < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_callable, :_next
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise__Callback_ref: -> { nil }
+
+
+
+    def initialize(callable, next_)
+        
+        self.__init_fields__
+        (self)._callable = callable
+        (self)._next = next_
+
+        nil
+    end
+
+
+
+
+    def call(result)
+        
+        event = ::Quark.mdk_runtime.promise._CallbackEvent.new((self)._callable, (self)._next, result)
+        (@_next)._dispatcher._queue(event)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise._Callback"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_callable"))
+            return (self)._callable
+        end
+        if ((name) == ("_next"))
+            return (self)._next
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_callable"))
+            (self)._callable = ::DatawireQuarkCore.cast(value) { ::Quark.quark.UnaryCallable }
+        end
+        if ((name) == ("_next"))
+            (self)._next = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.Promise }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._callable = nil
+        self._next = nil
+
+        nil
+    end
+
+
+end
+Callback.unlazy_statics
+
+def self._Passthrough; Passthrough; end
+class Passthrough < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise__Passthrough_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        
+        return arg
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise._Passthrough"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Passthrough.unlazy_statics
+
+def self._CallIfIsInstance; CallIfIsInstance; end
+class CallIfIsInstance < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_underlying, :_class
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise__CallIfIsInstance_ref: -> { nil }
+
+
+
+    def initialize(underlying, klass)
+        
+        self.__init_fields__
+        (self)._underlying = underlying
+        (self)._class = klass
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        
+        if ((self)._class.hasInstance(arg))
+            return ((self)._underlying).call(arg)
+        else
+            return arg
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise._CallIfIsInstance"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_underlying"))
+            return (self)._underlying
+        end
+        if ((name) == ("_class"))
+            return (self)._class
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_underlying"))
+            (self)._underlying = ::DatawireQuarkCore.cast(value) { ::Quark.quark.UnaryCallable }
+        end
+        if ((name) == ("_class"))
+            (self)._class = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._underlying = nil
+        self._class = nil
+
+        nil
+    end
+
+
+end
+CallIfIsInstance.unlazy_statics
+
+def self.PromiseValue; PromiseValue; end
+##
+# Snapshot of the value of a Promise, if it has one.
+
+class PromiseValue < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_successResult, :_failureResult, :_hasValue
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise_PromiseValue_ref: -> { nil }
+
+
+
+    def initialize(successResult, failureResult, hasValue)
+        
+        self.__init_fields__
+        (self)._successResult = successResult
+        (self)._failureResult = failureResult
+        (self)._hasValue = hasValue
+
+        nil
+    end
+
+
+
+
+    ##
+    # Return true if the Promise had a value at the time this was created.
+
+    def hasValue()
+        
+        return (self)._hasValue
+
+        nil
+    end
+
+    ##
+    # Return true if value is error. Result is only valid if hasValue() is true.
+
+    def isError()
+        
+        return ((self)._failureResult) != (nil)
+
+        nil
+    end
+
+    ##
+    # Return the value. Result is only valid if hasValue() is true.
+
+    def getValue()
+        
+        if (self.isError())
+            return (self)._failureResult
+        else
+            return (self)._successResult
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise.PromiseValue"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_successResult"))
+            return (self)._successResult
+        end
+        if ((name) == ("_failureResult"))
+            return (self)._failureResult
+        end
+        if ((name) == ("_hasValue"))
+            return (self)._hasValue
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_successResult"))
+            (self)._successResult = value
+        end
+        if ((name) == ("_failureResult"))
+            (self)._failureResult = ::DatawireQuarkCore.cast(value) { ::Quark.quark.error.Error }
+        end
+        if ((name) == ("_hasValue"))
+            (self)._hasValue = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._successResult = nil
+        self._failureResult = nil
+        self._hasValue = nil
+
+        nil
+    end
+
+
+end
+PromiseValue.unlazy_statics
+
+def self.Promise; Promise; end
+##
+# An object that will eventually have a result.
+# Results are passed to callables whose return value is passed
+# to resulting Promise. If a return result is a Promise it will
+# be chained automatically, i.e. callables will never be called
+# with a Promise, only with values.
+
+class Promise < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_lock, :_successResult, :_failureResult, :_hasResult, :_successCallbacks, :_failureCallbacks, :_dispatcher
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_runtime_promise__Callback__ref: -> { nil }
+    static mdk_runtime_promise_Promise_ref: -> { nil }
+
+
+
+    def initialize(dispatcher)
+        
+        self.__init_fields__
+        (self)._dispatcher = dispatcher
+        (self)._lock = ::DatawireQuarkCore::Lock.new()
+        (self)._hasResult = false
+        (self)._successResult = nil
+        (self)._failureResult = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.error.Error }
+        (self)._successCallbacks = ::DatawireQuarkCore::List.new([])
+        (self)._failureCallbacks = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+
+
+
+    def _maybeRunCallbacks()
+        
+        (self)._lock.acquire()
+        if (!((self)._hasResult))
+            (self)._lock.release()
+            return
+        end
+        callbacks = (self)._successCallbacks
+        value = (self)._successResult
+        if (((self)._failureResult) != (nil))
+            callbacks = (self)._failureCallbacks
+            value = (self)._failureResult
+        end
+        (self)._failureCallbacks = ::DatawireQuarkCore::List.new([])
+        (self)._successCallbacks = ::DatawireQuarkCore::List.new([])
+        (self)._lock.release()
+        idx = 0
+        while ((idx) < ((callbacks).size)) do
+            (callbacks)[idx].call(value)
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def _resolve(result)
+        
+        if (::Quark.quark.reflect.QuarkClass.ERROR.hasInstance(result))
+            self._reject(::DatawireQuarkCore.cast(result) { ::Quark.quark.error.Error })
+            return
+        end
+        (self)._lock.acquire()
+        if ((self)._hasResult)
+            ::DatawireQuarkCore.print("BUG: Resolved Promise that already has a value.")
+            (self)._lock.release()
+            return
+        end
+        (self)._hasResult = true
+        (self)._successResult = result
+        (self)._lock.release()
+        self._maybeRunCallbacks()
+
+        nil
+    end
+
+    def _reject(err)
+        
+        (self)._lock.acquire()
+        if ((self)._hasResult)
+            ::DatawireQuarkCore.print("BUG: Rejected Promise that already has a value.")
+            (self)._lock.release()
+            return
+        end
+        (self)._hasResult = true
+        (self)._failureResult = err
+        (self)._lock.release()
+        self._maybeRunCallbacks()
+
+        nil
+    end
+
+    ##
+    # Add callback that will be called on non-Error values.
+    # Its result will become the value of the returned Promise.
+
+    def andThen(callable)
+        
+        return self.andEither(callable, ::Quark.mdk_runtime.promise._Passthrough.new())
+
+        nil
+    end
+
+    ##
+    # Add callback that will be called on Error values.
+    # Its result will become the value of the returned Promise.
+
+    def andCatch(errorClass, callable)
+        
+        return self.andEither(::Quark.mdk_runtime.promise._Passthrough.new(), ::Quark.mdk_runtime.promise._CallIfIsInstance.new(callable, errorClass))
+
+        nil
+    end
+
+    ##
+    # Callback that will be called for both success and error results.
+
+    def andFinally(callable)
+        
+        return self.andEither(callable, callable)
+
+        nil
+    end
+
+    ##
+    # Two callbacks, one for success and one for error results.
+
+    def andEither(success, failure)
+        
+        result = ::Quark.mdk_runtime.promise.Promise.new((self)._dispatcher)
+        (self)._lock.acquire()
+        ((self)._successCallbacks) << (::Quark.mdk_runtime.promise._Callback.new(success, result))
+        ((self)._failureCallbacks) << (::Quark.mdk_runtime.promise._Callback.new(failure, result))
+        (self)._lock.release()
+        self._maybeRunCallbacks()
+        return result
+
+        nil
+    end
+
+    ##
+    # Synchronous extraction of the promise's current value, if it has any.
+    # Its result will become the value of the returned Promise.
+
+    def value()
+        
+        (self)._lock.acquire()
+        result = ::Quark.mdk_runtime.promise.PromiseValue.new((self)._successResult, (self)._failureResult, (self)._hasResult)
+        (self)._lock.release()
+        return result
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise.Promise"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_lock"))
+            return (self)._lock
+        end
+        if ((name) == ("_successResult"))
+            return (self)._successResult
+        end
+        if ((name) == ("_failureResult"))
+            return (self)._failureResult
+        end
+        if ((name) == ("_hasResult"))
+            return (self)._hasResult
+        end
+        if ((name) == ("_successCallbacks"))
+            return (self)._successCallbacks
+        end
+        if ((name) == ("_failureCallbacks"))
+            return (self)._failureCallbacks
+        end
+        if ((name) == ("_dispatcher"))
+            return (self)._dispatcher
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_lock"))
+            (self)._lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("_successResult"))
+            (self)._successResult = value
+        end
+        if ((name) == ("_failureResult"))
+            (self)._failureResult = ::DatawireQuarkCore.cast(value) { ::Quark.quark.error.Error }
+        end
+        if ((name) == ("_hasResult"))
+            (self)._hasResult = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_successCallbacks"))
+            (self)._successCallbacks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_failureCallbacks"))
+            (self)._failureCallbacks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_dispatcher"))
+            (self)._dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._lock = nil
+        self._successResult = nil
+        self._failureResult = nil
+        self._hasResult = nil
+        self._successCallbacks = nil
+        self._failureCallbacks = nil
+        self._dispatcher = nil
+
+        nil
+    end
+
+
+end
+Promise.unlazy_statics
+
+def self.PromiseResolver; PromiseResolver; end
+##
+# Create Promises and input their initial value.
+#
+
+class PromiseResolver < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :promise
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_promise_PromiseResolver_ref: -> { nil }
+
+
+
+    def initialize(dispatcher)
+        
+        self.__init_fields__
+        (self).promise = ::Quark.mdk_runtime.promise.Promise.new(dispatcher)
+
+        nil
+    end
+
+
+
+
+    ##
+    # Set the attached Promise's initial value.
+
+    def resolve(result)
+        
+        (self).promise._resolve(result)
+
+        nil
+    end
+
+    ##
+    # Set the attached Promise's initial value to an Error.
+
+    def reject(err)
+        
+        (self).promise._reject(err)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.promise.PromiseResolver"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("promise"))
+            return (self).promise
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("promise"))
+            (self).promise = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.Promise }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.promise = nil
+
+        nil
+    end
+
+
+end
+PromiseResolver.unlazy_statics
+end # module Promise
+end # module MdkRuntime
+end # module Quark