rrt_ruby 0.2.1-mswin32

data/lib/riva_ruby.rb

@@ -0,0 +1,78 @@
+#== Synopsis
+#	Code used over and over again
+#== Author
+# Vassilis Rizopoulos
+#
+#== Changelog
+# Created: 26.09.2005
+#
+# Last modified: 12.10.2005 by riva
+#
+#== Copyright
+# Copyright (c) 2005 Vassilis Rizopoulos
+#
+# Licensed under the same terms as Ruby.
+module RivaLib
+	#RivaLogger was created to make Logger integration in classes easier (I'm just bored with typing).
+	#
+	#Include this module in a class and call logger_init from it's initialize method 
+	#and you have a default logger included in the class.
+	#
+	#Example of using this module in a class hierarchy:
+	#
+	#class Test
+	#  include RivaLogger
+	#  def initialize init_param,logger=nil
+	#    @init_param=init_param
+	#    logger_init=logger
+	#  end
+	#  def canta
+	#      @logger.debug("o solemio")
+	#  end
+	#end
+	#
+	# m=Test.new('cucu')
+	# m.canta -->nothing
+	# logger=Logger.new(STDOUT)
+	# logger.level=Logger::DEBUG
+	# logger.datetime_format="%Y%m%d %H:%M:%S"
+	# t=Test.new("cucu",logger)
+	# t.canta --> D, [20050914 14:40:27#2136]  DEBUG -- :'o sole mio'
+	#
+	#The logger parameter in the initialize method can be used to 
+	#pass the logging context from the instantiating object, or it can be ommited and
+	#the attr_writer accessor can be used in it's place.
+	#
+	#This approach has the disadvantage of conflicting with classes that already have a @logger attribute
+	#so some caution is required.
+	module RivaLogger
+		require 'logger'
+		attr_reader :logger
+		attr_writer :logger
+		def logger_init logger=nil
+			@logger=logger
+			begin 
+				@logger=Logger.new(STDOUT)
+				@logger.level=Logger::WARN
+				@logger.level=Logger::INFO if $VERBOSE
+				@logger.level=Logger::DEBUG if $DEBUG
+				@logger.datetime_format="%Y%m%d %H:%M:%S"
+			end unless logger
+		end
+		
+		#This is for use on top level scripts
+		#It creates a logger just as I want it
+		def RivaLogger.setup_logger(filename=nil,verbose=false,debug=false)
+			if filename
+				logger=Logger.new(filename) 
+			else
+				logger=Logger.new(STDOUT)
+			end
+			logger.level=Logger::WARN
+			logger.level=Logger::INFO if verbose || $VERBOSE
+			logger.level=Logger::DEBUG if debug || $DEBUG
+			logger.datetime_format="%Y%m%d %H:%M:%S"
+			return logger
+		end
+	end
+end

data/lib/rrt_ruby/rrt_component.rb

