rrt_ruby 0.2.1-mswin32 → 0.3.0-mswin32

data/lib/rrt_ruby/rrt_component.rb

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

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

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