|
libFAUDES
Sections
Index
|
cfl_registry.hGo 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