datawire_mdk 2.0.5

data/lib/mdk_runtime/actors.rb

@@ -0,0 +1,457 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_runtime; MdkRuntime; end
+module MdkRuntime
+def self.actors; Actors; end
+module Actors
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_runtime',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_runtime',)
+require_relative '../quark' # 0 () ('mdk_runtime',)
+require_relative '../quark/concurrent' # 0 ('quark',) ('mdk_runtime',)
+
+
+def self.Actor; Actor; end
+##
+# A store of some state. Emits events and handles events.
+
+class Actor < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_actors_Actor_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # The Actor should start operating.
+
+    def onStart(dispatcher)
+        raise NotImplementedError, '`Actor.onStart` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # The Actor should begin shutting down.
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called on incoming one-way message from another actor sent via tell().
+
+    def onMessage(origin, message)
+        raise NotImplementedError, '`Actor.onMessage` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Actor.unlazy_statics
+
+def self._QueuedMessage; QueuedMessage; end
+##
+# A message that can be queued for delivery in a MessageDispatcher.
+
+class QueuedMessage < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_actors__QueuedMessage_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def deliver()
+        raise NotImplementedError, '`_QueuedMessage.deliver` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+QueuedMessage.unlazy_statics
+
+def self._InFlightMessage; InFlightMessage; end
+##
+# A message that queued for delivery by a MessageDispatcher.
+
+class InFlightMessage < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :origin, :msg, :destination
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_actors__InFlightMessage_ref: -> { nil }
+
+
+
+    def initialize(origin, msg, destination)
+        
+        self.__init_fields__
+        (self).origin = origin
+        (self).msg = msg
+        (self).destination = destination
+
+        nil
+    end
+
+
+
+
+    ##
+    # Deliver the message.
+
+    def deliver()
+        
+        (self).destination.onMessage((self).origin, (self).msg)
+
+        nil
+    end
+
+    def toString()
+        
+        return (((((("{") + ((@origin).to_s)) + ("->")) + ((@destination).to_s)) + (": ")) + ((@msg).to_s)) + ("}")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.actors._InFlightMessage"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("origin"))
+            return (self).origin
+        end
+        if ((name) == ("msg"))
+            return (self).msg
+        end
+        if ((name) == ("destination"))
+            return (self).destination
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("origin"))
+            (self).origin = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("msg"))
+            (self).msg = value
+        end
+        if ((name) == ("destination"))
+            (self).destination = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.origin = nil
+        self.msg = nil
+        self.destination = nil
+
+        nil
+    end
+
+
+end
+InFlightMessage.unlazy_statics
+
+def self._StartStopActor; StartStopActor; end
+##
+# Start or stop an Actor.
+
+class StartStopActor < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :actor, :dispatcher, :start
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_actors__StartStopActor_ref: -> { nil }
+
+
+
+    def initialize(actor, dispatcher, start)
+        
+        self.__init_fields__
+        (self).actor = actor
+        (self).dispatcher = dispatcher
+        (self).start = start
+
+        nil
+    end
+
+
+
+
+    def toString()
+        
+        result = "stopping"
+        if ((self).start)
+            result = "starting"
+        end
+        return ((result) + (" ")) + (((self).actor).to_s)
+
+        nil
+    end
+
+    def deliver()
+        
+        if ((self).start)
+            (self).actor.onStart((self).dispatcher)
+        else
+            (self).actor.onStop()
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.actors._StartStopActor"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("actor"))
+            return (self).actor
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("start"))
+            return (self).start
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("actor"))
+            (self).actor = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("start"))
+            (self).start = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.actor = nil
+        self.dispatcher = nil
+        self.start = nil
+
+        nil
+    end
+
+
+end
+StartStopActor.unlazy_statics
+
+def self.MessageDispatcher; MessageDispatcher; end
+##
+# Manage a group of related Actors.
+#
+# Each Actor should only be started and used by one MessageDispatcher.
+#
+# Reduce accidental re-entrancy by making sure messages are run asynchronously.
+#
+
+class MessageDispatcher < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :_queued, :_delivering, :_lock
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_runtime_actors__QueuedMessage__ref: -> { nil }
+    static mdk_runtime_actors_MessageDispatcher_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Queue a message from origin to destination, and trigger delivery if necessary.
+
+    def tell(origin, message, destination)
+        
+        inFlight = ::Quark.mdk_runtime.actors._InFlightMessage.new(origin, message, destination)
+        self._queue(inFlight)
+
+        nil
+    end
+
+    ##
+    # Start an Actor.
+
+    def startActor(actor)
+        
+        self._queue(::Quark.mdk_runtime.actors._StartStopActor.new(actor, self, true))
+
+        nil
+    end
+
+    ##
+    # Stop an Actor.
+
+    def stopActor(actor)
+        
+        self._queue(::Quark.mdk_runtime.actors._StartStopActor.new(actor, self, false))
+
+        nil
+    end
+
+    def _callQueuedMessage(ignore, message)
+        
+        message.deliver()
+        return true
+
+        nil
+    end
+
+    ##
+    # Queue a message for delivery.
+
+    def _queue(inFlight)
+        
+        @logger.debug(("Queued ") + ((inFlight).to_s))
+        (self)._lock.acquire()
+        ((self)._queued) << (inFlight)
+        if ((self)._delivering)
+            (self)._lock.release()
+            return
+        end
+        (self)._delivering = true
+        while ((((self)._queued).size) > (0)) do
+            toDeliver = (self)._queued
+            (self)._queued = ::DatawireQuarkCore::List.new([])
+            (self)._lock.release()
+            idx = 0
+            while ((idx) < ((toDeliver).size)) do
+                @logger.debug(("Delivering ") + (((toDeliver)[idx]).to_s))
+                deliver = ::Quark.quark._BoundMethod.new(self, "_callQueuedMessage", ::DatawireQuarkCore::List.new([(toDeliver)[idx]]))
+                ::Quark.quark.concurrent.Context.runtime().callSafely(deliver, false)
+                idx = (idx) + (1)
+            end
+            (self)._lock.acquire()
+        end
+        (self)._delivering = false
+        (self)._lock.release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.actors.MessageDispatcher"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("_queued"))
+            return (self)._queued
+        end
+        if ((name) == ("_delivering"))
+            return (self)._delivering
+        end
+        if ((name) == ("_lock"))
+            return (self)._lock
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("_queued"))
+            (self)._queued = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_delivering"))
+            (self)._delivering = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_lock"))
+            (self)._lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("actors")
+        self._queued = ::DatawireQuarkCore::List.new([])
+        self._delivering = false
+        self._lock = ::DatawireQuarkCore::Lock.new()
+
+        nil
+    end
+
+
+end
+MessageDispatcher.unlazy_statics
+end # module Actors
+end # module MdkRuntime
+end # module Quark