khammurabi 0.2

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

@@ -0,0 +1,60 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ObjectAddon'
+	require 'nist/khammurabi/Cluster'
+	
+  class InstantiatorNode < GraphNode
+
+    attr :instantiations, true # Hash { Object => Array( Object ) }
+    attr :objectProduction, true # Object
+    attr :graph, true # Graph
+
+    def InstantiatorNode.init( objectProduction, name, engine )
+      oin = InstantiatorNode.new
+      oin.objectProduction = objectProduction
+      oin.name = name
+      oin.engine = engine
+      oin
+    end
+
+    def initialize
+      super
+      self.instantiations = Hash.new
+      self
+    end
+
+    def execute
+			#self.debug = true
+			self.notice( "Executing" )
+			# clear the Tokens that made it this far from the graph
+			
+			self.tokens.each do |token|
+				self.registerToken( token )
+				token.registerOwner( self )
+				self.engine.clusterManager.deleteFromCluster( token, token.cluster )
+				engine.recursivelyDeRegisterTokenByID( token, self )
+				token.deRegisterOwner
+				engine.deleteFromWorkingMemoryUsingEqual?( token )
+			end
+
+			#print "printing token ids: "
+			#self.engine.printTokenIDs
+			#exit
+			
+      self.notice( "executing.. my name: #{self.name}" )
+      self.engine.objectProductionWasInstantiated( self.objectProduction )
+      self.instantiations[ self.objectProduction ] = Array.new if self.instantiations[ self.objectProduction ] == nil
+      self.instantiations[ self.objectProduction ].push( self.tokens )
+			self.notice( "instantiations size: #{self.instantiations.size}" )
+      if self.objectProduction
+	  		self.objectProduction.actions.each do |action| 
+					self.notice( "Action has class: #{action.class}" )
+					action.execute
+				end
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,19 @@
+module MK
+
+	class Message
+	
+		attr :message, true # String, or whatever
+		
+		def Message.init( _message )
+			message = Message.new
+			message.message = _message
+			message
+		end
+		
+		def initialize
+			self.message = nil
+		end
+		
+	end
+end
+

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

@@ -0,0 +1,97 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+
+  
+  # This class utilizes one parent but an arbitrary number of children. Each child
+  # is indexed. To describe what this an object of type MultiChildrenArbitraryNode (let's call it arb) does,
+  # assume that there are N children (call them child0, child1, etc) and that the 
+  # incoming tokens are represented by tokenK where K is between 0 and N - 1. 
+  # arb will pass token0 to child0, token1 to child1, etc. When K = N, arb will 
+  # pass tokenK to child0. Another way to look at it is that arb passes tokenK to childB
+  # where K is congruent to B (mod N) 
+  class MultiChildrenArbitratorNode < GraphNode
+
+    attr :nodeIndex, true # Fixnum .. which node to use
+		attr :multiChildren, true 
+		attr :level, true
+		
+    def MultiChildrenArbitratorNode.init( engine )
+      mcan = MultiChildrenArbitratorNode.new
+      mcan.engine = engine
+      mcan
+    end
+
+    def initialize
+      super
+      self.maxChildren = -1
+      self.nodeIndex = 0
+      self.multiChildren = Array.new
+			self.level = -1
+			@registeringNormalChild = false
+			@managingTokens = true
+      self
+    end
+    
+    # Adds a child
+    def addChild( child )
+      if @registeringNormalChild == true
+	  		super
+      else
+	  	#print "Adding a multiChild... its name: #{child.name}\n"
+				self.multiChildren.push( child )
+      end
+    end
+
+    # See class description for explanation of this method
+    def execute
+      return if self.tokens.size == 0
+			#exit
+			
+			self.tokens.each do |token|
+				token.beginBroadcastingTo( self )
+				childToAdd = @multiChildren[ nodeIndex ]
+				self.notice( "MCAN #{self.name} execute, nodeIndex: #{nodeIndex}" ) 
+				#caller.each { |call| print "\t\t#{call}\n" }
+				@registeringNormalChild = true
+				self.removeChildren
+				self.addChild( childToAdd )
+				@registeringNormalChild = false
+				self.registerPassedToken( token )
+				self.arbitrateNextNodeIndex
+				@managingToken = token
+				self.manageTokens
+				@managingToken = nil
+			end
+    end
+
+		def tokenFailed( token )
+			token = token.first if token.class == Array # this may happen since broadcast sends out an Array
+			self.notice( "Token: #{token.tokenID} FAILED" )
+			if @managingToken.equal?( token )
+				self.arbitrateLastNodeIndex
+			end
+			self.notice( "My arbitration index: #{self.nodeIndex}" )
+		end
+		
+    # Wraps index around when it gets too large (larger than the # of nodes)
+    def arbitrateNextNodeIndex
+      if self.nodeIndex < @multiChildren.size - 1
+	  		self.nodeIndex = self.nodeIndex + 1
+      else
+	  		self.nodeIndex = 0
+      end
+    end
+
+		def arbitrateLastNodeIndex
+      if self.nodeIndex > 0 # @multiChildren.size - 1
+	  		self.nodeIndex = self.nodeIndex - 1
+      else
+	  		self.nodeIndex = @multiChildren.size - 1
+      end
+    end
+
+		def representative; self.multiChildren.first; end
+		
+	end
+end

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

