fhlow 1.91.0

data/lib/module_fhlow/leaffactory.rb

@@ -0,0 +1,97 @@
+#----------------------------------------------------------------------------
+# 
+# Copyright (C) 2007 Simon Lasselsberger
+# simon.lasselsberger@fh-hagenberg.at
+#
+# This file is part of the _fhlow_ scripting environment.
+#
+# The _fhlow_ scripting environment is free software; you can redistribute 
+# it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# _fhlow_ is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with _fhlow_; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#----------------------------------------------------------------------------
+
+module Fhlow
+
+    # This class implements the Factory Pattern in order to create concrete Leaf's 
+    # (Package's and Unit's). There also needs to be a concrete PackageFactory and 
+    # UnitFacotry because this class is _abstract_. Therefore it is very easy to
+    # implement new Leaf's if needed.
+    class LeafFactory
+        protected
+            # _Abstract_ constructor
+            def initialize()
+            end
+
+        public
+
+            # An Array of subclasses.
+            @@factories = []
+
+            # Is invoked when this class gets inherited. This mechanism makes a register 
+            # function in subclasses obsolete because they register themselves when they
+            # inherit.
+            # +_lf+:: a sublcass of LeafFactory
+            def LeafFactory.inherited(_lf)
+                @@factories.push(_lf)
+            end
+
+            
+=begin            def LeafFactory.getFactories()
+                @@factories
+            end
+=end
+
+            # In order to request a concrete Leaf this function can be used by passing the
+            # __prefix_ (to specify which concrete Leaf is needed) and some arguments 
+            # (which will be used to initialize the concrete Leaf).
+            # +_prefix+:: Is used to specify which concrete Leaf is needed.
+            # <tt>*_args</tt>:: see Package.create and Unit.create for more information.
+            def LeafFactory.getLeafFor(_prefix, *_args)
+                @@factories.each do |subclass|
+                    if subclass.getPrefix == _prefix
+                        return subclass.new.create(*_args)
+                    end
+                end
+            end
+
+            
+            # This function loads all files with the extension _.rb_ from the specified directory.
+            # So concrete Leaf's are clearly seperated from the rest of the fhlow implementation.
+            # +_dirname+:: Absolute path to the directory.
+            def LeafFactory.load(_dirname)
+                Dir.open(_dirname).each do |file|
+                    if file =~ /[.]rb$/
+                        require _dirname+"/"+file 
+                    end
+                end
+            end
+
+
+            # This function is _abstract_ and has to be implemented in the subclasses. It's purpose
+            # is to return the prefix of the concrete Leaf.
+            def LeafFactory.getPrefix()
+                raise NotImplementedError, "You have to implement getPrefix() in sublcasses inherited from LeafFactory!"
+            end
+
+
+            # This function is _abstract_ and has to be implemented in the subclasses. It's purpose
+            # is to create an object of the subclass.
+            # <tt>*_args</tt>:: An Array of arguments that are passed to the constructor if the subclass.
+            def create(*_args)
+                raise NotImplementedError, "You have to implement create() in sublcasses inherited from LeafFactory!"
+            end
+
+        end
+
+end

data/lib/module_fhlow/leafs/Package.rb

@@ -0,0 +1,55 @@
+require 'leaf'
+require 'leaffactory'
+
+module Fhlow
+
+    # This is a concrete implementation of the abstract class Leaf. A Package represents one Leaf 
+    # with the prefix "pkg". 
+    class Package < Leaf
+
+        # Calls the constructor of Leaf.
+        # +_name+::     The Name of the Leaf.
+        # +_parent+::   The reference to the parent.
+        # +_conf+::     The configuration information from higher levels.
+        # +_log+::      The reference to the Log object.
+        # +_pen+::      The reference to a Pen object.
+        def initialize(_name, _parent, _log, _pen)
+            super("pkg", _name, _parent, _log, _pen)
+        end
+
+        # This function returns an Array of filenames in respect of the dependency tree.
+        # +_deptype+::      Type of the requested dependencies (could be Units, BhvUnits, Packages and so on)
+        # +_istoplevel+::   Is used to indicate the first entrance to this function.
+        # +_caller+::       Reference to the caller of the function. This is needed to request architectures.
+        # +_files+::        The Array of the files which will be filled with the requested filenames and returned in the end.
+        def getFiles(_deptype, _istoplevel=true, _caller=nil, _files=Array.new)
+            @dependencies.values.each { |v| v.each { |dep| dep.getFiles(_deptype, false, self, _files)} } unless @dependencies.nil?
+            
+            # only act if Packages are needed
+            if _deptype == "Packages"
+                _files.push(getPath+"src/"+name+"-p.vhd")
+            end
+        end
+
+
+    end
+
+    # This is a concrete implementation of the _abstract_ class LeafFactory . 
+    # A PackageFactory creates objects of Unit. 
+    class PackageFactory < LeafFactory
+
+        # Return the prefix used by Units.
+        def PackageFactory.getPrefix()
+            return "pkg"
+        end
+
+        # Creates objects of Unit.
+        # <tt>*_args</tt>:: Array of argumens passed to the constructor of Unit. See Unit.initialize for more details.
+        def create(*_args)
+            return Package.new(*_args)
+        end
+
+    end
+
+end
+

