khammurabi 0.2

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

@@ -0,0 +1,14 @@
+class Fixnum
+
+	def factorial
+		fact = 1
+		for i in 2..self
+			fact = fact * i
+		end
+		fact
+	end
+	
+	#def clone; Fixnum( self ); end
+	
+end
+

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

@@ -0,0 +1,305 @@
+module MK
+
+  require 'nist/khammurabi/Token'
+  require 'nist/khammurabi/ObjectAddon'
+
+  # GraphNode describes a node that has one child and one parent, although subclasses can
+  # modify this to allow for more than one parent or child.
+  # Tokens are passed through GraphNode's, but it is left up to subclasses to decide
+  # what to do with them.
+	# Terms used:
+	# Rejected token -- The GraphNode doesn't want the Token anymore. Used for passing ownership onto another GraphNode
+	# Passed token -- The GraphNode
+  class GraphNode
+
+    attr :tokens, true         # Array( Token )
+    attr :children, true       # Array( GraphNode )
+    attr :parents, true        # Array( GraphNode )
+    attr :engine, true         # Engine which owns (and probably created) this
+    attr :name, true           # String
+    attr :maxParents, true     # set to 1, subclasses can change
+    attr :maxChildren, true    # set to 1, subclasses can change
+    attr :passedTokens, true   # A dynamic object usually controlled by other objects
+    attr :rejectedTokens, true # Changes
+		attr :shouldExecute, true # Boolean
+		attr :sittingChild, true 
+		
+    def initialize
+      self.tokens    = Array.new
+      self.children  = Array.new
+      self.parents    = Array.new
+      self.name      = String.new
+      self.maxParents = self.maxChildren = 1
+      self.engine = nil
+      self.passedTokens = Array.new
+      self.rejectedTokens = Array.new
+      self.shouldExecute = true
+			self.sittingChild = nil
+			self
+    end
+
+    # Attempts to add token to self and then execute. Fails if token is 
+    # already registered
+    def addToken( token, sender )
+      self.tokens = Array.new if self.tokens == nil
+      return if self.registerToken( token ) == false
+      execute if self.shouldExecute
+    end
+
+    # Convenience method to add an array of tokens
+    def setTokens( toks, sender ); toks.each { |token| self.addToken( token, sender ) == 1 }; end
+
+    # Sets the GraphNode child
+    def setChild( child )
+      self.children = Array.new
+      self.children.push( child )
+    end
+
+    # Clears children
+    def removeChildren; self.children = Array.new; end
+    
+    # Clears parents
+    def removeParents; self.parents = Array.new; end
+
+		def setChildren( children )
+			children.each do |child|
+				self.addChild( child )
+			end
+		end
+		
+    # Attemps to add child to children. Fails if child is already a child
+    # or if number of children is already at maximum
+    def addChild( child ) 
+      if self.children.includeID?( child )
+				self.warning( "adding a child which is already part of the children of this node  class: #{self.class}" )
+				return
+      end
+      self.warning( "GraphNode#addChild warning -- self.children can't be larger than #{self.maxChildren} for this node type #{self.class}" ) if ( self.maxChildren != -1 ) and ( self.children.size + 1 ) > self.maxChildren
+			if self.maxChildren != -1 and ( self.children.size + 1 > self.maxChildren )
+				self.children.shift
+			end
+      self.children.push( child )
+    end
+
+		def setParents( parents )
+			self.parents.clear
+			parents.each { |parent| self.addParent( parent ) }
+		end
+		
+    # Sets the GraphNode parent
+    def setParent( parent )
+      self.parents = Array.new
+      self.parents.push( parent )
+    end
+
+    # Attempts to add parent to parents. Fails if parent is already a parent
+    # or if number of parents is already at maximum
+    def addParent( parent )
+      return if parents.includeID?( parent )
+      self.warning( "GraphNode#addParent warning -- self.parents can't be larger than #{self.maxParents} for this node type #{self.class}" ) if ( self.maxParents != -1 ) and ( self.parents.size + 1 ) > self.maxParents
+      if self.maxParents != -1 and ( self.parents.size + 1 > self.maxParents )
+				self.parents.shift
+			end
+			self.parents.push( parent )
+    end
+    
+		# Convenience methods
+		def parent; self.parents.first; end
+		def child; self.children.first; end
+		
+		def makeSingleChildConnection( oNode )
+			self.setChild( oNode )
+			oNode.setParent( self )
+		end
+		
+		def makeChildConnection( oNode )
+			self.addChild( oNode )
+			oNode.addParent( self )
+		end
+		
+    # Returns true if GraphNode has token, false otherwise
+    def hasToken?( token ); self.tokens.includeID?( token ); end
+    
+    # Subclass responsibility sometimes
+    def execute
+			self.error( "GraphNode#execute -- subclass responsibility\n" ) if self.class == GraphNode
+			self.error( "Executing, but I don't have a child to pass on to" ) if self.children.size == 0
+		end
+
+    # Used for sorting -- bases result on:
+    # self.name <=> otherNode.name
+    def <=>( otherNode ); self.name <=> otherNode.name; end
+
+    
+    # Attemps to register token. Fails if engine won't register token (see Engine.rb 
+    # for details). 
+    def registerToken( token )
+			self.notice( "REGISTERING token with tokenID: #{token.tokenID}  #{token.object_id}.. token's object: #{token.objectGraphWrappers.first.object.to_s}" )
+			self.error( "No suitable engine found!") if engine == nil or !engine.kind_of?( MK::Engine )
+			#print "engine has class: #{engine.class}\n"
+      return false if self.engine and self.engine.registerToken( token ) == false
+      self.notice( "Token #{token.tokenID} registered" )
+      token.registerOwner( self ) #graphNode = self
+			self.tokens.push( token )
+			self.notice( "Token #{token.object_id}'s size: #{tokens.size}" )
+    end
+    
+		def registerTokens( ts )
+			ts = [ ts ] if ts.class != Array
+			ts.each { |t| self.registerToken( t ) }
+		end
+
+		# Deregisters token from engine and this node. A clean wipe
+    def deRegisterToken( token )
+    	#return if !tokens.include?( token )  
+			self.notice( "DEREGISTERING token #{token.tokenID}  #{token.object_id}.." )
+      token.deRegisterOwner
+      self.engine.deRegisterToken( token )
+      self.tokens.deleteID( token )
+			self.passedTokens.deleteID( token )
+			self.rejectedTokens.deleteID( token )
+    end
+		
+		def deRegisterTokens( ts = nil )
+			ts = self.tokens if ts == nil
+			ts = [ ts ] if ts.class != Array
+			ts.each { |t| self.deRegisterToken( t ) }
+		end
+		
+		def deRegisterTokenByID( tokenID )
+			tokenIDStr = ""
+			#self.tokens.each { |token| tokenIDStr = "#{tokenIDStr} #{token.tokenID}" }
+			#self.notice( "deRegistering token by ID with ID: #{tokenID} my token IDs: #{tokenIDStr}" )
+			tokensToDelete = self.tokens.select { |token| token.tokenID == tokenID }
+			tokensToDelete = [ tokensToDelete ] if tokensToDelete.class != Array
+			tokensToDelete.each { |token| deRegisterToken( token ) }
+		end
+		
+    # Convenience method to register an array of passed tokens
+    def registerPassedTokens( toks ); toks.each { |tok| self.registerPassedToken( tok ) }; end
+
+    # Attemps to register a passed token. Fails if token isn't registered at all.
+    def registerPassedToken( token )
+			self.notice( "PASSING token #{token.tokenID}" )
+      # sanity check
+			if !self.tokens.includeID?( token )
+				errorStr = "Trying to register a passed token (ID: #{token.tokenID}) which hasn't been registered first as a token"
+				if self.tokens.size > 0
+					errorStr = errorStr + "\n\tI have tokens:"
+					self.tokens.each do |t|
+						errorStr = errorStr + "\n\t#{t.object_id}"
+					end
+				end
+				self.error( errorStr )
+			end
+      self.passedTokens.push( token ) if !self.passedTokens.includeID?( token )
+			self.rejectedTokens.rejectID!( token )
+    end
+
+    # Convenience method to register an array of rejected tokens
+    def registerRejectedTokens( toks ); toks.each { |tok| self.registerRejectedToken( tok ) }; end
+
+    # Attemps to register a rejected token. Fails if token isn't registered at all.
+    def registerRejectedToken( token )
+      # sanity check
+      self.error( "Trying to register a rejected token (ID: #{token.tokenID}) which hasn't been registered first as a token" ) if !self.tokens.include?( token )
+			self.notice( "REJECTING token #{token.tokenID}" )
+      self.rejectedTokens.push( token ) if !self.rejectedTokens.includeID?( token )
+			self.passedTokens.rejectID!( token )
+    end
+
+    # Convenience method -- calls manageRejectedTokens and managePassedTokens
+    def manageTokens( nodes = nil ) 
+			self.manageRejectedTokens
+			self.managePassedTokens( nodes )
+    end
+
+		def manageTokensWithoutExecution
+			self.manageRejectedTokens
+			self.managePassedTokensWithoutExecution
+		end
+		
+    # Clears rejected tokens, and tell's Engine to do the same
+    def manageRejectedTokens
+			self.notice( "<enter>ManageRejectedTokens   rejectedTokens has size: #{self.rejectedTokens.size}" )
+      self.rejectedTokens.each do |token|
+				self.engine.tokenWasRejected( token )
+				self.deRegisterToken( token )
+      end
+      self.tokens = self.tokens - self.rejectedTokens
+      self.rejectedTokens = Array.new
+			self.notice( "<leave>ManageRejectedTokens" )
+    end
+
+    # Deregisters each passed token, unsets it as a token owned by self, 
+    # and passes it on to each child
+    def managePassedTokens( nodes = nil )
+			sittingChild = nil
+
+			tokenStr = ""
+			self.tokens.each { |token| tokenStr = "#{tokenStr}#{token.tokenID}, " }
+			passedTokenStr = ""
+			self.passedTokens.each { |token| passedTokenStr = "#{passedTokenStr}#{token.tokenID}, " }
+      self.notice( "<enter>ManagePassedTokens  I have #{self.tokens.size} tokens: #{tokenStr}" )
+			self.notice( "I have #{self.passedTokens.size} passed tokens. They are: #{passedTokenStr}" )
+
+			self.tokens = self.tokens - self.passedTokens
+      tokensToPass = passedTokens
+      self.passedTokens = Array.new
+      self.notice( "I have #{tokensToPass.size} tokens to pass" )
+			tokensToPass.each do |token|
+				self.error( "This token is both passed and rejected!" ) if rejectedTokens.includeID?( token ) 
+	  		self.deRegisterToken( token )
+				childrenToPassTo = self.children
+				childrenToPassTo = nodes if nodes != nil
+				childrenToPassTo = [ childrenToPassTo ] if childrenToPassTo.class != Array
+		 		childrenToPassTo.size.times do |cidx| # each do |child|
+					child = childrenToPassTo[ cidx ]
+					next if child == nil
+					self.notice( "Passing token #{token.tokenID} with ID: #{token.object_id} to child with name: #{child.name}" )
+					# If the token isn't registered, then pass it to the next child.. if it is registered, mark the child that it is at
+					if self.engine.tokenIsRegistered?( token )
+						#print "it's registered\n"
+						self.sittingChild = childrenToPassTo[ cidx - 1 ]
+						break
+					else 
+						child.addToken( token, self )
+					end
+				end
+			end
+    end
+
+    def managePassedTokensWithoutExecution
+			self.notice( "<enter>ManagePassedTokens  self.tokens.size: #{self.tokens.size}" )
+			self.tokens = self.tokens - self.passedTokens
+      tokensToPass = passedTokens
+      self.passedTokens = Array.new
+      self.notice( "I have #{tokensToPass.size} tokens to pass" )
+			tokensToPass.each do |token|
+	  		self.deRegisterToken( token )
+		 		self.children.each do |child| 
+					self.notice( "Passing token to child with name: #{child.name}" )
+					child.stopExecution
+					child.addToken( token, self )
+					child.startExecution
+				end
+			end
+    end
+
+		def stopExecution
+			self.shouldExecute = false
+		end
+
+		def startExecution
+			self.shouldExecute = true
+		end
+
+    # Does nothing for now
+    def cleanTokens
+    end
+
+		# Printing
+		def tokens_to_s; self.tokens.printList( :tokenID ); end
+				
+  end
+end

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