@@ -0,0 +1,77 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+
+  
+  # Objects of this class march along its children one at a time, keeping a marker
+	# for the child currently being used
+  class MultiChildrenSelectorNode < GraphNode
+
+    attr :nodeIndex, true # Fixnum .. which node to use
+		attr :level, true
+		attr :sittingChildren, true 
+		
+    def MultiChildrenSelectorNode.init( name, engine, debug )
+      mcsn = MultiChildrenSelectorNode.new
+			mcsn.name = name
+      mcsn.engine = engine
+			mcsn.debug = debug
+      mcsn
+    end
+
+    def initialize
+      super
+      self.maxChildren = -1
+      self.nodeIndex = 0
+			self.level = -1
+			self.sittingChildren = Hash.new # Hash( Token => Node )
+			self
+    end
+    
+    # See class description for explanation of this method
+    def execute
+      return if self.tokens.size == 0
+		
+			#caller.each { |call| print "\t\t#{call}\n" }
+    
+			self.tokens.each do |token|
+				token.beginBroadcastingTo( self )
+				#print "\n\n** ITERATING **\n"
+				a = nodeIndex
+				size = self.children.size
+				childs = Array.new
+				size.times do |ni|
+					#print "a: #{a} childs: #{childs.join( " " )} \nchildren: #{children.join( " " )}\n"
+					if self.sittingChild == nil or !self.sittingChildren.values.includeID?( self.children[ a ] )
+						childs.push( children[ a ] )
+						#print "IN HERE childs now: #{childs.join( " " )}\n"
+					else
+						#print "sittingChild: #{self.sittingChild.name} sittingChildren: #{self.sittingChildren.values.join( " " )}\n"
+					end
+					a = a + 1
+					a = 0 if a == size
+				end
+				#print "childs: #{childs.join( " " )}\n"
+				# Put the sittinChildren at the end
+				childs.concat( sittingChildren.values ) if sittingChildren.values.size > 0
+				self.nodeIndex = self.nodeIndex + 1
+				self.nodeIndex = 0 if self.nodeIndex == size
+				self.registerPassedToken( token )
+				#print "goign to manage .."
+				#childs.each { |child| print "#{child.name}  " }
+				#print "\n"
+				#$defout.flush
+				self.manageTokens( childs ) # self.children.each do |child|
+				if self.sittingChild != nil
+					#print "Adding a sitting child of name: #{sittingChild.name}\n"
+					self.sittingChildren[ token.object_id ] = sittingChild
+				end
+			end
+		end
+
+		def tokenFailed( token, *vars )
+			self.sittingChildren[ token.object_id ] = nil
+		end
+		
+	end
+end

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

@@ -0,0 +1,63 @@
+# Adds some functionality to the Object object
+class Object
+  
+  attr :debug, true # Boolean
+  attr :type, true # Fixnum
+	attr :listeners, true # Array of listeners
+	
+	# take this out later.. such a cludge
+	@@outfile = nil
+	@@debugType = 1
+  @@outserver = nil
+	
+  # The most severe notification. Prints string to stdout (regardless of debug setting),and exits
+  def error( string )
+		nameStr = " Name: #{self.name}" if self.name
+		print "\n\n+ * * Error * * + ID: #{self.object_id}#{nameStr} Class #{self.class} -- #{string}\n\n" # .  Printing call stack: \n\n"
+		caller.each { |call| print "\t\t#{call}\n" }
+    exit
+  end
+  
+  # Less severe than an error but more severe than a notice. Outputs nothing if debug is false
+  def warning( string )
+		nameStr = " Name: #{self.name}" if self.name
+		print "* * Warning * * ID: #{self.object_id}#{nameStr} from class #{self.class} -- #{string}\n" if self.debug
+	end
+  
+  # The least severe of all the notifications. Outputs nothing if debug is false
+  def notice( string )
+		nameStr = " Name: #{self.name}" if self.name
+		outputStr = "__Notice__ ID: #{self.object_id}#{nameStr} Class #{self.class} -- #{string} \n"
+		if self.debug
+			print outputStr if @@debugType == 1
+			@@outfile.print( outputStr ) if @@debugType == 2
+			@@outserver.print( outputStr ) if @@debugType == 3
+		end
+	end
+
+	def beginBroadcastingTo( object )
+		self.listeners == nil and self.listeners = Array.new
+		self.listeners.push( object )
+	end
+	
+	def stopBroadcastingTo( object )
+		self.listeners.deleteID( object )
+	end
+	
+	def broadcast( message, *vars )
+		if self.listeners != nil and self.listeners.class == Array
+			self.listeners.each do |listener|
+				listener.send( message, vars )
+			end
+		end
+	end
+	
+	def outfile=( _outfile );	@@outfile = _outfile; end
+	def outfile; @@outfile; end
+	def debugType=( _type ); @@debugType = _type; end
+	def debugType; @@debugType; end
+	def outserver=( _outserver ); @@outserver = _outserver; end
+	def outserver; @@outserever; end
+	
+end
+

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

