omf_rete 0.5 → 0.6.1

data/lib/omf_rete/store/alpha_store.rb

@@ -0,0 +1,118 @@
+require 'set'
+require 'omf_rete/store/alpha/alpha_inner_element'
+require 'omf_rete/store/alpha/alpha_leaf_element'
+
+module OMF::Rete::Store
+
+  #
+  # Class to store tuples for use in MoanaFilter
+  #
+  class AlphaStore #< MObject
+    include OMF::Rete::Store
+
+    attr_reader :length
+
+    # Initialize a tuple store for tuples of
+    # fixed length +length+.
+    #
+    def initialize(length, opts = {})
+      @length = length
+      @root = Alpha::AlphaInnerElement.new(0, length)
+      @index = []
+      length.times do @index << {} end
+    end
+
+
+    # Register a +TSet+ and add all tuples currently
+    # and in the future matching +pattern+
+    #
+    def registerTSet(tset, pattern)
+      #puts "registerTSet: #{pattern}"
+      pat = pattern.collect do |el|
+        (el.is_a?(Symbol) && el.to_s.end_with?('?')) ? nil : el
+      end
+      @root.registerTSet(tset, pat)
+      # seed tset which already stored data
+      find(pat).each do |t|
+        tset.addTuple(t)
+      end
+      tset
+    end
+
+    def createTSet(description, indexPattern)
+      tset = Moana::Filter::IndexedTupleSet.new(description, indexPattern)
+      registerTSet(tset, description)
+      tset
+    end
+
+    def addTuple(tarray)
+      @length.times do |i|
+        item = tarray[i]
+        ia = @index[i][item] ||= Set.new
+        unless ia.add?(tarray)
+          return  # this is a duplicate
+        end
+      end
+      @root.addTuple(tarray)
+    end
+
+    # Remove a tuple from the store
+    #
+    def removeTuple(tarray)
+      @length.times do |i|
+        item = tarray[i]
+        if ia = @index[i][item]
+          ia.delete(tarray)
+        end
+      end
+      @root.removeTuple(tarray)
+    end
+
+    # Return a set of tuples which match +pattern+. Pattern is
+    # a tuples of the same length this store is configured for
+    # where any non-nil element is matched directly and any
+    # nil element is considered a wildcard.
+    #
+    def find(pattern)
+      #puts "patern: #{pattern.inspect}"
+      seta = []
+      allWildcards = true
+      @length.times do |i|
+        if (item = pattern[i])
+          if (item != :_)
+            allWildcards = false
+            res = @index[i][item] || Set.new
+            #puts "res: index #{i}, res: #{res.inspect}"
+            seta << res
+          end
+        end
+      end
+
+      if (allWildcards)
+        res = Set.new
+        @index[0].each_value do |s|
+          res.merge(s)
+        end
+        return res
+      end
+      # get intersection of all returned sets
+      if (seta.empty?)
+        return Set.new
+      end
+      res = nil
+      seta.each do |s|
+        if res
+          res = res.intersection(s)
+        else
+          res = s
+        end
+        #puts "merge: in: #{s.inspect}, res: #{res.inspect}"
+      end
+      return res
+    end
+
+    def to_s()
+      "Store"
+    end
+  end # Store
+end # Moana

data/lib/omf_rete/store/named_alpha_store.rb

@@ -0,0 +1,38 @@
+require 'omf_rete/store/alpha_store'
+
+module OMF::Rete::Store
+
+  class WrongNameException < StoreException
+    def initialize(name, tuple)
+      super "Expected first element in '#{tuple}' to be '#{name}'"
+    end
+  end
+
+  #
+  # This is a store where the first element in each
+  # tuple is supposed to have the same name.
+  #
+  class NamedAlphaStore < AlphaStore
+    include OMF::Rete::Store
+
+    # Initialize a tuple store for tuples of
+    # fixed length +length+ where the first element
+    # is always 'name' (included in length)
+    #
+    def initialize(name, length, opts = {})
+      @name = name
+      super length, opts
+      #@store = AlphaStore.new(length - 1)
+    end
+
+    def addTuple(tarray)
+      unless tarray[0] == @name
+        raise WrongNameException.new(@name, tarray)
+      end
+      super
+      #@store.addTuple(tarray[1 .. -1])
+    end
+
+
+  end
+end

data/lib/omf_rete/store/object_store.rb

