MINT-core 1.0.1 → 2.0.0

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

@@ -0,0 +1,64 @@
+class NegationObservation < Observation
+
+  def check_true_at_startup(cb)
+    # check if observation is already true at startup
+    model = MINT::Interactor.class_from_channel_name(element)
+    e = model.get(name)
+    p "Error interactor #{name} of class #{model} is not available!" if e.nil?
+    e_states= e.states.map &:to_s
+    if e
+      if ((e_states & states).length == 0) and ((e.abstract_states.split('|') & states).length == 0)
+        cb.call element, true, result(MultiJson.decode e.to_json(:only => e.class::PUBLISH_ATTRIBUTES)),id
+        return true
+      end
+    end
+    return false
+  end
+
+  def start(observations_results,cb)
+    @observation_results=observations_results
+
+    res = false
+
+    res = check_true_at_startup(cb) if is_continuous? or is_instant?
+
+    if not res and is_instant? # instant checks do not require a subscribe and directly fail if false
+      fail(cb)
+      return self
+    end
+
+    return self if res and is_instant?
+
+    redis = RedisConnector.redis
+    @proc_observation = Proc.new { |key,message|
+      if @should_listen
+        found=MultiJson.decode message
+
+        if name.nil? or name.eql? found["name"]
+
+          if found.has_key? "new_states"
+            if (found["new_states"] & states).length==0 # checks if both arrays share no element
+
+              cb.call element, true , result(found),id
+            else
+              if (found["states"] & states).length > 0
+                cb.call element, false, {},id
+              end
+            end
+          end
+        end
+      end
+    }
+
+    if not    @cb_observation_has_subscribed
+      @should_listen = true
+      redis.pubsub.psubscribe("#{element}*",@proc_observation).callback {
+        @cb_observation_has_subscribed = true
+        call_subscribed_callbacks
+      }
+    end
+    self
+  end
+
+
+end

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

@@ -0,0 +1,219 @@
+class Observation
+
+  def initialize(parameters)
+    @observation = parameters
+
+    # state of subscription, to ensure that an observation only subscribes once
+    @cb_observation_has_subscribed = false
+
+    # defines if the ongoing subscription should act or has been temporary disabled using stop
+    @should_listen = false
+  end
+
+  def is_continuous?
+    @observation[:process].nil? or @observation[:process] == :continuous
+  end
+
+  def is_instant?
+    @observation[:process] == :instant
+  end
+
+  def is_onchange?
+    @observation[:process] == :onchange
+  end
+
+
+  def id
+    @observation[:id]
+  end
+
+  def element
+    @observation[:element]
+  end
+
+  def states
+    @observation[:states].map &:to_s
+  end
+
+  def resultName
+    @observation[:result]
+  end
+
+  def result(r)
+    if resultName and r
+      {resultName => r }
+    else
+      {}
+    end
+  end
+
+  def name
+    if @observation[:name] =~ /\./ # check if refers to variable used in sync mappings
+      selector = @observation[:name].split "."
+      variable = selector.shift
+      attributes = selector
+      if (@observation_results and @observation_results.has_key? variable)
+        interactor_data= @observation_results[variable]
+        interactor = MINT::Interactor.get(interactor_data["mint_model"],interactor_data["name"])
+
+        attributes.each do |attr|
+          interactor = interactor.method(attr).call
+        end
+        return interactor
+      end
+    else
+      return @observation[:name]
+    end
+  end
+
+  def check_true_at_startup(cb)
+    # check if observation is already true at startup
+    model = MINT::Interactor.class_from_channel_name(element)
+
+    results = nil
+    if (name)  # if a name is specified, query directly otherwise select by state and return the first one found
+      results = []
+      r =model.get(model.getModel,name)
+      return false if r.nil? # handles the case that the named interactor does not exist!
+      results << r
+    else
+      results = model.all
+    end
+
+    # if no states variable is set, there is no need to filter states
+    if states and states.length >0  and results.length > 0
+      r = results.find_all { |e|
+        ((e.states.map(&:to_s) & states).length>0) or ((e.abstract_states.split('|') & states).length>0)
+      }
+    else
+      r = results
+    end
+
+    if r.length > 0
+      if r.length ==1
+        cb.call element, true, result(MultiJson.decode r[0].to_json(:only => r[0].class::PUBLISH_ATTRIBUTES)),id
+      else
+        res = []
+        r.each do |e|
+          res << MultiJson.decode(e.to_json(:only => e.class::PUBLISH_ATTRIBUTES))
+        end
+
+        cb.call element, true, result(res),id
+      end
+
+      return true
+    else
+      return false
+    end
+
+  end
+
+  def stop
+    #   RedisConnector.redis.pubsub.unsubscribe_proc("#{element}",@proc_observation)
+    @should_listen = false
+    #@cb_observation_has_subscribed = false
+    @subscribed_callbacks = []
+  end
+
+  def fail(cb)
+    cb.call element, :fail , nil, id
+  end
+
+  def start(observations_results,cb)
+    @observation_results=observations_results
+
+    if @cb_observation_has_subscribed # restart!!
+      @should_listen = true
+
+      if is_instant?
+        fail(cb)  if not check_true_at_startup(cb)
+      elsif is_continuous?
+        check_true_at_startup(cb)
+      end
+      return self
+    end
+
+    @proc_observation_wo_name = Proc.new { |key, message|
+      if @should_listen
+        found=MultiJson.decode message
+        if name.nil? or name.eql? found["name"]
+          if found.has_key? "new_states"
+            if (found["new_states"] & states).length>0 # checks if both arrays share at least one element
+              cb.call element, true , result(found),id
+            else
+              if (found["states"] & states).length == 0
+                cb.call element, false, {},id
+              end
+            end
+          end
+        end
+      end
+    }
+
+    @proc_observation = Proc.new { |message|
+          if @should_listen
+            found=MultiJson.decode message
+              if found.has_key? "new_states"
+                if (found["new_states"] & states).length>0 # checks if both arrays share at least one element
+                  cb.call element, true , result(found),id
+                else
+                  if (found["states"] & states).length == 0
+                    cb.call element, false, {},id
+                  end
+                end
+              end
+          end
+        }
+
+    res = false
+
+    res = check_true_at_startup(cb) if is_continuous? or is_instant?
+
+    if not res and is_instant? # instant checks do not require a subscribe and directly fail if false
+      fail(cb)
+      return self
+    end
+
+    if not    @cb_observation_has_subscribed
+      @should_listen = true
+      redis = RedisConnector.redis
+
+      if (name)
+        redis.pubsub.subscribe("#{element}.#{name}",@proc_observation).callback { |count|
+          @cb_observation_has_subscribed = true
+          call_subscribed_callbacks
+        }
+      else
+        redis.pubsub.psubscribe("#{element}*",@proc_observation_wo_name).callback { |count|
+          @cb_observation_has_subscribed = true
+          call_subscribed_callbacks
+        }
+      end
+
+    end
+    self
+  end
+
+
+
+  # This callback is used to inform that the observation has been successfully subscribed
+  def is_subscribed_callback(&block)
+    return unless block
+
+    if @cb_observation_has_subscribed
+      block.call(self)
+    else
+      @subscribed_callbacks ||= []
+      @subscribed_callbacks.unshift block # << block
+    end
+  end
+
+  def call_subscribed_callbacks
+    @subscribed_callbacks ||= []
+    while cb = @subscribed_callbacks.pop
+      cb.call(self)
+    end
+    @subscribed_callbacks.clear if @subscribed_callbacks
+  end
+
+end

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