@@ -0,0 +1,192 @@
+module MK
+
+  require 'stringio'
+  require 'nist/khammurabi/ObjectOperation'
+  require 'nist/khammurabi/ObjectAddon'
+	require 'nist/khammurabi/BooleanAddon'
+  require 'nist/khammurabi/ValueTestSuite'
+
+  # Objects of this class-type describe objects of any type by 
+  # mapping each variable name of the input object, objectDescribing,
+  # into a ConstantObjectOperation or VariableObjectOperation. When used manually, the user
+  # sets objectDescribing and then calls parseObject. ObjectDescription's are temporary
+	# objects that are created during graph creation and not used after.
+  # Objects of this type are owned by an ObjectProduction.
+  class ObjectDescription
+    
+    attr :objectDescribing, true # Object # defunct
+    attr :objectProduction, true # Owner/parent/guardian
+    attr :objectOperations, true # Hash ( Object => ObjectOperation )
+    attr :instanceVariables, true # The instance variables of objectDescribing
+    attr :objectClass, true # Class of object which this describes
+
+    def initialize
+      objectDescribing = nil
+      self.objectOperations = Hash.new { nil }
+      self.instanceVariables = Array.new
+      self.objectClass = Object
+    end
+
+    def ObjectDescription.init( objectDescribing )
+      od = ObjectDescription.new
+      od.objectDescribing = objectDescribing
+      od.parseObject
+      od
+    end
+
+		def hash
+			objectDescribing.hash + objectClass.hash + objectOperations.hash
+		end
+		
+    # Clones instanceVariables and objectOperations
+    def clone
+      cologne = ObjectDescription.new
+      self.instanceVariables.each { |iv| cologne.parseInstanceVariable( iv ) }
+      self.objectOperations.each_pair do |key,value|  
+				valueCologne = value.clone
+				cologne.addObjectOperation( key, valueCologne )
+			end
+      cologne
+    end
+
+    # Does == on objectOperations
+    def ==( otherObject )
+      retval = true
+      if otherObject == nil 
+		  	retval = false
+      else
+	  		self.objectOperations.each_key do |key|
+					if otherObject.objectOperations[ key ].equal?( nil ) or objectOperations[ key ].equal?( nil ) or objectOperations[ key ] != otherObject.objectOperations[ key ]
+	    			retval = false
+						break
+					end
+				end
+			end
+			retval
+    end
+
+		# Checks if all the smaller objectDescription's constants are in the larger objectDescription's
+		# The objectDescription with more constant's is more specific, but can still match the same objects
+		# as objectDescriptions with less constants, provided that the input object is the same for both, and also
+		# provided that the objectDescription with less constants has the same constant tests as the larger one. Hope
+		# that confusing sentence makes sense
+		def ===( otherObject )
+			self.error( "Can't === with self" ) if otherObject.equal?( self )
+			retval = true
+
+			smaller = otherObject
+			larger = self
+			if self.constants.size < otherObject.constants.size
+				smaller = self
+				larger = otherObject
+			end
+
+			#print "smaller: #{smaller.object_id} larger: #{larger.object_id}\n"
+			smaller.constants.each_pair do |object, objectOperation|
+				#print "looking at: #{object}\n"
+				if !larger.constants.has_key?( object ) or larger[ object ] != smaller[ object ]
+					retval = false
+					break
+				end
+			end
+			retval
+		end
+
+    # Call after setting self.objectDescribing (if setting up manually.. normally this should be done
+    # using ObjectDescription.init)
+    def parseObject
+      if self.objectDescribing == nil
+	  		self.warning( "Trying to parse a nil object! returning..." ) 
+				return
+      end
+      self.instanceVariables = self.objectDescribing.instance_variables
+      self.instanceVariables.each { |instanceVariable| parseInstanceVariable( instanceVariable ) }
+    end
+
+    # A private method that maps variables to ConstantObjectOperations. This method shouldn't be called manually.
+    def parseInstanceVariable( instanceVariable, tests = nil )
+      return if @objectOperations.has_key?( instanceVariable ) == true
+			#test = nil
+			#test = MK::EqualityTest.init( self.objectDescribing.instance_eval( instanceVariable ) ) if self.objectDescribing != nil
+			#tests = [ test ] if tests == nil and test != nil
+			tests = MK::EqualityTest.init( self.objectDescribing.instance_eval( instanceVariable ) ) if self.objectDescribing != nil
+			coo = MK::ConstantObjectOperation.init( tests, instanceVariable, true )
+      shiftedInstanceVariable = instanceVariable[ 1 .. instanceVariable.size - 1 ]
+      self.instance_eval( "def #{shiftedInstanceVariable}; #{instanceVariable}; end" )
+      self.instance_variable_set( eval( ":#{instanceVariable}" ), coo )
+			self.addObjectOperation( instanceVariable, coo )
+			#exit
+    end
+
+		# The second variable is an adjective
+		def parseInstanceVariableAsVariable( instanceVariable, variableName, tests = nil )
+      return if @objectOperations.has_key?( instanceVariable ) == true
+			tests = [ MK::EqualityTest.new ] if tests == nil
+			tests = [ tests ] if tests.class != Array 
+			#tests.each { |test| test.variableName = variableName }
+			voo = MK::VariableObjectOperation.init( tests, instanceVariable, true, variableName )
+      shiftedInstanceVariable = instanceVariable[ 1 .. instanceVariable.size - 1 ]
+      self.instance_eval( "def #{shiftedInstanceVariable}; #{instanceVariable}; end" )
+      self.instance_variable_set( eval( ":#{instanceVariable}" ), voo )
+			self.addObjectOperation( instanceVariable, voo )
+    end
+
+    # Convenience method to return self.objectOperations[key]
+    def []( key ); @objectOperations[ key ]; end
+
+    # Sets the object as a variable object (it will now be tested using a VariableObjectOperation)
+    def setObjectAsVariable( object, variableName, valueTests )
+			self.objectOperations[ object ] = VariableObjectOperation.init( valueTests, self[ object ].name.clone, self[ object ].testMe.clone, variableName )
+		end
+		# Sets the object as a constant object (it will now be tested using a ConstantObjectOperation)
+    def setObjectAsConstant( object, valueTests )
+			self.objectOperations[ object ] = ConstantObjectOperation.init( valueTests, self[ object ].name.clone, self[ object ].testMe.clone )
+		end
+		def addValueTest( variableName, valueTest ); self.objectOperations[ variableName ].valueTests.push( valueTest ); end
+		def setValueTest( variableName, valueTest ); self.objectOperations[ variableName ].valueTests = [ valueTest ].flatten;   end
+		def deleteObjectOperation( vname );          self.objectOperations.reject! { |name, op| name.eql?( vname ) };    end
+
+    # Returns each object that corresponds to a constant object (that is -- the test on it 
+    # is a ConstantObjectOperation)
+    def constants; self.objectOperations.hashSelect { |variableName, oo| oo.kind_of?( ConstantObjectOperation ) }; end
+    def variables; self.objectOperations.hashSelect { |variableName, oo| oo.kind_of?( VariableObjectOperation ) }; end
+
+    # Returns a clone of self that is concat'd with other
+    def concat( other ); self.clone.concat!( other ); end
+
+    # Assigns variable an ObjectOperation. If variable already has one, then
+    # objectOperation is concatted to it
+    def addObjectOperation( variable, objectOperation )
+			if self.objectOperations.has_key?( variable )
+				self.objectOperations[ variable ].valueTests.concat( objectOperation.valueTests )
+      else
+				self.objectOperations[ variable ] = objectOperation
+      end
+    end
+
+    # Combines the instanceVariables and objectOperations from self and other
+    def concat!( other )
+      # sanity check
+      self.error( "I only know how to concatenate another object of type ObjectDescription.. not a: #{other.class}" ) if other.class != self.class
+      self.error( "I only know how to concatenate another object who's object describing is the same as mine.. that type is: #{self.objectDescribing.class} and other's: #{other.objectDescribing.class}" ) if other.objectDescribing.class != self.objectDescribing.class
+      instanceVariables = other.objectDescribing.instance_variables
+      instanceVariables.each { |instanceVariable| parseInstanceVariable( instanceVariable ) }
+      other.objectOperations.each_pair { |key,value| self.addObjectOperation( key, value.clone ) }
+			self
+		end
+
+    # Prints each Object and ObjectOperation that is attributed to it to stream
+    def printOn( stream )
+      stream << "<ObjectDescription> objectOperations: "
+      @objectOperations.each_pair do |key,value|
+				stream << "<key: #{key} value: #{value}>      "
+      end
+      stream << "</ObjectDescription>"
+      stream
+    end
+
+    # Uses printOn( stdout )
+    def to_s; printOn( StringIO.new ).string; end
+
+  end
+end