mort666-wongi-engine 0.2.9

data/lib/wongi-engine/beta/ncc_partner.rb

@@ -0,0 +1,40 @@
+module Wongi
+  module Engine
+    class NccPartner < BetaNode
+      include TokenContainer
+
+      attr_accessor :ncc
+      attr_accessor :divergent
+
+      def beta_activate token
+        t = Token.new self, token, nil, {}
+        owner = owner_for( t )
+        t.overlay.add_token(t, self)
+        if owner
+          owner.ncc_results << t
+          t.owner = owner
+          owner.node.ncc_deactivate owner
+        end
+      end
+
+      def beta_deactivate t
+        token = tokens.find { |tok| tok.parent == t }
+        return unless token
+        token.overlay.remove_token(token, self)
+        if owner = token.owner
+          owner.ncc_results.delete token
+          if owner.ncc_results.empty?
+            ncc.ncc_activate owner
+          end
+        end
+      end
+
+      private
+
+      def owner_for token
+        divergent_token = token.ancestors.find { |t| t.node == divergent }
+        ncc.tokens.find { |t| t.ancestors.include? divergent_token }
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta/neg_node.rb

@@ -0,0 +1,115 @@
+module Wongi
+  module Engine
+
+    NegJoinResult = Struct.new :token, :wme do
+      def unlink
+        wme.neg_join_results.delete self
+        token.neg_join_results.delete self
+      end
+    end
+
+    class NegNode < BetaNode
+      include TokenContainer
+
+      attr_reader :alpha, :tests
+
+      def initialize parent, tests, alpha, unsafe
+        super(parent)
+        @tests, @alpha, @unsafe = tests, alpha, unsafe
+      end
+
+      def alpha_activate wme
+        tokens.each do |token|
+          if matches?( token, wme ) && ( @unsafe || ! token.generated?( wme ) )# feedback loop protection
+            # order matters for proper invalidation
+            make_join_result(token, wme)
+            #token.delete_children #if token.neg_join_results.empty? # TODO why was this check here? it seems to break things
+            children.each do |child|
+              child.tokens.each do |t|
+                if t.parent == token
+                  child.beta_deactivate t
+                  #token.destroy
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def alpha_deactivate wme
+        wme.neg_join_results.dup.each do |njr|
+          tokens.each do |token|
+            next unless token == njr.token
+            njr.unlink
+            if token.neg_join_results.empty?
+              children.each do |child|
+                child.beta_activate Token.new( child, token, nil, {} )
+              end
+            end
+          end
+        end
+      end
+
+      def beta_activate token
+        return if tokens.find { |et| et.duplicate? token }
+        token.overlay.add_token(token, self)
+        alpha.wmes.each do |wme|
+          if matches?( token, wme )
+            make_join_result(token, wme)
+          end
+        end
+        if token.neg_join_results.empty?
+          children.each do |child|
+            child.beta_activate Token.new( child, token, nil, {} )
+          end
+        end
+      end
+
+      def beta_deactivate token
+        return nil unless tokens.find token
+        token.overlay.remove_token(token, self)
+        token.deleted!
+        if token.parent
+          token.parent.children.delete token # should this go into Token#destroy?
+        end
+        token.neg_join_results.each &:unlink
+        children.each do |child|
+          child.tokens.each do |t|
+            if t.parent == token
+              child.beta_deactivate t
+              #token.destroy
+            end
+          end
+        end
+        token
+      end
+
+      def refresh_child child
+        tokens.each do |token|
+          if token.neg_join_results.empty?
+            child.beta_activate Token.new( child, token, nil, {} )
+          end
+        end
+        alpha.wmes.each do |wme|
+          alpha_activate wme
+        end
+      end
+
+      protected
+
+      def matches? token, wme
+        puts "matching #{wme} against #{token}" if debug?
+        @tests.each do |test|
+          return false unless test.matches?( token, wme )
+        end
+        true
+      end
+
+      def make_join_result token, wme
+        njr = NegJoinResult.new token, wme
+        token.neg_join_results << njr
+        wme.neg_join_results << njr
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta/optional_node.rb

