khammurabi 0.2

data/khammurabi-0.2/lib/nist/khammurabi/VariableTestNode.rb

@@ -0,0 +1,73 @@
+module MK
+  
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/ObjectGraphWrapper'
+  require 'nist/khammurabi/VariableTestNodeExecutor'
+  require 'nist/khammurabi/ObjectAddon'
+
+  # A class which uses a VariableObjectOperation to test the Tokens
+  # that pass into it. Uses a VariableTestNodeExecutor to do the dirty work.
+	# VariableTestNode is a "sticky" node, which means that tokens passed into it
+	# stick, or stay, in the node even if the token is passed on. Tokens are 
+	# unstuck if they make it to an ObjectInstantiator.
+  class VariableTestNode < TestNode
+    
+    attr :variableName, true # String
+    attr :variableTestNodeExecutor, true # VariableTestNodeExecutor
+		attr :level, true # Used for cluster matching
+		attr :switcheroos, true # VariableTestNode's that should be switched around during execution 
+														# to ensure proper testing
+														
+    #def VariableTestNode.init( name, objectOperationTest, variableName, variableTestNodeExecutor, engine, parent )
+		def VariableTestNode.init( name, objectOperationTest, variableTestNodeExecutor, engine, parent, level = -1 )	
+      variableTestNode = VariableTestNode.new
+      variableTestNode.name = name
+      variableTestNode.objectOperationTest = objectOperationTest
+      variableTestNode.variableTestNodeExecutor = variableTestNodeExecutor
+      variableTestNode.engine = engine
+      variableTestNode.setParent( parent )
+			variableTestNode.level = level
+      variableTestNode
+    end
+
+    def initialize
+      super
+      self.tokens = Array.new
+      self.variableTestNodeExecutor = nil
+			self.level = -1
+			self.switcheroos = Array.new
+      self
+    end
+		
+    # Calls variableTestNodeExecutor.execute
+    def execute
+			super
+			self.notice( "Execute, I have #{self.tokens.size} tokens" )
+			!self.shouldExecute and return
+			
+      # sanity check
+      self.error( "VariableTestNode#execute error -- trying to execute without having a properly initialized @variableTestNodeExecutor\n" ) if self.variableTestNodeExecutor == nil
+      # VariableTestNodeExecutor manages the tokens for self
+      self.variableTestNodeExecutor.execute
+    end # execute
+
+		def registerToken( token )
+			if token.variableTop == nil
+				self.notice( "Setting token #{token.tokenID}'s variableTop to self" )
+				token.variableTop = self
+				token.beginBroadcastingTo( self )
+			else
+				self.notice( "Token #{token.tokenID}'s variableTop is already set" )
+			end
+			super
+		end
+
+		def tokenFailed( vars )
+			token = vars.first
+			token.variableTop = nil if token.variableTop.equal?( self )
+		end
+
+  end # class
+end # module
+
+

data/khammurabi-0.2/lib/nist/khammurabi/VariableTestNodeExecutor.rb

