| |
libFAUDES
Sections
Index
|
indexset.hGo to the documentation of this file.00001 /** @file indexset.h @brief Classes IndexSet, TaIndexSet */ 00002 00003 00004 /* FAU Discrete Event Systems Library (libfaudes) 00005 00006 Copyright (C) 2006 Bernd Opitz 00007 Copyright (C) 2007 Thomas Moor 00008 Exclusive copyright is granted to Klaus Schmidt 00009 00010 This library is free software; you can redistribute it and/or 00011 modify it under the terms of the GNU Lesser General Public 00012 License as published by the Free Software Foundation; either 00013 version 2.1 of the License, or (at your option) any later version. 00014 00015 This library is distributed in the hope that it will be useful, 00016 but WITHOUT ANY WARRANTY; without even the implied warranty of 00017 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00018 Lesser General Public License for more details. 00019 00020 You should have received a copy of the GNU Lesser General Public 00021 License along with this library; if not, write to the Free Software 00022 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ 00023 00024 00025 00026 #ifndef FAUDES_INDEXSET_H 00027 #define FAUDES_INDEXSET_H 00028 00029 #include "definitions.h" 00030 #include "attributes.h" 00031 #include "baseset.h" 00032 #include "abaseset.h" 00033 #include "symboltable.h" 00034 #include <set> 00035 #include <map> 00036 #include <algorithm> 00037 00038 00039 namespace faudes { 00040 00041 00042 00043 /** @addtogroup ContainerClasses */ 00044 /** @{*/ 00045 00046 // Forward declaration for the attributed version of indexset 00047 template<class Attr> class TaIndexSet; 00048 00049 /** 00050 * Set of indices. This class is built on top of the faudes version 00051 * TBaseSet of STL sets. It provides the essentials of the STL interface 00052 * and inherits the standard token IO interface from Type, so you may 00053 * use Read and Write for file/string/console IO. 00054 * 00055 * IndexSet is used as common base for TaIndexSet (indices with attributes), 00056 * NameSet (indices with symbolic names) and TaNameSet (indices with 00057 * attributes and symbolic names). 00058 * 00059 * The index of value 0 is reserved to indicate the invalid index. If the macro FAUDES_CHECKED 00060 * is defined, the attempt to insert an index 0 triggers an exception (id 61). Invalid 00061 * iterators throw an exception (id 62) when used as an argument to a IndexSet function. 00062 * 00063 * Technically, file IO is done by TaIndexSet functions. This requires a copy and for 00064 * that reason may be reimplemented in a future versions. 00065 * The format is demonstrated by the following example 00066 * of a set with name "MySet" consisting of indices 17, 25, 26, 27, 28, 40: 00067 * \code 00068 * <Myset> 00069 * 17 00070 * <Consecutive> 25 4 </Consecutive> 00071 * 40 00072 * </MySet> 00073 * \endcode 00074 * Theere is a minimum number of consecutive indices for the use of the consecutive 00075 * section defined in definitions.h. 00076 * 00077 */ 00078 00079 class IndexSet : public virtual TBaseSet<Idx> { 00080 00081 FAUDES_TYPE_DECLARATION(IndexSet,TBaseSet<Idx>) 00082 00083 /** 00084 * We implement "protected privacy for template classes" by friendship. 00085 * This is used for the pragmatic implemention conversion constructors. 00086 */ 00087 template<class Attr> friend class TaIndexSet; 00088 00089 public: 00090 00091 /** 00092 * Constructor. 00093 */ 00094 IndexSet(void); 00095 00096 /** 00097 * Copy-constructor. 00098 */ 00099 IndexSet(const TBaseSet<Idx>& rOtherSet); 00100 00101 /** 00102 * Construct from file. Uses the Read(TokenReader&, const std::string&) function to read. 00103 * a IndexSet from section rLabel in file rFilename. 00104 * 00105 * @param rFilename 00106 * Name of file to read 00107 * @param rLabel 00108 * Section to read 00109 * 00110 * @exception Exception 00111 * - IO Errors (id 1) 00112 * - token musmatch (id 50, 51, 52) 00113 */ 00114 IndexSet(const std::string& rFilename, const std::string& rLabel = ""); 00115 00116 /** 00117 * Virtual destructor 00118 */ 00119 virtual ~IndexSet(void) {}; 00120 00121 /** 00122 * Get maximum index used in this set (0 for emptyset) 00123 * 00124 * @return 00125 * max indices 00126 */ 00127 Idx MaxIndex(void) const; 00128 00129 /** 00130 * Test whether index is not 0 00131 * @param rIndex 00132 * Index to test 00133 * @return 00134 * True if idx!=0 00135 */ 00136 bool Valid(const Idx& rIndex) const; 00137 00138 /** 00139 * Iterators on indexset. 00140 */ 00141 typedef TBaseSet<Idx>::Iterator Iterator; 00142 00143 /** 00144 * Insert new index to set 00145 * 00146 * @return 00147 * New index 00148 */ 00149 Idx Insert(void); 00150 00151 /** 00152 * Insert specified index 00153 * 00154 * @param rIndex 00155 * Index to insert 00156 * @return 00157 * True if index was new to set 00158 */ 00159 bool Insert(const Idx& rIndex); 00160 00161 /** 00162 * Compute an Idx type signature for a Set. The value is computed by 00163 * summing up the product of every index with an integer starting at 00164 * 1 (for the first index) and ending at Size() (for the last index). 00165 * 00166 * @return 00167 * Idx type set signature 00168 */ 00169 Idx Signature(void) const; 00170 00171 /** 00172 * Return pretty printable index. 00173 * 00174 * @param rIndex 00175 * Index to print 00176 * 00177 * @return 00178 * String 00179 */ 00180 std::string Str(const Idx& rIndex) const {return ToStringInteger(rIndex); }; 00181 00182 protected: 00183 00184 /** 00185 * Assign my members. This method maintains attributes 00186 * provided that the type can be appropriately casted. 00187 * 00188 * @param rSource 00189 * Source to copy from 00190 * @return 00191 * Ref to this set 00192 */ 00193 virtual IndexSet& DoAssign(const IndexSet& rSource); 00194 00195 /** 00196 * Write to TokenWriter, see Type::Write for public wrappers. 00197 * Appends the IndexSet to 00198 * TokenWriter. This will write a section with label as specified that holds 00199 * integer tokens to represent the IndexSet. For non-default attribute values, 00200 * the respective index is followed by the attribute value. The latter may 00201 * consist of sections (or tokens different from integer or string) to allow 00202 * for transparent reading; see AttributeVoid and AttributeFlags. Example for 00203 * a set with name "MySet" consisting of indices 17, 25, 40, where index 25 has a 00204 * nontrivial attribute attached: 00205 * \code 00206 * <Myset> 00207 * 17 00208 * 25 <AValue> "Some Value" </AValue> 00209 * 40 00210 * </MySet> 00211 * \endcode 00212 * 00213 * @param tw 00214 * Reference to TokenWriter 00215 * @param rLabel 00216 * Label of section to write, defaults to name of set or "IndexSet" 00217 * @param pContext 00218 * Write context to provide contextual information 00219 * 00220 * @exception Exception 00221 * - IO errors (id 2) 00222 */ 00223 virtual void DoWrite(TokenWriter& tw, const std::string& rLabel="", const Type* pContext=0) const; 00224 00225 /** 00226 * Read from TokenReader, see Type::Read for public wrappers. 00227 * This method invokes TokenReader::SeekBegin() to seek the specified 00228 * section, reads subsequent integer tokens as indexes, and calls matching TokenReader::SeekEnd(). 00229 * If no section is specified, the section is assumed to start at the current position 00230 * of the token stream. If the current position is no begin token, 00231 * the section "IndexSet" is read. 00232 * When used by a derived class with attributes, attributes are read, too. 00233 * 00234 * @param rTr 00235 * Reference to tokenreader 00236 * @param rLabel 00237 * Section to read, defaults to current begin label or else "IndexSet" 00238 * @param pContext 00239 * Read context to provide contextual information 00240 * 00241 * @exception Exception 00242 * - IO errors (id 1) 00243 * - token mismatch (id 50, 51, 52) 00244 */ 00245 virtual void DoRead(TokenReader& rTr, const std::string& rLabel="", const Type* pContext=0); 00246 00247 00248 }; 00249 00250 /* convenience typedef for stateset */ 00251 typedef IndexSet StateSet; 00252 00253 00254 00255 /** 00256 * Set of indices with attributes. A TaIndexSet<Attr> is a template derived from IndexSet, 00257 * such that each set element has an Attribute of class Attr. 00258 * The template parameter Attr must provide basic functions for file IO and must define a default 00259 * value, see AttributeVoid and AttributeFlags for an examples. 00260 * Attributes are maintained by an STL map to associate indices 00261 * with attributes different from the default value. Thus, attributes with default value 00262 * do not take up any memeory. 00263 * 00264 * @param mAttributeMap 00265 * STL map of type std::map<Idx,Attr> to hold attributes 00266 * 00267 * The copy constructor copies attributes; the methods InsertSet(), EraseSet() and 00268 * RestrictSet() maintain attributes; all other set operations derived from IndexSet 00269 * either return a IndexSet (no attributes) or set all attributes to the dafault value. 00270 * To set or get an attribute of an index that does not exist in the set is considered 00271 * as an error and triggers an exception (id 60) when the macro FAUDES_CHECKED is defined. 00272 * 00273 * The format for token IO is demonstrated by the following example 00274 * of a set with name "MySet" consisting of indices 17, 25, 40, where index 25 has a 00275 * nontrivial attribute attached: 00276 * \code 00277 * <Myset> 00278 * 17 00279 * 25 <AValue> "Some Value" </AValue> 00280 * 40 00281 * </MySet> 00282 * \endcode 00283 * Note that attributes may be either subsections or tokens of type different from integer and string. 00284 * This is to allow reading a token stream to a class with incompatible (or no) attributes. 00285 */ 00286 00287 00288 00289 template<class Attr> 00290 class TaIndexSet : public IndexSet, public TaBaseSet<Idx,Attr> { 00291 00292 FAUDES_TYPE_DECLARATION(TaIndexSet,IndexSet) 00293 00294 /** 00295 * We implement "protected privacy for template classes" by friendship. 00296 * This is used for the pragmatic implemention conversion constructors. 00297 */ 00298 friend class IndexSet; 00299 00300 00301 public: 00302 /** 00303 * Constructor. 00304 */ 00305 TaIndexSet(void); 00306 00307 /** 00308 * Copy-constructor (from TaIndexSet, incl attributes) 00309 */ 00310 TaIndexSet(const TaIndexSet& rOtherSet); 00311 00312 /** 00313 * Copy-constructor (from IndexSet, sets attributes to default) 00314 */ 00315 TaIndexSet(const IndexSet& rOtherSet); 00316 00317 /** 00318 * Construct from file. 00319 * This constructor uses the Read(TokenReader&, const std::string&) function to read. 00320 * 00321 * @param rFilename 00322 * Name of file 00323 * @param rLabel 00324 * Section for the set in file 00325 * 00326 * @exception Exception 00327 * - IO errors (id 1) 00328 * - token mismatch (id 50, 51, 52) 00329 */ 00330 TaIndexSet(const std::string& rFilename, const std::string& rLabel = ""); 00331 00332 /** 00333 * Virtual destructor 00334 */ 00335 virtual ~TaIndexSet(void) {}; 00336 00337 /** Relaxed assignment method. Maintain provided they can be casted.. 00338 * 00339 * @param rSrc 00340 * Source from which to assign 00341 * @return 00342 * Ref to this set 00343 */ 00344 virtual TaIndexSet& Assign(const IndexSet& rSrc); 00345 00346 /** Relaxed assignment operator. Maintain attributes provided they can be casted. 00347 * 00348 * @param rSrc 00349 * Source from which to assign 00350 * @return 00351 * Ref to this set 00352 */ 00353 virtual TaIndexSet& operator=(const IndexSet& rSrc); 00354 00355 /** 00356 * Set attributes. Provided that rOtherSet has attributes that can be 00357 * casted to the appropriate type, attributes are copied per element from rOtherSet. 00358 * Elements of this set which are not in rOtherSet maintain their attribute. 00359 * 00360 * @param rOtherSet 00361 * Other IndexSet 00362 * @exception Exception 00363 * - Element does not exist (63) 00364 * - Cannot cast attribute type (63) 00365 */ 00366 virtual void Attributes(const IndexSet& rOtherSet); 00367 00368 /** 00369 * Set attributes. Attributes are copied per element from rOtherSet. 00370 * Elements of this set which are not in rOtherSet maintain their attribute. 00371 * 00372 * @param rOtherSet 00373 * Other IndexSet 00374 */ 00375 virtual void Attributes(const TaIndexSet& rOtherSet); 00376 00377 /** 00378 * Iterators on indexset. 00379 */ 00380 typedef IndexSet::Iterator Iterator; 00381 00382 /** 00383 * Erase Element (incl its attribute) 00384 * 00385 * @param rIndex 00386 * Index to specify element 00387 * @return 00388 * True if element used to exist 00389 */ 00390 bool Erase(const Idx& rIndex); 00391 00392 00393 /** 00394 * Erase element by iterator (incl attribute) 00395 * 00396 * @param pos 00397 * Iterator to specify element 00398 * @return 00399 * Iterator to next element or End() 00400 */ 00401 Iterator Erase(const Iterator& pos); 00402 00403 00404 /** 00405 * Erase elements given by other set. This function 00406 * ignores the attributes of the other set and maintains the attributes 00407 * of the remaining elements in this set. 00408 * 00409 * @param rOtherSet 00410 * Elements to erase 00411 */ 00412 void EraseSet(const IndexSet& rOtherSet); 00413 00414 /** 00415 * Restrict to specified subset. Erases any elements no in 00416 * the specified set. This function 00417 * ignores the attributes of the other set and maintains the attributes 00418 * of the remaining elements in this set. 00419 * 00420 * @param rOtherSet 00421 * Elements to erase 00422 */ 00423 void RestrictSet(const IndexSet& rOtherSet); 00424 00425 00426 /** 00427 * Insert new index to set using default attribute. 00428 * 00429 * @return 00430 * New index 00431 */ 00432 Idx Insert(void); 00433 00434 /** 00435 * Insert new index with attribute. 00436 * If the index allready exists, the 00437 * attribute is overwritten by rAttr. 00438 * 00439 * @param rAttr 00440 * Specify attribute of new element 00441 * @return 00442 * new index 00443 */ 00444 Idx Insert(const Attr& rAttr); 00445 00446 /** 00447 * Insert element. If the element exists, the attribute is maintained. 00448 * If the element does not exist, it is inserted with default attribute. 00449 * 00450 * @param rIndex 00451 * Index to specify element 00452 * @return 00453 * True if element was new to set 00454 */ 00455 bool Insert(const Idx& rIndex); 00456 00457 /** 00458 * Insert element with attribute. 00459 * 00460 * @param rIndex 00461 * Index to specify element 00462 * @param attr 00463 * Specify attribute of (new) element 00464 * @return 00465 * True if element was new to set 00466 */ 00467 bool Insert(const Idx& rIndex, const Attr& attr); 00468 00469 /** 00470 * Inserts elements of rOtherSet. 00471 * Attributes of this set are maintained, newly inserted elements have default attribute. 00472 * 00473 * 00474 * @param rOtherSet 00475 * Other IndexSet 00476 */ 00477 virtual void InsertSet(const IndexSet& rOtherSet); 00478 00479 /** 00480 * Inserts elements of rOtherSet. 00481 * Attributes of this set are maintained, new elements are inserted with attribute. 00482 * 00483 * @param rOtherSet 00484 * Other IndexSet 00485 */ 00486 virtual void InsertSet(const TaIndexSet& rOtherSet); 00487 00488 /** 00489 * Clear all set. 00490 */ 00491 virtual void Clear(void); 00492 00493 00494 00495 protected: 00496 00497 /** 00498 * Assign my members. This method maintains attributes. 00499 * 00500 * @param rSource 00501 * Source to copy from 00502 * @return 00503 * Ref to this set 00504 */ 00505 virtual TaIndexSet& DoAssign(const TaIndexSet& rSource); 00506 00507 00508 }; 00509 00510 /** Convenience Macro */ 00511 //template<class Attr> typedef TaStateSet<class Attr> TaIndexSet<class Attr> 00512 #define TaStateSet TaIndexSet 00513 00514 00515 /** @} doxygen group */ 00516 00517 00518 /* 00519 ************************************************************************************* 00520 ************************************************************************************* 00521 Implementation 00522 ************************************************************************************* 00523 ************************************************************************************* 00524 */ 00525 00526 00527 // std faudes type 00528 FAUDES_TYPE_IMPLEMENTATION(TaIndexSet<Attr>,IndexSet,template<class Attr>) 00529 00530 // (by above macro) 00531 // template<class Attr> const TaIndexSet<Attr>* TaIndexSet<Attr>::Cast(const Type*) const {} 00532 00533 // TaIndexSet() 00534 template<class Attr> 00535 TaIndexSet<Attr>::TaIndexSet(void) : 00536 TBaseSet<Idx>(), 00537 IndexSet(), 00538 TaBaseSet<Idx,Attr>() 00539 { 00540 FD_DC("TaIndexSet(" << this << ")::TaIndexSet()"); 00541 } 00542 00543 // TaIndexSet(rOtherSet) 00544 template<class Attr> 00545 TaIndexSet<Attr>::TaIndexSet(const TaIndexSet& rOtherSet) : 00546 TBaseSet<Idx>(), 00547 IndexSet(), 00548 TaBaseSet<Idx,Attr>() 00549 { 00550 FD_DC("TaIndexSet(" << this << ")::TaIndexSet(rOtherSet " << &rOtherSet << ")"); 00551 // copy my members 00552 DoAssign(rOtherSet); 00553 } 00554 00555 // TaIndexSet(rOtherSet) 00556 template<class Attr> 00557 TaIndexSet<Attr>::TaIndexSet(const IndexSet& rOtherSet) : 00558 TBaseSet<Idx>(), 00559 IndexSet(), 00560 TaBaseSet<Idx,Attr>() 00561 { 00562 FD_DC("TaIndexSet(" << this << ")::TaIndexSet(rOtherSet " << &rOtherSet << ")"); 00563 // copy my members 00564 Assign(rOtherSet); 00565 } 00566 00567 00568 // File constructor 00569 template<class Attr> 00570 TaIndexSet<Attr>::TaIndexSet(const std::string& rFilename, const std::string& rLabel) : 00571 TBaseSet<Idx>(), 00572 IndexSet(), 00573 TaBaseSet<Idx,Attr>() 00574 { 00575 FD_DC("TaIndexSet(" << this << ")::TaIndexSet(" << rFilename << ")"); 00576 Read(rFilename, rLabel); 00577 } 00578 00579 00580 // DoAssign (attributes known and match) 00581 template<class Attr> 00582 TaIndexSet<Attr>& TaIndexSet<Attr>::DoAssign(const TaIndexSet<Attr>& rSourceSet) { 00583 FD_DC("TaIndexSet(" << this << ")::DoAssign( [a] " << &rSourceSet<<")"); 00584 // call base incl attributes 00585 TaBaseSet<Idx,Attr>::DoAssign(rSourceSet); 00586 // done 00587 return *this; 00588 } 00589 00590 // Relaxed Assign() 00591 template<class Attr> 00592 TaIndexSet<Attr>& TaIndexSet<Attr>::Assign(const IndexSet& rSourceSet) { 00593 FD_DC("TaIndexSet(" << this << ")::Assign([v] " << &rSourceSet<<")"); 00594 FD_DC("TaIndexSet(" << this << ")::Assign(): src type " << typeid(rSourceSet).name()); 00595 FD_DC("TaIndexSet(" << this << ")::Assign(): dst type " << typeid(*this).name()); 00596 // call attribute smart base 00597 TaBaseSet<Idx,Attr>::Assign(rSourceSet); 00598 // done 00599 return *this; 00600 } 00601 00602 // Relaxed Assignment Operator(rSet) 00603 template<class Attr> 00604 TaIndexSet<Attr>& TaIndexSet<Attr>::operator=(const IndexSet& rSourceSet) { 00605 return Assign(rSourceSet); 00606 } 00607 00608 00609 // Attributes(set) 00610 template<class Attr> 00611 void TaIndexSet<Attr>::Attributes(const TaIndexSet& rOtherSet) { 00612 FD_DC("TaIndexSet(" << this << ")::Attributes(set) with type " << typeid(rOtherSet.Attribute()).name()); 00613 TaBaseSet<Idx,Attr>::Attributes(rOtherSet); 00614 } 00615 00616 // Attributes(set) 00617 template<class Attr> 00618 void TaIndexSet<Attr>::Attributes(const IndexSet& rOtherSet) { 00619 FD_DC("TaIndexSet(" << this << ")::Attributes(set) with type " << typeid(rOtherSet.Attribute()).name()); 00620 TaBaseSet<Idx,Attr>::Attributes(rOtherSet); 00621 } 00622 00623 00624 //Clear 00625 template<class Attr> 00626 void TaIndexSet<Attr>::Clear(void) { 00627 FD_DC("TaIndexSet(" << this << ")::Clear()"); 00628 TaBaseSet<Idx,Attr>::Clear(); 00629 } 00630 00631 // Insert() 00632 template<class Attr> 00633 Idx TaIndexSet<Attr>::Insert(void) { 00634 FD_DC("TaIndexSet(" << this << ")::Insert()"); 00635 Idx index=MaxIndex()+1; 00636 TaBaseSet<Idx,Attr>::Insert(index); 00637 return index; 00638 } 00639 00640 //Insert(idx) 00641 template<class Attr> 00642 bool TaIndexSet<Attr>::Insert(const Idx& rIndex) { 00643 FD_DC("TaIndexSet(" << this << ")::Insert("<< rIndex <<")"); 00644 bool ret=IndexSet::Insert(rIndex); // automatic: keep attribute if exists 00645 return ret; 00646 } 00647 00648 // Insert(attr) 00649 template<class Attr> 00650 Idx TaIndexSet<Attr>::Insert(const Attr& attr) { 00651 FD_DC("TaIndexSet(" << this << ")::Insert(" << attr.ToString() << ")"); 00652 Idx index = Insert(); 00653 if(!attr.IsDefault()) { 00654 TaBaseSet<Idx,Attr>::Attribute(index,attr); 00655 } 00656 return index; 00657 } 00658 00659 //Insert(idx,attr) 00660 template<class Attr> 00661 bool TaIndexSet<Attr>::Insert(const Idx& rIndex, const Attr& attr) { 00662 FD_DC("TaIndexSet(" << this << ")::Insert("<< rIndex <<",attr)"); 00663 return TaBaseSet<Idx,Attr>::Insert(rIndex,attr); 00664 } 00665 00666 00667 // InsertSet(set) 00668 template<class Attr> 00669 void TaIndexSet<Attr>::InsertSet(const TaIndexSet& rOtherSet) { 00670 FD_DC("TaIndexSet(" << this << ")::InsertSet( T " << &rOtherSet << ")"); 00671 TaBaseSet<Idx,Attr>::InsertSet(rOtherSet); 00672 } 00673 00674 // InsertSet(set) 00675 template<class Attr> 00676 void TaIndexSet<Attr>::InsertSet(const IndexSet& rOtherSet) { 00677 FD_DC("TaIndexSet(" << this << ")::InsertSet(" << &rOtherSet << ")"); 00678 IndexSet::InsertSet(rOtherSet); 00679 } 00680 00681 //Erase(idx) 00682 template<class Attr> 00683 bool TaIndexSet<Attr>::Erase(const Idx& rIndex) { 00684 return TaBaseSet<Idx,Attr>::Erase(rIndex); 00685 } 00686 00687 //Erase(pos) 00688 template<class Attr> 00689 typename TaIndexSet<Attr>::Iterator TaIndexSet<Attr>::Erase(const Iterator& pos) { 00690 return TaBaseSet<Idx,Attr>::Erase(pos); 00691 } 00692 00693 00694 //EraseSet(set) 00695 template<class Attr> 00696 void TaIndexSet<Attr>::EraseSet(const IndexSet& rOtherSet) { 00697 FD_DC("TaIndexSet(" << this << ")::EraseSet(" << rOtherSet.ToString() << ")"); 00698 TaBaseSet<Idx,Attr>::EraseSet(rOtherSet); 00699 } 00700 00701 //RestrictSet(set) 00702 template<class Attr> 00703 void TaIndexSet<Attr>::RestrictSet(const IndexSet& rOtherSet) { 00704 FD_DC("TaIndexSet(" << this << ")::RestrictSet(" << rOtherSet.ToString() << ")"); 00705 TaBaseSet<Idx,Attr>::RestrictSet(rOtherSet); 00706 } 00707 00708 00709 00710 00711 } // namespace faudes 00712 00713 #endif |
libFAUDES 2.14g --- 2009-12-3 --- c++ source docu by doxygen 1.5.6