@@ -0,0 +1,142 @@
+module Wongi
+  module Engine
+
+    OptionalJoinResult = Struct.new :token, :wme do
+      def unlink
+        wme.opt_join_results.delete self
+        token.opt_join_results.delete self
+      end
+    end
+
+    class OptionalNode < BetaNode
+      include TokenContainer
+
+      attr_reader :alpha, :tests, :assignment_pattern
+
+      def initialize parent, alpha, tests, assignments
+        super( parent )
+        @alpha = alpha
+        @tests = tests
+        @assignment_pattern = assignments
+      end
+
+      def make_opt_result token, wme
+        jr = OptionalJoinResult.new token, wme
+        token.opt_join_results << jr
+        wme.opt_join_results << jr
+      end
+
+      def alpha_activate wme
+        assignments = collect_assignments( wme )
+        tokens.each do |token|
+          if matches? token, wme
+            children.each do |child|
+              if token.optional?
+                token.no_optional!
+                child.tokens.each do |ct|
+                  child.beta_deactivate(ct) if ct.parent == token
+                end
+              end
+              child.beta_activate Token.new( child, token, wme, assignments )
+            end
+            make_opt_result token, wme
+          end
+        end
+      end
+
+      def alpha_deactivate wme
+        wme.opt_join_results.dup.each do |ojr|
+          tokens.each do |token|
+            next unless token == ojr.token
+            ojr.unlink
+            if token.opt_join_results.empty?
+              children.each do |child|
+                child.tokens.each do |ct|
+                  child.beta_deactivate(ct) if ct.parent == token
+                end
+                token.optional!
+                child.beta_activate Token.new( child, token, nil, { } )
+              end
+            end
+          end
+        end
+      end
+
+      def beta_activate t
+        return if tokens.find { |token| token.parent == t }
+        token = Token.new( self, t, nil, { } )
+        token.overlay.add_token(token, self)
+        match = false
+        alpha.wmes.each do |wme|
+          assignments = collect_assignments(wme)
+          if matches? token, wme
+            match = true
+            children.each do |child|
+              child.beta_activate Token.new( child, token, wme, assignments )
+            end
+            make_opt_result token, wme
+          end
+        end
+        unless match
+          token.optional!
+          children.each do |child|
+            child.beta_activate Token.new( child, token, nil, { } )
+          end
+        end
+      end
+
+      def beta_deactivate t
+        token = tokens.find { |token| token.parent == t }
+        return unless token
+        token.overlay.remove_token(token, self)
+        token.deleted!
+        if token.parent
+          token.parent.children.delete token
+        end
+        token.opt_join_results.each &:unlink
+        children.each do |child|
+          child.tokens.each do |t|
+            if t.parent == token
+              child.beta_deactivate t
+            end
+          end
+        end
+        token
+      end
+
+      def refresh_child child
+        tmp = children
+        self.children = [ child ]
+        refresh # do the beta part
+        alpha.wmes.each do |wme|
+          alpha_activate wme
+        end
+        self.children = tmp
+      end
+
+      private
+
+      def matches? token, wme
+        @tests.each do |test|
+          return false unless test.matches?( token, wme )
+        end
+        true
+      end
+
+      def collect_assignments wme
+        assignments = {}
+        return assignments if assignment_pattern.nil?
+        if assignment_pattern.subject != :_
+          assignments[ assignment_pattern.subject ] = TokenAssignment.new(wme, :subject)
+        end
+        if assignment_pattern.predicate != :_
+          assignments[ assignment_pattern.predicate ] = TokenAssignment.new(wme, :predicate)
+        end
+        if assignment_pattern.object != :_
+          assignments[ assignment_pattern.object ] = TokenAssignment.new(wme, :object)
+        end
+        assignments
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta/or_node.rb

@@ -0,0 +1,37 @@
+module Wongi
+  module Engine
+    class OrNode < BetaMemory
+
+      attr_reader :parents
+      attr_reader :rete
+
+      def initialize parents
+        super nil
+        @parents = parents
+        parents.each do |parent|
+          parent.children << self
+        end
+        retes = parents.map( &:rete ).uniq
+        raise "Cannot combine variants from several Retes" if retes.size > 1
+        @rete = retes.first
+      end
+
+      def ident
+        ids = parents.map( &:id ).join ", "
+        "<R> #{self.class} #{id}, parents #{ids}"
+      end
+
+
+      def depth
+        parents.map( &:depth ).max + 1
+      end
+
+      def refresh
+        parents.each do |parent|
+          parent.refresh_child self
+        end
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/beta/production_node.rb

