datawire_mdk 2.0.5

data/lib/mdk_util.rb

@@ -0,0 +1,141 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_util; MdkUtil; end
+module MdkUtil
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
+require_relative 'quark' # 0 () ()
+require_relative 'datawire_mdk_md' # 0 () ()
+
+
+def self.WaitForPromise; WaitForPromise; end
+##
+# Utility to blockingly wait for a Promise to get a value.
+
+class WaitForPromise < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_util_WaitForPromise_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def _finished(value, done)
+        
+        done.acquire()
+        done.wakeup()
+        done.release()
+        return true
+
+        nil
+    end
+
+    def self.wait(p, timeout, description)
+        
+        snapshot = p.value()
+        if (snapshot.hasValue())
+            return snapshot.getValue()
+        end
+        done = ::DatawireQuarkCore::Condition.new()
+        waiter = ::Quark.mdk_util.WaitForPromise.new()
+        p.andThen(::Quark.quark._BoundMethod.new(waiter, "_finished", ::DatawireQuarkCore::List.new([done])))
+        msTimeout = ((timeout) * (1000.0)).round()
+        done.acquire()
+        done.waitWakeup(msTimeout)
+        done.release()
+        snapshot = p.value()
+        if (!(snapshot.hasValue()))
+            raise (("Timeout waiting for ") + (description))
+        end
+        return snapshot.getValue()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_util.WaitForPromise"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WaitForPromise.unlazy_statics
+
+def self.toNativePromise(p)
+    
+    if (!(false))
+        raise ("This method only works on Javascript.")
+    end
+    return
+
+
+    nil
+end
+
+def self.extend(list, value, size)
+    
+    while (((list).size) < (size)) do
+        (list) << (value)
+    end
+
+
+    nil
+end
+
+def self.versionMatch(requested, actual)
+    
+    if ((requested) == (nil))
+        return true
+    end
+    reqparts = ::DatawireQuarkCore.split(requested, ".")
+    actparts = ::DatawireQuarkCore.split(actual, ".")
+    ::Quark.mdk_util.extend(reqparts, "0", 3)
+    ::Quark.mdk_util.extend(actparts, "0", 3)
+    if (((reqparts)[0]) != ((actparts)[0]))
+        return false
+    end
+    if (((actparts)[1]) > ((reqparts)[1]))
+        return true
+    end
+    if (((actparts)[1]) < ((reqparts)[1]))
+        return false
+    end
+    return ((actparts)[2]) >= ((reqparts)[2])
+
+
+    nil
+end
+end # module MdkUtil
+end # module Quark

data/lib/quark.rb