@@ -0,0 +1,119 @@
+require 'set'
+require 'omf_rete/store/predicate_store'
+
+module OMF::Rete::Store
+
+  class WrongPatternLengthException < StoreException
+    def initialize(exp_length, tuple)
+      super "Expected tuple '#{tuple}' to be of length '#{exp_length}'"
+    end
+  end
+
+  #
+  # Turns a standard object into a store.
+  #
+  # NOTE: This store is NOT tracking changes to the
+  # state of the object. It is assumed to stay constant
+  # while it is in this store.
+  #
+  class ObjectStore
+    include OMF::Rete::Store
+
+
+
+    # @param opts :include_object Make the fist element the object
+    def initialize(opts = {})
+      @include_object = opts[:name] || (opts[:include_object] == true ? self : nil)
+      @object = nil
+      @tsets = {}
+    end
+
+    # Make this store represent 'obj'. this will
+    # 'eject' the currently represented object (if exist)
+    #
+    def representObject(obj)
+      @object = obj
+      # First clear registered tsets and then seed with state from 'obj'
+      @tsets.each do |tset, pat|
+        tset.clear()
+      end
+      @tsets.each do |tset, pat|
+        find(pat).each do |t|
+          tset.addTuple(t)
+        end
+      end
+      obj
+    end
+
+    # Register a +TSet+ and add all the
+    # object's state matching the pattern
+    #
+    def registerTSet(tset, pattern)
+      pat = pattern.collect do |el|
+        (el.is_a?(Symbol) && el.to_s.end_with?('?')) ? nil : el
+      end
+      @tsets[tset] = pat
+
+      # seed tset which already stored data
+      find(pat).each do |t|
+        tset.addTuple(t)
+      end
+      tset
+    end
+
+    # Return a set of tuples which match +pattern+. Pattern is
+    # a tuples where the first element (include_object == false)
+    # or the second element (include_object == true) is a property
+    # of this object. If the next element is nil, return the value.
+    # if the next one is not nil, only return a tuple if it is set
+    # to the same value.
+    #
+    # If the property value is an Enumerable, return a separate tuple
+    # for every value returned by the enumerable.
+    #
+    def find(pattern)
+      res = Set.new
+      if @include_object
+        raise WrongPatternLengthException.new(3, pattern) unless pattern.length == 3
+        obj = pattern[0]
+        return res if obj && obj != @include_object # not for us
+      else
+        raise WrongPatternLengthException.new(2, pattern) unless pattern.length == 2
+      end
+      unless pred = @include_object ? pattern[1] : pattern[0]
+        raise OMF::Rete::Store::UnknownPredicateException.new(pred, pattern)
+      end
+      pred = pred.to_sym
+      return res unless @object.respond_to? pred
+
+      val = @object.send(pred)
+      if exp_value = @include_object ? pattern[2] : pattern[1]
+        # Only return tuple if identical
+        a = [pred, exp_value]
+        a.insert(0, @include_object) if @include_object
+        # need to check if same
+        if (val.is_a?(Enumerable) ? val.include?(exp_value) : val == exp_value)
+          res << a
+        end
+        return res
+      end
+
+      a = [pred]
+      a.insert(0, @include_object) if @include_object
+      if val.is_a?(Enumerable)
+        res = Set.new(val.map {|v| a.dup << v})
+      else
+        res << (a << val)
+      end
+      return res
+    end
+
+    def to_s()
+      "ObjectStore"
+    end
+
+    def confirmLength(tuple)
+      tuple.is_a?(Array) && tuple.length == (@include_object ? 3 : 2)
+    end
+  end # class
+end # module

data/lib/omf_rete/store/predicate_store.rb

@@ -0,0 +1,96 @@
+require 'omf_rete/store/named_alpha_store'
+
+module OMF::Rete::Store
+
+  class UnknownPredicateException < StoreException
+    def initialize(pred, tuple, stores = {})
+      if pred
+        super "Unknown predicate '#{pred}' in '#{tuple}' - (#{stores.keys})"
+      else
+        super "Missing predicate in '#{tuple}'"
+      end
+    end
+  end
+
+  class AlreadyRegisteredPredicateException < StoreException
+    def initialize(pred)
+      super "Predicate '#{pred}' is already registered"
+    end
+  end
+
+  #
+  # This store supports  'predicate' tuples. The predicate of a tuple is identified
+  # by it's first element and each predicate can have a different scheme (tuple length).
+  # Each predicate needs to be registered through 'registerPredicate'.
+  #
+  # Subscriptions and 'find' queries need to name the predicate. In other words, they CANNOT
+  # span multiple predicates.
+  #
+  class PredicateStore
+    include OMF::Rete::Store
+
+    def initialize(opts = {})
+      @stores = {}
+    end
+
+    # Register a new predicate 'pred_name' whose tuples are of 'length'.
+    #
+    def registerPredicate(pred_name, length, opts = {})
+      pred_name = pred_name.to_sym
+      if @stores.key? pred_name
+        raise AlreadyRegisteredPredicateException.new(pred_name)
+      end
+      @stores[pred_name] = NamedAlphaStore.new(pred_name, length, opts)
+    end
+
+    # Register a 'store' for predicate 'pred_name'.
+    #
+    def registerPredicateStore(pred_name, store)
+      pred_name = pred_name.to_sym
+      if @stores.key? pred_name
+        raise AlreadyRegisteredPredicateException.new(pred_name)
+      end
+      @stores[pred_name] = store
+    end
+
+    ## Store API ###
+
+    def registerTSet(tset, pattern)
+      tset = get_store(pattern).registerTSet(tset, pattern)
+      #puts ">>> Register tset - #{pattern} - #{tset}"
+      tset
+    end
+
+    def addTuple(tarray)
+      get_store(tarray).addTuple(tarray)
+    end
+
+    def removeTuple(tarray)
+      get_store(tarray).removeTuple(tarray)
+    end
+
+    def find(pattern)
+      get_store(pattern).find(pattern)
+    end
+
+    def to_s()
+      "Predicate Store"
+    end
+
+    def confirmLength(tuple)
+      tuple.is_a?(Array) && get_store(tuple).confirmLength(tuple)
+    end
+
+
+    protected
+
+    def get_store(tuple)
+      pred = tuple[0]
+      unless !pred.nil? && store = @stores[pred.to_sym]
+        raise UnknownPredicateException.new(pred, tuple, @stores)
+      end
+      store
+    end
+
+  end # class
+end # module