@@ -1,6 +1,6 @@
 module MINT
 
-  # click_select_mapping = Sequential.new(HWButton,:pressed,HWButton,:released, 300, { AIINChoose  =>"focused"},:choose)
+  # click_select_mapping = Sequential.new(HWButton,:pressed,HWButton,:released, 300, { AIChoiceElement  =>"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)
@@ -19,7 +19,6 @@ module MINT
 
     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

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

@@ -0,0 +1,60 @@
+module MINT
+  class SequentialMapping <  ComplementaryMapping
+
+    @active_observation = nil
+
+    def start_observations
+      @active_observation = 0
+
+      observations[@active_observation].start(@observation_results,self.method(:cb_activate_action)).is_subscribed_callback { |observation|
+        @observation_state[observation.element] = false
+        @state_callback.call(@mapping[:name], {:id => observation.id, :state => :activated}) if @state_callback
+        call_activated_callbacks
+      }
+    end
+
+    # function is called every time an observation has been fulfilled
+    def cb_activate_action(element,in_state,result,id)
+#      @state_callback.call(@mapping[:name], {:id => id, :state => in_state.to_s.to_sym}) if @state_callback
+      @state_callback.call(@mapping[:name], {:id => id, :element => element, :result => result, :state => in_state.to_s.to_sym}) if @state_callback
+
+      @observation_state[element] = in_state
+
+      # ignore incoming updates of a previous observation that is still subscribed
+      return if not observations[@active_observation].element.eql? element
+
+      if in_state == :fail
+            observations[@active_observation].stop # unsubscribe observation
+             restart # restart mapping
+             return
+           end
+      if in_state
+        @observation_results.merge! result
+        observations[@active_observation].stop # unsubscribe observation
+        @active_observation += 1
+
+        # check if already all other observations have been matched
+        if observations.length <= @active_observation
+          startAction(@observation_results).actions_succeeded_callback { |m,result|
+                      state = :failed
+                      state = :succeeded if result
+
+                      @state_callback.call(@mapping[:name], {:id => @mapping[:id], :mapping_state => state}) if @state_callback
+
+            # add callback for action if succeeded & implement parallel action execution
+            m.restart
+
+          }
+        else # start next observation
+          observations[@active_observation].start(@observation_results,self.method(:cb_activate_action))
+        end
+      end
+    end
+
+    def restart
+      @active_observation = 0
+      super
+      self
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module MINT
+   class AIChoiceElement < AIReference
+
+     def unchoose_others
+       aios = []
+       self.parent.children.each do |c|
+         if c.is_in? :chosen
+           aios << c
+         end
+       end
+       aios.each do |aio|
+         aio.process_event("unchoose")
+       end
+     end
+   end
+
+end

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

@@ -0,0 +1,7 @@
+module MINT
+  class AICommand < AIReference
+    def getSCXML
+      "#{File.dirname(__FILE__)}/aicommand.scxml"
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module MINT
+
+  class AIContainer < AIOUT
+
+    property :children, String
+
+    def children
+      p = super
+      result = nil
+      if p
+        result=[]
+        c = p.split("|")
+        c.each  do |name|
+          result << AIO.get(name)
+        end
+        return result
+      else
+        []
+      end
+      []
+    end
+
+    def children= children
+      if children.is_a? Array
+        a= children.map { |c| c.name if not c.is_a? String}
+
+        super(a.join("|"))
+      else
+        super(children)
+        end
+    end
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/aicontainer.scxml"
+    end
+
+    def suspend_children
+      cs = self.children
+      if (cs)
+        cs.each do |c|
+          c.process_event("suspend")
+        end
+
+      end
+    end
+
+    def present_children
+      if (self.children)
+        self.children.each do |c|
+          c.process_event("present")
+        end
+
+      end
+    end
+
+
+    def  focus_child
+      if (self.children && self.children.first)
+        self.children.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