@@ -0,0 +1,246 @@
+module MK
+
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/ObjectAddon'
+	require 'nist/khammurabi/TokenCluster'
+	
+  # This class takes multiple VariableTestNodes and tests
+  # them based upon the VariableObjectOperations in each one
+  class VariableTestNodeExecutor
+    attr :variableTestNodes, true # Array( VariableTestNode )
+    attr :engine, true # Engine
+		attr :name, true
+		
+    def VariableTestNodeExecutor.init( engine, variableTestNodes = Array.new, name = "VTNE (default)" )
+      variableTestNodeExecutor = VariableTestNodeExecutor.new
+      variableTestNodeExecutor.engine = engine
+			variableTestNodeExecutor.addVariableTestNodes( variableTestNodes )
+			variableTestNodeExecutor.name = name
+			variableTestNodeExecutor
+    end
+
+    def initialize
+      self.variableTestNodes = Array.new
+      self.engine = nil
+			self.name = "VTNE"
+    end
+    
+  # TestNode methods
+  def addVariableTestNode( node ); self.variableTestNodes.push( node ); end
+	def setVariableTestNodes( nodes )
+		self.variableTestNodes.reject { |val| true }
+		self.addVariableTestNodes( nodes )
+	end
+	
+	def addVariableTestNodes( nodes )
+		nodes.each do |node| 
+			self.addVariableTestNode( node )
+			node.variableTestNodeExecutor = self
+		end
+	end
+	
+	def execute
+		self.notice( "################### Execute information ###############################################" )
+		self.notice( "=== Execute called for variable nodes [#{self.variableTestNodes.printList( :name )}]" )
+		self.variableTestNodes.each do |vtn|
+			self.notice( "=== VariableTestNode #{vtn.name} has tokens: [#{vtn.tokens.printList( :tokenID )}]" )
+		end
+		self.notice( "#######################################################################################" )	
+		#self.debug = true
+		
+		uniqueTokenMap = Hash.new
+		####  Execution makes no sense if there aren't enough tokens to process ######################################
+		self.variableTestNodes.each do |vtn|
+			if vtn.tokens.size == 0
+				self.notice( "Not executing because one vtn (namely #{vtn.name}) has no tokens" )
+				return
+			end
+			# see if each there are enough unique tokens to continue
+			vtn.tokens.each do |token|
+				uniqueTokenMap[ token.object_id ] = true
+			end
+		end
+		if uniqueTokenMap.keys.size < self.variableTestNodes.size 
+			self.notice( "Didn't get a unique amount of tokens" )
+			return
+		end
+		###############################################################################################################
+
+
+		# Figure out the tokens and clusters to use
+		tokens = Array.new
+		clusters = Array.new
+		vtnSize = self.variableTestNodes.size
+		#print "vtns size: #{self.variableTestNodes.size}\n"
+		self.variableTestNodes.each do |vtn| 
+			vtn.tokens.each do |token|
+				# sanity check
+				self.error( "Token's owner isn't initialized, but should be" ) if token.owner == nil
+				tokens.pushUniqueID( token )
+				self.notice( "Token #{token.tokenID}'s cluster: #{token.cluster} completeness: #{token.cluster.complete?( self )}" )
+				clusters.pushUniqueID( token.cluster )
+			end
+		end
+		
+		self.notice( "-1-1 Token's clusters: " )
+		tokens.each do |token|
+			self.notice( "\tToken #{token.tokenID}'s cluster: #{token.cluster} completeness: #{token.cluster.complete?( self )}" )
+		end
+
+
+		########################################################################################
+		## A few thigns can happen at this point 																							##
+		## 0. If a token matches with a cluster, it joins it 																  ##
+		## 1. If a cluster becomes volatile, it is disbanded and its tokens are rolled back   ##
+		##    to the last unvolatile state																										##
+		## 2. If a cluster becomes k-complete, it is sent on																	##
+		############################ Test for 0 ################################################
+		clusters.each do |cluster|
+			next if cluster.complete?( self ) == true or cluster.size == 0
+			clusters.each do |otherCluster|
+				next if cluster.equal?( otherCluster ) or otherCluster.size == 0 or cluster.complete?( self ) or otherCluster.complete?( self )
+				retval = cluster.matchesWith?( otherCluster )
+				if retval.first.include?( TokenCluster.matchValue ) and \
+					 !retval.first.include?( TokenCluster.sameOwnerValue ) and \
+					 !retval.first.include?( TokenCluster.inClusterValue ) and \
+					 !retval.first.include?( TokenCluster.hostileValue )
+					 #print "cluster's first owner: #{cluster.elements.first.owner.name} and other's: #{otherCluster.elements.first.owner.name}\n"
+					 self.notice( "retval: [#{retval.join( " " )}] concatting #{otherCluster.clusterID} with elements: #{otherCluster.elements.printList( :tokenID ) } to #{cluster} with elements: #{cluster.elements.printList( :tokenID )}" )
+					self.engine.clusterManager.lossyConcat( cluster, otherCluster )
+				end
+			end
+		end
+		
+		# clean the clusters
+		clusters.reject! { |cluster| cluster.size == 0 }
+		clusters = self.engine.clusterManager.cleanClusters( clusters )
+
+		self.notice( "Clusters have been cleaned, and I'm going to use #{clusters.size} cluster(s):" )
+		clusters.each do |cluster|	
+			self.notice( "\t#{cluster.to_s}" )
+		end
+		
+		self.notice( "00 Token's clusters: " )
+		tokens.each do |token|
+			self.notice( "\tToken #{token.tokenID}'s cluster: #{token.cluster} completeness: #{token.cluster.complete?( self )}" )
+		end
+
+		############################ Test for 1 ####################################
+		self.notice( "**** Test for 1     ****" )
+		failRecords = Hash.new # used to store the match records for each token in the cluster
+		rolledBackNodes = Array.new
+		fail = false
+		clusters.each do |cluster|
+			next if cluster.size == 1
+			clusterTokens = Array.new
+			clusterTokens.concat( cluster.elements )
+			clusterTokens.reject! { |token| token.owner == nil }
+			clusterTokens.each do |token|
+				retval = cluster.matchesWith?( token )
+				failRecords[ token ] = retval.second
+				
+				self.notice( "--=-- Testing token: #{token.tokenID} with cluster: #{cluster.to_s}" )
+				self.notice( "--=-- retval is: #{retval.join( " " )}" )
+				
+				if retval.first.include?( TokenCluster.matchFailureValue )
+					self.notice( "token failed to match" )
+					fail = true # fail this cluster, but continue on to collect every match failure
+				end
+			end # cluster.elements.each do |token|
+			if fail == true
+				# At this stage, the cluster is broken (or volatile), so it is disbanded, each 
+				# token is assigned to a new cluster, the proper clusters become hostile to each other,
+				# and they are rolled back to a working state
+				# When the cluster is disbanded, each token is assinged a new cluster which contains
+				# only the token
+				#print "match values: " + cluster.matchesWith?( clusterTokens.second ).first.join( " " ) + " \n"
+
+				self.engine.clusterManager.disbandCluster( cluster, MK::TokenCluster )
+				self.engine.clusterManager.formClusterWithHostilities( clusterTokens )
+				self.notice( "Done disbanding cluster and forming new ones. They are: " )
+				clusterTokens.each do |token|
+					self.notice( "\t<For token: #{token.tokenID}, cluster: #{token.cluster}>" )
+				end
+				differences = Array.new
+				thisLevel = self.variableTestNodes.first.level
+				clusterTokens.each do |token|
+					difference = thisLevel - token.variableTop.level
+					differences.push( difference )
+					self.error( "Difference must be positive! it is: #{difference}" ) if difference < 0
+				end
+				minDifference = differences.minimum
+				self.notice( "Got a minDifference of: #{minDifference}" )
+				rolledBackNodes = Array.new
+				if minDifference > 0
+					clusterTokens.each do |token|
+						rolledBackNode = token.owner
+						minDifference.times do |i|
+							break if rolledBackNode.parent == nil
+							rolledBackNode = rolledBackNode.parent
+						end
+						self.error( "Rolled back node is nil but shouldn't be" ) if rolledBackNode == nil
+						self.notice( "ROLLED back token #{token.tokenID} from node #{token.owner.name} to node: #{rolledBackNode.name} which has tokens: #{rolledBackNode.tokens_to_s}" )
+						token.owner.registerRejectedToken( token )
+						token.owner.manageRejectedTokens
+						rolledBackNode.registerToken( token )
+						rolledBackNodes.push( rolledBackNode )
+					end # tokens.each do |token|
+				end # if minDifference > 0
+			end # if fail == true
+		end # clusters.each do |cluster|
+		## Execute each rolledBackNode .. this won't create a cycle, because if a token doesn't match
+		## it becomes hostile
+		rolledBackNodes.each do |rbn|
+			self.notice( "(Jump) Executing a rolled-back-node: #{rbn.name}" )
+			rbn.execute
+			self.notice( "(/Jump) Done executing a rolled-back-node: #{rbn.name}" )
+			#rbn.manageTokens
+		end
+		self.notice( "**** Done testing 1 ****" )
+		############################################################################
+
+		self.notice( "VTN's tokens: " )
+		self.variableTestNodes.each do |vtn|
+			self.notice( "\t VariableTestNode #{vtn.name} has tokens: [#{vtn.tokens.printList( :tokenID )}]" )
+		end
+		self.notice( "Token's clusters: " )
+		tokens.each do |token|
+			self.notice( "\tToken #{token.tokenID}'s cluster: #{token.cluster} completeness: #{token.cluster.complete?( self )}" )
+		end
+		
+		################ Quest for completeness (final chapter). This is where Trogdor is slain ################
+		#self.debug = true
+		#self.notice( "QUEST for completeness" )
+		#self.notice( "(0) Clusters has size: #{clusters.size} they are: " )
+		#clusters.each { |cluster| self.notice( "\t#{cluster.to_s2}" ) } 
+		# clean the clusters
+		clusters.reject! { |cluster| cluster.size == 0 }
+		clusters = self.engine.clusterManager.cleanClusters( clusters )
+		goodNodes = Array.new
+		clusters.each do |cluster|
+			# make sure that it is up-to-date
+			#print "vtn size: #{self.variableTestNodes.size}\n"
+			cluster.kLevel = self.variableTestNodes.size
+			if cluster.complete?( self )
+				self.notice( "Got a complete cluster" )
+				cluster.elements.each do |token|
+					# Make sure that we have enough permission to pass this token
+					if tokens.includeID?( token )
+						node = token.owner
+						node.registerPassedToken( token ) if node != nil
+						goodNodes.push( node ) if node != nil
+					end
+				end
+			end
+		end
+		#print "GOING TO TELL CHILDREN TO MANAGE TOKENS\n"
+		#self.notice( "Going to tell children to manage tokens" )
+		goodNodes.each { |node| node.manageTokens } # self.notice( "**Telling child: #{node.name}" ) ; node.manageTokens }
+		#print "DONE TELLING CHILDREN TO MANAGE TOKENS\n"
+		#goodNodes.each { |node| node.execute }
+		#########################################################################
+	 end # def execute
+	
+	end # class VariableNodeExecute
+end # module MK
+

