datawire_mdk 2.0.5

data/lib/quark/concurrent.rb

@@ -0,0 +1,1250 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.concurrent; Concurrent; end
+module Concurrent
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+require_relative 'error' # 1 () ()
+require_relative '../quark' # 0 () ('quark',)
+require_relative 'spi' # 1 () ()
+
+
+def self.Event; Event; end
+##
+# The contract between event implementations and Collector
+
+class Event < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_Event_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getContext()
+        raise NotImplementedError, '`Event.getContext` is an abstract method'
+
+        nil
+    end
+
+    def fireEvent()
+        raise NotImplementedError, '`Event.fireEvent` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Event.unlazy_statics
+
+def self.FutureListener; FutureListener; end
+##
+# event handler for a future completion
+
+class FutureListener < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_FutureListener_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onFuture(future)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+FutureListener.unlazy_statics
+
+def self.FutureCompletion; FutureCompletion; end
+##
+# internal class that binds a listener to a future
+
+class FutureCompletion < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :future, :listener
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_FutureCompletion_ref: -> { nil }
+
+
+
+    def initialize(future, listener)
+        
+        self.__init_fields__
+        (self).future = future
+        (self).listener = listener
+
+        nil
+    end
+
+
+
+
+    def getContext()
+        
+        return (self).future
+
+        nil
+    end
+
+    def fireEvent()
+        
+        (self).listener.onFuture((self).future)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.FutureCompletion"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("future"))
+            return (self).future
+        end
+        if ((name) == ("listener"))
+            return (self).listener
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("future"))
+            (self).future = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Future }
+        end
+        if ((name) == ("listener"))
+            (self).listener = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.FutureListener }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.future = nil
+        self.listener = nil
+
+        nil
+    end
+
+
+end
+FutureCompletion.unlazy_statics
+
+def self.EventContext; EventContext; end
+##
+# Captures the current context, base class for all event source implementations
+
+class EventContext < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_context
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_EventContext_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        self.__init_fields__
+        (self)._context = ::Quark.quark.concurrent.Context.current()
+
+        nil
+    end
+
+
+
+
+    def getContext()
+        
+        return (self)._context
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.EventContext"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._context = nil
+
+        nil
+    end
+
+
+end
+EventContext.unlazy_statics
+
+def self.Future; Future; end
+##
+# The base class for value objects
+
+class Future < ::Quark.quark.concurrent.EventContext
+    attr_accessor :_finished, :_error, :_callbacks, :_lock
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark_concurrent_FutureCompletion__ref: -> { nil }
+    static quark_concurrent_Future_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+        (self)._finished = false
+        (self)._callbacks = ::DatawireQuarkCore.cast(nil) { ::DatawireQuarkCore::List }
+        (self)._lock = ::DatawireQuarkCore::Lock.new()
+
+        nil
+    end
+
+
+
+
+    def onFinished(callback)
+        
+        (self)._lock.acquire()
+        if ((self)._finished)
+            ((self)._context).collector.put(::Quark.quark.concurrent.FutureCompletion.new(self, callback))
+        else
+            if (((self)._callbacks) == (nil))
+                (self)._callbacks = ::DatawireQuarkCore::List.new([])
+            end
+            ((self)._callbacks) << (::Quark.quark.concurrent.FutureCompletion.new(self, callback))
+        end
+        (self)._lock.release()
+
+        nil
+    end
+
+    def finish(error)
+        
+        callbacks = ::DatawireQuarkCore.cast(nil) { ::DatawireQuarkCore::List }
+        (self)._lock.acquire()
+        if (!((self)._finished))
+            (self)._finished = true
+            (self)._error = error
+            callbacks = (self)._callbacks
+            (self)._callbacks = ::DatawireQuarkCore.cast(nil) { ::DatawireQuarkCore::List }
+        end
+        (self)._lock.release()
+        if ((callbacks) != (nil))
+            i = 0
+            while ((i) < ((callbacks).size)) do
+                ((self)._context).collector.put((callbacks)[i])
+                i = (i) + (1)
+            end
+        end
+
+        nil
+    end
+
+    def isFinished()
+        
+        (self)._lock.acquire()
+        finished = (self)._finished
+        (self)._lock.release()
+        return finished
+
+        nil
+    end
+
+    def getError()
+        
+        (self)._lock.acquire()
+        error = (self)._error
+        (self)._lock.release()
+        return error
+
+        nil
+    end
+
+    def await(timeout)
+        
+        ::Quark.quark.concurrent.FutureWait.new().wait(self, timeout)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.Future"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        if ((name) == ("_finished"))
+            return (self)._finished
+        end
+        if ((name) == ("_error"))
+            return (self)._error
+        end
+        if ((name) == ("_callbacks"))
+            return (self)._callbacks
+        end
+        if ((name) == ("_lock"))
+            return (self)._lock
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("_finished"))
+            (self)._finished = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_error"))
+            (self)._error = ::DatawireQuarkCore.cast(value) { ::Quark.quark.error.Error }
+        end
+        if ((name) == ("_callbacks"))
+            (self)._callbacks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_lock"))
+            (self)._lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self._finished = nil
+        self._error = nil
+        self._callbacks = nil
+        self._lock = nil
+
+        nil
+    end
+
+
+end
+Future.unlazy_statics
+
+def self.FutureWait; FutureWait; end
+##
+# Synchronization point for a Future.)
+
+class FutureWait < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_lock, :_future
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_FutureWait_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        self.__init_fields__
+        (self)._lock = ::DatawireQuarkCore::Condition.new()
+        (self)._future = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.concurrent.Future }
+
+        nil
+    end
+
+
+
+
+    def wait(future, timeout)
+        
+        if (future.isFinished())
+            return
+        end
+        (self)._future = future
+        (self)._future.onFinished(self)
+        rounded = ((1000.0) * (timeout)).round()
+        deadline = (::Quark.quark.now()) + (rounded)
+        while (!((self)._future.isFinished())) do
+            remaining = (deadline) - (::Quark.quark.now())
+            if ((rounded) != (0))
+                if ((remaining) <= ((0)))
+                    break
+                end
+            else
+                remaining = (3141)
+            end
+            (self)._lock.acquire()
+            (self)._lock.waitWakeup(remaining)
+            (self)._lock.release()
+        end
+        (self)._future = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.concurrent.Future }
+
+        nil
+    end
+
+    def onFuture(future)
+        
+        (self)._lock.acquire()
+        (self)._lock.wakeup()
+        (self)._lock.release()
+
+        nil
+    end
+
+    def self.waitFor(future, timeout)
+        
+        if (false)
+            w = ::Quark.quark.concurrent.FutureWait.new()
+            w.wait(future, timeout)
+            if (!(future.isFinished()))
+                nil
+            end
+        end
+        return future
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.FutureWait"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_lock"))
+            return (self)._lock
+        end
+        if ((name) == ("_future"))
+            return (self)._future
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_lock"))
+            (self)._lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Condition }
+        end
+        if ((name) == ("_future"))
+            (self)._future = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Future }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._lock = nil
+        self._future = nil
+
+        nil
+    end
+
+
+end
+FutureWait.unlazy_statics
+
+def self.Queue; Queue; end
+##
+# A simple FIFO
+
+class Queue < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :items, :head, :tail
+
+
+
+    def initialize()
+        
+        self.__init_fields__
+        (self).items = ::DatawireQuarkCore::List.new()
+        (self).head = 0
+        (self).tail = 0
+
+        nil
+    end
+
+
+
+
+    def put(item)
+        
+        if (((self).tail) < (((self).items).size))
+            ((self).items)[(self).tail] = (item)
+        else
+            ((self).items) << (item)
+        end
+        (self).tail = ((self).tail) + (1)
+
+        nil
+    end
+
+    def get()
+        
+        item = ::DatawireQuarkCore.cast(nil) { ::Quark.T }
+        if (((self).head) < ((self).tail))
+            item = ((self).items)[(self).head]
+            (self).head = ((self).head) + (1)
+        else
+            if (((self).head) > (0))
+                (self).head = 0
+                (self).tail = 0
+            end
+        end
+        return item
+
+        nil
+    end
+
+    def size()
+        
+        return ((self).tail) - ((self).head)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.Queue<quark.Object>"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("items"))
+            return (self).items
+        end
+        if ((name) == ("head"))
+            return (self).head
+        end
+        if ((name) == ("tail"))
+            return (self).tail
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("items"))
+            (self).items = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("head"))
+            (self).head = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("tail"))
+            (self).tail = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.items = nil
+        self.head = nil
+        self.tail = nil
+
+        nil
+    end
+
+
+end
+
+def self.CollectorExecutor; CollectorExecutor; end
+##
+# Fire events one by one with no locks held
+
+class CollectorExecutor < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :events, :collector
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_Queue_quark_concurrent_Event__ref: -> { nil }
+    static quark_concurrent_CollectorExecutor_ref: -> { nil }
+
+
+
+    def initialize(collector)
+        
+        self.__init_fields__
+        (self).events = ::Quark.quark.concurrent.Queue.new()
+        (self).collector = collector
+
+        nil
+    end
+
+
+
+
+    def _start()
+        
+        (self).events = (self).collector._swap((self).events)
+        if (((self).events.size()) > (0))
+            ::Quark.quark.concurrent.Context.runtime().schedule(self, 0.0)
+        end
+
+        nil
+    end
+
+    def onExecute(runtime)
+        
+        next_ = (self).events.get()
+        old = ::Quark.quark.concurrent.Context.current()
+        while ((next_) != (nil)) do
+            ::Quark.quark.concurrent.Context.swap(next_.getContext().getContext())
+            next_.fireEvent()
+            next_ = (self).events.get()
+        end
+        ::Quark.quark.concurrent.Context.swap(old)
+        (self).collector._poll()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.CollectorExecutor"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("events"))
+            return (self).events
+        end
+        if ((name) == ("collector"))
+            return (self).collector
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("events"))
+            (self).events = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Queue }
+        end
+        if ((name) == ("collector"))
+            (self).collector = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Collector }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.events = nil
+        self.collector = nil
+
+        nil
+    end
+
+
+end
+CollectorExecutor.unlazy_statics
+
+def self.Collector; Collector; end
+##
+# An active queue of events. Each event will fire sequentially, one by one. Multiple instances of Collector are not serialized with eachother and may run in parallel.
+
+class Collector < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :lock, :pending, :executor, :idle
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_Collector_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        self.__init_fields__
+        (self).lock = ::DatawireQuarkCore::Lock.new()
+        (self).pending = ::Quark.quark.concurrent.Queue.new()
+        (self).executor = ::Quark.quark.concurrent.CollectorExecutor.new(self)
+        (self).idle = true
+
+        nil
+    end
+
+
+
+
+    def put(event)
+        
+        (self).lock.acquire()
+        (self).pending.put(event)
+        if ((self).idle)
+            (self).executor._start()
+        end
+        (self).lock.release()
+
+        nil
+    end
+
+    def _swap(drained)
+        
+        pending = (self).pending
+        (self).idle = (pending.size()) == (0)
+        (self).pending = drained
+        return pending
+
+        nil
+    end
+
+    def _poll()
+        
+        (self).lock.acquire()
+        (self).executor._start()
+        (self).lock.release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.Collector"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("lock"))
+            return (self).lock
+        end
+        if ((name) == ("pending"))
+            return (self).pending
+        end
+        if ((name) == ("executor"))
+            return (self).executor
+        end
+        if ((name) == ("idle"))
+            return (self).idle
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("lock"))
+            (self).lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("pending"))
+            (self).pending = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Queue }
+        end
+        if ((name) == ("executor"))
+            (self).executor = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.CollectorExecutor }
+        end
+        if ((name) == ("idle"))
+            (self).idle = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.lock = nil
+        self.pending = nil
+        self.executor = nil
+        self.idle = nil
+
+        nil
+    end
+
+
+end
+Collector.unlazy_statics
+
+def self.TimeoutListener; TimeoutListener; end
+##
+# Timeout expiry handler
+
+class TimeoutListener < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_TimeoutListener_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onTimeout(timeout)
+        raise NotImplementedError, '`TimeoutListener.onTimeout` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+TimeoutListener.unlazy_statics
+
+def self.TimeoutExpiry; TimeoutExpiry; end
+##
+# Timeout expiry event
+
+class TimeoutExpiry < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :timeout, :listener
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_TimeoutExpiry_ref: -> { nil }
+
+
+
+    def initialize(timeout, listener)
+        
+        self.__init_fields__
+        (self).timeout = timeout
+        (self).listener = listener
+
+        nil
+    end
+
+
+
+
+    def getContext()
+        
+        return (self).timeout
+
+        nil
+    end
+
+    def fireEvent()
+        
+        (self).listener.onTimeout((self).timeout)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.TimeoutExpiry"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("timeout"))
+            return (self).timeout
+        end
+        if ((name) == ("listener"))
+            return (self).listener
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("timeout"))
+            (self).timeout = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Timeout }
+        end
+        if ((name) == ("listener"))
+            (self).listener = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.TimeoutListener }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.timeout = nil
+        self.listener = nil
+
+        nil
+    end
+
+
+end
+TimeoutExpiry.unlazy_statics
+
+def self.Timeout; Timeout; end
+##
+# Timeout
+
+class Timeout < ::Quark.quark.concurrent.EventContext
+    attr_accessor :timeout, :lock, :listener
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_Timeout_ref: -> { nil }
+
+
+
+    def initialize(timeout)
+        
+        super()
+        (self).timeout = timeout
+        (self).listener = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.concurrent.TimeoutListener }
+        (self).lock = ::DatawireQuarkCore::Lock.new()
+
+        nil
+    end
+
+
+
+
+    def start(listener)
+        
+        (self).listener = listener
+        delay = (self).timeout
+        ::Quark.quark.concurrent.Context.runtime().schedule(self, delay)
+
+        nil
+    end
+
+    def cancel()
+        
+        (self).lock.acquire()
+        (self).listener = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.concurrent.TimeoutListener }
+        (self).lock.release()
+
+        nil
+    end
+
+    def onExecute(runtime)
+        
+        (self).lock.acquire()
+        if (((self).listener) != (nil))
+            ((self)._context).collector.put(::Quark.quark.concurrent.TimeoutExpiry.new(self, (self).listener))
+            (self).listener = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.concurrent.TimeoutListener }
+        end
+        (self).lock.release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.Timeout"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        if ((name) == ("timeout"))
+            return (self).timeout
+        end
+        if ((name) == ("lock"))
+            return (self).lock
+        end
+        if ((name) == ("listener"))
+            return (self).listener
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("timeout"))
+            (self).timeout = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("lock"))
+            (self).lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("listener"))
+            (self).listener = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.TimeoutListener }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.timeout = nil
+        self.lock = nil
+        self.listener = nil
+
+        nil
+    end
+
+
+end
+Timeout.unlazy_statics
+
+def self.TLSContextInitializer; TLSContextInitializer; end
+##
+# internal
+
+class TLSContextInitializer < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_concurrent_TLSContextInitializer_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getValue()
+        
+        return ::Quark.quark.concurrent.Context.new(::Quark.quark.concurrent.Context.global())
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.TLSContextInitializer"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+TLSContextInitializer.unlazy_statics
+
+def self.Context; Context; end
+##
+# The logical stack for async stuff.
+
+class Context < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_parent, :_runtime, :collector
+    extend ::DatawireQuarkCore::Static
+
+    static _global: -> { nil }
+    static _current: -> { ::DatawireQuarkCore::TLS.new(::Quark.quark.concurrent.TLSContextInitializer.new()) }
+    static quark_concurrent_Context_ref: -> { nil }
+
+
+
+    def initialize(parent)
+        
+        self.__init_fields__
+        (self)._parent = parent
+        if ((parent) == (nil))
+            (self)._runtime = ::Quark.quark.spi.RuntimeFactory.factory.makeRuntime()
+            (self).collector = ::Quark.quark.concurrent.Collector.new()
+        else
+            (self)._runtime = (parent)._runtime
+            (self).collector = (parent).collector
+        end
+
+        nil
+    end
+
+
+
+
+    def self.current()
+        
+        return ::Quark.quark.concurrent.Context._current.getValue()
+
+        nil
+    end
+
+    def self.global()
+        
+        if ((::Quark.quark.concurrent.Context._global) == (nil))
+            ::Quark.quark.concurrent.Context._global = ::Quark.quark.concurrent.Context.new(nil)
+        end
+        return ::Quark.quark.concurrent.Context._global
+
+        nil
+    end
+
+    def self.runtime()
+        
+        return (::Quark.quark.concurrent.Context.current())._runtime
+
+        nil
+    end
+
+    def self.swap(c)
+        
+        ::Quark.quark.concurrent.Context._current.setValue(c)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.concurrent.Context"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_global"))
+            return ::Quark.quark.concurrent.Context._global
+        end
+        if ((name) == ("_current"))
+            return ::Quark.quark.concurrent.Context._current
+        end
+        if ((name) == ("_parent"))
+            return (self)._parent
+        end
+        if ((name) == ("_runtime"))
+            return (self)._runtime
+        end
+        if ((name) == ("collector"))
+            return (self).collector
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_global"))
+            ::Quark.quark.concurrent.Context._global = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("_current"))
+            ::Quark.quark.concurrent.Context._current = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
+        end
+        if ((name) == ("_parent"))
+            (self)._parent = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("_runtime"))
+            (self)._runtime = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Runtime }
+        end
+        if ((name) == ("collector"))
+            (self).collector = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Collector }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._parent = nil
+        self._runtime = nil
+        self.collector = nil
+
+        nil
+    end
+
+
+end
+Context.unlazy_statics
+end # module Concurrent
+end # module Quark
+end # module Quark