libFAUDES

Sections

Index

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_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