@@ -0,0 +1,177 @@
+#Contains the Component View corresponding elements and Finder functionality.
+#See RRT_RUBY::RRTComponent
+
+#
+RRT_DIR="rrt_ruby/" unless defined?(::RRT_DIR)
+require RRT_DIR+'rrt_generic'
+module RRT_RUBY
+	#Adds functionality for accessing the Component View of 
+	#a RoseRT model.
+	module RRTComponent
+		#Represents an RRT Component
+		class Component<RRTGeneric::Element
+			attr_reader :platform,:type,:package
+			def initialize element
+				begin
+					super(element)
+					@type=element.Type
+					@platform=element.Platform
+					@package=element.ParentComponentPackage.GetQualifiedName 
+				rescue
+					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
+				end
+			end
+			def to_s
+				super()+", #{@type}/#{@platform}."
+			end
+		end
+		#A Library Component
+		class Library<Component
+			attr_reader :output_directory,:unit_name
+			
+			def initialize element
+				begin
+					super(element)
+				rescue
+					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
+				end
+			end
+			def to_s
+				super()
+			end
+		end
+		
+		#An Executable Component
+		class Executable<Component
+			attr_reader :topcapsule, :filename
+			
+			def initialize element
+				begin
+					super(element)
+					@topcapsule=element.FindProperty("OT::CppExec","TopCapsule").Value.sub("[event_ui\r\n\tdescription='","")
+					@topcapsule.sub!(/'\r\n\tcaption='Select.+\n.*/,"")
+					@filename=""
+					
+				rescue
+					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
+				end
+			end
+			def to_s
+				super()+", #{@topcapsule}."
+			end
+		end
+		
+		#~ class ExternalLibrary<Component
+			#~ 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 functionality for querying component view elements.
+		module ComponentFinderModule
+			#Delivers all fully qualified component names under the defined package.
+			#If the parameter does not correspond to a component view package it will return an empty array
+			def component_names root_package
+				components=Array.new
+				#first of all find the package in the model
+				pkg= find_component_package(root_package,debug)
+				begin 
+					comps=pkg.GetAllComponents
+					@logger.debug("There are #{comps.Count} components under #{pkg.GetQualifiedName}")
+					cnt=comps.Count
+					1.upto(cnt){|i|
+						components<<comps.GetAt(i).GetQualifiedName
+					}
+				end if pkg
+				return components
+			end
+			#Returns all components in the given package
+			def components root_package
+				components=Array.new
+				#first of all find the package in the model
+				pkg= find_component_package(root_package,debug)
+				begin 
+					comps=pkg.GetAllComponents
+					@logger.debug("There are #{comps.Count} components under #{pkg.GetQualifiedName}")
+					cnt=comps.Count
+					1.upto(cnt){|i|
+						components<<Component.new(comps.GetAt(i))
+					}
+				end if pkg
+				return components
+			end
+			#Returns all executables in the given package
+			def executables root_package
+				components=Array.new
+				#first of all find the package in the model
+				pkg= find_component_package(root_package,debug)
+				begin 
+					comps=pkg.GetAllComponents
+					@logger.debug("There are #{comps.Count} components under #{pkg.GetQualifiedName}")
+					cnt=comps.Count
+					1.upto(cnt){|i|
+						comp=comps.GetAt(i)
+						components<<Executable.new(comp) if comp.Type=~/Executable/
+					}
+				end if pkg
+				return components
+			end
+			#returns all libraries in the given package  and it's subpackages
+			def libraries root_package
+				components=Array.new
+				#first of all find the package in the model
+				pkg= find_component_package(root_package,debug)
+				begin 
+					comps=pkg.GetAllComponents
+					@logger.debug("There are #{comps.Count} components under #{pkg.GetQualifiedName}")
+					cnt=comps.Count
+					1.upto(cnt){|i|
+						comp=comps.GetAt(i)
+						type=comp.Type
+						components<<Library.new(comp) if type=~/Library/ && !(type=~/External/)
+					}
+				end if pkg
+				return components
+			end
+			#Returns all external libraries in the given package and it's subpackages
+			def external_libraries root_package
+				comps=components(root_package,debug)
+				return comps.collect{|c|
+					c if c.type=~/External/
+				}.compact
+			end
+			#This will return the first component package matching the name, nil if no component package is found.
+			#
+			#If no fully qualified name is provided, then the first match is returned
+			def find_component_package package_name,debug=false
+				#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
+					return obj if package_name==simple_name&&obj.Name==simple_name && obj.IsClass("ComponentPackage")
+					#match the qualified name
+					return obj if obj.GetQualifiedName==package_name && obj.IsClass("ComponentPackage")
+				}
+				return nil
+			end
+		end
+		#This is just for compatibility with the older scripts. The RRTFinder should be used instead.
+		class ComponentFinder<RRTGeneric::Finder
+			include RRTComponent::ComponentFinderModule
+		end
+		
+	end
+end

data/lib/rrt_ruby/rrt_deployment.rb

