rrt_ruby 0.2.1-mswin32 → 0.3.0-mswin32

data/lib/rrt_ruby/rrt_logical.rb

@@ -1,314 +0,0 @@
-#Contains the Logical View corresponding elements and Finder functionality.
-#See RRT_RUBY::RRTLogical
-
-#
-RRT_DIR="rrt_ruby/" unless defined?(::RRT_DIR)
-require RRT_DIR+'rrt_generic'
-module RRT_RUBY
-	#Adds functionality for accessing the Logical View of 
-	#a RoseRT model.
-	module RRT_RUBY::RRTLogical
-		class LogicalPackage<RRTGeneric::Element
-			attr_reader :capsules,:classes,:packages,:protocols,:parent
-			def initialize element
-				begin
-					super(element)
-					@capsules=extract_capsules(element.Capsules)
-					@classes=extract_classes(element.Classes)
-					@packages=extract_packages(element.LogicalPackages)
-					@protocols=extract_protocols(element.Protocols)
-					@parent=element.ParentLogicalPackage.GetQualifiedName
-				end
-			end
-			def to_s
-				return "#{@name}, #{@packages.size} packages, #{@capsules.size} capsules, #{@classes.size} classes, #{@protocols.size} protocols"
-			end
-			private
-			def extract_classes col
-				ar=Array.new
-				count=col.Count
-				1.upto(count){|i|
-					ar<<RRTLogical::Class.new(col.GetAt(i))
-				}
-				return ar
-			end
-			def extract_capsules col
-				ar=Array.new
-				count=col.Count
-				1.upto(count){|i|
-					ar<<Capsule.new(col.GetAt(i))
-				}
-				return ar
-			end
-			def extract_protocols col
-				ar=Array.new
-				count=col.Count
-				1.upto(count){|i|
-					ar<<Protocol.new(col.GetAt(i))
-				}
-				return ar
-			end
-			def extract_packages col
-				ar=Array.new
-				count=col.Count
-				1.upto(count){|i|
-					ar<<LogicalPackage.new(col.GetAt(i))
-				}
-				return ar
-			end
-		end
-		class Capsule<RRTGeneric::Element
-			attr_reader :roles,:connectors,:dependencies
-			def initialize element
-				begin
-					super(element)
-					#get the roles out of the element
-					@roles=extract_roles(element.Structure.ClassifierRoles)
-					@connectors=extract_connectors(element.Structure.Connectors)
-					@dependencies=extract_dependencies(element.GetClassDependencies)
-				rescue
-					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
-				end
-			end
-			
-			def to_s
-				return "#{@name}, #{@roles.size} roles, #{@dependencies.size} dependencies"
-			end
-			
-			private
-			#extracts information out of the OLE element to construct the list of Roles contained in the capsule
-			def 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 extract_connectors col
-				ar=Array.new
-				count=col.Count
-				1.upto(count){|i|
-					ar<<Connector.new(col.GetAt(i))
-				}
-				return ar
-			end
-			#extracts the classes with which this capsule has a dependency
-			def extract_dependencies col
-				ar=Array.new
-				count=col.Count
-				1.upto(count){|i|
-					ar<<RRTLogical::Class.new(col.GetAt(i).GetSupplierClassifier)
-				}
-				return ar
-			end
-		
-		end
-		
-		class Role<RRTGeneric::Element
-			attr_reader :class_name, :cardinality, :capsule, :parent
-			def initialize element
-				begin
-					super(element)
-					#name for the class and cardinality
-					@class_name=element.ClassifierName
-					@cardinality=element.multiplicity
-					#get the name of the capsule containing the role
-					@parent=element.ParentCollaboration.ParentClassifier.Name
-					#get the capsule for the role
-					@capsule=nil
-					#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 RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
-				end
-			end
-			
-			def to_s
-				return "#{@name}/#{@class_name}"
-			end
-		end
-		
-		
-		class Connector<RRTGeneric::Element
-			attr_reader :connects_to,:cardinality
-			def initialize element
-				begin
-					super(element)
-					@connects_to=Array.new
-					#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 RRTGeneric::ElementException.new(element),"error while initialising element:#{$!}"
-				end
-			end
-			
-			def to_s
-				super()
-			end
-		end
-		class Class<RRTGeneric::Element
-			attr_reader :attributes
-			def initialize element
-				begin
-					super(element)
-					@attributes=extract_attributes(element)
-				rescue
-					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
-				end
-			end
-			
-			def to_s
-				super()+", #{@attributes.size} attributes"
-			end
-			
-			private
-			#extracts the attributes of this class
-			def 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
-		end
-	
-		class Attribute<RRTGeneric::Element
-			attr_reader :init_value, :type
-			
-			def initialize element
-				begin
-					super(element)
-					@init_value=element.InitValue
-					@type=element.Type
-				rescue
-					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
-				end
-			end
-			
-			def to_s
-				return "#{@name}=#{@init_value}/#{@type}"
-			end
-		end
-		class Protocol<RRTGeneric::Element
-			def initialize element
-				begin
-					super(element)
-				rescue
-					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
-				end
-			end
-			
-			def to_s
-				super()
-			end
-		end
-		
-		#Adds functionlaity for querying component view elements.
-		module LogicalFinderModule
-			LOGICAL_PACKAGE='LogicalPackage'
-			#delivers all fully qualified capsule names under the defined package.
-			#If the parameter does not correspond to a logical view package it will return an empty array
-			#It will not recurse.
-			def capsule_names root_package,debug=false
-				raise RRTGeneric::FinderException.new(@modelname),"This Finder instance is invalid" unless @model
-				capsules=Array.new
-				#first of all find the package in the model
-				pkg= find_logical_package(root_package,debug)
-				begin 
-					caps=pkg.capsules
-					@logger.debug("There are #{caps.size} capsules under #{pkg.qualifiedname}")
-					caps.each{|i|
-						capsules<<caps.qualifiedname
-					}
-				end if pkg
-				return capsules
-			end
-			#delivers all fully qualified package names under the defined package.
-			#If the parameter does not correspond to a logical view package it will return an empty array
-			#It will not recurse.
-			def package_names root_package,debug=false
-				raise RRTGeneric::FinderException.new(@modelname),"This Finder instance is invalid" unless @model
-				packages=Array.new
-				#first of all find the package in the model
-				pkg= find_logical_package(root_package,debug)
-				begin 
-					caps=pkg.LogicalPackages
-					@logger.debug("There are #{caps.Count} packages under #{pkg.GetQualifiedName}")
-					cnt=caps.Count
-					1.upto(cnt){|i|
-						packages<<caps.GetAt(i).GetQualifiedName
-					}
-				end if pkg
-				return packages
-			end
-			
-			#This will return the first logical view package matching the name or
-			#nil if no  package is found
-			#if no fully qualified name is provided, then the first match is returned
-			def find_logical_package package_name,debug=false
-				ret=nil
-				raise RRTGeneric::FinderException.new(@modelname),"This Finder instance is invalid" unless @model
-				#get the simple package name
-				splitted=package_name.split("::")
-				simple_name=splitted[splitted.size-1] unless splitted.size==0
-				#get a collection with all the packages with the same name
-				col=@model.FindModelElements(simple_name)
-				count=col.Count
-				@logger.debug("There are #{count} packages named #{simple_name}")
-				1.upto(count){|i|
-					obj=col.GetAt(i)
-					#match the first if no qualified name is given
-					ret=LogicalPackage.new(obj) if obj&&package_name==simple_name&&obj.Name==simple_name && obj.IsClass(LOGICAL_PACKAGE)
-					#match the qualified name
-					ret=LogicalPackage.new(obj)  if obj&&obj.GetQualifiedName==package_name && obj.IsClass(LOGICAL_PACKAGE)
-				}
-				col=nil
-				count=0
-				return ret
-			end
-				
-			def find_capsule capsule_name
-				raise RRTGeneric::FinderException.new(@modelname),"This Finder instance is invalid" unless @model
-				#get the simple capsule name
-				splitted=capsule_name.split("::")
-				simple_name=splitted[splitted.size-1] unless splitted.size==0
-				#find it
-				col=@model.FindModelElements(simple_name)
-				count=col.Count
-				1.upto(count){|i|
-					it=col.GetAt(i)
-					#match the first if no qualified name is given
-					return Capsule.new(it) if it &&capsule_name==simple_name&&it.Name==capsule_name && it.IsClass("Capsule")
-					#match the qualified name
-					return Capsule.new(it) if it&&it.GetQualifiedName==capsule_name&& it.IsClass("Capsule")
-				}
-				@logger.debug("Capsule #{capsule_name} not found in #{@modelname}")
-				return nil
-			end
-			#returns the RRTLogical::Class instance of the first class with the provided name.
-			#nil if nothing is found
-			def find_class name
-				raise RRTGeneric::FinderException.new(@modelname) unless @model
-				col=@model.FindModelElements(name)
-				count=col.Count
-				1.upto(count){|i|
-					it=col.GetAt(i)
-					return Class.new(it) if it && it.Name==name && it.IsClass("Class")
-				}
-				return nil
-			end
-		end
-		#This is just for compatibility with the older scripts. The RRTFinder should be used instead.
-		class LogicalFinder<RRTGeneric::Finder
-			include RRTLogical::LogicalFinderModule
-		end
-	end
-end