MINT-core 1.0.0

data/lib/MINT-core/mapping/complementary.rb

@@ -0,0 +1,100 @@
+module MINT
+
+
+  class ComplementaryCallMethod < ExecuteOnStateChange
+    def initialize(source_model,state,conditions,execute)
+      super(source_model,state,self.method(:executeWithConditions),nil)
+      @original_execute = execute
+      @conditions = conditions
+      p "initialized #{conditions.inspect}"
+    end
+
+    # TODO basic condition checker still without consideration of time span :-(
+    def checkConditions
+      p "in check AND cond #{@conditions.inspect}"
+      result = nil
+      @conditions.each do |model,state|
+        result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(state)}/)
+        if result.nil?
+          puts "Received #{@state} notify for model #{@source_model} but condition state #{state} of model #{model} not true"
+          return false
+        end
+      end
+      return result
+    end
+
+    def  executeWithConditions(result)
+      p "Catched "
+      result = checkConditions
+      if result
+        p "executing #{@original_execute} on #{result.inspect}"
+        @original_execute.call result
+      end
+    end
+
+  end
+
+  class ComplementarySendEvent< ComplementaryCallMethod
+    def initialize(source_model,state,conditions,execute)
+      super(source_model,state,conditions,execute)
+    end
+
+    def  executeWithConditions(result)
+      p "Catched "
+      result = checkConditions
+      if result
+        p "executing #{@original_execute} on #{result.inspect}"
+        p result.process_event(@original_execute)
+      end
+    end
+  end
+
+  class ComplementarySendEvents< ComplementaryCallMethod
+    def initialize(source_model,state,conditions,execute)
+      super(source_model,state,conditions,execute)
+    end
+
+    def  executeWithConditions(result)
+      publish_events(@original_execute)
+    end
+
+  end
+
+  class ComplementaryOR<ComplementarySendEvent
+    def initialize(source_model,state,conditions,execute)
+      super(source_model,state,conditions,execute)
+    end
+
+    def checkConditions
+      p "in check OR cond #{@conditions.inspect}"
+      result = nil
+      @conditions.each do |model,state|
+        state.each do |s|
+          result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(s)}/)
+          if not result.nil?
+            return result
+          end
+        end
+
+      end
+      return false
+    end
+  end
+
+  class ComplementaryMethodCall < ComplementarySendEvent
+    def initialize(source_model,state,conditions,execute,callback)
+      super(source_model,state,conditions,execute)
+      @callback= callback
+    end
+    def  executeWithConditions(result)
+      p "Catched "
+      result = checkConditions
+      if result
+        p "executing #{@orginal_execute} on #{result.inspect}"
+        r = result.process_event(@orginal_execute)
+        @callback.call r
+      end
+    end
+
+  end
+end

data/lib/MINT-core/mapping/mapping.rb

@@ -0,0 +1,47 @@
+module MINT
+
+  # Basic abstract class to define a mapping, which specifies a communication between model agents.
+  # Therefore ia mapping listens to a source model of another agents' model for actions like e.g. new elements,
+  # updates to elements or element removals.
+  #
+  class Mapping
+    attr_accessor :source_model, :on_action, :execute
+
+    # A mapping is initialized with
+    # @param [Class] source_model the other agents' model to listen to for events
+    # @param [String] action  to the tuple space that should be listened to. This is one of "take", "read", "write"
+    # @param [Method] execute this method of the agent that runs the mapping, the specified action has happened.
+    # @param [Method] inital method to call upon initialization of the mapping without the action to be happened, but scans the model for already happened events (write) and executes the method with these data.
+    #
+    def initialize (source_model,action,execute,initial=nil)
+      @source_model = source_model
+      @execute = execute
+      @initial = initial
+      @on_action = action
+    end
+
+    # Starts the mapping thread to listen to events
+    #
+    def execute
+      raise NotImplementedError, "#{self.class}#execute not implemented"
+    end
+
+    def publish_events(events)
+#      p "in check OR cond #{@conditions.inspect}"
+
+      events.each do |c,event|
+        c.each do |model,state|
+          state.each do |s|
+            result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(s)}/)
+            if not result.nil?
+              p "Sending #{event} to #{result.name}"
+              p result.inspect
+              p result.process_event(event)
+            end
+          end
+        end
+      end
+      true
+    end
+  end
+end

data/lib/MINT-core/mapping/on_state_change.rb