@@ -0,0 +1,96 @@
+#Contains the Deployment View corresponding elements and Finder functionality.
+#See RRT_RUBY::RRTDeployment
+
+#
+RRT_DIR="rrt_ruby/" unless defined?(::RRT_DIR)
+require RRT_DIR+'rrt_generic'
+module RRT_RUBY
+	#Adds functionality for accessing the Deployment View of 
+	#a RoseRT model.
+	module RRT_RUBY::RRTDeployment
+		class Processor<RRTGeneric::Element
+			attr_reader :cpu,:os,:address,:server,:processes
+			def initialize element
+				begin
+					super(element)
+					@cpu=element.CPU
+					@os=element.OS
+					@address=element.Address
+					@server=element.ServerAddress
+					@processes=Array.new
+					extract_processes(element)
+				rescue
+					raise RRTGeneric::ElementException.new(element),"error while initialising element: #{$!}"
+				end
+			end
+			def to_s
+				return super()+", #{@os}/#{@cpu}, #{@address}, #{@processes.size} processes"
+			end
+			private
+			def extract_processes(element)
+				comps=element.ComponentInstances
+				cnt=comps.Count
+				1.upto(cnt){|i|
+					@processes<<Instance.new(comps.GetAt(i))
+				}
+			end
+		end
+	
+		class Instance<RRTGeneric::Element
+			def initialize element
+				begin
+					super(element)
+					@component=element.Component
+				rescue
+					raise RRTGeneric::ElementException.new(element),"error while initialising element #{$!}"
+				end
+			end
+			def to_s
+				super()+", #{@component}"
+			end
+		end
+		#Adds functionality for querying deployment view elements.
+		module DeploymentFinderModule
+			#delivers all processors under the defined package.
+			#If the parameter does not correspond to a deployment view package it will return an empty array
+			def processors root_package,debug=false
+				components=Array.new
+				#first of all find the package in the model
+				pkg= find_deployment_package(root_package,debug)
+				begin 
+					comps=pkg.GetAllProcessors
+					$stdout.puts("There are #{comps.Count} processors under #{pkg.GetQualifiedName}") if debug
+					cnt=comps.Count
+					1.upto(cnt){|i|
+						components<<Processor.new(comps.GetAt(i))
+					}
+				end if pkg
+				return components
+			end
+			#This will return the first deployment package matching the name
+			#nil if no deployment package is found
+			#if no fully qualified name is provided, then the first match is returned
+			def find_deployment_package package_name,debug=false
+				#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
+				$stdout.puts "There are #{count} packages named #{simple_name}" if debug
+				1.upto(count){|i|
+					obj=col.GetAt(i)
+					#match the first if no qualified name is given
+					return obj if package_name==simple_name&&obj.Name==simple_name && obj.IsClass("DeploymentPackage")
+					#match the qualified name
+					return obj if obj.GetQualifiedName==package_name && obj.IsClass("DeploymentPackage")
+				}
+				return nil
+			end
+		end
+		#This is just for compatibility with the older scripts. The RRTFinder should be used instead.
+		class DeploymentFinder<RRTGeneric::Finder
+			include RRTDeployment::DeploymentFinderModule
+		end
+	end
+end

data/lib/rrt_ruby/rrt_generic.rb

