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