libFAUDES

Sections

Index

cfl_registry.h

Go to the documentation of this file.
00001 /** @file cfl_registry.h Runtime interface, registry for faudes-types and functions */
00002 
00003 /* FAU Discrete Event Systems Library (libfaudes)
00004 
00005 Copyright (C) 2009 Ruediger Berndt
00006 Copyright (C) 2009 Thomas Moor
00007 
00008 This library is free software; you can redistribute it and/or
00009 modify it under the terms of the GNU Lesser General Public
00010 License as published by the Free Software Foundation; either
00011 version 2.1 of the License, or (at your option) any later version.
00012 
00013 This library is distributed in the hope that it will be useful,
00014 but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016 Lesser General Public License for more details.
00017 
00018 You should have received a copy of the GNU Lesser General Public
00019 License along with this library; if not, write to the Free Software
00020 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
00021 
00022 
00023 #ifndef FAUDES_RTIREGISTRY_H
00024 #define FAUDES_RTIREGISTRY_H
00025 
00026 #include "cfl_types.h"
00027 #include "cfl_functions.h"
00028  
00029 namespace faudes{
00030 
00031 
00032 /**
00033  * The TypeRegistry registers faudes-types. A faudes-type may be
00034  * any class derived from faudes::Type, e.g. EventSet and generator.
00035  * The registry maintains a mapping from faudes-type names to registred 
00036  * faudes::TypeDefinition. It provides an interface to inspect 
00037  * TypeDefinitions or to construct faudes-type objects by their type name. 
00038  *
00039  * Technical note: the class is implemented according to the \"Singleton\" design 
00040  * pattern, ie, only one global instance of the registry can exist.
00041  *
00042  *
00043  * @ingroup RunTimeInterface
00044  */
00045 
00046 
00047 class TypeRegistry : public Type {
00048 
00049 public:
00050 
00051   /** Convenience typedef to access registry entries */     
00052   typedef std::map<std::string, TypeDefinition*>::const_iterator Iterator;
00053 
00054   /**
00055    * Method to access the single global instance of the registry.
00056    */
00057   static TypeRegistry* G();
00058 
00059   /** 
00060    * Clear all registered type definitions. This will also delete the
00061    * correponsing prototype objects. It will, however, not delete
00062    * autoregistered registry entries.
00063    */
00064   void Clear();
00065 
00066   /** 
00067    * Clear all registered type definitions. This will also delete the
00068    * correponsing prototype objects. It will, however, not delete
00069    * autoregistered registry entries.
00070    */
00071   void ClearAll();
00072 
00073   /**
00074    * Return number of registered type definitions.
00075    *
00076    * @return
00077    *  Size of map.
00078    */
00079   int Size() const;
00080 
00081   /**
00082    * Test existence of a faudes-type by its name.
00083    *
00084    * @param rName
00085    *  Name of type to look up
00086    *
00087    * @return
00088    *  True, if a corresponding definition is registered.
00089    */
00090   bool Exists(const std::string& rName) const;
00091 
00092   /**
00093    * Test existence of a faudes-type by faudes object
00094    *
00095    * @param rType
00096    *  Object of type to look up
00097    *
00098    * @return
00099    *  True, if a corresponding definition is registered.
00100    */
00101   bool Exists(const Type& rType) const;
00102 
00103   /**
00104    * STL interator to the internal type-name map.
00105    *
00106    * @return
00107    *  Iterator to the first element.
00108    */
00109   Iterator Begin(void) const;
00110 
00111   /**
00112    * STL interator to the internal type-name map.
00113    *
00114    * @return
00115    *  Iterator to the end of the map.
00116    */
00117   Iterator End(void) const;
00118 
00119   /**
00120    * Add another type definition to the registry.
00121    *
00122    * The registry takes the ownership pf the provided
00123    * type definition. It will be deleted either in Clear() or 
00124    * when the registry is destructed. The insertion of an allready registered
00125    * type is ignored as long as the ctype matches. If the ctype
00126    * fails to match, an exception is thrown.
00127    *
00128    * @param pTypeDef
00129    *  Type definition to insert
00130    *
00131    * @exception Exception
00132    *  - Identical name found (id 46)
00133    */
00134   void Insert(TypeDefinition* pTypeDef);
00135 
00136   /**
00137    * Register a faudes-type with specified type name.
00138    *
00139    * This is a convenience function: it uses the template parameter to
00140    * construct the new instance of TypeDefinition to be registered. However,
00141    * no documentation is added. See also MergeDocumentation.
00142    *
00143    * @tparam T
00144    *   Template parameter to specify c++ type to register
00145    * @param rTypeName
00146    *   Specify the faudes-type name 
00147    * @exception Exception
00148    *  - Identical name found (id 46)
00149    */
00150   template<class T>
00151   void Insert(const std::string& rTypeName="") {
00152     FD_DRTI("TypeRegistry::Insert<" << typeid(T).name() << ">(" << rTypeName << ")");
00153     TypeDefinition* td = TypeDefinition::Constructor<T>(rTypeName);
00154     Insert(td);
00155   }
00156 
00157   /**
00158    * Register a faudes-type with specified type name.
00159    *
00160    * This is a convenience function: it uses the specified object as a
00161    * a prototype and registers it under the given name. The registry takes 
00162    * ownership of the prototype. However,
00163    * no documentation is added. See also MergeDocumentation.
00164    *
00165    * @param pProto
00166    *   Prototype object
00167    * @param rTypeName
00168    *   Specify the faudes-type name 
00169    * @exception Exception
00170    *  - Identical name found (id 46)
00171    */
00172   void Insert(Type* pProto, const std::string& rTypeName) {
00173     FD_DRTI("TypeRegistry::Insert(prototype, " << rTypeName << ")");
00174     TypeDefinition* td = TypeDefinition::Constructor(pProto, rTypeName);
00175     Insert(td);
00176   }
00177 
00178   /**
00179    * Scan token input for type documentation.
00180    * This function scans the entire token stream for sections
00181    * with label "TypeDefinition". Any such section that refers to a type name
00182    * which is known to the registry, will be applied to the corresponding 
00183    * registry entry. Typical invokation is as follows
00184    *
00185    * @code
00186    * TypeRegistry::G()->Insert<EventSet>("EventSet");
00187    * TypeRegistry::G()->Insert<Generator>("Generator");
00188    * TypeRegistry::G()->MergeDocumentation("alldocufile.rti");
00189    * @endcode
00190    *
00191    * @param rTr
00192    *  Token stream.
00193    * @exception Exception
00194    *  - Token mismatch (id 50, 51, 52)
00195    *  - IO Error (id 1)
00196    */
00197   void MergeDocumentation(TokenReader& rTr);
00198 
00199   /**
00200    * Scan file for type documentation.
00201    * Convenience method, see also MergeDocumentation(TokenReader& rTr)
00202    *
00203    * @param rFileName
00204    *  Name of file to scan.
00205    * @exception Exception
00206    *  - Token mismatch (id 50, 51, 52)
00207    *  - IO Error (id 1)
00208    */
00209   void MergeDocumentation(const std::string& rFileName);
00210 
00211 
00212   /**
00213    * Set Xml element tag for given faudes-type.
00214    *
00215    * Access to the XElementTag of a type definition. The latter is
00216    * used for Xml token IO of sets and vectors.
00217    * Unregistered types are silently ignored.
00218    *
00219    * @param rTypeName
00220    *  Name of faudes-type
00221    * @param rTag
00222    *    New value of tag
00223    */
00224   void XElementTag(const std::string& rTypeName, const std::string& rTag);
00225 
00226   /**
00227    * Get Xml element tag for given faudes-type.
00228    *
00229    * Access to the XElementTag of a type definition. The latter is
00230    * used for Xml token IO of sets and vectors.
00231    * Unregistered types return the empty string.
00232    *
00233    * @param rTypeName
00234    *  Name of faudes-type
00235    * @return
00236    *    Xml element tag
00237    */
00238   const std::string& XElementTag(const std::string& rTypeName) const;
00239 
00240   /**
00241    * Get AutoRegister flag for given faudes-type.
00242    *
00243    * Access the AutoRegister flag of a type definition. 
00244    * The flag is true for entries with were instantiated by
00245    * automatically by static constructor objects. AutoRegistered flags
00246    * will not be cleared.
00247    *
00248    * @param rTypeName
00249    *  Name of faudes-type
00250    * @return
00251    *    AutoRegister flag
00252    */
00253   bool AutoRegister(const std::string& rTypeName) const;
00254 
00255   /**
00256    * Set AutoRegister flag for given faudes-type.
00257    *
00258    * Access the AutoRegister flag of a type definition. 
00259    * The flag is true for entries with were instantiated by
00260    * automatically by static constructor objects. AutoRegistered flags
00261    * will not be cleared.
00262    *
00263    * @param rTypeName
00264    *  Name of faudes-type
00265    * @param rTag
00266    *    New value of flag
00267    */
00268   void AutoRegister(const std::string& rTypeName, bool flag);
00269 
00270   /**
00271    * Construct a faudes object by type name
00272    *
00273    * Uses the internal prototype object to construct
00274    * an object of the same c type on the heap. 
00275    *
00276    * @param rTypeName
00277    *  Label of TypeDefinition to search for.
00278    * @return
00279    *  Pointer to new faudes::Type instance 
00280    * @exception Exception
00281    *  - Unknown type (id 47)
00282    */
00283   Type* NewObject(const std::string& rTypeName) const;
00284 
00285   /**
00286    * Construct a faudes object by prototype object.
00287    *
00288    * Depreciated: use new on the faudes object instead.
00289    *
00290    * @param rType
00291    *  Prototype object.
00292    *
00293    * @return
00294    *  Pointer to new faudes::Type instance
00295    * @exception Exception
00296    *  - Unknown type (id 47)
00297    */
00298   Type* NewObject(const Type& rType) const;
00299 
00300 
00301   /**
00302    * Look up the type definition by faudes-type name
00303    *
00304    * @param rTypeName
00305    *  Faudes-tyep name to search for.
00306    *
00307    * @return
00308    *  Reference to faudes::TypeDefinition
00309    *
00310    * @exception Exception
00311    *  - Unknown type (id 46)
00312    */
00313   const TypeDefinition& Definition(const std::string& rTypeName) const;
00314 
00315   /**
00316    * Look up the type definition by faudes object
00317    *
00318    * @param rType
00319    *  Reference to faudes::Type to search for.
00320    *
00321    * @return
00322    *  Reference to faudes::TypeDefinition
00323    *
00324    * @exception Exception
00325    *  - Unknown type (id 46)
00326    */
00327   const TypeDefinition& Definition(const Type& rType) const;
00328 
00329   /**
00330    * Look up the type definition by faudes-type name
00331    *
00332    * @param rTypeName
00333    *  Faudes-tyep name to search for.
00334    *
00335    * @return
00336    *  Pointer to faudes::TypeDefinition, NULL for unknoen type.
00337    *
00338    */
00339   const TypeDefinition* Definitionp(const std::string& rTypeName) const;
00340 
00341   /**
00342    * Look up the type definition by faudes object
00343    *
00344    * @param rType
00345    *  Reference to faudes::Type to search for.
00346    *
00347    * @return
00348    *  Pointer to faudes::TypeDefinition, NULL for unknoen type.
00349    *
00350    */
00351   const TypeDefinition* Definitionp(const Type& rType) const;
00352 
00353 
00354   /**
00355    * Look up the prototype object by faudes-type name
00356    *
00357    * @param rTypeName
00358    *  Label of faudes::TypeDefinition to search for.
00359    *
00360    * @return
00361    *  Reference to faudes::Type object, Null for unknown type
00362    *
00363    */
00364   const Type* Prototype(const std::string& rTypeName) const;
00365 
00366   /**
00367    * Look up the type name by faudes object
00368    *
00369    * @param rType
00370    *  Reference to faudes::Type to search for.
00371    *
00372    * @return
00373    *  Type name as string or "" if unknown.
00374    *
00375    */
00376   const std::string& TypeName(const Type& rType) const;
00377 
00378  protected:
00379 
00380   /**
00381    * Write registry data of this to TokenWriter.
00382    *
00383    * Since the registry cannot reconfigure itself from a token stream,
00384    * this output is informative only. However, MergeDocumentation will 
00385    * accept the format to extract documentation.
00386    *
00387    * @param rTw
00388    *   Reference to TokenWriter
00389    * @param rLabel
00390    *   Label of section to write
00391    * @param pContext
00392    *   Write context to provide contextual information
00393    *
00394    * @exception Exception 
00395    *   - IO errors (id 2)
00396    */
00397   virtual void DoWrite(TokenWriter& rTw, const std::string& rLabel="",const Type* pContext=0) const;
00398 
00399   /** Convenience typedef to access registry entries */     
00400   typedef std::map<std::string, TypeDefinition*>::iterator iterator;
00401 
00402   /** Singleton instance */
00403   static TypeRegistry* mpInstance;
00404 
00405   /** Constructor */
00406   TypeRegistry(){}
00407 
00408   /** Destructor */
00409   virtual ~TypeRegistry(){
00410     Clear();
00411   }
00412 
00413   /** Map to associate labels and faudes::TypeDefinitions. */
00414   std::map<std::string, TypeDefinition*> mNameToTypeDef;
00415   std::map<std::string, TypeDefinition*> mIdToTypeDef;
00416 
00417 }; // TypeRegistry
00418 
00419 
00420 /**
00421  * Auto register faudes-type with specified type name.
00422  *
00423  * This is a convenience class template to automize faudes type registration.
00424  * It uses the Insert template of the type registry. If the type name 
00425  * is already registered, no registration will not take place and the old
00426  * configuration is maintained. Also registration with faudes-type name "Void" 
00427  * will be silently ignored.
00428  * Type documentation is not supported but may
00429  * be added via MergeDocumentation. 
00430  *
00431  * @tparam T
00432  *   Template parameter to specify the C++ type to register
00433  * @param rTypeName
00434  *   Specify the faudes-type name 
00435  */
00436 template<class T>
00437 class AutoRegisterType {
00438  public:
00439   AutoRegisterType(const std::string& rTypeName="Void") {
00440     if(rTypeName=="Void") return;
00441     if(TypeRegistry::G()->Exists(rTypeName)) return;
00442     FD_DREG("AutoRegisterType(" << rTypeName << "): by prototype template with " << typeid(T).name());
00443     TypeRegistry::G()->Insert<T>(rTypeName);
00444     TypeRegistry::G()->AutoRegister(rTypeName,true);
00445   };
00446 };
00447 
00448 template<class T>
00449 class AutoRegisterXElementTag {
00450  public:
00451   AutoRegisterXElementTag(const std::string& rTypeName, const std::string& rTag) {
00452     static AutoRegisterType<T> srego(rTypeName);
00453     TypeRegistry::G()->XElementTag(rTypeName,rTag);
00454   };
00455 };
00456 
00457 
00458 
00459 
00460 /**
00461  * The FunctionRegistry registers faudes-functions. A faudes-functions
00462  * operates on faudes objects, eg the parallel composition of two 
00463  * generators is available as faudes-function. The registry maintains a
00464  * mapping between function names and a coresponding function::Definition.
00465  * The latter provides signatures, ie parameter types the function can 
00466  * take. The registry provides an interface to inspect 
00467  * TypeDefinitions or to construct function objects by their type name. 
00468  *
00469  * Technical note: the class is implemented according to the \"Singleton\" design 
00470  * pattern, ie, only one global instance of the registry can exist.
00471  *
00472  * @ingroup RunTimeInterface
00473  */
00474 
00475 class FunctionRegistry : public Type {
00476 
00477 public:
00478 
00479   /** Convenience typedef to access registry entries */     
00480   typedef std::map<std::string, FunctionDefinition*>::const_iterator Iterator;
00481 
00482   /**
00483    * Method to access the single global instance of the registry.
00484    */
00485   static FunctionRegistry* G();
00486 
00487   /** 
00488    * Clear all registered function definitions. This will also delete the
00489    * correponsing prototype objects.
00490    */
00491   void Clear();
00492 
00493   /**
00494    * Return number of registered function definitions.
00495    *
00496    * @return
00497    *  Size of map.
00498    */
00499   int Size() const;
00500 
00501   /**
00502    * Test existence of a faudes-function by its name.
00503    *
00504    * @param rName
00505    *  Name of function to look up
00506    *
00507    * @return
00508    *  True, if a corresponding definition is registered.
00509    */
00510   bool Exists(const std::string& rName) const;
00511 
00512   /**
00513    * Test existence of a faudes-function by faudes object
00514    *
00515    * @param rFunction
00516    *  Object of function to look up
00517    *
00518    * @return
00519    *  True, if a corresponding definition is registered.
00520    */
00521   bool Exists(const Function& rFunction) const;
00522 
00523   /**
00524    * STL interator to the internal function-name map.
00525    *
00526    * @return
00527    *  Iterator to the first element.
00528    */
00529   Iterator Begin(void) const;
00530 
00531   /**
00532    * STL interator to the internal function-name map.
00533    *
00534    * @return
00535    *  Iterator to the end of the map.
00536    */
00537   Iterator End(void) const;
00538 
00539   /**
00540    * Add another function definition to the registry.
00541    *
00542    * The registry takes the ownership pf the provided
00543    * function definition. It will be deleted either in Clear() or 
00544    * when the registry is destructed.
00545    *
00546    * @param pFunctionDef
00547    *  Function definition to insert
00548    *
00549    * @exception Exception
00550    *  - Identical name found (id 46)
00551    */
00552   void Insert(FunctionDefinition* pFunctionDef);
00553 
00554   /**
00555    * Register a faudes-function with specified function name.
00556    *
00557    * This is a convenience function: it uses the template parameter to
00558    * construct the new instance of FunctionDefinition to be registered. However,
00559    * no documentation is added. See also MergeDocumentation.
00560    *
00561    * @tparam T
00562    *   Template parameter to specify c++ function to register
00563    * @param rFunctionName
00564    *   Specify the faudes-function name 
00565    * @exception Exception
00566    *  - Identical name found (id 46)
00567    */
00568   template<class T>
00569   void Insert(const std::string& rFunctionName="") {
00570     FD_DRTI("FunctionRegistry::Insert<>(" << rFunctionName << ")");
00571     FunctionDefinition* td = FunctionDefinition::Constructor<T>(rFunctionName);
00572     Insert(td);
00573   }
00574 
00575   /**
00576    * Scan token input for function documentation.
00577    * This function scans the entire token stream for sections
00578    * with label "FunctionDefinition". Any such section that refers to a function name
00579    * which is known to the registry, will be applied to the corresponding 
00580    * registry entry.
00581    *
00582    *
00583    * @param rTr
00584    *  Token stream.
00585    * @exception Exception
00586    *  - Token mismatch (id 50, 51, 52)
00587    *  - IO Error (id 1)
00588    */
00589   void MergeDocumentation(TokenReader& rTr);
00590 
00591   /**
00592    * Scan file for function documentation.
00593    * Convenience method, see also MergeDocumentation(TokenReader& rTr)
00594    *
00595    * @param rFileName
00596    *  Name of file to scan.
00597    * @exception Exception
00598    *  - Token mismatch (id 50, 51, 52)
00599    *  - IO Error (id 1)
00600    */
00601   void MergeDocumentation(const std::string& rFileName);
00602 
00603   /**
00604    * Construct a faudes object by function name
00605    *
00606    * Uses the internal prototype object to construct
00607    * an object of the same c function on the heap. 
00608    *
00609    * @param rFunctionName
00610    *  Label of FunctionDefinition to search for.
00611    * @return
00612    *  Pointer to new faudes::Function instance 
00613    * @exception Exception
00614    *  - Unknown function (id 47)
00615    */
00616   Function* NewFunction(const std::string& rFunctionName) const;
00617 
00618   /**
00619    * Construct a faudes object by protofunction object.
00620    *
00621    * Depreciated: use new on the faudes object instead.
00622    *
00623    * @param rFunction
00624    *  Protofunction object.
00625    *
00626    * @return
00627    *  Pointer to new faudes::Function instance 
00628    * @exception Exception
00629    *  - Unknown function (id 47)
00630    */
00631   Function* NewFunction(const Function& rFunction) const;
00632 
00633 
00634   /**
00635    * Look up the function definition by faudes-function name
00636    *
00637    * @param rFunctionName
00638    *  Label of faudes::FunctionDefinition to search for.
00639    *
00640    * @return
00641    *  Reference to faudes::FunctionDefinition
00642    *
00643    * @exception Exception
00644    *  - Unknown function (id 46)
00645    */
00646   const FunctionDefinition& Definition(const std::string& rFunctionName) const;
00647 
00648   /**
00649    * Look up the function definition by faudes object
00650    *
00651    * Techcal note: this implementation is slow, we should
00652    * use a function id map. 
00653    *
00654    * @param rFunction
00655    *  Reference to faudes::Function to search for.
00656    *
00657    * @return
00658    *  Reference to faudes::FunctionDefinition
00659    *
00660    * @exception Exception
00661    *  - Unknown function (id 46)
00662    */
00663   const FunctionDefinition& Definition(const Function& rFunction) const;
00664 
00665   /**
00666    * Look up the function name by faudes object
00667    *
00668    * @param rFunction
00669    *  Reference to faudes::Function to search for.
00670    *
00671    * @return
00672    *  Function name as string or "" if unknown.
00673    *
00674    */
00675   const std::string& FunctionName(const Function& rFunction) const;
00676 
00677  protected:
00678 
00679   /**
00680    * Write registry data of this to TokenWriter.
00681    *
00682    * Since the registry cannot reconfigure itself from a token stream,
00683    * this output is informative only. However, MergeDocumentation will 
00684    * accept the format to insert/extract documentation.
00685    *
00686    * @param rTw
00687    *   Reference to TokenWriter
00688    * @param rLabel
00689    *   Label of section to write
00690    * @param pContext
00691    *   Write context to provide contextual information
00692    *
00693    * @exception Exception 
00694    *   - IO errors (id 2)
00695    */
00696   virtual void DoWrite(TokenWriter& rTw, const std::string& rLabel="",const Type* pContext=0) const;
00697 
00698   /** Convenience typedef to access registry entries */     
00699   typedef std::map<std::string, FunctionDefinition*>::iterator iterator;
00700 
00701   /** Singleton instance */
00702   static FunctionRegistry* mpInstance;
00703 
00704   /** Constructor */
00705   FunctionRegistry(){}
00706 
00707   /** Destructor */
00708   virtual ~FunctionRegistry(){
00709     Clear();
00710   }
00711 
00712   /** Map to associate labels and faudes::FunctionDefinitions. */
00713   std::map<std::string, FunctionDefinition*> mNameToFunctionDef;
00714   std::map<std::string, FunctionDefinition*> mIdToFunctionDef;
00715 
00716 }; // FunctionRegistry
00717 
00718 
00719 /** 
00720  * Load all registered types and functions.
00721  *
00722  * The default file is some not so educated guess, so you
00723  * should specify it explicitely.
00724  *
00725  * @param rPath
00726  *   Source file
00727  *
00728  * @ingroup RunTimeInterface
00729  */
00730 
00731 void LoadRegistry(const std::string& rPath="");
00732 
00733 
00734 /** 
00735  * Dump all registered types and functions
00736  *
00737  * The destinations defaults to stdout.
00738  *
00739  * @param rPath
00740  *   Destination file
00741  *
00742  * @ingroup RunTimeInterface
00743  */
00744 
00745 void SaveRegistry(const std::string& rPath="");
00746 
00747 
00748 /** 
00749  * Clear all registry
00750  *
00751  * @ingroup RunTimeInterface
00752  */
00753 
00754 void ClearRegistry(void);
00755 
00756 
00757 /** 
00758  * Instantiate faudes typed objects by type name.
00759  * Convenience function to access registry singleton.
00760  * 
00761  * @param rTypeName
00762  *  Type to instantiate
00763  *
00764  * @ingroup RunTimeInterface
00765  */
00766 
00767 Type* NewFaudesObject(const std::string& rTypeName);
00768 
00769 /** 
00770  * Query type name.
00771  * Convenience function to access registry singleton.
00772  * 
00773  * @param rObject
00774  *  Faudes object instance
00775  * @return
00776  *  Faudes type name or "" if unkown.
00777  *
00778  * @ingroup RunTimeInterface
00779  */
00780 
00781 const std::string& FaudesTypeName(const Type& rObject);
00782 
00783 
00784 /** 
00785  * Instantiate faudes function objects by function name.
00786  * Convenience function to access registry singleton.
00787  *
00788  * @param rFunctName
00789  *  Function to instantiate
00790  *
00791  * @ingroup RunTimeInterface
00792  */
00793 
00794 Function* NewFaudesFunction(const std::string& rFunctName);
00795 
00796 /** 
00797  * Query function name.
00798  * Convenience function to access registry singleton.
00799  * 
00800  * @param rObject
00801  *  Faudes object instance
00802  * @return
00803  *  Faudes function name or "" if unkown.
00804  *
00805  * @ingroup RunTimeInterface
00806  */
00807 
00808 const std::string& FaudesFunctionName(const Type& rObject);
00809 
00810 
00811 
00812 /**********************************************************************************************
00813 ***********************************************************************************************
00814 ***********************************************************************************************
00815 
00816 Implemention of template members functions
00817 
00818 ***********************************************************************************************
00819 ***********************************************************************************************
00820 **********************************************************************************************/
00821 
00822 
00823 
00824 
00825 
00826 } // namespace
00827 
00828 #endif /* FAUDES_RTIREGISTRY_H */

libFAUDES 2.18b --- 2010-12-17 --- c++ source docu by doxygen 1.6.3