@@ -0,0 +1,229 @@
+RRT_DIR="rrt_ruby/" unless defined?(::RRT_DIR)
+require RRT_DIR+'../riva_ruby'
+module RRT_RUBY
+	#This module provides the namespace for the basic RRT RRTEI Ruby interface.
+	#
+	#It introduces the Finder class as the primary interface for accessing RRT models.
+	#
+	#The module (as well as the others - RRTLogical, RRTComponent, RRTDeployment) 
+	#does not provide a one-to-one representation of RRTEI objects, just a convenience mapping 
+	#for accessing the most important features of each view.
+	#
+	#We do not attempt to duplicate the interface, just make the most usual tasks easier.
+	module RRT_RUBY::RRTGeneric
+		require 'win32ole'
+		VERSION_MAJOR=1
+		VERSION_MINOR=0
+		OLEAPP_NAME='RoseRT.Application'
+		#This is the base class for all model elements. It corresponds to RRTEI::ModelElement 
+		class Element
+			attr_reader :name,:qualifiedname,:stereotype,:documentation
+			#element is the OLE Object of a RRTEI::ModelElement or derived class
+			def initialize element
+				begin
+					@name=element.Name
+					@qualifiedname=element.GetQualifiedName
+					@stereotype=element.Stereotype
+					@documentation=element.Documentation
+				rescue
+					raise ElementException.new(element),"error while initialising element: #{$!}"
+				end
+			end
+	  
+			def to_s
+				return "<<#{@stereotype}>>#{@name}"
+			end
+		end
+		#Finder provides an interface for accessing RRT models using OLE Automation.
+		#Finder represents a read-only interface to a model's content, and will remain so in future versions.
+		#
+		#It will create an OLE Instance of RRT on initialization.
+		#
+		#In order to properly release this instance Finder#stop must be called prior to exiting 
+		#the Ruby application.
+		#
+		#Alternatively Finder#open can be used with a block.
+		#
+		#RRT under Windows XP (not tested on other versions) only allows three instances. Unfortunately, once an OLE Automation instance
+		#is accessed, references prevent the instances from being destroyed even after stopping a Finder.
+		#
+		#This effectively limits the number of possible Finder instances per application to three.
+		#
+		#Notice that you still need to call stop or use open with a block otherwise the RRT
+		#application will remain in memory after termination of the Ruby application.
+		class Finder
+			include RivaLib::RivaLogger
+			attr_reader :modelname, :model
+			#Initialize will throw an exception if the model cannot be opened.
+			#
+			#Finder uses Logger to log on STDOUT. Optionally you can pass a Logger instance
+			#and it will be used.
+			def initialize modelname="",logger=nil
+				@modelname=modelname
+				@app=WIN32OLE.new(RRTGeneric::OLEAPP_NAME)
+				@model=@app.OpenModel(@modelname) unless modelname.empty?
+				logger_init(logger)
+			end
+			#open is used in conjuction with a block.
+			#
+			#It creates a Finder instance and passes it to the block. 
+			#At the end of the block the Finder is stopped and invalidated.
+			#
+			#You can optionally pass a Logger instance to be used by the Finder.
+			#
+			#Without a block the method is just an alias for Finder#new
+			def Finder.open modelname,logger=nil
+				begin
+					fndr=new(modelname,logger)
+					if block_given?
+						begin
+							yield fndr
+						ensure
+							fndr.stop
+						end
+					else
+						return fndr
+					end
+				end
+			end
+			#Instructs the Finder to load a new model into it's associated RRT instance.
+			#
+			#If modelname matches the current modelname or the Finder is invalid...well, nothing will happen.
+			def reload modelname
+				begin 
+					@modelname=modelname
+					@model=@app.openmodel(@modelname)
+				end if @app && @app.CurrentModel.GetFileName.upcase!=modelname.upcase
+			end
+			#Stops the Finder releasing the OLE interface and invalidating this Finder instance.
+			#
+			#This method *must* be called to clean up resources unless you used Finder#start with a block. 
+			#
+			#If you don't call this method you will end up with a zombie RoserRT instance and a couple of MBs less memory.
+			#
+			#After calling stop the Finder instance cannot be used again (most methods throw a FinderException).
+			#
+			#Unfortunately, there is no control on when the RRT instance is going to exit.
+			#
+			#Usually RRT instances that have been accessed will not exit until the application/script ends.
+			#Since RRT only allows three running instances, this means you can only reload a stopped finder twice.
+			def stop
+				@logger.debug("Stopping Finder")
+				@app.exit if @app
+				@app.ole_free()
+				@model=nil
+				@app=nil
+			end
+			#Shows the RRT UI for the associated OLE instance
+			#Makes the RRT UI associated with the Finder visible.
+			#
+			#Throws a FinderException if no instance exists
+			def show
+				raise FinderException.new(@modelname),"This Finder instance is invalid" unless @model
+				@app.visible=true
+			end
+			#Hides the RRT UI for the associated OLE instance.
+			#
+			#Throws a FinderException if no instance exists
+			def hide
+				raise FinderException.new(@modelname),"This Finder instance is invalid" unless @model
+				@app.visible=false
+			end
+			#returns the name of the model with which the finder is connected
+			#Alias for LogicalFinder#modelname
+			def name
+				return @modelname
+			end
+			def to_s
+				return "Active on #{@modelname}" if @model
+				return "Invalid for #{@modelname}"
+			end
+		end
+		
+		#This is a convenience method that makes some assumptions about the use of the win32ole interface.
+		#
+		#It is  here to be used with scripts that don't need the full Finder functionality or want to work directly with the RRTEI interface.
+		#
+		#It only takes a block to make sure we clean up the application object afterwards. 
+		#This cleanup has a sideeffect: open RRT instances will be closed after the block finishes.
+		#
+		#RRT only seems to create one OLE application server (instance started with this session do not register as OLE servers).
+		def RRTGeneric.open_model pathname,logger=nil
+			#opens the model with the given pathname and returns a reference to the Win32OLE model object.
+			#first check the pathname
+			if File.exists?(pathname) then 
+				#check if there is an open RRT instance with this model
+				begin 
+					rt = WIN32OLE.connect(RRTGeneric::OLEAPP_NAME)
+				rescue
+					#no OLE Server present, create a new instance
+					logger.info("No OLE Server found. Creating new instance") if logger
+					rt=WIN32OLE.new(RRTGeneric::OLEAPP_NAME)
+				end
+				begin
+					# We are in Windows so filenames are case insensitive
+					if rt.CurrentModel.GetFileName.upcase==pathname.upcase
+						logger.debug("Using existing model") if logger
+						model = rt.CurrentModel  
+						#it was open before, so don't close the app at the end
+						exit_app=false
+					else
+						logger.info("Opening model") if logger
+						model=rt.openmodel(pathname)
+						exit_app=true
+					end
+					yield model
+				ensure 
+					if rt && exit_app 
+						rt.exit 
+						rt.ole_free()
+					end
+				end
+				return model
+			else
+				logger.fatal("File not found #{pathname}") if logger
+			end if block_given?
+		end
+		#Given a valid model (OLE object) it will return the first OLE object matching name and type.
+		#
+		#This wraps the FindModelElements method of the RRTEI API.
+		def RRTGeneric.find_element model,name,type
+			raise FinderException.new(""),"no model specified" unless model
+			col=model.FindModelElements(name)
+			count=col.Count
+			1.upto(count){|i|
+				it=col.GetAt(i)
+				return it if it && it.Name==name && it.IsClass(type)
+			}
+			return nil
+		end
+		
+		#Returns the pathname for the current model if an OLE server is present, nil otherwise
+		def RRTGeneric.current_model
+			begin
+				rt = WIN32OLE.connect(RRTGeneric::OLEAPP_NAME)
+				return rt.CurrentModel.GetFileName
+			rescue
+				return nil
+			end
+		end
+		
+		class ModelException<RuntimeError
+			def initialize(model)
+				@model=model
+			end
+		end
+		class ElementException<RuntimeError
+			def initialize element
+				@element=element
+			end
+		end
+		class FinderException<RuntimeError
+			attr_reader :modelname
+			def initialize modelname
+				super
+				@modelname=modelname
+			end
+		end
+	end
+end