@@ -0,0 +1,3684 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require_relative "datawire-quark-core"
+def self.quark; Quark; end
+module Quark
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'datawire_mdk_md' # 0 () ()
+require_relative 'quark/concurrent' # 0 ('quark',) ()
+require_relative 'quark/error' # 0 ('quark',) ()
+require_relative 'quark/logging' # 0 ('quark',) ()
+require_relative 'quark/behaviors' # 0 ('quark',) ()
+require_relative 'quark/test' # 0 ('quark',) ()
+require_relative 'quark/spi' # 0 ('quark',) ()
+require_relative 'quark/spi_api' # 0 ('quark',) ()
+require_relative 'quark/spi_api_tracing' # 0 ('quark',) ()
+require_relative 'quark/os' # 0 ('quark',) ()
+require_relative 'quark/mock' # 0 ('quark',) ()
+
+
+def self.Task; Task; end
+class Task < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Task_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onExecute(runtime)
+        raise NotImplementedError, '`Task.onExecute` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Task.unlazy_statics
+
+def self.Runtime; Runtime; end
+class Runtime < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Runtime_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def open(url, handler)
+        raise NotImplementedError, '`Runtime.open` is an abstract method'
+
+        nil
+    end
+
+    def request(request, handler)
+        raise NotImplementedError, '`Runtime.request` is an abstract method'
+
+        nil
+    end
+
+    def schedule(handler, delayInSeconds)
+        raise NotImplementedError, '`Runtime.schedule` is an abstract method'
+
+        nil
+    end
+
+    def codec()
+        raise NotImplementedError, '`Runtime.codec` is an abstract method'
+
+        nil
+    end
+
+    def serveHTTP(url, servlet)
+        raise NotImplementedError, '`Runtime.serveHTTP` is an abstract method'
+
+        nil
+    end
+
+    def serveWS(url, servlet)
+        raise NotImplementedError, '`Runtime.serveWS` is an abstract method'
+
+        nil
+    end
+
+    def respond(request, response)
+        raise NotImplementedError, '`Runtime.respond` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Display the explanatory message and then terminate the program
+
+    def fail(message)
+        raise NotImplementedError, '`Runtime.fail` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Get a logger for the specified topic.
+
+    def logger(topic)
+        raise NotImplementedError, '`Runtime.logger` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Get epoch time in milliseconds
+
+    def now()
+        raise NotImplementedError, '`Runtime.now` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Suspend execution of this thread for some number of seconds
+
+    def sleep(seconds)
+        raise NotImplementedError, '`Runtime.sleep` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Get a v4 random UUID (Universally Unique IDentifier)
+
+    def uuid()
+        raise NotImplementedError, '`Runtime.uuid` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Call a UnaryCallable safely, catching native exceptions.
+    #
+    # The UnaryCallable is called with null.
+    #
+    # The result of calling the UnaryCallable will be returned, unless an
+    # exception is caught in which case the default is returned.
+    #
+
+    def callSafely(callable, defaultResult)
+        raise NotImplementedError, '`Runtime.callSafely` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Runtime.unlazy_statics
+
+##
+# Get epoch time in milliseconds
+
+def self.now()
+    
+    return ::Quark.quark.concurrent.Context.runtime().now()
+
+
+    nil
+end
+
+##
+# Suspend execution of this thread for some number of seconds
+
+def self.sleep(seconds)
+    
+    ::Quark.quark.concurrent.Context.runtime().sleep(seconds)
+
+
+    nil
+end
+
+##
+# Get a v4 random UUID (Universally Unique IDentifier)
+
+def self.uuid()
+    
+    return ::Quark.quark.concurrent.Context.runtime().uuid()
+
+
+    nil
+end
+
+
+def self.Maybe; Maybe; end
+class Maybe < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Maybe_quark_Object__ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getValue()
+        raise NotImplementedError, '`Maybe.getValue` is an abstract method'
+
+        nil
+    end
+
+    def hasValue()
+        raise NotImplementedError, '`Maybe.hasValue` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Maybe.unlazy_statics
+
+def self.ParsedNumber; ParsedNumber; end
+class ParsedNumber < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_value, :_hasValue
+    extend ::DatawireQuarkCore::Static
+
+    static MINUS: -> { ("-")[0].ord }
+    static PLUS: -> { ("+")[0].ord }
+    static ZERO: -> { ("0")[0].ord }
+    static NINE: -> { ("9")[0].ord }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getValue()
+        
+        return (self)._value
+
+        nil
+    end
+
+    def hasValue()
+        
+        return (self)._hasValue
+
+        nil
+    end
+
+    def _parseLong(num)
+        
+        i = 0
+        val = (0)
+        neg = false
+        if ((i) == ((num).size))
+            return (0)
+        end
+        first = (num)[0].ord
+        if (((first) == (::Quark.quark.ParsedNumber.MINUS)) || ((first) == (::Quark.quark.ParsedNumber.PLUS)))
+            neg = (first) == (::Quark.quark.ParsedNumber.MINUS)
+            i = (i) + (1)
+        end
+        if ((i) == ((num).size))
+            return (0)
+        end
+        while ((i) < ((num).size)) do
+            d = (num)[i].ord
+            if (((d) < (::Quark.quark.ParsedNumber.ZERO)) || ((d) > (::Quark.quark.ParsedNumber.NINE)))
+                break
+            else
+                val = ((10) * (val)) + (((d) - (::Quark.quark.ParsedNumber.ZERO)))
+            end
+            i = (i) + (1)
+        end
+        (self)._hasValue = (i) == ((num).size)
+        if (neg)
+            return -(val)
+        else
+            return val
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.ParsedNumber<quark.Object>"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("MINUS"))
+            return ::Quark.quark.ParsedNumber.MINUS
+        end
+        if ((name) == ("PLUS"))
+            return ::Quark.quark.ParsedNumber.PLUS
+        end
+        if ((name) == ("ZERO"))
+            return ::Quark.quark.ParsedNumber.ZERO
+        end
+        if ((name) == ("NINE"))
+            return ::Quark.quark.ParsedNumber.NINE
+        end
+        if ((name) == ("_value"))
+            return (self)._value
+        end
+        if ((name) == ("_hasValue"))
+            return (self)._hasValue
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("MINUS"))
+            ::Quark.quark.ParsedNumber.MINUS = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("PLUS"))
+            ::Quark.quark.ParsedNumber.PLUS = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("ZERO"))
+            ::Quark.quark.ParsedNumber.ZERO = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("NINE"))
+            ::Quark.quark.ParsedNumber.NINE = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_value"))
+            (self)._value = ::DatawireQuarkCore.cast(value) { ::Quark.T }
+        end
+        if ((name) == ("_hasValue"))
+            (self)._hasValue = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._value = nil
+        self._hasValue = false
+
+        nil
+    end
+
+
+end
+ParsedNumber.unlazy_statics
+
+def self.ParsedInt; ParsedInt; end
+class ParsedInt < ::Quark.quark.ParsedNumber
+    attr_accessor :MIN, :MAX
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ParsedNumber_quark_int__ref: -> { nil }
+    static quark_ParsedInt_ref: -> { nil }
+
+
+
+    def initialize(num)
+        
+        super()
+        temp = self._parseLong(num)
+        if (((temp) < (((self).MIN))) || ((temp) > (((self).MAX))))
+            (self)._hasValue = false
+            if ((temp) < ((0)))
+                (self)._value = (self).MIN
+            else
+                (self)._value = (self).MAX
+            end
+        else
+            (self)._value = (temp)
+        end
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.ParsedInt"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("MINUS"))
+            return ::Quark.quark.ParsedNumber.MINUS
+        end
+        if ((name) == ("PLUS"))
+            return ::Quark.quark.ParsedNumber.PLUS
+        end
+        if ((name) == ("ZERO"))
+            return ::Quark.quark.ParsedNumber.ZERO
+        end
+        if ((name) == ("NINE"))
+            return ::Quark.quark.ParsedNumber.NINE
+        end
+        if ((name) == ("_value"))
+            return (self)._value
+        end
+        if ((name) == ("_hasValue"))
+            return (self)._hasValue
+        end
+        if ((name) == ("MIN"))
+            return (self).MIN
+        end
+        if ((name) == ("MAX"))
+            return (self).MAX
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("MINUS"))
+            ::Quark.quark.ParsedNumber.MINUS = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("PLUS"))
+            ::Quark.quark.ParsedNumber.PLUS = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("ZERO"))
+            ::Quark.quark.ParsedNumber.ZERO = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("NINE"))
+            ::Quark.quark.ParsedNumber.NINE = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_value"))
+            (self)._value = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_hasValue"))
+            (self)._hasValue = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("MIN"))
+            (self).MIN = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("MAX"))
+            (self).MAX = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.MIN = (-(2147483647)) - (1)
+        self.MAX = 2147483647
+
+        nil
+    end
+
+
+end
+ParsedInt.unlazy_statics
+
+def self.ParsedLong; ParsedLong; end
+class ParsedLong < ::Quark.quark.ParsedNumber
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ParsedNumber_quark_long__ref: -> { nil }
+    static quark_ParsedLong_ref: -> { nil }
+
+
+
+    def initialize(num)
+        
+        super()
+        (self)._value = self._parseLong(num)
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.ParsedLong"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("MINUS"))
+            return ::Quark.quark.ParsedNumber.MINUS
+        end
+        if ((name) == ("PLUS"))
+            return ::Quark.quark.ParsedNumber.PLUS
+        end
+        if ((name) == ("ZERO"))
+            return ::Quark.quark.ParsedNumber.ZERO
+        end
+        if ((name) == ("NINE"))
+            return ::Quark.quark.ParsedNumber.NINE
+        end
+        if ((name) == ("_value"))
+            return (self)._value
+        end
+        if ((name) == ("_hasValue"))
+            return (self)._hasValue
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("MINUS"))
+            ::Quark.quark.ParsedNumber.MINUS = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("PLUS"))
+            ::Quark.quark.ParsedNumber.PLUS = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("ZERO"))
+            ::Quark.quark.ParsedNumber.ZERO = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("NINE"))
+            ::Quark.quark.ParsedNumber.NINE = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_value"))
+            (self)._value = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_hasValue"))
+            (self)._hasValue = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+ParsedLong.unlazy_statics
+
+def self.ListUtil; ListUtil; end
+class ListUtil < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark_Object__ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def slice(list, start, stop)
+        
+        result = ::DatawireQuarkCore::List.new([])
+        if ((start) >= ((list).size))
+            start = (list).size
+        else
+            start = (start) % ((list).size)
+        end
+        if ((stop) >= ((list).size))
+            stop = (list).size
+        else
+            stop = (stop) % ((list).size)
+        end
+        idx = start
+        while ((idx) < (stop)) do
+            (result) << ((list)[idx])
+            idx = (idx) + (1)
+        end
+        return result
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.ListUtil<quark.Object>"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+ListUtil.unlazy_statics
+
+def self.UnaryCallable; UnaryCallable; end
+class UnaryCallable < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_UnaryCallable_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        raise NotImplementedError, '`UnaryCallable.call` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+UnaryCallable.unlazy_statics
+
+##
+# Allow native code to call UnaryCallables.
+
+def self.callUnaryCallable(callee, arg)
+    
+    return (callee).call(arg)
+
+
+    nil
+end
+
+
+def self._getLogger(topic)
+    
+    if (::Quark.quark.logging.Config._autoconfig())
+        ::Quark.quark.logging.makeConfig().configure()
+    end
+    return ::Quark.quark.concurrent.Context.runtime().logger(topic)
+
+
+    nil
+end
+
+
+
+##
+# Serializes object tree into JSON. skips over fields starting with underscore
+
+def self.toJSON(obj, cls)
+    
+    result = ::DatawireQuarkCore::JSONObject.new
+    if ((obj) == (nil))
+        result.setNull()
+        return result
+    end
+    if (((cls) == (nil)) || (cls.isAbstract()))
+        cls = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(obj))
+    end
+    idx = 0
+    if (((cls).name) == ("quark.String"))
+        result.setString(::DatawireQuarkCore.cast(obj) { ::String })
+        return result
+    end
+    if (((((((cls).name) == ("quark.byte")) || (((cls).name) == ("quark.short"))) || (((cls).name) == ("quark.int"))) || (((cls).name) == ("quark.long"))) || (((cls).name) == ("quark.float")))
+        result.setNumber(obj)
+        return result
+    end
+    if (((cls).name) == ("quark.List"))
+        result.setList()
+        list = ::DatawireQuarkCore.cast(obj) { ::DatawireQuarkCore::List }
+        while ((idx) < ((list).size)) do
+            result.setListItem(idx, ::Quark.quark.toJSON((list)[idx], nil))
+            idx = (idx) + (1)
+        end
+        return result
+    end
+    if (((cls).name) == ("quark.Map"))
+        result.setObject()
+        map = ::DatawireQuarkCore.cast(obj) { ::Hash }
+        keys = ::DatawireQuarkCore::List.new((map).keys)
+        key = nil
+        strKey = nil
+        keyMap = {}
+        strKeys = ::DatawireQuarkCore::List.new([])
+        while ((idx) < ((keys).size)) do
+            key = (keys)[idx]
+            strKey = (key).to_s
+            strKey = ::Quark.quark.toJSON(key, (cls.getParameters())[0]).toString()
+            (keyMap)[strKey] = (key)
+            (strKeys) << (strKey)
+            idx = (idx) + (1)
+        end
+        (strKeys).sort!
+        idx = 0
+        hash = ::DatawireQuarkCore.cast(nil) { ::DatawireQuarkCore::JSONObject }
+        hashIdx = 0
+        while ((idx) < ((strKeys).size)) do
+            strKey = (strKeys)[idx]
+            key = (keyMap)[strKey]
+            value = (map)[key]
+            if (((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(key))).name) == ("quark.String"))
+                (result).setObjectItem((::DatawireQuarkCore.cast(key) { ::String }), (::Quark.quark.toJSON(value, (cls.getParameters())[1])))
+            else
+                if ((hash) == (nil))
+                    hash = ::DatawireQuarkCore::JSONObject.new.setList()
+                    (result).setObjectItem(("$map"), (hash))
+                end
+                hash.setListItem(hashIdx, ::Quark.quark.toJSON(key, (cls.getParameters())[0]))
+                hash.setListItem((hashIdx) + (1), ::Quark.quark.toJSON(value, (cls.getParameters())[1]))
+                hashIdx = (hashIdx) + (2)
+            end
+            idx = (idx) + (1)
+        end
+        return result
+    end
+    (result).setObjectItem(("$class"), (::DatawireQuarkCore::JSONObject.new.setString((cls).id)))
+    fields = cls.getFields()
+    while ((idx) < ((fields).size)) do
+        fieldName = ((fields)[idx]).name
+        if (!((fieldName).start_with?("_")))
+            (result).setObjectItem((fieldName), (::Quark.quark.toJSON((obj)._getField(fieldName), (fields)[idx].getType())))
+        end
+        idx = (idx) + (1)
+    end
+    return result
+
+
+    nil
+end
+
+##
+# deserialize json into provided result object. Skip over fields starting with underscore
+
+def self.fromJSON(cls, result, json)
+    
+    if ((((json) == (nil)) || (json.isNull())) || (json.isUndefined()))
+        return nil
+    end
+    idx = 0
+    if (((cls) == (nil)) || (cls.isAbstract()))
+        type = json.getType()
+        if ((type) == ("boolean"))
+            cls = ::Quark.quark.reflect.QuarkClass.BOOL
+        end
+        if ((type) == ("number"))
+            cls = ::Quark.quark.reflect.QuarkClass.BOOL
+        end
+        if ((type) == ("string"))
+            cls = ::Quark.quark.reflect.QuarkClass.STRING
+        end
+        if ((type) == ("list"))
+            if ((result) == (nil))
+                result = ::DatawireQuarkCore::List.new([])
+            end
+            cls = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(result))
+        end
+        if ((type) == ("object"))
+            klazz = (json).getObjectItem("$class").getString()
+            if ((klazz) != (nil))
+                cls = ::Quark.quark.reflect.QuarkClass.get(klazz)
+            else
+                if ((result) == (nil))
+                    result = {}
+                end
+                cls = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(result))
+            end
+        end
+    end
+    if ((result) == (nil))
+        if (((cls).name) == ("quark.String"))
+            s = json.getString()
+            return s
+        end
+        if (((cls).name) == ("quark.float"))
+            flt = json.getNumber()
+            return flt
+        end
+        if (((cls).name) == ("quark.int"))
+            i = (json).getNumber.round
+            return i
+        end
+        if (((cls).name) == ("quark.long"))
+            l = (json.getNumber()).round()
+            return l
+        end
+        if (((cls).name) == ("quark.bool"))
+            b = json.getBool()
+            return b
+        end
+        result = cls.construct(::DatawireQuarkCore::List.new([]))
+    end
+    if (((cls).name) == ("quark.List"))
+        list = ::DatawireQuarkCore.cast(result) { ::DatawireQuarkCore::List }
+        while ((idx) < (json.size())) do
+            (list) << (::Quark.quark.fromJSON((cls.getParameters())[0], nil, json.getListItem(idx)))
+            idx = (idx) + (1)
+        end
+        return list
+    end
+    if (((cls).name) == ("quark.Map"))
+        map = ::DatawireQuarkCore.cast(result) { ::Hash }
+        keys = json.keys()
+        while ((idx) < ((keys).size)) do
+            key = (keys)[idx]
+            value = (json).getObjectItem(key)
+            if ((key) != ("$map"))
+                (map)[key] = (::Quark.quark.fromJSON((cls.getParameters())[1], nil, value))
+            else
+                hashIdx = 0
+                while ((hashIdx) < (value.size())) do
+                    hkey = ::Quark.quark.fromJSON((cls.getParameters())[0], nil, value.getListItem(hashIdx))
+                    hvalue = ::Quark.quark.fromJSON((cls.getParameters())[1], nil, value.getListItem((hashIdx) + (1)))
+                    (map)[hkey] = (hvalue)
+                    hashIdx = (hashIdx) + (2)
+                end
+            end
+            idx = (idx) + (1)
+        end
+    end
+    fields = cls.getFields()
+    while ((idx) < ((fields).size)) do
+        f = (fields)[idx]
+        idx = (idx) + (1)
+        if (((f).name).start_with?("_"))
+            next
+        end
+        if (((json).getObjectItem((f).name).isDefined()) && (!((json).getObjectItem((f).name).isNull())))
+            (result)._setField(((f).name), (::Quark.quark.fromJSON(f.getType(), nil, (json).getObjectItem((f).name))))
+        end
+    end
+    return result
+
+
+    nil
+end
+
+
+def self.ServletError; ServletError; end
+class ServletError < ::Quark.quark.error.Error
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ServletError_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super(message)
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.ServletError"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("message"))
+            return (self).message
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+ServletError.unlazy_statics
+
+def self.Servlet; Servlet; end
+##
+# A service addresable with an url
+
+class Servlet < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Servlet_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # called after the servlet is successfully installed. The url will be the actual url used, important especially if ephemeral port was requested
+
+    def onServletInit(url, runtime)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # called if the servlet could not be installed
+
+    def onServletError(url, error)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # called when the servlet is removed
+
+    def onServletEnd(url)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Servlet.unlazy_statics
+
+def self.Resolver; Resolver; end
+class Resolver < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Resolver_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def resolve(serviceName)
+        raise NotImplementedError, '`Resolver.resolve` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Resolver.unlazy_statics
+
+def self.ResponseHolder; ResponseHolder; end
+class ResponseHolder < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :response, :failure
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ResponseHolder_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onHTTPResponse(request, response)
+        
+        (self).response = response
+
+        nil
+    end
+
+    def onHTTPError(request, error)
+        
+        @failure = error
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.ResponseHolder"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("response"))
+            return (self).response
+        end
+        if ((name) == ("failure"))
+            return (self).failure
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("response"))
+            (self).response = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPResponse }
+        end
+        if ((name) == ("failure"))
+            (self).failure = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPError }
+        end
+
+        nil
+    end
+
+    def onHTTPInit(request)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPFinal(request)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.response = nil
+        self.failure = nil
+
+        nil
+    end
+
+
+end
+ResponseHolder.unlazy_statics
+
+def self.Service; Service; end
+class Service < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Service_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getName()
+        raise NotImplementedError, '`Service.getName` is an abstract method'
+
+        nil
+    end
+
+    def getInstance()
+        raise NotImplementedError, '`Service.getInstance` is an abstract method'
+
+        nil
+    end
+
+    def getTimeout()
+        raise NotImplementedError, '`Service.getTimeout` is an abstract method'
+
+        nil
+    end
+
+    def rpc(methodName, args)
+        
+        rpc = ::Quark.quark.behaviors.RPC.new(self, methodName)
+        return rpc.call(args)
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Service.unlazy_statics
+
+def self.BaseService; BaseService; end
+class BaseService < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_BaseService_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getName()
+        
+        return ::DatawireQuarkCore.cast(nil) { ::String }
+
+        nil
+    end
+
+    def getInstance()
+        
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.ServiceInstance }
+
+        nil
+    end
+
+    def getTimeout()
+        
+        return -(1.0)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.BaseService"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def rpc(methodName, args)
+        
+        rpc = ::Quark.quark.behaviors.RPC.new(self, methodName)
+        return rpc.call(args)
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+BaseService.unlazy_statics
+
+def self.ServiceInstance; ServiceInstance; end
+class ServiceInstance < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :serviceName, :url, :breaker
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ServiceInstance_ref: -> { nil }
+
+
+
+    def initialize(serviceName, url, failureLimit, retestDelay)
+        
+        self.__init_fields__
+        (self).serviceName = serviceName
+        (self).url = url
+        (self).breaker = ::Quark.quark.behaviors.CircuitBreaker.new((((("[") + (serviceName)) + (" at ")) + (url)) + ("]"), failureLimit, retestDelay)
+
+        nil
+    end
+
+
+
+
+    def isActive()
+        
+        return ((self).breaker).active
+
+        nil
+    end
+
+    def getURL()
+        
+        return (self).url
+
+        nil
+    end
+
+    def succeed(info)
+        
+        if (!(self.isActive()))
+            ::Quark.quark.Client.logger.info(((("- CLOSE breaker for ") + ((self).serviceName)) + (" at ")) + ((self).url))
+        end
+        (self).breaker.succeed()
+
+        nil
+    end
+
+    def fail(info)
+        
+        if (!(self.isActive()))
+            ::Quark.quark.Client.logger.warn(((("- OPEN breaker for ") + ((self).serviceName)) + (" at ")) + ((self).url))
+        end
+        (self).breaker.fail()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.ServiceInstance"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("serviceName"))
+            return (self).serviceName
+        end
+        if ((name) == ("url"))
+            return (self).url
+        end
+        if ((name) == ("breaker"))
+            return (self).breaker
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("serviceName"))
+            (self).serviceName = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("url"))
+            (self).url = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("breaker"))
+            (self).breaker = ::DatawireQuarkCore.cast(value) { ::Quark.quark.behaviors.CircuitBreaker }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.serviceName = nil
+        self.url = nil
+        self.breaker = nil
+
+        nil
+    end
+
+
+end
+ServiceInstance.unlazy_statics
+
+def self.DegenerateResolver; DegenerateResolver; end
+##
+# DegenerateResolver assumes that the serviceName is an URL.
+
+class DegenerateResolver < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_DegenerateResolver_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def resolve(serviceName)
+        
+        return ::DatawireQuarkCore::List.new([serviceName])
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.DegenerateResolver"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+DegenerateResolver.unlazy_statics
+
+def self.Client; Client; end
+class Client < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :resolver, :serviceName, :_timeout, :_failureLimit, :_retestDelay, :mutex, :instanceMap, :counter
+    extend ::DatawireQuarkCore::Static
+
+    static logger: -> { ::Quark.quark._getLogger("quark.client") }
+    static quark_Map_quark_String_quark_ServiceInstance__ref: -> { nil }
+    static quark_Client_ref: -> { nil }
+
+
+
+    def initialize(serviceName)
+        
+        self.__init_fields__
+        (self).serviceName = serviceName
+        (self).resolver = ::Quark.quark.DegenerateResolver.new()
+        (self)._timeout = 0.0
+        (self).mutex = ::DatawireQuarkCore::Lock.new()
+        (self).instanceMap = {}
+        (self).counter = 0
+        failureLimit = ::DatawireQuarkCore.cast((self)._getField("failureLimit")) { ::Integer }
+        if ((failureLimit) != (nil))
+            (self)._failureLimit = failureLimit
+        end
+        ::Quark.quark.Client.logger.info((((self).to_s) + (" failureLimit ")) + (((self)._failureLimit).to_s))
+        retestDelay = ::DatawireQuarkCore.cast((self)._getField("retestDelay")) { ::Float }
+        if ((retestDelay) != (nil))
+            (self)._retestDelay = retestDelay
+        end
+        ::Quark.quark.Client.logger.info((((self).to_s) + (" retestDelay ")) + (((self)._retestDelay).to_s))
+
+        nil
+    end
+
+
+
+
+    def setResolver(resolver)
+        
+        (self).resolver = resolver
+
+        nil
+    end
+
+    def getInstance()
+        
+        urls = (self).resolver.resolve((self).serviceName)
+        if (((urls).size) <= (0))
+            return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.ServiceInstance }
+        end
+        (urls).sort!
+        (self).mutex.acquire()
+        result = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.ServiceInstance }
+        next_ = ((self).counter) % ((urls).size)
+        (self).counter = ((self).counter) + (1)
+        idx = next_
+        while (true) do
+            url = (urls)[idx]
+            instance = ((self).instanceMap)[url]
+            if ((instance) == (nil))
+                instance = ::Quark.quark.ServiceInstance.new((self).serviceName, url, @_failureLimit, @_retestDelay)
+                ((self).instanceMap)[url] = (instance)
+            end
+            if (instance.isActive())
+                ::Quark.quark.Client.logger.info(((((("- ") + ((self).serviceName)) + (" using instance ")) + (((idx) + (1)).to_s)) + (": ")) + (url))
+                result = instance
+                break
+            end
+            idx = ((idx) + (1)) % ((urls).size)
+            if ((idx) == (next_))
+                ::Quark.quark.Client.logger.info((("- ") + ((self).serviceName)) + (": no live instances! giving up."))
+                break
+            end
+        end
+        (self).mutex.release()
+        return result
+
+        nil
+    end
+
+    def getName()
+        
+        return (self).serviceName
+
+        nil
+    end
+
+    def getTimeout()
+        
+        return (self)._timeout
+
+        nil
+    end
+
+    def setTimeout(timeout)
+        
+        (self)._timeout = timeout
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.Client"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return ::Quark.quark.Client.logger
+        end
+        if ((name) == ("resolver"))
+            return (self).resolver
+        end
+        if ((name) == ("serviceName"))
+            return (self).serviceName
+        end
+        if ((name) == ("_timeout"))
+            return (self)._timeout
+        end
+        if ((name) == ("_failureLimit"))
+            return (self)._failureLimit
+        end
+        if ((name) == ("_retestDelay"))
+            return (self)._retestDelay
+        end
+        if ((name) == ("mutex"))
+            return (self).mutex
+        end
+        if ((name) == ("instanceMap"))
+            return (self).instanceMap
+        end
+        if ((name) == ("counter"))
+            return (self).counter
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            ::Quark.quark.Client.logger = value
+        end
+        if ((name) == ("resolver"))
+            (self).resolver = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Resolver }
+        end
+        if ((name) == ("serviceName"))
+            (self).serviceName = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("_timeout"))
+            (self)._timeout = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("_failureLimit"))
+            (self)._failureLimit = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_retestDelay"))
+            (self)._retestDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("mutex"))
+            (self).mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("instanceMap"))
+            (self).instanceMap = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("counter"))
+            (self).counter = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.resolver = nil
+        self.serviceName = nil
+        self._timeout = nil
+        self._failureLimit = 3
+        self._retestDelay = 30.0
+        self.mutex = nil
+        self.instanceMap = nil
+        self.counter = nil
+
+        nil
+    end
+
+
+end
+Client.unlazy_statics
+
+def self.ServerResponder; ServerResponder; end
+class ServerResponder < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :sendCORS, :request, :response
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ServerResponder_ref: -> { nil }
+
+
+
+    def initialize(sendCORS, request, response)
+        
+        self.__init_fields__
+        (self).sendCORS = sendCORS
+        (self).request = request
+        (self).response = response
+
+        nil
+    end
+
+
+
+
+    def onFuture(result)
+        
+        error = result.getError()
+        if ((error) != (nil))
+            @response.setCode(404)
+        else
+            if ((self).sendCORS)
+                (self).response.setHeader("Access-Control-Allow-Origin", "*")
+            end
+            (self).response.setBody(::Quark.quark.toJSON(result, nil).toString())
+            (self).response.setCode(200)
+        end
+        ::Quark.quark.concurrent.Context.runtime().respond(@request, @response)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.ServerResponder"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("sendCORS"))
+            return (self).sendCORS
+        end
+        if ((name) == ("request"))
+            return (self).request
+        end
+        if ((name) == ("response"))
+            return (self).response
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("sendCORS"))
+            (self).sendCORS = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("request"))
+            (self).request = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPRequest }
+        end
+        if ((name) == ("response"))
+            (self).response = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPResponse }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.sendCORS = nil
+        self.request = nil
+        self.response = nil
+
+        nil
+    end
+
+
+end
+ServerResponder.unlazy_statics
+
+def self.Server; Server; end
+class Server < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :impl, :_sendCORS
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Server_quark_Object__ref: -> { nil }
+
+
+
+    def initialize(impl)
+        
+        self.__init_fields__
+        (self).impl = impl
+        (self)._sendCORS = false
+
+        nil
+    end
+
+
+
+
+    def sendCORS(send)
+        
+        (self)._sendCORS = send
+
+        nil
+    end
+
+    def onHTTPRequest(request, response)
+        
+        body = request.getBody()
+        envelope = ::DatawireQuarkCore::JSONObject.parse(body)
+        if ((((envelope).getObjectItem("$method")) == (envelope.undefined())) || (((envelope).getObjectItem("rpc")) == (envelope.undefined())))
+            response.setBody((("Failed to understand request.\n\n") + (body)) + ("\n"))
+            response.setCode(400)
+            ::Quark.quark.concurrent.Context.runtime().respond(request, response)
+        else
+            methodName = (envelope).getObjectItem("$method").getString()
+            json = (envelope).getObjectItem("rpc")
+            method = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(self)).getField("impl").getType().getMethod(methodName)
+            params = method.getParameters()
+            args = ::DatawireQuarkCore::List.new([])
+            idx = 0
+            while ((idx) < ((params).size)) do
+                (args) << (::Quark.quark.fromJSON((params)[idx], nil, json.getListItem(idx)))
+                idx = (idx) + (1)
+            end
+            result = ::DatawireQuarkCore.cast(method.invoke(@impl, args)) { ::Quark.quark.concurrent.Future }
+            result.onFinished(::Quark.quark.ServerResponder.new((self)._sendCORS, request, response))
+        end
+
+        nil
+    end
+
+    def onServletError(url, error)
+        
+        ::Quark.quark.concurrent.Context.runtime().fail(((("RPC Server failed to register ") + (url)) + (" due to: ")) + (error.getMessage()))
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.Server<quark.Object>"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("impl"))
+            return (self).impl
+        end
+        if ((name) == ("_sendCORS"))
+            return (self)._sendCORS
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("impl"))
+            (self).impl = ::DatawireQuarkCore.cast(value) { ::Quark.T }
+        end
+        if ((name) == ("_sendCORS"))
+            (self)._sendCORS = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def serveHTTP(url)
+        
+        ::Quark.quark.concurrent.Context.runtime().serveHTTP(url, self)
+
+        nil
+    end
+
+    ##
+    # called after the servlet is successfully installed. The url will be the actual url used, important especially if ephemeral port was requested
+
+    def onServletInit(url, runtime)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # called when the servlet is removed
+
+    def onServletEnd(url)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.impl = nil
+        self._sendCORS = nil
+
+        nil
+    end
+
+
+end
+Server.unlazy_statics
+
+
+
+def self.HTTPError; HTTPError; end
+class HTTPError < ::Quark.quark.error.Error
+    extend ::DatawireQuarkCore::Static
+
+    static quark_HTTPError_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super(message)
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.HTTPError"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("message"))
+            return (self).message
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+HTTPError.unlazy_statics
+
+def self.HTTPHandler; HTTPHandler; end
+class HTTPHandler < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_HTTPHandler_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onHTTPInit(request)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPResponse(request, response)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPError(request, message)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPFinal(request)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+HTTPHandler.unlazy_statics
+
+def self.HTTPRequest; HTTPRequest; end
+class HTTPRequest < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_HTTPRequest_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getUrl()
+        raise NotImplementedError, '`HTTPRequest.getUrl` is an abstract method'
+
+        nil
+    end
+
+    def setMethod(method)
+        raise NotImplementedError, '`HTTPRequest.setMethod` is an abstract method'
+
+        nil
+    end
+
+    def getMethod()
+        raise NotImplementedError, '`HTTPRequest.getMethod` is an abstract method'
+
+        nil
+    end
+
+    def setBody(data)
+        raise NotImplementedError, '`HTTPRequest.setBody` is an abstract method'
+
+        nil
+    end
+
+    def getBody()
+        raise NotImplementedError, '`HTTPRequest.getBody` is an abstract method'
+
+        nil
+    end
+
+    def setHeader(key, value)
+        raise NotImplementedError, '`HTTPRequest.setHeader` is an abstract method'
+
+        nil
+    end
+
+    def getHeader(key)
+        raise NotImplementedError, '`HTTPRequest.getHeader` is an abstract method'
+
+        nil
+    end
+
+    def getHeaders()
+        raise NotImplementedError, '`HTTPRequest.getHeaders` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+HTTPRequest.unlazy_statics
+
+def self.HTTPResponse; HTTPResponse; end
+class HTTPResponse < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_HTTPResponse_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getCode()
+        raise NotImplementedError, '`HTTPResponse.getCode` is an abstract method'
+
+        nil
+    end
+
+    def setCode(code)
+        raise NotImplementedError, '`HTTPResponse.setCode` is an abstract method'
+
+        nil
+    end
+
+    def getBody()
+        raise NotImplementedError, '`HTTPResponse.getBody` is an abstract method'
+
+        nil
+    end
+
+    def setBody(body)
+        raise NotImplementedError, '`HTTPResponse.setBody` is an abstract method'
+
+        nil
+    end
+
+    def setHeader(key, value)
+        raise NotImplementedError, '`HTTPResponse.setHeader` is an abstract method'
+
+        nil
+    end
+
+    def getHeader(key)
+        raise NotImplementedError, '`HTTPResponse.getHeader` is an abstract method'
+
+        nil
+    end
+
+    def getHeaders()
+        raise NotImplementedError, '`HTTPResponse.getHeaders` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+HTTPResponse.unlazy_statics
+
+def self.HTTPServlet; HTTPServlet; end
+##
+# Http servlet
+
+class HTTPServlet < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_HTTPServlet_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # incoming request. respond with Runtime.respond(). After responding the objects may get recycled by the runtime
+
+    def onHTTPRequest(request, response)
+        
+        nil
+
+        nil
+    end
+
+    def serveHTTP(url)
+        
+        ::Quark.quark.concurrent.Context.runtime().serveHTTP(url, self)
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+HTTPServlet.unlazy_statics
+
+
+def self.WSError; WSError; end
+class WSError < ::Quark.quark.error.Error
+    extend ::DatawireQuarkCore::Static
+
+    static quark_WSError_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super(message)
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.WSError"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("message"))
+            return (self).message
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+WSError.unlazy_statics
+
+def self.WSHandler; WSHandler; end
+class WSHandler < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_WSHandler_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Called when the WebSocket is first created.
+
+    def onWSInit(socket)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket connects successfully.
+
+    def onWSConnected(socket)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket receives a message.
+
+    def onWSMessage(socket, message)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket receives a binary message.
+
+    def onWSBinary(socket, message)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket disconnects cleanly.
+
+    def onWSClosed(socket)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket disconnects with an error, or fails to connect.
+
+    def onWSError(socket, error)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket is done with life, one way or another.
+
+    def onWSFinal(socket)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WSHandler.unlazy_statics
+
+def self.WebSocket; WebSocket; end
+class WebSocket < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_WebSocket_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def send(message)
+        raise NotImplementedError, '`WebSocket.send` is an abstract method'
+
+        nil
+    end
+
+    def sendBinary(bytes)
+        raise NotImplementedError, '`WebSocket.sendBinary` is an abstract method'
+
+        nil
+    end
+
+    def close()
+        raise NotImplementedError, '`WebSocket.close` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WebSocket.unlazy_statics
+
+def self.WSServlet; WSServlet; end
+##
+# Websocket servlet
+
+class WSServlet < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_WSServlet_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # called for each new incoming WebSocket connection
+
+    def onWSConnect(upgrade_request)
+        
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.WSHandler }
+
+        nil
+    end
+
+    def serveWS(url)
+        
+        ::Quark.quark.concurrent.Context.runtime().serveWS(url, self)
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WSServlet.unlazy_statics
+
+
+
+def self.URL; URL; end
+##
+# A URL class.
+
+class URL < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :scheme, :host, :port, :path
+    extend ::DatawireQuarkCore::Static
+
+    static quark_URL_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def self.parse(url)
+        
+        result = ::Quark.quark.URL.new()
+        if ((url) == (nil))
+            return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.URL }
+        end
+        parts = nil
+        remaining = nil
+        idx = ((url).index("://") or -1)
+        if ((idx) >= (0))
+            (result).scheme = (url)[(0)...(idx)]
+            remaining = (url)[((idx) + (3))...((url).size)]
+        else
+            remaining = url
+        end
+        firstSlash = ((remaining).index("/") or -1)
+        if ((firstSlash) == (0))
+            (result).path = remaining
+            return result
+        end
+        if ((firstSlash) < (0))
+            firstSlash = (remaining).size
+        else
+            (result).path = (remaining)[(firstSlash)...((remaining).size)]
+        end
+        idx = ((remaining).index(":") or -1)
+        if ((idx) > (firstSlash))
+            (result).host = (remaining)[(0)...(firstSlash)]
+        else
+            if ((idx) >= (0))
+                (result).host = (remaining)[(0)...(idx)]
+                (result).port = (remaining)[((idx) + (1))...(firstSlash)]
+            else
+                (result).host = (remaining)[(0)...(firstSlash)]
+            end
+        end
+        return result
+
+        nil
+    end
+
+    def toString()
+        
+        result = ""
+        if ((@scheme) != (nil))
+            result = (@scheme) + ("://")
+        end
+        if ((@host) != (nil))
+            result = (result) + (@host)
+        end
+        if ((@port) != (nil))
+            result = ((result) + (":")) + (@port)
+        end
+        if ((@path) != (nil))
+            result = (result) + (@path)
+        end
+        return result
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.URL"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("scheme"))
+            return (self).scheme
+        end
+        if ((name) == ("host"))
+            return (self).host
+        end
+        if ((name) == ("port"))
+            return (self).port
+        end
+        if ((name) == ("path"))
+            return (self).path
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("scheme"))
+            (self).scheme = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("host"))
+            (self).host = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("port"))
+            (self).port = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("path"))
+            (self).path = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.scheme = nil
+        self.host = nil
+        self.port = nil
+        self.path = nil
+
+        nil
+    end
+
+
+end
+URL.unlazy_statics
+
+
+
+
+
+
+
+def self._ChainPromise; ChainPromise; end
+class ChainPromise < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_next
+    extend ::DatawireQuarkCore::Static
+
+    static quark__ChainPromise_ref: -> { nil }
+
+
+
+    def initialize(next_)
+        
+        self.__init_fields__
+        (self)._next = next_
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        
+        ::Quark.quark._CallbackEvent.fullfilPromise((self)._next, arg)
+        return nil
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._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.quark.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, :_callback
+    extend ::DatawireQuarkCore::Static
+
+    static quark__CallbackEvent_ref: -> { nil }
+
+
+
+    def initialize(callable, next_, value, callback)
+        
+        self.__init_fields__
+        (self)._callable = callable
+        (self)._next = next_
+        (self)._value = value
+        (self)._callback = callback
+
+        nil
+    end
+
+
+
+
+    def getContext()
+        
+        return (self)._callback
+
+        nil
+    end
+
+    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 fireEvent()
+        
+        result = ((self)._callable).call((self)._value)
+        if (::Quark.quark.reflect.QuarkClass.get("quark.Promise").hasInstance(result))
+            toChain = ::DatawireQuarkCore.cast(result) { ::Quark.quark.Promise }
+            toChain.andFinally(::Quark.quark._ChainPromise.new((self)._next))
+        else
+            ::Quark.quark._CallbackEvent.fullfilPromise((self)._next, result)
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._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
+        if ((name) == ("_callback"))
+            return (self)._callback
+        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.quark.Promise }
+        end
+        if ((name) == ("_value"))
+            (self)._value = value
+        end
+        if ((name) == ("_callback"))
+            (self)._callback = ::DatawireQuarkCore.cast(value) { ::Quark.quark._Callback }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._callable = nil
+        self._next = nil
+        self._value = nil
+        self._callback = nil
+
+        nil
+    end
+
+
+end
+CallbackEvent.unlazy_statics
+
+def self._Callback; Callback; end
+class Callback < ::Quark.quark.concurrent.EventContext
+    attr_accessor :_callable, :_next
+    extend ::DatawireQuarkCore::Static
+
+    static quark__Callback_ref: -> { nil }
+
+
+
+    def initialize(callable, next_)
+        
+        super()
+        (self)._callable = callable
+        (self)._next = next_
+
+        nil
+    end
+
+
+
+
+    def call(result)
+        
+        event = ::Quark.quark._CallbackEvent.new((self)._callable, (self)._next, result, self)
+        (self.getContext()).collector.put(event)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._Callback"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        if ((name) == ("_callable"))
+            return (self)._callable
+        end
+        if ((name) == ("_next"))
+            return (self)._next
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("_callable"))
+            (self)._callable = ::DatawireQuarkCore.cast(value) { ::Quark.quark.UnaryCallable }
+        end
+        if ((name) == ("_next"))
+            (self)._next = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Promise }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        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 quark__Passthrough_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        
+        return arg
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._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 quark__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 "quark._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 quark_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 "quark.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
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark__Callback__ref: -> { nil }
+    static quark_Promise_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        self.__init_fields__
+        (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)
+        
+        result = ::Quark.quark.Promise.new()
+        (self)._lock.acquire()
+        ((self)._successCallbacks) << (::Quark.quark._Callback.new(callable, result))
+        ((self)._failureCallbacks) << (::Quark.quark._Callback.new(::Quark.quark._Passthrough.new(), result))
+        (self)._lock.release()
+        self._maybeRunCallbacks()
+        return result
+
+        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)
+        
+        result = ::Quark.quark.Promise.new()
+        callback = ::Quark.quark._Callback.new(::Quark.quark._CallIfIsInstance.new(callable, errorClass), result)
+        (self)._lock.acquire()
+        ((self)._failureCallbacks) << (callback)
+        ((self)._successCallbacks) << (::Quark.quark._Callback.new(::Quark.quark._Passthrough.new(), result))
+        (self)._lock.release()
+        self._maybeRunCallbacks()
+        return result
+
+        nil
+    end
+
+    ##
+    # Two callbacks, one for success and one for error results.
+
+    def andEither(success, failure)
+        
+        result = ::Quark.quark.Promise.new()
+        (self)._lock.acquire()
+        ((self)._successCallbacks) << (::Quark.quark._Callback.new(success, result))
+        ((self)._failureCallbacks) << (::Quark.quark._Callback.new(failure, result))
+        (self)._lock.release()
+        self._maybeRunCallbacks()
+        return result
+
+        nil
+    end
+
+    ##
+    # Callback that will be called for both success and error results.
+
+    def andFinally(callable)
+        
+        return self.andEither(callable, callable)
+
+        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.quark.PromiseValue.new((self)._successResult, (self)._failureResult, (self)._hasResult)
+        (self)._lock.release()
+        return result
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.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
+        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
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._lock = nil
+        self._successResult = nil
+        self._failureResult = nil
+        self._hasResult = nil
+        self._successCallbacks = nil
+        self._failureCallbacks = nil
+
+        nil
+    end
+
+
+end
+Promise.unlazy_statics
+
+def self.PromiseFactory; PromiseFactory; end
+##
+# Create Promises and input their initial value. Should typically only be used by Quark standard library.
+
+class PromiseFactory < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :promise
+    extend ::DatawireQuarkCore::Static
+
+    static quark_PromiseFactory_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        self.__init_fields__
+        (self).promise = ::Quark.quark.Promise.new()
+
+        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 "quark.PromiseFactory"
+
+        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.quark.Promise }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.promise = nil
+
+        nil
+    end
+
+
+end
+PromiseFactory.unlazy_statics
+
+def self._BoundMethod; BoundMethod; end
+class BoundMethod < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :target, :method, :additionalArgs
+    extend ::DatawireQuarkCore::Static
+
+    static quark__BoundMethod_ref: -> { nil }
+
+
+
+    def initialize(target, methodName, additionalArgs)
+        
+        self.__init_fields__
+        (self).target = target
+        (self).method = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(target)).getMethod(methodName)
+        (self).additionalArgs = additionalArgs
+
+        nil
+    end
+
+
+
+
+    def call(arg)
+        
+        args = ::Quark.quark.ListUtil.new().slice(@additionalArgs, 0, (@additionalArgs).size)
+        (args).insert((0), (arg))
+        return (self).method.invoke((self).target, args)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._BoundMethod"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("target"))
+            return (self).target
+        end
+        if ((name) == ("method"))
+            return (self).method
+        end
+        if ((name) == ("additionalArgs"))
+            return (self).additionalArgs
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("target"))
+            (self).target = value
+        end
+        if ((name) == ("method"))
+            (self).method = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.Method }
+        end
+        if ((name) == ("additionalArgs"))
+            (self).additionalArgs = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.target = nil
+        self.method = nil
+        self.additionalArgs = nil
+
+        nil
+    end
+
+
+end
+BoundMethod.unlazy_statics
+
+
+def self._IOScheduleTask; IOScheduleTask; end
+class IOScheduleTask < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :factory
+    extend ::DatawireQuarkCore::Static
+
+    static quark__IOScheduleTask_ref: -> { nil }
+
+
+
+    def initialize(factory)
+        
+        self.__init_fields__
+        (self).factory = factory
+
+        nil
+    end
+
+
+
+
+    def onExecute(runtime)
+        
+        (self).factory.resolve(true)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._IOScheduleTask"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("factory"))
+            return (self).factory
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("factory"))
+            (self).factory = ::DatawireQuarkCore.cast(value) { ::Quark.quark.PromiseFactory }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.factory = nil
+
+        nil
+    end
+
+
+end
+IOScheduleTask.unlazy_statics
+
+def self._IOHTTPHandler; IOHTTPHandler; end
+class IOHTTPHandler < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :factory
+    extend ::DatawireQuarkCore::Static
+
+    static quark__IOHTTPHandler_ref: -> { nil }
+
+
+
+    def initialize(factory)
+        
+        self.__init_fields__
+        (self).factory = factory
+
+        nil
+    end
+
+
+
+
+    def onHTTPInit(request)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPFinal(request)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPResponse(request, response)
+        
+        (self).factory.resolve(response)
+
+        nil
+    end
+
+    def onHTTPError(request, message)
+        
+        (self).factory.reject(message)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark._IOHTTPHandler"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("factory"))
+            return (self).factory
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("factory"))
+            (self).factory = ::DatawireQuarkCore.cast(value) { ::Quark.quark.PromiseFactory }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.factory = nil
+
+        nil
+    end
+
+
+end
+IOHTTPHandler.unlazy_statics
+
+def self.IO; IO; end
+##
+# Promise-based I/O and scheduling APIs.
+
+class IO < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_IO_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Send a HTTP request, get back Promise that gets HTTPResponse or HTTPError result.
+
+    def self.httpRequest(request)
+        
+        factory = ::Quark.quark.PromiseFactory.new()
+        ::Quark.quark.concurrent.Context.runtime().request(request, ::Quark.quark._IOHTTPHandler.new(factory))
+        return (factory).promise
+
+        nil
+    end
+
+    ##
+    # Schedule a callable to run in the future, return Promise with null result.
+
+    def self.schedule(delayInSeconds)
+        
+        factory = ::Quark.quark.PromiseFactory.new()
+        ::Quark.quark.concurrent.Context.runtime().schedule(::Quark.quark._IOScheduleTask.new(factory), delayInSeconds)
+        return (factory).promise
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.IO"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+IO.unlazy_statics
+end # module Quark
+end # module Quark