rrt_ruby 0.2.1-mswin32 → 0.3.0-mswin32

data/lib/rrt_ruby/classes.rb

@@ -0,0 +1,879 @@
+RRT_DIR="rrt_ruby/" unless defined?(::RRT_DIR)
+module RRT_RUBY
+	#This module is included by all elements that contain relations to other elements.
+	module HasRelations
+		#Adds a new Relation instance.
+		#
+		#Notice that it is possible to add a Relation that makes no sense , i.e.
+		#add a generalization from a class to a component package.
+		#
+		#_relation_ can also be an instance of RRT_RUBY::Class, Capsule, Protocol or a string with the fully qualified name of the supplier.
+		#
+		#Returns the Relation added or nil if nothing was added
+		def add_relation relation,rel_type=Relation::CLASS
+			case relation
+				when Relation
+					relation.parent=self.qualified_name
+					@relations=Array.new unless @relations
+					@relations<<relation
+					return relation
+				else
+					return add_relation(Relation.generate(relation,rel_type)) if relation
+				end
+				return nil
+		end
+		#Returns the array of Relation instances.
+		def relations
+			@relations=Array.new unless @relations
+			return @relations
+		end
+		
+		#Returns true if the same relation exists
+		def has_relation? relation
+			@relations=Array.new unless @relations
+			return @relations.include?(relation)
+		end
+	end
+	
+	#Errors from the Element derived classes are reported with this class
+	class ElementException<RuntimeError
+	end
+	
+	#Errors reported when handling a RoseRT model (such as source control status, writability etc)
+	#are of this class
+	class ModelException<RuntimeError
+	end
+	
+	#This is the base class for all model elements. It corresponds to RRTEI::ModelElement 
+	class Element
+		attr_reader :name,:parent,:stereotype,:documentation
+		attr_writer :stereotype,:documentation
+		#element is the OLE Object of a RRTEI::ModelElement or derived class
+		def initialize element=nil
+			@name="<unnamed>"
+			@stereotype=""
+			@documentation=""
+			@parent=""
+			begin
+				@name=element.Name
+				qualified=element.GetQualifiedName
+				#construct the parent name
+				splitted=qualified.split("::")
+				@parent=splitted.collect{|s|
+					s unless splitted.size==0 || s==splitted[splitted.size-1] 
+				}.compact.join('::')
+				@parent="" unless @parent
+				@stereotype=element.Stereotype
+				@documentation=element.Documentation
+			rescue
+				raise ElementException,"Error while initialising element: #{$!}"
+			end if element
+		end
+		#Returns the fully qualified name for this element
+		def qualified_name
+			return @name if @parent.empty?
+			return "#{@parent}::#{@name}"
+		end
+		def to_s
+			return "<<#{@stereotype}>>#{@name}"
+		end
+		#changes the name of the element and the parent of all contained elements
+		def name=name
+			@name=name
+			change_parentage
+		end
+		#changes the parent of the element and the parent of all contained elements
+		def parent=name
+			@parent=name
+			change_parentage
+		end
+		protected
+		#This should be overwritten to provide the elements to be updated
+		def contained_elements
+			return []
+		end
+		private
+		#Sets parent for all elements of _collection_
+		def change_parentage
+			contained_elements.each{|e|
+				e.parent=self.qualified_name
+			}
+		end
+	end
+	#Relation represents any kind of relation between elements in the model.
+	#
+	#At the moment a Relation instance can represent a dependency (class, package or component)
+	#a generalization or a realization.
+	#
+	#Associations are not yet implemented
+	class Relation<Element
+		CLASS="ClassDependency"
+		COMPONENT="ComponentDependency"
+		LOGICALPACKAGE="LogicalPackageDependency"
+		GENERALIZATION="Generalization"
+		REALIZE="RealizeRelation"
+		attr_reader :supplier,:relation_type
+		attr_writer :supplier,:relation_type
+
+		def initialize element=nil,type=""
+			@supplier=""
+			@relation_type=type
+			super(element)
+			begin
+				@supplier=element.GetSupplier.GetQualifiedName
+			rescue
+				raise ElementException,"Error while initialising relation: #{$!}"
+			end if element
+		end
+		
+		#Two Relation objects are equal when they are of the same type and have the same supplier
+		def eql?(other) 
+			return true if other.instance_of?(Relation)&&self.supplier==other.supplier && self.relation_type==other.relation_type
+			return false
+		end
+		
+		def ==(other)
+			return eql?(other)
+		end
+		
+		def to_s
+			case @relation_type
+				when CLASS : txt="Dependency to class #{@supplier}"
+				when COMPONENT : txt="Dependency to component #{@supplier}"
+				when LOGICALPACKAGE : txt="Dependency to package #{@supplier}"
+				when GENERALIZATION : txt="Generalization of #{@supplier}"
+				when REALIZE : txt="Realization of #{@supplier}"
+				else
+					txt="Unknown relation (#{@relation_type}) to #{@supplier}"
+			end
+			return txt
+		end
+		
+		#Creates a Relation object
+		#_supplier_ can  be an instance of RRT_RUBY::Class, Capsule, Protocol in which case the qualified name of the instance is used as a supplier
+		#
+		#or a string containing the fully qualified name of the supplier.
+		#
+		#Returns the Relation or nil if _supplier_ was invalid
+		#
+		#By default it creates class dependencies
+		def self.generate supplier,rel_type=Relation::CLASS
+			case supplier
+				when String
+					#nothing if the string is empty
+					return nil if supplier.empty?
+					rel=Relation.new(nil,rel_type)
+					rel.supplier=supplier
+					return rel
+				when RRT_RUBY::Class || Capsule || Protocol
+					rel=Relation.new(nil,rel_type)
+					rel.supplier=supplier.qualified_name
+					return rel
+			end
+			return nil
+		end
+	end
+	
+	
+	#~ class Model#:nodoc: all
+		#~ attr_reader :logical_view
+		#~ attr_reader :component_view
+		#~ attr_reader :deployment_view
+		#~ def initialize logical_view=nil,component_view=nil,deployment_view=nil
+			#~ if logical_view
+				#~ @logical_view=logical_view if logical_view.instance_of?(LogicalPackage)
+			#~ else
+				#~ @logical_view=LogicalPackage.new
+			#~ end
+			#~ @logical_view.name="Logical View"
+		#~ end
+	#~ end
+	
+	############################# Logical view #############################
+	
+	#A LogicalPackage contains Element instances that belong to the logical view of a model.
+	#
+	#Using the LogicalPackage instance returned by Finder#root_logical_package you have access to the entire
+	#logical view contents of a model.
+	#
+	#A LogicalPackage contains Capsule, Class, Protocol and LogicalPackage instances.
+	class LogicalPackage<Element
+		include HasRelations
+		attr_reader :capsules,:classes,:packages,:protocols
+		def initialize element=nil
+			@index=Hash.new
+			@capsules=Array.new
+			@classes=Array.new
+			@packages=Array.new
+			@protocols=Array.new
+			super(element)
+			begin
+				@capsules=Extractor.extract_capsules(element.Capsules)
+				@classes=Extractor.extract_classes(element.Classes)
+				@packages=Extractor.extract_logical_packages(element.LogicalPackages)
+				@protocols=Extractor.extract_protocols(element.Protocols)
+				@relations=Extractor.extract_relations(element.GetLogicalPackageDependencies,Relation::LOGICALPACKAGE)
+				@relations+=Extractor.extract_relations(element.GetGeneralizations,Relation::GENERALIZATION)
+				update_index
+			rescue
+				raise ElementException,"Error while initialising logical package: #{$!}"
+			end if element
+		end
+		
+		def to_s
+			return "#{@name}, #{@packages.size} packages, #{@capsules.size} capsules, #{@classes.size} classes, #{@protocols.size} protocols"
+		end
+		#Returns an array with all the classes contained by this package and it's subpackages
+		def all_classes
+			c=@classes
+			@packages.each{|p|
+				c+=p.all_classes
+			}
+			return c
+		end
+		#Returns an array with all the capsules contained by this package and it's subpackages
+		def all_capsules
+			c=@capsules
+			@packages.each{|p|
+				c+=p.all_capsules
+			}
+			return c
+		end
+		#Returns an array with all the protocols contained by this package and it's subpackages
+		def all_protocols
+			c=@protocols
+			@packages.each{|p|
+				c+=p.all_protocols
+			}
+			return c
+		end
+		#Returns a package contained in self whose name matches 
+		#the given name.
+		def package(package_name)
+			collection=all_packages
+			return find_package_element(package_name,collection)
+		end
+		
+		#Returns a capsule contained in self whose name matches 
+		#the given name.
+		def capsule(capsule_name)
+			collection=all_capsules
+			return find_package_element(capsule_name,collection)
+		end
+		#Returns a class contained in self whose name matches 
+		#the given name.
+		def class(name)
+			collection=all_classes
+			return find_package_element(name,collection)
+		end
+		#Returns a protocol contained in self whose name matches 
+		#the given name.
+		def protocol(name)
+			collection=all_protocols
+			return find_package_element(name,collection)
+		end
+		
+		#Searches all elements contained in this package for a match to _qualified_name_
+		def element(qualified_name)
+			el=@index[qualified_name]
+			@packages.each{|pkg|
+				el=pkg.element(qualified_name)
+				return el if el
+			} unless el
+			return el
+		end
+		#If the parameter is a string a package with that name will be created in self
+		#
+		#If the parameter is a LogicalPackage instance it will be added to self and the package's parent will change
+		def add_package package
+			case package
+				when String
+					pkg=LogicalPackage.new
+					pkg.name=package
+					return add_package(pkg)
+				when LogicalPackage
+					#set the parent for this package
+					package.parent=self.qualified_name
+					#add it to the packages
+					@packages=Array.new unless @packages
+					@packages<<package
+					#update the index
+					@index[package.qualified_name]=package
+					return package
+			end
+		end
+		#If the parameter is a string a class with that name will be created in self
+		#
+		#If the parameter is a Class instance it will be added to self and the classes's parent will change
+		def add_class cl
+			case cl
+				when String
+					c=RRT_RUBY::Class.new
+					c.name=cl
+					return add_class(c)
+				when RRT_RUBY::Class
+					#set the parent for this package
+					cl.parent=self.qualified_name
+					#add it to the classes
+					@classes=Array.new unless @classes
+					@classes<<cl
+					#update the index
+					@index[cl.qualified_name]=cl
+					return cl
+			end
+		end
+		#Sets the parent name and also recursively updates and contained elements.
+		def parent=package_name
+			super(package_name)
+			update_index
+		end
+		#Sets the name and also recursively updates the parent name for contained elements.
+		def name=new_name
+			super(new_name)
+			update_index
+		end
+		#Returns an array with all packages contained in this package
+		#
+		#If you have the following structure
+		# A contains B,C
+		# B contains D,E
+		# D contains F
+		#you will get [B,C,D,F,E]
+		def all_packages
+			c=@packages
+			@packages.each{|p|
+				c+=p.all_packages
+			}
+			return c.uniq
+		end
+		protected
+		#all contained elements
+		def contained_elements
+			return @index.values+self.relations
+		end
+		private
+		def find_package_element name,collection
+			ret=collection.find{|p|
+				p.qualified_name==name
+			}
+			#check the simple name unless already matched
+			ret=collection.find{|p|
+				p.name==name
+			} unless ret
+			return ret
+		end
+		#Adds the entries to the Hash
+		def update_index
+			@classes.each{|e|
+				@index[e.qualified_name]=e
+			}
+			@capsules.each{|e|
+				@index[e.qualified_name]=e
+			}
+			@packages.each{|e|
+				@index[e.qualified_name]=e
+			}
+			@protocols.each{|e|
+				@index[e.qualified_name]=e
+			}
+			self.relations.each{|e|
+				@index[e.qualified_name]=e
+			}
+		end
+		
+	end
+	
+	#Represents a Class element in a model
+	class Class<Element
+		include HasRelations
+		attr_reader :attributes
+		def initialize element=nil
+			@attributes=Hash.new
+			super(element)
+			begin
+				@attributes=Extractor.extract_attributes(element)
+				@relations=Extractor.extract_relations(element.GetClassDependencies,Relation::CLASS)
+				@relations+=Extractor.extract_relations(element.GetGeneralizations,Relation::GENERALIZATION)
+				@relations+=Extractor.extract_relations(element.GetRealizeRelations ,Relation::REALIZE)
+			rescue
+				raise ElementException,"error while initialising class: #{$!}"
+			end if element
+		end
+		#If the parameter is a string an attribute with that name will be created in self
+		#
+		#If the parameter is an Attribute instance it will be added to self and the Attribute's parent will change
+		#
+		#Returns the added Attribute, nil if something other than String or Attribute was provided.
+		def add_attribute attr
+			case attr
+				when String
+					c=Attribute.new
+					c.name=attr
+					return add_attribute(c)
+				when Attribute
+					#set the parent for this package
+					attr.parent=self.qualified_name
+					@attributes[attr.name]=attr 
+					return attr
+			end
+			return nil	
+		end
+	
+		def to_s
+			super()+", #{@attributes.size} attributes"
+		end
+		protected
+		#all contained elements
+		def contained_elements
+			collection=self.attributes.values
+			collection+=self.relations
+			return collection
+		end
+	end
+	
+	#Represents a Capsule element in a model
+	class Capsule<Class
+		include HasRelations
+		attr_reader :roles, :connectors
+		def initialize element=nil
+			@roles=Array.new
+			@connectors=Array.new
+			super(element)
+			begin
+				#get the roles out of the element
+				@roles=Extractor.extract_roles(element.Structure.ClassifierRoles)
+				@connectors=Extractor.extract_connectors(element.Structure.Connectors)
+			rescue
+				raise ElementException,"Error while initialising capsule: #{$!}"
+			end if element 
+		end
+		
+		#Adds a Role instance to this Capsule's roles.
+		def add_role role
+			begin
+				role.parent=self.qualified_name
+				@roles<<role 
+			end if role.instance_of?(Role)
+		end
+		
+		def to_s
+			return "#{@name}, #{@roles.size} roles, #{@relations.size} relations"
+		end
+		protected
+		#all contained elements
+		def contained_elements
+			collection=self.roles
+			collection=self.connectors
+			collection+=self.relations
+			return collection
+		end
+	end
+	
+	#Represents an Attribute element.
+	#
+	#Attributes are member and/or class variables in classes and capsules
+	class Attribute<Element
+		#default Attribute value
+		attr_reader :init_value
+		#Attribute type
+		attr_reader :type
+		attr_writer :init_value, :type
+		
+		def initialize element=nil
+			@init_value=""
+			@type=nil
+			super(element)
+			begin
+				@init_value=element.InitValue
+				@type=element.Type
+			rescue
+				raise ElementException,"Error while initialising attribute: #{$!}"
+			end if element
+		end
+		
+		def to_s
+			return "#{@name}=#{@init_value}/#{@type}"
+		end
+	end
+	
+	#A Role is an instance of a Capsule within another Capsule (a composition relation between Capsule objects)
+	class Role<Element
+		attr_reader :class_name, :cardinality, :capsule
+		def initialize element=nil
+			@class_name=""
+			@cardinality=""
+			@capsule=nil
+			super(element)
+			begin
+				#name for the class and cardinality
+				@class_name=element.ClassifierName
+				@cardinality=element.multiplicity
+				#checking against the name of the parent ensures that we avoid endless loops
+				@capsule=Capsule.new(element.Classifier) if element.Classifier.IsClass("Capsule") && element.Classifier.name==@parent
+			rescue
+				raise ElementException,"Error while initialising role: #{$!}"
+			end
+		end
+		
+		def to_s
+			return "#{@name}/#{@class_name}"
+		end
+	end
+	
+	#A Connector is a connection between two wired ports.
+	#
+	#Connector is a member of Capsule indicating wired connections with contained ports.
+	class Connector<Element
+		attr_reader :connects_to,:cardinality
+		def initialize element
+			@connects_to=Array.new
+			@cardinality="*"
+			super(element)
+			begin
+				#this gets name of the capsule containing the port this connector connects to.
+				#with this configuration the Connector is only to be used as a member of a capsule (so this defines one end of the connection and the parent object defines the  other end)
+				@connects_to<<element.PortRole1.ParentCapsuleRole.Name if element.PortRole1
+				@connects_to<<element.PortRole2.ParentCapsuleRole.Name if element.PortRole2
+				@cardinality=element.Cardinality
+			rescue
+				raise ElementException,"error while initialising connector:#{$!}"
+			end if element
+		end
+		
+		def to_s
+			super()
+		end
+	end
+	
+	#A Protocol is a class defining an asynchronous interface for Capsule use.
+	class Protocol<Element
+		include HasRelations
+		def initialize element=nil
+			super(element)
+		end
+			
+		def to_s
+			super()
+		end
+	end
+	
+	############################## Component View ##########################
+	
+	#A ComponentPackage contains Component and ComponentPackage instances
+	#
+	#Components come in two types: Executable and Library
+	class ComponentPackage<Element
+		include HasRelations
+		attr_reader :components,:packages
+		def initialize element=nil
+			@index=Hash.new
+			@packages=Array.new
+			@components=Array.new
+			super(element)
+			begin
+				@relations=Extractor.extract_relations(element.GetComponentDependencies,Relation::COMPONENT)
+				@components=Extractor.extract_components(element.Components)
+				@packages=Extractor.extract_component_packages(element.ComponentPackages)
+				update_index
+			rescue
+				raise ElementException,"Error while initialising component package: #{$!}"
+			end if element
+		end
+		#Returns an array with all packages contained in this package
+		#
+		#If you have the following structure
+		# A contains B,C
+		# B contains D,E
+		# D contains F
+		#you will get [B,C,D,F,E]
+		def all_packages
+			c=@packages
+			@packages.each{|p|
+				c+=p.all_packages
+			}
+			return c.uniq
+		end
+		
+		def all_components
+			c=@components
+			@packages.each{|p|
+				c+=p.all_components
+			}
+			return c.uniq
+		end
+		protected
+		#all contained elements - to use for changing parentage
+		def contained_elements
+			return @index.values+self.relations
+		end
+		private
+		#Adds the entries to the Hash
+		def update_index
+			@components.each{|e|
+				@index[e.qualified_name]=e
+			}
+			@packages.each{|e|
+				@index[e.qualified_name]=e
+			}
+			self.relations.each{|e|
+				@index[e.qualified_name]=e
+			}
+		end
+	end
+	#Represents an RRT Component
+	class Component<Element
+		include HasRelations
+		attr_reader :platform,:type
+		def initialize element=nil
+			super(element)
+			begin
+				@type=element.Type
+				@platform=element.Platform
+				@relations=Extractor.extract_relations(element.GetComponentDependencies,Relation::COMPONENT)
+			rescue
+				raise ElementException,"error while initialising element: #{$!}"
+			end if element
+		end
+		def to_s
+			super()+", #{@type}/#{@platform}."
+		end
+	end
+	#A Library Component
+	class Library<Component
+		#attr_reader :output_directory,:unit_name
+		
+		def initialize element=nil
+			super(element)
+		end
+		def to_s
+			super()
+		end
+	end
+	
+	#An Executable Component
+	class Executable<Component
+		attr_reader :topcapsule
+		attr_writer :topcapsule
+		
+		def initialize element=nil
+			@topcapsule=""
+			super(element)
+			begin
+				@topcapsule=element.FindProperty("OT::CppExec","TopCapsule").Value.sub("[event_ui\r\n\tdescription='","")
+				@topcapsule.sub!(/'\r\n\tcaption='Select.+\n.*/,"")
+			rescue
+				raise ElementException,"error while initialising element: #{$!}"
+			end if element
+		end
+		def to_s
+			super()+", #{@topcapsule}."
+		end
+	end
+	
+	
+	############################## Deployment View ##########################
+	
+	#A DeploymentPackage contains Processor and DeploymentPackage instances
+	class DeploymentPackage<Element
+		attr_reader :packages
+		def initialize element=nil
+			@index=Hash.new
+			@packages=Array.new
+			super(element)
+			begin
+				@packages=Extractor.extract_deployment_packages(element.DeploymentPackages)
+				update_index
+			rescue
+				raise ElementException,"Error while initialising deployment package: #{$!}"
+			end if element
+		end
+		#Returns an array with all packages contained in this package
+		#
+		#If you have the following structure
+		# A contains B,C
+		# B contains D,E
+		# D contains F
+		#you will get [B,C,D,F,E]
+		def all_packages
+			c=@packages
+			@packages.each{|p|
+				c+=p.all_packages
+			}
+			return c.uniq
+		end
+		protected
+		#all contained elements - to use for changing parentage
+		def contained_elements
+			return @index.values
+		end
+		private
+		#Adds the entries to the Hash
+		def update_index
+			@packages.each{|e|
+				@index[e.qualified_name]=e
+			}
+		end
+	end
+
+	#A Processor defines a unit of the deployment view
+	class Processor<Element
+		attr_reader :cpu,:os,:address,:server,:instances
+		def initialize element=nil
+			@cpu=""
+			@os=""
+			@address=""
+			@server=""
+			@instances=Array.new
+			super(element)
+			begin
+				@cpu=element.CPU
+				@os=element.OS
+				@address=element.Address
+				@server=element.ServerAddress
+				@instances=Extractor.extract_instances(element)
+			rescue
+				raise ElementException,"error while initialising element: #{$!}"
+			end if element
+		end
+		def to_s
+			return super()+", #{@os}/#{@cpu}, #{@address}, #{@processes.size} processes"
+		end
+	end
+	#An Instance of an Executable resides in a Processor.
+	class Instance<Element
+		def initialize element=nil
+			#@component=nil
+			begin
+				super(element)
+				#@component=element.Component
+			rescue
+				raise ElementException,"error while initialising element #{$!}"
+			end if element
+		end
+		def to_s
+			super()#+", #{@component}"
+		end
+	end
+	#~ class ExternalLibrary<Component
+		#~ def initialize element
+			#~ begin
+				#~ super(element)
+			#~ rescue
+				#~ raise ElementException,"error while initialising element"
+			#~ end
+		#~ end
+		#~ def to_s
+			#~ super()
+		#~ end
+	#~ end
+	private
+	#The methods in this module perform conversions from RRTEI element collections to arrays of RRT_RUBY class instances
+	module Extractor
+		def self.extract_classes col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<RRT_RUBY::Class.new(col.GetAt(i))
+			}
+			return ar
+		end
+		def self.extract_capsules col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<Capsule.new(col.GetAt(i))
+			}
+			return ar
+		end
+		def self.extract_protocols col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<Protocol.new(col.GetAt(i))
+			}
+			return ar
+		end
+		def self.extract_logical_packages col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<LogicalPackage.new(col.GetAt(i))
+			}
+			return ar
+		end
+		def self.extract_component_packages col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<ComponentPackage.new(col.GetAt(i))
+			}
+			return ar
+		end
+		def self.extract_deployment_packages col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<DeploymentPackage.new(col.GetAt(i))
+			}
+			return ar
+		end
+		def self.extract_components col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				type=col.GetAt(i).Type
+				ar<<RRT_RUBY::Executable.new(col.GetAt(i)) if type=~/Executable/
+				ar<<RRT_RUBY::Library.new(col.GetAt(i)) if type=~/Library/ && !(type=~/External/)
+				ar<<RRT_RUBY::Component.new(col.GetAt(i)) if type=~/External/
+				
+			}
+			return ar
+		end
+		#extracts information out of the OLE element to construct the list of Roles contained in the capsule
+		def self.extract_roles col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<Role.new(col.GetAt(i))
+			}
+			return ar
+		end
+		#extracts information out of the OLE element to construct the list of Connectors contained in the capsule
+		def self.extract_connectors col
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<Connector.new(col.GetAt(i))
+			}
+			return ar
+		end
+		#extracts the relations of a given type
+		def self.extract_relations col,rel_type
+			ar=Array.new
+			count=col.Count
+			1.upto(count){|i|
+				ar<<Relation.new(col.GetAt(i),rel_type)
+			}
+			return ar
+		end
+		#extracts the attributes from a class element
+		def self.extract_attributes element
+			ar=Hash.new
+			col=element.Attributes
+			count=col.Count
+			1.upto(count){|i|
+				a=Attribute.new(col.GetAt(i))
+				ar[a.name]=a
+			}
+			return ar
+		end
+		#extracts the instances from a processor element
+		def self.extract_instances(element)
+			comps=element.ComponentInstances
+			cnt=comps.Count
+			1.upto(cnt){|i|
+				@processes<<Instance.new(comps.GetAt(i))
+			}
+		end
+	end
+end