data/lib/module_fhlow/leafs/Unit.rb

@@ -0,0 +1,152 @@
+require 'leaf'
+require 'leaffactory'
+
+module Fhlow
+
+    # This is a concrete implementation of the abstract class Leaf. A Unit represents one Leaf 
+    # with the prefix "unit". It also contains information about it's architectures.
+    # Architectures are stored in a Hash (@architectures) whose keys are references to Leafs that 
+    # have dependencies on this Unit.
+    # == TODO
+    # * make this explaination more clear
+    class Unit < Leaf
+
+        # Calls the constructor of Leaf and initializes the _architecture_ member.
+        # +_name+::     The Name of the Leaf.
+        # +_parent+::   The reference to the parent.
+        # +_conf+::     The configuration information from higher levels.
+        # +_log+::      The reference to the Log object.
+        # +_pen+::      The reference to a Pen object.
+        def initialize (_name, _parent, _log, _pen)
+            super("unit", _name, _parent, _log, _pen)    
+            @architectures = Hash.new
+        end
+
+        # Return the architectures needed by _caller_. Most likely a call of this function will look like this:
+        #    someLeaf.getArchitectures(self)
+        # +_caller+:: The reference to the caller.
+        def getArchitectures(_caller)
+            @architectures[_caller]
+        end
+
+        # This function is an extension to Leaf.fetchDependencies. The section [Self] in the config file
+        # holds the information about the architectures which are needed by this Unit for itself.
+        def fetchDependencies()
+
+            # call the fetchDependencies() function from Leaf
+            super()
+            
+            # there needs to be a [Self] section the config file 
+            if @conf["Self"].nil?
+                raise FhlowException.new(getPath), "Couldn't find section [Self] in any config.flw file responsible for this leaf."
+            end
+
+            # iterate through all items of the [Dependencies] section
+            @conf["Self"].each do |item|    # item -> one item of the [Self] section
+                raise FhlowException.new(getPath), "Wrong item found in section [Self] in any config.flw file responsible for this leaf." unless item.instance_of?(Config::SimpleArchitecture)
+
+                # The substition of "Architectures" with "Units" is done in order to improve the usability of the config files.
+                # The section [Self] contains only informations about architectures so the user should work with items with a
+                # proper name. Internally there should be no difference between the architectures from [Dependencies] and [Self]
+                #    Architectures   -> Units
+                #    tbArchitectures -> tbUnits
+                addArchitectures(self, item.name.gsub("Architectures", "Units"), item.value)
+            end
+            
+        end
+
+
+        # This function returns an Array of filenames in respect of the dependency tree.
+        # +_deptype+::      Type of the requested dependencies (could be Units, BhvUnits, Packages and so on)
+        # +_istoplevel+::   Is used to indicate the first entrance to this function.
+        # +_caller+::       Reference to the caller of the function. This is needed to request architectures.
+        # +_files+::        The Array of the files which will be filled with the requested filenames and returned in the end.
+        # == TODO
+        # * configuration handling -c::
+        # * file not found exception::
+        # * -e -ea -eac -ac handling::
+        def getFiles(_deptype, _istoplevel=true, _caller=nil, _files=Array.new)
+            @dependencies.values.each { |v| v.each { |dep| dep.getFiles(_deptype, false, self, _files)} } unless @dependencies.nil?
+            
+            # only act if the Unit is able to handle the _deptype
+            case _deptype
+                when "Units", "BhvUnits", "tbUnits"
+                    
+                    if _istoplevel and (getArchitectures(self).nil? or getArchitectures(self)[_deptype].nil?)
+                        raise FhlowException.new(@prefix+@name), "No architectures for <#{_deptype}> specified!"
+                    end
+
+                    if getArchitectures(_istoplevel ? self : _caller) and 
+                       getArchitectures(_istoplevel ? self : _caller)[_deptype] and
+                       !getArchitectures(_istoplevel ? self : _caller)[_deptype].empty?
+
+                        localfiles = Dir[getPath+"src/"+ (_deptype=="tbUnits" ? "tb" : "") +@name+"-e.vhd"]
+                        
+                        getArchitectures(_istoplevel ? self : _caller)[_deptype].each do |arch| 
+                            localfiles = localfiles | Dir[getPath+"src/"+ (_deptype=="tbUnits" ? "tb" : "") +@name+"-"+arch+"-{a,ea,eac,ac,c}.vhd"]
+                        end
+                            
+                        raise FhlowFileNotFoundException.new(getPath+"src/"), "No entity file found." unless localfiles.find { |str| str =~ /.*#{@name}-(e|\w+-e\w{1,2})\.vhd/ }
+        
+                        localfiles.each do |file| 
+                            raise FhlowFileNotFoundException.new(file), "File not found." unless File.exist?(file)
+                            _files.push(file) 
+                        end
+                    end
+
+            end
+            _files.uniq!
+            _files
+        end
+
+
+=begin        def each(_name, _caller,  &block)
+            @dependencies[_name].each{ |d| d.each(_name, self, &block) } unless @dependencies[_name].nil?
+            yield(self, _caller)
+        end
+=end
+
+
+        # This function adds information to a Unit which of its architectures are needed by which owner-Unit.
+        # +_owner+:: Reference to the owner-Unit.
+        # +_deptype+:: Type of the dependency for which the architectures will be added. (could be Units, BhvUnits, Packages and so on)
+        # +_architectures+:: An Arra of architecture names.
+        def addArchitectures(_owner, _deptype, _architectures)
+            if @architectures.empty? || @architectures[_owner].nil? || @architectures[_owner][_deptype].nil?
+                if @architectures[_owner].nil?
+                    @architectures[_owner] = { _deptype => _architectures} 
+                else
+                    @architectures[_owner][_deptype] = _architectures
+                end
+            else
+                @architectures[_owner][_deptype] += _architectures
+            end
+
+            @architectures[_owner][_deptype] = @architectures[_owner][_deptype].uniq
+        end
+
+
+
+
+    end
+
+    
+    # This is a concrete implementation of the _abstract_ class LeafFactory . 
+    # A UnitFactory creates objects of Unit.
+    class UnitFactory < LeafFactory
+
+        # Return the prefix used by Units.
+        def UnitFactory.getPrefix()
+            return "unit"
+        end
+
+        # Creates objects of Unit.
+        # <tt>*_args</tt>:: Array of argumens passed to the constructor of Unit. See Unit.initialize for more details.
+        def create(*_args)
+            return Unit.new(*_args)
+        end
+
+    end
+
+end
+

data/lib/module_fhlow/log.rb

@@ -0,0 +1,100 @@
+#----------------------------------------------------------------------------
+# 
+# Copyright (C) 2007 Simon Lasselsberger
+# simon.lasselsberger@fh-hagenberg.at
+#
+# This file is part of the _fhlow_ scripting environment.
+#
+# The _fhlow_ scripting environment is free software; you can redistribute 
+# it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# _fhlow_ is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with _fhlow_; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#----------------------------------------------------------------------------
+
+
+require 'singleton'
+require 'leaf'
+
+module Fhlow
+
+    # A Log object records all the messages to the specified log file and optional
+    # direkt to the console.
+    class Log
+
+        # The loglevel specifies which messages are logged.
+        # These loglevels are valid:
+        # 3::  *logfile*: error;
+        # 2::  *logfile*: error, warning;
+        # 1::  *logfile*: error, warning, info;
+        # 0::  *logfile*: error, warning, info, debug;
+        # -1:: *logfile*: error, warning, info, debug; *console*: error;
+        # -2:: *logfile*: error, warning, info, debug; *console*: error, warning;
+        # -3:: *logfile*: error, warning, info, debug; *console*: error, warning, info;
+        # -4:: *logfile*: error, warning, info, debug; *console*: error, warning, info, debug;
+        attr_writer :loglevel
+
+
+        # Initializes the members and opens the logfile.
+        # +_logfilename+::  Filename of the logfile (may include the path).
+        # +_loglevel+::     See attrubute +loglevel+
+        # +_pen+::          Reference to the console output object.
+        # +_cwidth+::       Width of the caller collumn
+        def initialize(_logfilename, _loglevel, _pen, _cwidth=25)
+            @loglevel       = _loglevel
+            @pen            = _pen
+            @cwidth         = _cwidth 
+            @logfile        = File.new(_logfilename,'w')
+        end
+
+
+        # Closes the logfile.
+        def close
+            @logfile.close if @logfile.instance_of?(File)
+        end 
+
+        # Logs a debug message if the loglevel fits.
+        # +_caller+::   Information about where this function was invoked.
+        # +_debugmsg+:: The actual message.
+        def debug(_caller, _debugmsg)
+            @logfile.puts("["+Time.now.to_s+"] DebugMsg by "+_caller.to_s.ljust(@cwidth)+" -> "+_debugmsg.to_s) if @loglevel <= 0
+            @pen.print("- DebugMsg -  by "+_caller.to_s.ljust(@cwidth)+" -> "+_debugmsg.to_s+"\n") if @loglevel <= -4
+        end
+
+        # Logs an info message if the loglevel fits.
+        # +_caller+::   Information about where this function was invoked.
+        # +_info+::     The actual message.
+        def info(_caller, _info)
+            @logfile.puts("["+Time.now.to_s+"] Info     by "+_caller.to_s.ljust(@cwidth)+" -> "+_info.to_s) if @loglevel <= 1
+            @pen.print("- Info -      by "+_caller.to_s.ljust(@cwidth)+" -> "+_info.to_s+"\n") if @loglevel <= -3
+        end
+
+        # Logs a warning message if the loglevel fits.
+        # +_caller+::   Information about where this function was invoked.
+        # +_warning+::  The actual message.
+        def warning(_caller, _warning)
+            @logfile.puts("["+Time.now.to_s+"] Warning  by "+_caller.to_s.ljust(@cwidth)+" -> "+_warning.to_s) if @loglevel <= 2
+            @pen.print(@pen.lightyellow, "- Warning -   by "+_caller.to_s.ljust(@cwidth)+" -> "+_warning.to_s+"\n", @pen.clear) if @loglevel <= -2
+        end
+
+        # Logs an error message if the loglevel fits.
+        # +_caller+::   Information about where this function was invoked.
+        # +_error+::    The actual message.
+        def error(_caller, _error)
+            @logfile.puts("["+Time.now.to_s+"] Error    by "+_caller.to_s.ljust(@cwidth)+" -> "+_error.to_s) if @loglevel <= 3
+            @pen.print(@pen.lightred, "- Error -     by "+_caller.to_s.ljust(@cwidth)+" -> ",_error.to_s,"\n", @pen.clear) if @loglevel <= -1
+        end
+
+    end
+
+end
+

data/lib/module_fhlow/node.rb

@@ -0,0 +1,206 @@
+#----------------------------------------------------------------------------
+# 
+# Copyright (C) 2006 Simon Lasselsberger
+# simon.lasselsberger@fh-hagenberg.at
+#
+# This file is part of the _fhlow_ scripting environment.
+#
+# The _fhlow_ scripting environment is free software; you can redistribute 
+# it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# _fhlow_ is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with _fhlow_; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#----------------------------------------------------------------------------
+
+require 'config'
+
+module Fhlow
+
+    # Nodes are something like containers that are able to contain Leaf and Node objects.
+    # Each Node creates it's children (Leaf and Node objects) when it is created. So parsing
+    # the fhlow structure is implicitly done by creating the RootNode object.
+    # The valid prefixes of Node and Leaf objects for each nodelevel (see initialize) are stored
+    # in the default configfile (<fhlow-root>/flw/defaults.flw). 
+    class Node
+
+            # The name of the node.
+            attr_reader :name  
+
+            # The prefix of the node.
+            attr_reader :prefix
+
+            # The configuration object.
+            attr_reader :conf
+            
+        public
+            # Initializes the members, creates the children (Leaf and Node objects) corresponding to the default
+            # configfile (<fhlow-root>/flw/defaults.flw) and reads the configuration file for this Node.
+            # +_prefix+::       Prefix of the Node.
+            # +_name+::         Name of the Node.
+            # +_parent+::       Reference to the parent Node.
+            # +_nodelevel+::    The level of the Node inside the fhlow structure.
+            # +_log+::          Reference to a Log object.
+            # +_pen+::          Reference to a Pen obejct (output to console).
+            def initialize(_prefix, _name, _parent, _nodelevel, _log, _pen)
+                @prefix     = _prefix
+                @name       = _name
+                
+                # a hash is used for nodes and leafs because the key (prefix+nodename) can be used to
+                # directly access the desired object (by for example getObject) so we don't have
+                # to iterate through the whole structure _recursively_. a hash will therefore be
+                # much faster!
+                @nodes      = Hash.new
+                @leafs      = Hash.new
+                
+                @nodelevel  = _nodelevel
+                @parent     = _parent
+                @log        = _log
+                @pen        = _pen
+                
+                if File.exist?(@parent.getPath+@prefix+@name+"/config.flw")
+                    # read the config file
+                    @conf = Config::Config.new(@parent.getPath+@prefix+@name+"/config.flw") 
+                    # inherit the configurations from previous levels
+                    @conf.merge(@parent.conf)
+                    @log.debug(@prefix+@name, "Sucessfully merged inherited configs from #{@parent.prefix+@parent.name}.")
+                else
+                    @log.warning(self, "config.flw does not exists in #{@prefix}#{@name}.")
+                    raise FhlowException, "No configurations found in #{@prefix}#{@name}!" if @parent.conf.nil?
+                    @conf = @parent.conf
+                end
+
+                raise FhlowException, "\"NodePrefixes\" in section \"fhlow\" is not set in any of your config files." unless @conf["fhlow"]["NodePrefixes"]
+                raise FhlowException, "\"LeafPrefixes\" in section \"fhlow\" is not set in any of your config files." unless @conf["fhlow"]["LeafPrefixes"]
+
+                @log.info(@prefix+@name, "initializing node...")
+                
+                
+                if @nodelevel < @conf["fhlow"]["NodePrefixes"].length
+                   
+                    # add the nodes
+                    @conf["fhlow"]["NodePrefixes"][@nodelevel].strip.split(",").each do |pf|
+                        pf.strip!
+                        Dir[getPath+pf+"*"].each do |nodename| 
+                            nodename = nodename.gsub(/.*\/#{pf}/, "")
+                            @log.debug(@prefix+@name, "adding node "+"    "*@nodelevel+pf+nodename)
+                            # a hash is used for nodes because the key (prefix+nodename) can be used to
+                            # directly access the desired object (by for example getObject) so we don't have
+                            # to iterate through the whole structure _recursively_. a hash will therefore be
+                            # much faster!
+                            @nodes.store(pf+nodename, Node.new(pf, nodename, self, @nodelevel+1, @log, @pen))
+                        end
+                    end
+     
+                end 
+
+                
+                if @nodelevel > 0 && @conf["fhlow"]["LeafPrefixes"][@nodelevel-@conf["fhlow"]["NodePrefixes"].length-1]
+                    
+                    # add the leafs
+                    @conf["fhlow"]["LeafPrefixes"][@nodelevel-@conf["fhlow"]["NodePrefixes"].length-1].strip.split(",").each do |prefix|
+                        prefix.strip!
+                        Dir[getPath+prefix+"*"].each do |leafname|
+                            leafname = leafname.gsub(/.*\/#{prefix}/, "")
+                            @log.debug(@prefix+@name, "adding leaf "+prefix+leafname)
+                            # a hash is used for leafs because the key (prefix+leafname) can be used to
+                            # directly access the desired object (by for example getObject) so we don't have
+                            # to iterate through the whole structure _recursively_. a hash will therefore be
+                            # much faster!
+                            @leafs.store(prefix+leafname, LeafFactory.getLeafFor(prefix, leafname, self, @log, @pen))
+                        end
+                    end
+
+                end
+
+            end
+
+            # Returns the absolute path to the Node.
+            def getPath
+                @parent.getPath+@prefix+@name+"/"    
+            end
+
+
+            # Tells each children to fetch its dependencies.
+            def fetchDependencies()
+                @nodes.each_value { |node| node.fetchDependencies() } unless @nodes.empty?
+                @leafs.each_value { |leaf| leaf.fetchDependencies() } unless @leafs.empty?
+            end
+              
+            # Returns the requested Leaf.
+            # +_objectfootprint+::  An Array that specifies where in the fhlow structure the leaf can be found. may look like these:
+            # * ["Prol16", "Cpu"]
+            # * ["grp/Prol16", "unit/Cpu"]
+            # * ["Cpu"]
+            # * most likely the attribute +value+ from Config::SimpleUnit, Config::ComplexUnit, Config::SimplePackage or Config::ComplexPackage will be used
+            # +_passthrough+::      The amount of passthroughs to a lower level in the fhlow structure.
+            def getLeaf(_objectfootprint, _passthrough=0)
+                
+                raise FhlowException.new(@prefix+@name), "illegal _passthrough value: #{_passthrough}" if _passthrough < 0
+
+                if _passthrough > 0
+                    # passthrough the request until the object that should know the 
+                    # desired object is reached
+                    # -> go some levels down in the fhlow tree
+                    @parent.getLeaf(_objectfootprint, _passthrough-1)
+
+                else
+                    # now request the desired object from child objects
+                    # -> go some levels down in the fhlow tree
+                    
+
+                    if _objectfootprint.length > 1
+                        # there need to be nodes if there are more than one element in the _objectfootprint
+
+                        if _objectfootprint[0] =~ /(.*)\/(.*)/
+                            # take care of exact definitions (grp/Fhlow, prj/Fhlow, etc)
+                            raise FhlowObjectNotFoundException.new(@prefix+@name), "No such object <#{$1}#{$2}>!" unless @nodes[$1+$2]
+                            @nodes[$1+$2].getLeaf(_objectfootprint[1..-1])
+                        else
+                            # take care of multiple possiblities (unitTest and pkgTest in one group)
+                            possibilities = Array.new
+                            @nodes.each_key { |nodename| possibilities.push(nodename) if nodename =~ /.*#{_objectfootprint[0]}/ }
+                            raise FhlowObjectNotFoundException.new(@prefix+@name), "There are multible possibilities for node #{_objectfootprint[0]}: "+possiblities.join(", ") if possibilities.length > 1
+                            raise FhlowObjectNotFoundException.new(@prefix+@name), "No such node <"+ (possibilities.empty? ? _objectfootprint[0].to_s : possibilities[0].to_s)+">!" unless @nodes[possibilities[0]]
+                            @nodes[possibilities[0]].getLeaf(_objectfootprint[1..-1])
+                        end
+                    
+                    else
+                
+                        if _objectfootprint[0] =~ /(.*)\/(.*)/
+                            raise FhlowObjectNotFoundException.new(@prefix+@name), "No such object <#{$1}#{$2}>!" unless @leafs[$1+$2]
+                            return @leafs[$1+$2]   # finally the object can be returned
+                        else
+                            possibilities = Array.new
+                            @leafs.each_key { |leafname| possibilities.push(leafname) if leafname =~ /.*#{_objectfootprint[0]}/ }
+                            raise FhlowObjectNotFoundException.new(@prefix+@name), "There are multible possibilities for leaf #{_objectfootprint[0]}: "+posssibilities.join(", ") if possibilities.length > 1 
+                            raise FhlowObjectNotFoundException.new(@prefix+@name), "No such node <"+(possibilities.empty? ? _objectfootprint[0].to_s : possibilities[0].to_s)+">!" unless @leafs[possibilities[0]]
+                            return @leafs[possibilities[0]] # finally the object can be returned
+                        end
+
+                    end
+
+                end
+
+            end
+
+            # Prints the name of this group and information about its children.
+            # +_prefix+:: A prefix that is used for the output.
+            def printMe(_prefix = "    ")
+                @pen.print _prefix,@name+"\n"
+                @nodes.each_value {|x| x.printMe(_prefix+"    "); puts x } unless @nodes.empty?
+                @leafs.each_value {|x| x.printMe(_prefix+"    ") } unless @leafs.empty?
+                @pen.print "\n"
+            end        
+    end
+
+end
+