libFAUDES

Sections

Index

indexset.h

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

libFAUDES 2.14g --- 2009-12-3 --- c++ source docu by doxygen 1.5.6