@@ -0,0 +1,31 @@
+module Wongi
+  module Engine
+    
+    class ProductionNode < BetaMemory
+
+      attr_accessor :tracer
+      attr_accessor :compilation_context
+
+      def initialize parent, actions
+        super(parent)
+        @actions = actions.each { |action| action.production = self }
+      end
+
+      def beta_activate token
+        return unless super
+        @actions.each do |action|
+          action.execute token if action.respond_to? :execute
+        end
+      end
+
+      def beta_deactivate token
+        return unless super
+        @actions.each do |action|
+          action.deexecute token if action.respond_to? :deexecute
+        end
+      end
+
+    end
+
+  end
+end

data/lib/wongi-engine/compiler.rb

@@ -0,0 +1,115 @@
+module Wongi::Engine
+  Compiler = Struct.new(:rete, :node, :conditions, :parameters, :alpha_deaf) do
+
+    def compile
+      conditions.inject(self) do |context, condition|
+        condition.compile context
+      end.node
+    end
+
+    def declares_variable?(v)
+      parameters.include?(v) || declared_variables.include?(v)
+    end
+
+    def declare(v)
+      unless declared_variables.include?(v)
+        declared_variables << v
+      end
+    end
+
+    def declared_variables
+      @declared_variables ||= []
+    end
+
+    def dup
+      Compiler.new(rete, node, conditions, parameters, alpha_deaf).tap do |compiler|
+        declared_variables.each { |v| compiler.declare(v) }
+      end
+    end
+
+    # TODO: should the following be the responsibility of Compiler or of each individual DSL clause?
+
+    def beta_memory
+      return if node.is_a?(BetaMemory)
+      self.node = if existing = node.children.find { |n| n.is_a?(BetaMemory) }
+        existing
+      else
+        BetaMemory.new(node).tap do |memory|
+          memory.refresh
+        end
+      end
+    end
+
+    def assignment_node(variable, body)
+      beta_memory
+      self.node = AssignmentNode.new(self.node, variable, body).tap &:refresh
+      declare(variable)
+    end
+
+    def join_node(condition, tests, assignment)
+      alpha = rete.compile_alpha(condition)
+      beta_memory
+      self.node = if existing = node.children.find { |n| n.is_a?(JoinNode) && n.equivalent?(alpha, tests, assignment) }
+        existing
+      else
+        JoinNode.new(node, tests, assignment).tap do |join|
+          join.alpha = alpha
+          alpha.betas << join unless alpha_deaf
+        end
+      end
+    end
+
+    def neg_node(condition, tests, unsafe)
+      alpha = rete.compile_alpha(condition)
+      self.node = NegNode.new(node, tests, alpha, unsafe).tap do |node|
+        alpha.betas << node unless alpha_deaf
+        node.refresh
+      end
+    end
+
+    def opt_node(condition, tests, assignment)
+      alpha = rete.compile_alpha(condition)
+      beta_memory
+      self.node = OptionalNode.new(node, alpha, tests, assignment).tap do |node|
+        alpha.betas << node unless alpha_deaf
+      end
+    end
+
+    def or_node(variants)
+      beta_memory
+      branches = variants.map do |variant|
+        subcompiler = Compiler.new(rete, node, variant.conditions, parameters, false)
+        declared_variables.each { |v| subcompiler.declare(v) }
+        subcompiler.compile
+        subcompiler.declared_variables.each { |v| declare(v) }
+        subcompiler.node
+      end
+      self.node = OrNode.new(branches).tap &:refresh
+    end
+
+    def ncc_node(subrule, alpha_deaf)
+      beta_memory
+      subcompiler = Compiler.new(rete, node, subrule.conditions, parameters, alpha_deaf)
+      declared_variables.each { |v| subcompiler.declare(v) }
+      bottom = subcompiler.compile
+      if existing = node.children.find { |n| n.kind_of?( NccNode ) and n.partner.parent == bottom }
+        self.node = existing
+        return
+      end
+      ncc = NccNode.new node
+      partner = NccPartner.new subcompiler.tap(&:beta_memory).node
+      ncc.partner = partner
+      partner.ncc = ncc
+      partner.divergent = node
+      #    partner.conjuncts = condition.children.size
+      ncc.refresh
+      partner.refresh
+      self.node = ncc
+    end
+
+    def filter_node(filter)
+      beta_memory
+      self.node = FilterNode.new(node, filter)
+    end
+  end
+end