data/lib/rrt_ruby/rrt_logical.rb

@@ -0,0 +1,314 @@
+#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

data/lib/rrt_ruby.rb

@@ -0,0 +1,46 @@
+#rrt_ruby is a library that provides access to Rational Rose RealTime models through RRTEI (The Rose Real Time Extensibility Interface).
+#In order to use it, you need a valid RoseRT license.
+#
+#For more information look at RRT_RUBY
+
+#
+RRT_DIR="rrt_ruby/" unless defined?(::RRT_DIR)
+require RRT_DIR+'rrt_logical'
+require RRT_DIR+'rrt_deployment'
+require RRT_DIR+'rrt_component'
+#== Synopsis
+#The RRT_RUBY module provides the namespace for the rrt_ruby library.
+#
+#The library defines a set of objects that correspond to model elements and the RRTFinder class that provides a way of querying a model.
+#
+#
+#== Usage
+#The following code will return a LogicalPackage instance representing the requested package containing all capsules, classes and packages thereof.
+##The backslashes are vital - '/' won't work because we are making an OLE call and RoseRT doesn't understand paths with '/'.
+# RRTFinder.open("path\\name\\to\\model.rtmdl"){|finder|
+#	finder.find_logical_package("Package")
+# }
+#
+#== Author
+# Vassilis Rizopoulos
+#
+#== Changelog
+# Created: 28.09.2005
+#
+# Last modified: 28.09.2005 by damphyr
+#
+#== Copyright
+# Copyright (c) 2005 Vassilis Rizopoulos
+#
+# Licensed under the same terms as Ruby.
+public
+module RRT_RUBY
+	VERSION_MAJOR='0'
+	VERSION_MINOR='2'
+	#RRTFinder aggregates the RRTLogical, RRTComponent and RRTDeployment modules to provide access to all views of a RoseRT model (ok, ok, RRTUseCase is missing)
+	class RRTFinder<RRTGeneric::Finder
+		include RRTLogical::LogicalFinderModule
+		include RRTComponent::ComponentFinderModule
+		include RRTDeployment::DeploymentFinderModule
+	end
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.3
+specification_version: 1
+name: rrt_ruby
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+date: 2005-10-13
+summary: rrt_ruby is a Ruby library providing access to Rose RealTime models through RRTEI
+require_paths: 
+  - lib
+email: riva@braveworld.net
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: mswin32
+authors: 
+  - Vassilis Rizopoulos
+files: 
+  - lib/riva_ruby.rb
+  - lib/rrt_ruby.rb
+  - lib/rrt_ruby/rrt_component.rb
+  - lib/rrt_ruby/rrt_deployment.rb
+  - lib/rrt_ruby/rrt_generic.rb
+  - lib/rrt_ruby/rrt_logical.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: 
+  - A Rational Rose Real Time installation with version 2002.05.20 or later on Windows
+dependencies: []