@@ -0,0 +1,65 @@
+
+module MINT
+
+  # Basic mapping that observes state changes of elements in a model agents model.
+  #
+  class ExecuteOnStateChange < Mapping
+    attr_reader :state
+
+    def initialize(source_model,state,execute, initial=nil)
+      super(source_model,"write",execute,initial)
+      if (not state.is_a? Array)
+        @state = [state.to_s]
+      else
+        @state = state.map &:to_s
+      end
+    end
+
+    def execute
+      # query existing state
+      if @initial
+        results = @source_model.all({ :abstract_states=> /(^|\|)#{Regexp.quote(@state.first)}/})
+        p "Found results by read: #{results.inspect}"
+        results.each do |result|
+          call_if_result_matches result, @initial
+        end
+      end
+      #register for further events
+      #observer = agent.storage.notify 'write', {"_model_"=> @source_model.to_s} + @conditions
+
+      p "registered for model #{@source_model} writes on state #{@state}"
+      @source_model.notify("write", {  :new_states=> /(^|\|)#{Regexp.quote(@state.first)}/},self.method(:check_cond))
+
+    end
+
+    def check_cond(result)
+      call_if_result_matches(result,@execute)
+    end
+
+    def call_if_result_matches(result,method)
+      return if not result
+      states_to_check = Array.new @state
+      states_to_check.shift # we already hav checked for the first state
+      states_to_check.each do |state|
+        return false if not result.abstract_states =~/(^|\|)#{Regexp.quote(state)}/
+      end
+      method.call result
+      true
+    end
+
+  end
+
+  class ExecuteEventOnStateChange < ExecuteOnStateChange
+    def initialize(source_model,state,selector,event)
+      super(source_model,state,self.method(:process_event),nil)
+      @selector = selector
+      @event = event
+    end
+
+    def process_event(result)
+      @selector.each do |element|
+        element.process_event(@event)
+      end
+    end
+  end
+end

data/lib/MINT-core/mapping/sequential.rb

@@ -0,0 +1,87 @@
+module MINT
+
+  # click_select_mapping = Sequential.new(HWButton,:pressed,HWButton,:released, 300, { AIINChoose  =>"focused"},:choose)
+
+  class Sequential < Mapping
+    def initialize(source_model_1,state_1,source_model_2,state_2, state_2_conditions, min_time, max_time, conditions, error_recovery = nil)
+      super(source_model_1,"write",nil,nil)
+      @source_model_1= source_model_1
+      @state_1= state_1
+      @source_model_2= source_model_2
+      @state_2= state_2
+      @max_time = max_time
+      @min_time = min_time
+      @conditions = conditions
+      @time_state_1_happened = nil
+      @state_2_conditions = state_2_conditions
+      @error_recovery = error_recovery
+    end
+
+    def execute
+      t1 = @source_model_1.notify("write", {  :new_states=> /(^|\|)#{Regexp.quote(@state_1)}/},self.method(:save_state_1_happened))
+      p "registered for model #{@source_model_1} writes on state #{@state_1}"
+      #    t2 = @source_model_2.notify("write", {  :abstract_states=> /#{Regexp.quote(@state_2)}/},self.method(:check_sequence))
+      #   p "registered for model #{@source_model_2} writes on state #{@state_2}"
+      return t1
+      #,t2
+    end
+
+    def check_sequence(result)
+      ms = ((Time.now-@time_state_1_happened)*1000).to_i
+      if @time_state_1_happened and ((@min_time<=ms and ms <=@max_time) or (@min_time == 0 and @max_time==0))
+        if (check_state_2_conditions)
+          p "Sequence #{@source_model_1}=#{@state_1} --> #{@source_model_2}= #{@state_2} PROCEEDED in #{ms} ms"
+
+          publish_events @conditions
+
+        else
+          p "Sequence #{@source_model_1}=#{@state_1} --> #{@source_model_2}= #{@state_2} FAILED #{ms}ms because of state 2 conditions "
+
+          publish_events @error_recovery if @error_recovery
+
+        end
+      else
+        p "Sequence #{@source_model_1}=#{@state_1} --> #{@source_model_2}= #{@state_2} FAILED #{ms}ms instead of min/max #{@min_time}/#{@max_time}ms"
+
+        publish_events @error_recovery if @error_recovery
+
+      end
+      @time_state_1_happened = nil
+    end
+
+    def check_state_2_conditions
+      return true if not @state_2_conditions
+      @state_2_conditions.each do |model,state|
+#        state.each do |s|
+        result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(state)}/)
+        if result.nil?
+          return false
+        end
+        #       end
+      end
+      true
+    end
+
+    def save_state_1_happened(result)
+      p "Sequence #{@source_model_1}=#{@state_1} OK! --> #{@source_model_2}= #{@state_2} "
+
+      @time_state_1_happened = Time.now
+#      p "State #{@state_1} of #{@source_model_1} occurred!"
+      if @max_time >0
+        @source_model_2.wait("write", {  :new_states=> /(^|\|)#{Regexp.quote(@state_2)}/},self.method(:check_sequence))
+        p "registered for model #{@source_model_2} writes on state #{@state_2}"
+      else
+        result = @source_model_2.first(:abstract_states=> /(^|\|)#{Regexp.quote(@state_2)}/)
+        if (result)
+          p "check seq"
+          check_sequence(result)
+        else
+          p "Sequence #{@source_model_1}=#{@state_1} --> #{@source_model_2}= #{@state_2} without time slot FAILED because of state 2 conditions"
+
+        end
+      end
+    end
+
+
+  end
+end

data/lib/MINT-core/model/aui/AIC.rb

@@ -0,0 +1,86 @@
+module MINT
+  class AIC < AIOUTDiscrete
+    #    belongs_to :task @TODO - Mappings unklar
+    has n, :childs, 'AIO',
+        :parent_key => [ :id ],      # local to this model (Blog)
+        :child_key  => [ :aic_id ]  # in the remote model (Post)
+    has 1, :entry, 'AIO'
+
+    def initialize_statemachine
+      super
+      parser = StatemachineParser.new(self)
+      @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aic.scxml"
+=begin
+@statemachine = Statemachine.build do
+        superstate :AIC do
+          trans :initialized,:organize, :organized
+          trans :organized, :present, :presenting
+          trans :organized, :suspend, :suspended
+          trans :suspended, :present, :presenting
+          trans :suspended, :organize, :organized
+
+          state :suspended do
+            on_entry :sync_cio_to_hidden
+          end
+
+          superstate :presenting do
+            on_entry [:inform_parent_presenting, :present_children]
+            on_exit :hide_children
+            event :suspend, :suspended
+
+            state :defocused do
+              on_entry :sync_cio_to_displayed
+            end
+            state :focused do
+              on_entry :sync_cio_to_highlighted
+            end
+            trans :defocused,:focus,:focused
+            trans :focused,:defocus, :defocused
+            trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
+            trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+            trans :focused, :parent, :defocused, :focus_parent
+            trans :focused, :child, :defocused, :focus_child
+
+          end
+        end
+      end
+=end
+    end
+
+    def hide_children
+      if (self.childs)
+        self.childs.each do |c|
+          c.process_event("suspend")
+        end
+
+      end
+    end
+
+    def present_children
+      if (self.childs)
+        self.childs.each do |c|
+          c.process_event("present")
+        end
+
+      end
+    end
+
+
+    def  focus_child
+      if (self.childs && self.childs.first)
+        self.childs.first.process_event("focus")
+      else
+        return nil # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+
+    # hook that is called from a child if it enters presenting state
+    def child_to_presenting(child)
+      true
+    end
+
+  end
+
+
+end

data/lib/MINT-core/model/aui/AIChoice.rb

@@ -0,0 +1,65 @@
+module MINT
+  class AIChoice < AIC
+    def initialize_statemachine
+      if @statemachine.blank?
+        parser = StatemachineParser.new(self)
+        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aichoice.scxml"
+=begin
+@statemachine = Statemachine.build do
+          trans :initialized,:organize, :organized
+          trans :organized, :present, :p_t
+          trans :organized, :suspend, :suspended
+          trans :suspended, :present, :p_t
+          trans :suspended, :organize, :organized
+          state :suspended do
+            on_entry :sync_cio_to_hidden
+          end
+
+          superstate :p_t do     # TODO artificial superstate required to get following event working!
+            event :suspend, :suspended
+            parallel :p do
+              statemachine :s1 do
+                superstate :presenting do
+                on_entry :present_children
+                on_exit :hide_children
+                  state :defocused do
+                    on_entry :sync_cio_to_displayed
+                  end
+                  state :focused do
+                    on_entry :sync_cio_to_highlighted
+                  end
+                  trans :defocused,:focus,:focused
+                  trans :focused,:defocus, :defocused
+                  trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
+                  trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+                  trans :focused, :parent, :defocused, :focus_parent
+                  trans :focused, :child, :defocused, :focus_child
+
+                end
+              end
+              statemachine :s2 do
+                superstate :l do
+                  trans :listing, :drop, :listing, :add_element, "In(:focused)"
+                end
+              end
+            end
+          end
+        end
+=end
+      @statemachine.reset
+      end
+    end
+    def add_element
+      #if self.is_in? :focused
+        f = AISingleChoiceElement.first(:new_states=> /#{Regexp.quote("dragging")}/)
+        self.childs << f
+        self.childs.save
+        f.process_event(:drop)
+        f.process_event(:focus)
+        self.process_event(:defocus)
+        f.destroy
+      #end
+    end
+  end
+
+end