cfl_indexset.h

Go 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