data/khammurabi-0.2/lib/nist/khammurabi/XiaccEngine.rb

@@ -0,0 +1,201 @@
+module MK
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/ValueTestSuite'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ObjectDescription'
+  require 'nist/khammurabi/ActionOutput'
+  require 'nist/khammurabi/ActionObjectInsert'
+  require 'nist/khammurabi/ReteParseTreeNode'
+  require 'nist/khammurabi/ReteParseTreePrinter'
+  require 'nist/khammurabi/ReteParseTreeToObjectDescriptionConverter'
+  require 'nist/khammurabi/ValueTestSuite'
+  require 'nist/khammurabi/ObjectProductionAction'
+	require 'nist/khammurabi/XiaccParseInput'
+	require 'nist/khammurabi/XiaccParseSpecification'
+	
+  # Xiacc requires
+  require 'nist/xiacc/Language'
+  require 'nist/xiacc/Parser'
+  require 'nist/xiacc/CanonicalLRParserGenerator'
+  require 'nist/xiacc/ParserRecorder'
+  require 'nist/xiacc/TextLexer'
+  require 'nist/xiacc/TextLexerGenerator'
+
+  # This class specifies a grammar using the XI module that allows the input to be really cool
+  # like  "( age = 14 and sex = "m" ) or ( age = 15 and sex = "f" )"
+  class XiaccEngine < Engine
+	
+			attr :parser, true # XI::Parser
+			attr :lexer, true # XI::Lexer
+				
+		def initialize
+			super
+			# Set up the Xiacc engine
+			#################################### Language notes #########################################################
+			# '(' creates a new subtree                                                                                 #
+			# ')' closes up that subtree                                                                                #
+			#############################################################################################################
+			lang = XI::Language.new
+			lang.setTerminalCharacters( ", ( ) and or true false" )
+			lang.addTerminalDescription( "variable", Regexp.compile( /[[:alpha:]]([[:alnum:]])*/ ) )
+			lang.addTerminalDescription( "identifier", Regexp.compile( /\$[[:alpha:]]([[:alnum:]])*/ ) )
+			lang.addTerminalDescription( "value", Regexp.compile(  /[[:digit:]]*/ ) )
+			lang.addTerminalDescription( "string", Regexp.compile( /\"(([[:alnum:]]| )*)\"/ ) )
+			lang.addTerminalDescription( "operation", Regexp.compile( /<=|>=|!=|<|>|=|~|!~|/ ) )
+			lang.addTerminalDescription( "boolean", Regexp.compile( /true|false/ ) )
+			lang.setNonTerminalNames( "Testset Test Start" )
+			lang.addExpansionList( [ "Start -> Testset" ] )
+			#lang.addExpansionList( [ "Testset -> Test.objectDescription and", XI::Action.new( 'print "**parsed Test and\n";
+			lang.addExpansionList( [ "Testset -> Test.objectDescription", 
+																XI::CCAction.new( 'self.context[ "__currentNode" ].addChild( objectDescription );' ) ] )
+			lang.addExpansionList( [ "Testset -> (", 
+																XI::CCAction.new( 'node = MK::ReteParseTreeNode.new;
+																									 self.context[ "__parenNodes" ].push( self.context[ "__currentNode" ] );
+																									 self.context[ "__currentNode" ].addChild( node );
+																									 self.context[ "__currentNode" ] = node' ), 
+																"Testset )", 
+																XI::CCAction.new( 'self.context[ "__currentNode" ] = self.context[ "__parenNodes" ].last;
+																									 self.context[ "__parenNodes" ].pop;' ) ] )
+			lang.addExpansionList( [ "Testset -> Testset and", 
+																XI::CCAction.new( 'self.context[ "__currentNode" ].predicate = "and";
+																									 node = MK::ReteParseTreeNode.new;
+																									 self.context[ "__currentNode" ].addChild( node );
+																									 self.context[ "__currentNode" ] = node' ),
+															 "Testset" ] )
+			# , is shorthand for "and"
+			lang.addExpansionList( [ "Testset -> Testset ,", 
+																XI::CCAction.new( 'self.context[ "__currentNode" ].predicate = "and";
+																									 node = MK::ReteParseTreeNode.new;
+																									 self.context[ "__currentNode" ].addChild( node );
+																									 self.context[ "__currentNode" ] = node;'), 
+															 "Testset" ] )
+			lang.addExpansionList( [ "Testset -> Testset or", 
+																XI::CCAction.new( 'self.context[ "__currentNode" ].predicate = "or";
+																									 node = MK::ReteParseTreeNode.new;
+																									 self.context[ "__currentNode" ].addChild( node );
+																									 self.context[ "__currentNode" ] = node' ),
+																"Testset" ] )
+			lang.addExpansionList( [ "Test -> variable.var operation.op boolean.val", 
+																XI::CCAction.new( 'type = true if val.eql?( "true" );
+																									 type = false if val.eql?( "false" );
+																									 klass = MK::EqualityTest if op.eql?( "=" );
+																									 klass = MK::InequalityTest if op.eql?( "!=" );
+																									 @result = MK::ObjectDescription.new;
+																									 #print "var is: #{var}\n";
+																									 @result.parseInstanceVariable( "@#{var}" );
+																									 test = klass.init( type )
+																									 #print "got a test of: #{test}\n"
+																									 @result.addValueTest( "@#{var}", test );' ) ] )
+			lang.addExpansionList( [ "Test -> variable.var operation.op value.val", 
+																XI::CCAction.new( 'klass = MK::GreaterThanOrEqualTest if op.eql?( ">=" );
+																									 klass = MK::GreaterThanTest if op.eql?( ">" );
+																									 klass = MK::LessThanOrEqualTest if op.eql?( "<=" );
+																									 klass = MK::LessThanTest if op.eql?( "<" );
+																									 klass = MK::EqualityTest if op.eql?( "=" );
+																									 klass = MK::InequalityTest if op.eql?( "!=" );
+																									 @result = MK::ObjectDescription.new;
+																									 @result.parseInstanceVariable( "@#{var}" );
+																									 test = klass.init( val.to_f );
+																									 #print "tests testValue: #{test.testValue} object_id: #{test.object_id}\n";
+																									 @result.addValueTest( "@#{var}", test );' ) ] )
+			lang.addExpansionList( [ "Test -> variable.var operation.op string.val", 
+																XI::CCAction.new( 'klass = MK::GreaterThanOrEqualTest if op.eql?( ">=" );
+																									 klass = MK::GreaterThanTest if op.eql?( ">" );
+																									 klass = MK::LessThanOrEqualTest if op.eql?( "<=" );
+																									 klass = MK::LessThanTest if op.eql?( "<" );
+																									 klass = MK::EqualityTest if op.eql?( "=" );
+																									 klass = MK::InequalityTest if op.eql?( "!=" );
+																									 @result = MK::ObjectDescription.new;
+																									 @result.parseInstanceVariable( "@#{var}" );
+																									 test = klass.init( val[ 1 .. val.size - 2 ] )
+																									 @result.addValueTest( "@#{var}", test );' ) ] )
+			# For now, the only operations allowed with identifiers is equality and non-equality
+			# Greater than and less than just don't seem to make philosophical sense
+			# FFFFF
+			lang.addExpansionList( [ "Test -> variable.var operation.op identifier.id",
+																XI::CCAction.new( 'klass = MK::EqualityTest.new if op.eql?( "=" );
+																									 klass = MK::InequalityTest.new if op.eql?( "!=" );
+																									 klass = MK::ObjectIDEqualityTest.new if op.eql?( "~" );
+																									 klass = MK::ObjectIDInequalityTest.new if op.eql?( "!~" );
+																									 @result = MK::ObjectDescription.new;
+																									 @result.parseInstanceVariableAsVariable( "@#{var}", "#{id}", klass );' ) ] )
+																									 
+			lang.addExpansionList( [ "Test -> variable.variable operation.op variable.variable2",
+																XI::CCAction.new( '' ) ] ) # print "**did a variable = variable:    variable: #{variable} operation: #{op} variable: #{variable2}\n"') ] )
+			lang.augment
+			
+			lexerGenerator = XI::TextLexerGenerator.new( lang, nil )
+			self.lexer = lexerGenerator.generateLexer
+			
+			pg = XI::CanonicalLRParserGenerator.new
+			pg.language = lang
+			pg.generateStates
+		
+			self.parser = XI::InstanceManagerFromSpec.fromGenerator( pg, XI::Parser )
+			self.parser.recorder = XI::ParserRecorder.new
+			self.parser.lexer = lexer
+		end
+
+		# Used to add a grammar into the tree. 
+		# For example, given a Person class with class variables 'age', 'smoker' and 'cost', 
+		#          XiaccEngine xi
+		#          xi + [ Person, "age >= 45, age <= 65, smoker = false", "Cost: $10,000 per year" ]
+		def +( xiaccParseInputs )
+			xiaccParseInputs = [ xiaccParseInputs ] if xiaccParseInputs.class != Array
+			xiaccParseInputs.each do |xiaccParseInput|
+				next if !xiaccParseInput.kind_of?( XiaccParseInput )
+				
+				objectDescriptions = Array.new
+				actions = Array.new
+
+				xiaccParseInput.specifications.each do |specification|
+					self.error( "Can't work with a nil specification" ) if specification == nil
+
+					rootNode = ReteParseTreeNode.new
+					self.parser.reset
+					self.parser.context[ "__parenNodes" ] = Array.new
+					self.parser.context[ "__currentNode" ] = rootNode
+					self.lexer.input = specification.parseString # array[ index + 1 ]
+					self.parser.parseAll
+					converter = ReteParseTreeToObjectDescriptionConverter.init( rootNode )
+					converter.parse
+					if objectDescriptions.size == 0
+						converter.objectDescriptions.each do |od| 
+							od.objectClass = specification.klass # array[ index ]
+							objectDescriptions.push( [ od ] )
+						end
+					else
+						converter.objectDescriptions.each do |objectDescription|
+							objectDescriptions.each  { |od| od.push( objectDescription ) }
+						end
+					end
+
+					# now objectDescriptions is an Array( Array( ObjectDescription ) ) 
+					# each top-level Array corresponds to an ObjectProduction
+				end # xiaccParseInput.specifications.each do |specification|
+
+				xiaccParseInput.actions.each do |preAction|
+					if preAction.class == String
+						actions.push( MK::ActionOutput.init( preAction, self ) )
+					elsif preAction.kind_of?( MK::ObjectProductionAction ) == false
+						self.error( "I don't know how to handle this action type: #{preAction.class}" )
+					else
+						actions.push( preAction )
+					end
+				end # specification.actions.each do |preAction| ...
+				
+				objectProduction = MK::ObjectProduction.new
+				objectProduction.engine = self
+				actions.each { |action| objectProduction.addAction( action ) }
+				objectDescriptions.each do |objectDescriptionArray| 	
+					objectDescriptionArray.each { |objectDescription| objectProduction.addObjectDescription( objectDescription ) }
+				end
+				self.addObjectProduction( objectProduction )
+			end # xiaccParseInputs.each do |xiaccParseInput
+			self
+		end # def +
+
+	end # class XiaccEngine
+	
+end # Module MK