data/lib/omf_rete/store.rb

@@ -1,26 +1,40 @@
 
 require 'omf_rete'
 
-  
+
 module OMF::Rete::Store
+
+  class StoreException < Exception; end
+
+  class NotImplementedException < StoreException; end
+
   DEF_TYPE = :alpha
-  
-  def self.create(length, opts = {})
+
+  def self.create(length = -1, opts = {})
     case (type = opts[:type] || DEF_TYPE)
     when :alpha
-      require 'omf_rete/store/alpha/alpha_store'
-      return OMF::Rete::Store::Alpha::Store.new(length, opts)
+      require 'omf_rete/store/alpha_store'
+      return OMF::Rete::Store::AlphaStore.new(length, opts)
+    when :named_alpha
+      require 'omf_rete/store/named_alpha_store'
+      return OMF::Rete::Store::NamedAlphaStore.new(opts.delete(:name), length, opts)
+    when :predicate
+      require 'omf_rete/store/predicate_store'
+      return PredicateStore.new(opts)
+    when :object
+      require 'omf_rete/store/object_store'
+      return ObjectStore.new(opts)
     else
       raise "Unknown store type '#{type}'"
     end
   end
-  
+
   #--- INTERFACE ---
-  
-  def query(queryPattern, projectPattern = nil, &block)
-    raise "'query' - Not implemented."
-  end
-  
+
+  # def query(queryPattern, projectPattern = nil, &block)
+    # raise "'query' - Not implemented."
+  # end
+
   def subscribe(name, query, out_pattern = nil, &block)
     require 'omf_rete/planner/plan_builder'
 
@@ -28,14 +42,30 @@ module OMF::Rete::Store
     pb.build
     pb.materialize(out_pattern, &block)
   end
-  
+  alias :add_rule :subscribe
+
   def addTuple(tarray)
+    raise NotImplementedException.new
   end
-  
+
   # alias
   def add(*els)
     addTuple(els)
   end
+  alias :add_fact :add
+
+  # Remove a tuple from the store
+  #
+  def removeTuple(*els)
+    raise NotImplementedException.new
+  end
+
+  # alias
+  def remove(*els)
+    removeTuple(els)
+  end
+  alias :remove_fact :remove
+
 
   # Return a set of tuples which match +pattern+. Pattern is
   # a tuples of the same length this store is configured for
@@ -43,6 +73,7 @@ module OMF::Rete::Store
   # nil element is considered a wildcard.
   #
   def find(pattern)
+    raise NotImplementedException.new
   end
 
   # Register a function to be called whenever a query is performed
@@ -52,6 +83,20 @@ module OMF::Rete::Store
   # pattern.
   #
   def on_query(&requestProc)
+    raise NotImplementedException.new
   end
 
+  def createTSet(description, indexPattern)
+    tset = OMF::Rete::IndexedTupleSet.new(description, indexPattern)
+    registerTSet(tset, description)
+    tset
+  end
+
+  # Return true if tuple (or pattern) is a valid one for this store
+  #
+  def confirmLength(tuple)
+    tuple.is_a?(Array) && tuple.length == @length
+  end
+
+
 end

data/lib/omf_rete/tuple.rb

@@ -0,0 +1,53 @@
+
+module OMF::Rete
+  #
+  # This class represents a tuple and includes various ways to access
+  # the contained elements..
+  #
+  class Tuple
+    attr_reader :description
+
+    # Return content of tuple as array of elements. The order and names are
+    # contained in 'description'. Use the #[] method to more robustly access
+    # individual elements.
+    #
+    def to_a
+      @tarray
+    end
+
+    # Return content of tuple as a hash. The key is taken from the 'description'.
+    #
+    def to_hash
+      h = {}
+      @description.each_with_index do |n, i|
+        name = n.to_s.chomp('?').to_sym
+        h[name] = @tarray[i]
+      end
+      h
+    end
+
+    # Return a specific element either indicated by index (number) or name
+    # as listed in 'description'.
+    #
+    def [](index_or_name)
+      if index_or_name.is_a? Integer
+        return @tarray[index_or_number]
+      elsif index_or_name.is_a? Symbol
+        @description.each_with_index do |n, i|
+          return @tarray[i] if n == index_or_name
+        end
+      end
+      raise "Unknown element name: '#{index_or_name}'"
+    end
+
+    def initialize(tarray, description)
+      @tarray = tarray
+      @description = description
+    end
+
+    def method_missing(name, *args, &block)
+      self[name]
+    end
+
+  end
+end