@@ -0,0 +1,83 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ObjectAddon'
+  require 'nist/khammurabi/ArrayAddon'
+
+  # This class is used for securing up loose leaves at the end of a graph.
+  # See Engine's documentation for more information on how it is used in the
+  # compilation of the GraphNode tree.
+  # This class utilizes two parents. When both parents pass a token to it, it
+  # combines both tokens into one, and then passes the token onto its children.
+  class GraphNodeJoiner < GraphNode
+
+    attr :leftTokens, true  # tokens from the left parent
+    attr :rightTokens, true # tokens from the right parent
+    
+    def GraphNodeJoiner.init( name, parent1, parent2, engine )
+      graphNodeJoiner = GraphNodeJoiner.new
+      graphNodeJoiner.name = name
+      graphNodeJoiner.addParent( parent1 )
+      graphNodeJoiner.addParent( parent2 )
+      graphNodeJoiner.engine = engine
+      graphNodeJoiner
+    end
+
+    def initialize
+      super
+      self.maxParents = 2
+      self.leftTokens = Array.new
+      self.rightTokens = Array.new
+      self
+    end
+
+    # Attemps to add a token. Fails if sender is null or if sender isn't equal (id-wise)
+    # to one of its parents
+    def addToken( token, sender )
+			self.notice( "Adding token with id: #{token.tokenID}" )
+			#outString = "Tokens now: "
+      #self.tokens.each { |token| outString = outString + "#{token.tokenID} " }
+			#self.notice( outString )
+			return if self.registerToken( token ) == false
+      if sender.equal?( parents.first )
+	  		self.leftTokens.push( token )
+      elsif sender.equal?( parents.second )
+	  		self.rightTokens.push( token ) 
+      else
+	  		self.error( "GraphNodeJoiner#addToken error -- don't know which token set to set token to" )
+      end
+      return execute
+    end
+
+    # Convenience method for adding an array of tokens
+    def setTokens( tokens, sender )
+      tokens.each { |token| return 1 if self.addToken( token, sender ) == 1 }
+      return 0
+    end
+
+    # Checks if at least two tokens are available for joining (one from the left
+    # parent and one from the right parent). If so, rejects both tokens, creates a 
+    # new token composed of both left and right, and passes the new token.
+    def execute
+			super
+      if self.leftTokens.size > 0 and self.rightTokens.size > 0
+	  		token = Token[ self.leftTokens.first, self.rightTokens.first ]
+				self.registerRejectedToken( self.leftTokens.first )
+				self.registerRejectedToken( self.rightTokens.first )
+				self.manageTokens
+				self.leftTokens.reject! { |tok| tok.equal?( self.leftTokens.first ) }
+				self.rightTokens.reject! { |tok| tok.equal?( self.rightTokens.first ) }
+				self.registerToken( token )
+				self.registerPassedToken( token )
+				self.manageTokens
+			end
+    end
+
+    # Private convenience method to shift both left and rightTokens. Shouldn't be called manually.
+    def shiftTokens
+      self.leftTokens.shift
+      self.rightTokens.shift
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+class Hash
+
+	# Performs a join on each key,value pair. For example, if Hash h is composed of
+	# ( "one" => 1, "two" => 2, "three" => 3 ), calling h.join( "=>", ", " ) will print
+	#  "one" => 1, "two" => 2, "three" => 3
+	def join( str1, str2 )
+		retStr = ""
+		i = 0
+		self.each_pair do |key,value|
+			if i < self.size - 1
+				retStr = "#{retStr}#{key}#{str1}#{value}#{str2}"
+			else
+				retStr = "#{retStr}#{key}#{str1}#{value}"
+			end
+			i = i + 1
+		end
+		retStr
+	end
+
+	def hashSelect( &proc )
+		retHash = Hash.new
+		self.each_pair do |key,value|
+			retHash[ key ] = value if proc.call( key,value )
+		end
+		retHash
+	end
+	
+end
+

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

@@ -0,0 +1,24 @@
+require 'nist/khammurabi/ArrayAddon'
+
+# This module provides a framework for objects to have hostilities to other objects. This is used
+# in clusters (more speicifcally, joining of objects to clusters). If an object in cluster X is hostile to another object o2,
+# the X will normally not let o2 join it.
+# This module requires the object include'ing it to make an instance variable Array named hostilities
+module Hostilities
+
+	def becomeHostileTo( element ); self.hostilities.push( element );	end
+	def becomeFriendlyTo( element ); self.hostilities.deleteID( element ); end
+	def isHostileTo?( element ); self.hostilities.includeID?( element ); end
+
+	def hostilities_to_s
+		hStr = ""
+		self.hostilities.each_index do |index|
+			hostilities = self.hostilities[ index ]
+			hStr = "#{hStr}#{hostilities.tokenID}, " if index < self.hostilities.size - 1
+			hStr = "#{hStr}#{hostilities.tokenID}" if index == self.hostilities.size - 1
+		end
+		hStr
+	end
+
+end
+