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_exception.h" 00031 #include "cfl_abaseset.h" 00032 #include "cfl_symboltable.h" 00033 #include "cfl_registry.h" 00034 #include "cfl_basevector.h" 00035 #include <algorithm> 00036 00037 00038 namespace faudes { 00039 00040 00041 00042 /** @addtogroup ContainerClasses */ 00043 /** @{*/ 00044 00045 // Forward declaration for the attributed version of indexset 00046 template<class Attr> class TaIndexSet; 00047 00048 /** 00049 * Set of indices. This class is built on top of the faudes version 00050 * TBaseSet of STL sets. It provides the essentials of the STL interface 00051 * and inherits the standard token IO interface from Type, so you may 00052 * use Read and Write for file/string/console IO. 00053 * 00054 * IndexSet is used as common base for TaIndexSet (indices with attributes), 00055 * NameSet (indices with symbolic names) and TaNameSet (indices with 00056 * attributes and symbolic names). 00057 * 00058 * The index of value 0 is reserved to indicate the invalid index. If the macro FAUDES_CHECKED 00059 * is defined, the attempt to insert an index 0 triggers an exception (id 61). Invalid 00060 * iterators throw an exception (id 62) when used as an argument to a IndexSet function. 00061 * 00062 * Technically, file IO is done by TaIndexSet functions. This requires a copy and for 00063 * that reason may be reimplemented in a future versions. 00064 * The format is demonstrated by the following example 00065 * of a set with name "MySet" consisting of indices 17, 25, 26, 27, 28, 40: 00066 * \code 00067 * <Myset> 00068 * 17 00069 * <Consecutive> 25 4 </Consecutive> 00070 * 40 00071 * </MySet> 00072 * \endcode 00073 * Theere is a minimum number of consecutive indices for the use of the consecutive 00074 * section defined in definitions.h. 00075 * 00076 */ 00077 00078 class IndexSet : public virtual TBaseSet<Idx> { 00079 00080 FAUDES_TYPE_DECLARATION(IndexSet,IndexSet,TBaseSet<Idx>) 00081 00082 public: 00083 00084 /** 00085 * We implement "protected privacy for template classes" by friendship. 00086 * This is used for the pragmatic implemention conversion constructors. 00087 */ 00088 template<class Attr> friend class TaIndexSet; 00089 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 mismatch (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 void 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 * Write to TokenWriter, see Type::Write for public wrappers. Appends the IndexSet to 00232 * TokenWriter using XML format. 00233 * 00234 * @param tw 00235 * Reference to TokenWriter 00236 * @param rLabel 00237 * Label of section to write, defaults to name of set or "IndexSet" 00238 * @param pContext 00239 * Write context to provide contextual information 00240 * 00241 * @exception Exception 00242 * - IO errors (id 2) 00243 */ 00244 virtual void DoXWrite(TokenWriter& tw, const std::string& rLabel="", const Type* pContext=0) const; 00245 00246 /** 00247 * Read from TokenReader, see Type::Read for public wrappers. 00248 * This method invokes TokenReader::ReadBegin() to seek the specified 00249 * section, reads subsequent integer tokens as indexes, and calls matching TokenReader::ReadEnd(). 00250 * If no section is specified, the section is assumed to start at the current position 00251 * of the token stream. If the current position is no begin token, 00252 * the section "IndexSet" is read. 00253 * When used by a derived class with attributes, attributes are read, too. 00254 * 00255 * @param rTr 00256 * Reference to tokenreader 00257 * @param rLabel 00258 * Section to read, defaults to current begin label or else "IndexSet" 00259 * @param pContext 00260 * Read context to provide contextual information 00261 * 00262 * @exception Exception 00263 * - IO errors (id 1) 00264 * - token mismatch (id 50, 51, 52) 00265 */ 00266 virtual void DoRead(TokenReader& rTr, const std::string& rLabel="", const Type* pContext=0); 00267 00268 }; 00269 00270 /* convenience typedef for stateset */ 00271 typedef IndexSet StateSet; 00272 00273 00274 /** 00275 * Convenience typedef for vectors og generators 00276 * \ingroup GeneratorClasses 00277 */ 00278 typedef TBaseVector<IndexSet> IndexSetVector; 00279 00280 00281 /** 00282 * Set of indices with attributes. A TaIndexSet<Attr> is a template derived from IndexSet, 00283 * such that each set element has an Attribute of class Attr. 00284 * The template parameter Attr must provide basic functions for file IO and must define a default 00285 * value, see AttributeVoid and AttributeFlags for an examples. 00286 * Attributes are maintained by an STL map to associate indices 00287 * with attributes different from the default value. Thus, attributes with default value 00288 * do not take up any memeory. 00289 * 00290 * @param mAttributeMap 00291 * STL map of type std::map<Idx,Attr> to hold attributes 00292 * 00293 * The copy constructor copies attributes; the methods InsertSet(), EraseSet() and 00294 * RestrictSet() maintain attributes; all other set operations derived from IndexSet 00295 * either return a IndexSet (no attributes) or set all attributes to the dafault value. 00296 * To set or get an attribute of an index that does not exist in the set is considered 00297 * as an error and triggers an exception (id 60) when the macro FAUDES_CHECKED is defined. 00298 * 00299 * The format for token IO is demonstrated by the following example 00300 * of a set with name "MySet" consisting of indices 17, 25, 40, where index 25 has a 00301 * nontrivial attribute attached: 00302 * \code 00303 * <Myset> 00304 * 17 00305 * 25 <AValue> "Some Value" </AValue> 00306 * 40 00307 * </MySet> 00308 * \endcode 00309 * Note that attributes may be either subsections or tokens of type different from integer and string. 00310 * This is to allow reading a token stream to a class with incompatible (or no) attributes. 00311 */ 00312 00313 00314 00315 template<class Attr> 00316 class TaIndexSet : public IndexSet, public TaBaseSet<Idx,Attr> { 00317 00318 FAUDES_TYPE_TDECLARATION(Void,TaIndexSet,IndexSet) 00319 00320 public: 00321 00322 /** 00323 * We implement "protected privacy for template classes" by friendship. 00324 * This is used for the pragmatic implemention conversion constructors. 00325 */ 00326 friend class IndexSet; 00327 00328 00329 /** 00330 * Constructor. 00331 */ 00332 TaIndexSet(void); 00333 00334 /** 00335 * Copy-constructor (from TaIndexSet, incl attributes) 00336 */ 00337 TaIndexSet(const TaIndexSet& rOtherSet); 00338 00339 /** 00340 * Copy-constructor (from IndexSet, sets attributes to default) 00341 */ 00342 TaIndexSet(const IndexSet& rOtherSet); 00343 00344 /** 00345 * Construct from file. 00346 * This constructor uses the Read(TokenReader&, const std::string&) function to read. 00347 * 00348 * @param rFilename 00349 * Name of file 00350 * @param rLabel 00351 * Section for the set in file 00352 * 00353 * @exception Exception 00354 * - IO errors (id 1) 00355 * - token mismatch (id 50, 51, 52) 00356 */ 00357 TaIndexSet(const std::string& rFilename, const std::string& rLabel = ""); 00358 00359 /** 00360 * Virtual destructor 00361 */ 00362 virtual ~TaIndexSet(void) {}; 00363 00364 /** Relaxed assignment method. Maintain attributes provided they can be casted. 00365 * 00366 * @param rSrc 00367 * Source from which to assign 00368 * @return 00369 * Ref to this set 00370 */ 00371 virtual TaIndexSet& Assign(const IndexSet& rSrc); 00372 00373 /** Relaxed assignment operator. Maintain attributes provided they can be casted. 00374 * 00375 * @param rSrc 00376 * Source from which to assign 00377 * @return 00378 * Ref to this set 00379 */ 00380 virtual TaIndexSet& operator=(const IndexSet& rSrc); 00381 00382 /** 00383 * Set attributes. Provided that rOtherSet has attributes that can be 00384 * casted to the appropriate type, attributes are copied per element from rOtherSet. 00385 * Elements of this set which are not in rOtherSet maintain their attribute. 00386 * 00387 * @param rOtherSet 00388 * Other IndexSet 00389 * @exception Exception 00390 * - Element does not exist (63) 00391 * - Cannot cast attribute type (63) 00392 */ 00393 virtual void Attributes(const IndexSet& rOtherSet); 00394 00395 /** 00396 * Set attributes. Attributes are copied per element from rOtherSet. 00397 * Elements of this set which are not in rOtherSet maintain their attribute. 00398 * 00399 * @param rOtherSet 00400 * Other IndexSet 00401 */ 00402 virtual void Attributes(const TaIndexSet& rOtherSet); 00403 00404 /** 00405 * Iterators on indexset. 00406 */ 00407 typedef IndexSet::Iterator Iterator; 00408 00409 /** 00410 * Erase Element (incl its attribute) 00411 * 00412 * @param rIndex 00413 * Index to specify element 00414 * @return 00415 * True if element used to exist 00416 */ 00417 bool Erase(const Idx& rIndex); 00418 00419 00420 /** 00421 * Erase element by iterator (incl attribute) 00422 * 00423 * @param pos 00424 * Iterator to specify element 00425 * @return 00426 * Iterator to next element or End() 00427 */ 00428 Iterator Erase(const Iterator& pos); 00429 00430 00431 /** 00432 * Erase elements given by other set. This function 00433 * ignores the attributes of the other set and maintains the attributes 00434 * of the remaining elements in this set. 00435 * 00436 * @param rOtherSet 00437 * Elements to erase 00438 */ 00439 void EraseSet(const IndexSet& rOtherSet); 00440 00441 /** 00442 * Restrict to specified subset. Erases any elements no in 00443 * the specified set. This function 00444 * ignores the attributes of the other set and maintains the attributes 00445 * of the remaining elements in this set. 00446 * 00447 * @param rOtherSet 00448 * Elements to erase 00449 */ 00450 void RestrictSet(const IndexSet& rOtherSet); 00451 00452 00453 /** 00454 * Insert new index to set using default attribute. 00455 * 00456 * @return 00457 * New index 00458 */ 00459 Idx Insert(void); 00460 00461 /** 00462 * Insert new index with attribute. 00463 * If the index allready exists, the 00464 * attribute is overwritten by rAttr. 00465 * 00466 * @param rAttr 00467 * Specify attribute of new element 00468 * @return 00469 * new index 00470 */ 00471 Idx Insert(const Attr& rAttr); 00472 00473 /** 00474 * Insert element. If the element exists, the attribute is maintained. 00475 * If the element does not exist, it is inserted with default attribute. 00476 * 00477 * @param rIndex 00478 * Index to specify element 00479 * @return 00480 * True if element was new to set 00481 */ 00482 bool Insert(const Idx& rIndex); 00483 00484 /** 00485 * Insert element with attribute. 00486 * 00487 * @param rIndex 00488 * Index to specify element 00489 * @param attr 00490 * Specify attribute of (new) element 00491 * @return 00492 * True if element was new to set 00493 */ 00494 bool Insert(const Idx& rIndex, const Attr& attr); 00495 00496 /** 00497 * Inserts elements of rOtherSet. 00498 * Attributes of this set are maintained, newly inserted elements have default attribute. 00499 * 00500 * 00501 * @param rOtherSet 00502 * Other IndexSet 00503 */ 00504 virtual void InsertSet(const IndexSet& rOtherSet); 00505 00506 /** 00507 * Inserts elements of rOtherSet. 00508 * Attributes of this set are maintained, new elements are inserted with attribute. 00509 * 00510 * @param rOtherSet 00511 * Other IndexSet 00512 */ 00513 virtual void InsertSet(const TaIndexSet& rOtherSet); 00514 00515 /** 00516 * Clear all set. 00517 */ 00518 virtual void Clear(void); 00519 00520 00521 00522 protected: 00523 00524 /** 00525 * Assign my members. This method maintains attributes. 00526 * 00527 * @param rSource 00528 * Source to copy from 00529 * @return 00530 * Ref to this set 00531 */ 00532 virtual void DoAssign(const TaIndexSet& rSource); 00533 00534 00535 }; 00536 00537 /** Convenience Macro */ 00538 //template<class Attr> typedef TaStateSet<class Attr> TaIndexSet<class Attr> 00539 #define TaStateSet TaIndexSet 00540 00541 00542 00543 00544 /** @} doxygen group */ 00545 00546 00547 /* 00548 ************************************************************************************* 00549 ************************************************************************************* 00550 Implementation 00551 ************************************************************************************* 00552 ************************************************************************************* 00553 */ 00554 00555 00556 // std faudes type 00557 FAUDES_TYPE_TIMPLEMENTATION(Void,TaIndexSet<Attr>,IndexSet,template<class Attr>) 00558 00559 00560 // TaIndexSet() 00561 template<class Attr> 00562 TaIndexSet<Attr>::TaIndexSet(void) : 00563 TBaseSet<Idx>(), 00564 IndexSet(), 00565 TaBaseSet<Idx,Attr>() 00566 { 00567 FD_DC("TaIndexSet(" << this << ")::TaIndexSet()"); 00568 } 00569 00570 // TaIndexSet(rOtherSet) 00571 template<class Attr> 00572 TaIndexSet<Attr>::TaIndexSet(const TaIndexSet& rOtherSet) : 00573 TBaseSet<Idx>(), 00574 IndexSet(), 00575 TaBaseSet<Idx,Attr>() 00576 { 00577 FD_DC("TaIndexSet(" << this << ")::TaIndexSet(rOtherSet " << &rOtherSet << ")"); 00578 // copy my members 00579 DoAssign(rOtherSet); 00580 } 00581 00582 // TaIndexSet(rOtherSet) 00583 template<class Attr> 00584 TaIndexSet<Attr>::TaIndexSet(const IndexSet& rOtherSet) : 00585 TBaseSet<Idx>(), 00586 IndexSet(), 00587 TaBaseSet<Idx,Attr>() 00588 { 00589 FD_DC("TaIndexSet(" << this << ")::TaIndexSet(rOtherSet " << &rOtherSet << ")"); 00590 // copy my members 00591 Assign(rOtherSet); 00592 } 00593 00594 00595 // File constructor 00596 template<class Attr> 00597 TaIndexSet<Attr>::TaIndexSet(const std::string& rFilename, const std::string& rLabel) : 00598 TBaseSet<Idx>(), 00599 IndexSet(), 00600 TaBaseSet<Idx,Attr>() 00601 { 00602 FD_DC("TaIndexSet(" << this << ")::TaIndexSet(" << rFilename << ")"); 00603 Read(rFilename, rLabel); 00604 } 00605 00606 00607 // DoAssign (attributes known and match) 00608 template<class Attr> 00609 void TaIndexSet<Attr>::DoAssign(const TaIndexSet<Attr>& rSourceSet) { 00610 FD_DC("TaIndexSet(" << this << ")::DoAssign( [a] " << &rSourceSet<<")"); 00611 // call base incl attributes 00612 TaBaseSet<Idx,Attr>::DoAssign(rSourceSet); 00613 } 00614 00615 // Relaxed Assign() 00616 template<class Attr> 00617 TaIndexSet<Attr>& TaIndexSet<Attr>::Assign(const IndexSet& rSourceSet) { 00618 FD_DC("TaIndexSet(" << this << ")::Assign([v] " << &rSourceSet<<")"); 00619 FD_DC("TaIndexSet(" << this << ")::Assign(): src type " << typeid(rSourceSet).name()); 00620 FD_DC("TaIndexSet(" << this << ")::Assign(): dst type " << typeid(*this).name()); 00621 // call attribute smart base 00622 TaBaseSet<Idx,Attr>::Assign(rSourceSet); 00623 // done 00624 return *this; 00625 } 00626 00627 // Relaxed Assignment Operator(rSet) 00628 template<class Attr> 00629 TaIndexSet<Attr>& TaIndexSet<Attr>::operator=(const IndexSet& rSourceSet) { 00630 return Assign(rSourceSet); 00631 } 00632 00633 00634 // Attributes(set) 00635 template<class Attr> 00636 void TaIndexSet<Attr>::Attributes(const TaIndexSet& rOtherSet) { 00637 FD_DC("TaIndexSet(" << this << ")::Attributes(set) with type " << typeid(rOtherSet.Attribute()).name()); 00638 TaBaseSet<Idx,Attr>::Attributes(rOtherSet); 00639 } 00640 00641 // Attributes(set) 00642 template<class Attr> 00643 void TaIndexSet<Attr>::Attributes(const IndexSet& rOtherSet) { 00644 FD_DC("TaIndexSet(" << this << ")::Attributes(set) with type " << typeid(rOtherSet.Attribute()).name()); 00645 TaBaseSet<Idx,Attr>::Attributes(rOtherSet); 00646 } 00647 00648 00649 //Clear 00650 template<class Attr> 00651 void TaIndexSet<Attr>::Clear(void) { 00652 FD_DC("TaIndexSet(" << this << ")::Clear()"); 00653 TaBaseSet<Idx,Attr>::Clear(); 00654 } 00655 00656 // Insert() 00657 template<class Attr> 00658 Idx TaIndexSet<Attr>::Insert(void) { 00659 FD_DC("TaIndexSet(" << this << ")::Insert()"); 00660 Idx index=MaxIndex()+1; 00661 TaBaseSet<Idx,Attr>::Insert(index); 00662 return index; 00663 } 00664 00665 //Insert(idx) 00666 template<class Attr> 00667 bool TaIndexSet<Attr>::Insert(const Idx& rIndex) { 00668 FD_DC("TaIndexSet(" << this << ")::Insert("<< rIndex <<")"); 00669 bool ret=IndexSet::Insert(rIndex); // automatic: keep attribute if exists 00670 return ret; 00671 } 00672 00673 // Insert(attr) 00674 template<class Attr> 00675 Idx TaIndexSet<Attr>::Insert(const Attr& attr) { 00676 FD_DC("TaIndexSet(" << this << ")::Insert(" << attr.ToString() << ")"); 00677 Idx index = Insert(); 00678 if(!attr.IsDefault()) { 00679 TaBaseSet<Idx,Attr>::Attribute(index,attr); 00680 } 00681 return index; 00682 } 00683 00684 //Insert(idx,attr) 00685 template<class Attr> 00686 bool TaIndexSet<Attr>::Insert(const Idx& rIndex, const Attr& attr) { 00687 FD_DC("TaIndexSet(" << this << ")::Insert("<< rIndex <<",attr)"); 00688 return TaBaseSet<Idx,Attr>::Insert(rIndex,attr); 00689 } 00690 00691 00692 // InsertSet(set) 00693 template<class Attr> 00694 void TaIndexSet<Attr>::InsertSet(const TaIndexSet& rOtherSet) { 00695 FD_DC("TaIndexSet(" << this << ")::InsertSet( T " << &rOtherSet << ")"); 00696 TaBaseSet<Idx,Attr>::InsertSet(rOtherSet); 00697 } 00698 00699 // InsertSet(set) 00700 template<class Attr> 00701 void TaIndexSet<Attr>::InsertSet(const IndexSet& rOtherSet) { 00702 FD_DC("TaIndexSet(" << this << ")::InsertSet(" << &rOtherSet << ")"); 00703 IndexSet::InsertSet(rOtherSet); 00704 } 00705 00706 //Erase(idx) 00707 template<class Attr> 00708 bool TaIndexSet<Attr>::Erase(const Idx& rIndex) { 00709 return TaBaseSet<Idx,Attr>::Erase(rIndex); 00710 } 00711 00712 //Erase(pos) 00713 template<class Attr> 00714 typename TaIndexSet<Attr>::Iterator TaIndexSet<Attr>::Erase(const Iterator& pos) { 00715 return TaBaseSet<Idx,Attr>::Erase(pos); 00716 } 00717 00718 00719 //EraseSet(set) 00720 template<class Attr> 00721 void TaIndexSet<Attr>::EraseSet(const IndexSet& rOtherSet) { 00722 FD_DC("TaIndexSet(" << this << ")::EraseSet(" << rOtherSet.ToString() << ")"); 00723 TaBaseSet<Idx,Attr>::EraseSet(rOtherSet); 00724 } 00725 00726 //RestrictSet(set) 00727 template<class Attr> 00728 void TaIndexSet<Attr>::RestrictSet(const IndexSet& rOtherSet) { 00729 FD_DC("TaIndexSet(" << this << ")::RestrictSet(" << rOtherSet.ToString() << ")"); 00730 TaBaseSet<Idx,Attr>::RestrictSet(rOtherSet); 00731 } 00732 00733 00734 00735 00736 } // namespace faudes 00737 00738 #endif libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen |