cgenerator.h

Go to the documentation of this file.
00001 
00003 /* FAU Discrete Event Systems Library (libfaudes)
00004 
00005 Copyright (C) 2006  Bernd Opitz
00006 Copyright (C) 2007  Thomas Moor
00007 Exclusive copyright is granted to Klaus Schmidt
00008 
00009 This library is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU Lesser General Public
00011 License as published by the Free Software Foundation; either
00012 version 2.1 of the License, or (at your option) any later version.
00013 
00014 This library is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public
00020 License along with this library; if not, write to the Free Software
00021 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
00022 
00023 
00024 #ifndef CGENERATOR_H
00025 
00026 #include "definitions.h"
00027 #include "agenerator.h"
00028 
00029 namespace faudes {
00030 
00031 
00050 class AttributeCFlags : public AttributeFlags {
00051  public:
00055   AttributeCFlags(void) {mFlags=mDefCFlags;}
00056 
00058   virtual ~AttributeCFlags(void) {};
00059 
00072   virtual void Read(TokenReader& rTr);
00073  
00083   virtual void Write(TokenWriter& rTw) const;
00084 
00089   virtual void Write(void) const;
00090 
00100   virtual std::string ToString(void) const;
00101 
00106   void SetControllable(void) { mFlags |= mControllableFlag; }
00107 
00112   void ClrControllable(void) { mFlags &= ~mControllableFlag; };
00113      
00118   bool Controllable(void) const {return ( (mFlags & mControllableFlag) != 0 ); }
00119 
00120 
00125   void SetObservable(void) { mFlags |= mObservableFlag; }
00126 
00131   void ClrObservable(void) { mFlags &= ~mObservableFlag; };
00132      
00137   bool Observable(void) const {return ( (mFlags & mObservableFlag) != 0 ); }
00138 
00139 
00144   void SetForcible(void) { mFlags |= mForcibleFlag; }
00145 
00150   void ClrForcible(void) { mFlags &= ~mForcibleFlag; };
00151      
00156   bool Forcible(void) const {return ( (mFlags & mForcibleFlag) != 0 ); }
00157 
00158 
00162   bool  IsDefault(void) const {return mFlags==mDefCFlags;};
00163 
00164   // flag masks for the three properties
00165   const static fType mControllableFlag=0x01;
00166   const static fType mObservableFlag  =0x02;
00167   const static fType mForcibleFlag    =0x04;
00168 
00169  private:
00171   const static fType mDefCFlags         =0x02;
00172 
00174   const static fType mAllCFlags         =0x07;
00175 
00176 }; // class AttributeCFlags
00177 
00178 
00196 template <class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
00197     class TcGenerator : public TaGenerator<GlobalAttr, StateAttr, EventAttr, TransAttr> {    
00198   public:
00202     TcGenerator(void);
00203 
00209     TcGenerator(const vGenerator& rOtherGen);
00210         
00216     TcGenerator(const TcGenerator& rOtherGen);
00217 
00227     TcGenerator(const char* pFileName);
00228 
00235      TcGenerator* NewP(void) const;
00236 
00243      TcGenerator NewCGen(void) const;
00244 
00252     void InsControllableEvent(Idx index);
00253 
00264     Idx InsControllableEvent(const std::string& rName);
00265     
00273     void InsUncontrollableEvent(Idx index);
00274 
00285     Idx InsUncontrollableEvent(const std::string& rName);
00286         
00293     void SetControllable(Idx index);
00294 
00301     void SetControllable(const std::string& rName);
00302 
00309     void SetControllable(const EventSet& rEvents);
00310         
00317     void ClrControllable(Idx index);
00318 
00325     void ClrControllable(const std::string& rName);
00326 
00333     void ClrControllable(const EventSet& rEvents);
00334           
00344     bool Controllable(Idx index) const;
00345 
00355     bool Controllable(const std::string& rName) const;
00356 
00363     EventSet ControllableEvents(void) const;
00364 
00371     EventSet UncontrollableEvents(void) const;
00372 
00380     void InsObservableEvent(Idx index);
00381 
00392     Idx InsObservableEvent(const std::string& rName);
00393     
00401     void InsUnobservableEvent(Idx index);
00402 
00413     Idx InsUnobservableEvent(const std::string& rName);
00414         
00421     void SetObservable(Idx index);
00422 
00429     void SetObservable(const std::string& rName);
00430 
00437     void SetObservable(const EventSet& rEvents);
00438         
00445     void ClrObservable(Idx index);
00446 
00453     void ClrObservable(const std::string& rName);
00454 
00461     void ClrObservable(const EventSet& rEvents);
00462           
00472     bool Observable(Idx index) const;
00473 
00483     bool Observable(const std::string& rName) const;
00484 
00491     EventSet ObservableEvents(void) const;
00492 
00499     EventSet UnobservableEvents(void) const;
00500 
00508     void InsForcibleEvent(Idx index);
00509 
00520     Idx InsForcibleEvent(const std::string& rName);
00521     
00529     void InsUnforcibleEvent(Idx index);
00530 
00541     Idx InsUnforcibleEvent(const std::string& rName);
00542         
00549     void SetForcible(Idx index);
00550 
00557     void SetForcible(const std::string& rName);
00558 
00565     void SetForcible(const EventSet& rEvents);
00566         
00573     void ClrForcible(Idx index);
00574 
00581     void ClrForcible(const std::string& rName);
00582 
00589     void ClrForcible(const EventSet& rEvents);
00590           
00600     bool Forcible(Idx index) const;
00601 
00611     bool Forcible(const std::string& rName) const;
00612 
00619     EventSet ForcibleEvents(void) const;
00620 
00627     EventSet UnforcibleEvents(void) const;
00628 
00629   private:
00630 
00631   protected:
00632 }; // end class TcGeneraator
00633 
00634     
00636 typedef TcGenerator<AttributeVoid, AttributeVoid, AttributeCFlags,AttributeVoid> cGenerator;
00637 
00639 typedef TaNameSet<AttributeCFlags> cEventSet;
00640 
00641 /* convenience access to relevant scopes */
00642 #define THIS TcGenerator<GlobalAttr, StateAttr, EventAttr, TransAttr>
00643 #define BASE TaGenerator<GlobalAttr, StateAttr, EventAttr, TransAttr>
00644 #define TEMP template <class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
00645 
00646 
00647 // TcGenerator(void)
00648 TEMP THIS::TcGenerator(void) : BASE() {
00649   FD_DG("TcGenerator(" << this << ")::TcGenerator()");
00650 }
00651 
00652 // TcGenerator(rOtherGen)
00653 TEMP THIS::TcGenerator(const TcGenerator& rOtherGen) : BASE(rOtherGen) {
00654   FD_DG("TcGenerator(" << this << ")::TcGenerator(rOtherGen)");
00655 }
00656 
00657 // TcGenerator(rOtherGen)
00658 TEMP THIS::TcGenerator(const vGenerator& rOtherGen) : BASE(rOtherGen) {
00659   FD_DG("TcGenerator(" << this << ")::TcGenerator(rOtherGen)");
00660 }
00661 
00662 // TcGenerator(pFilename)
00663 TEMP THIS::TcGenerator(const char* pFileName) : BASE(pFileName) {
00664   FD_DG("TcGenerator(" << this << ")::TcGenerator(pFilename) : done");
00665 }
00666 
00667 /*
00668 // NewcGenerator()
00669 TEMP THIS THIS::NewcGenerator(void) const {
00670   THIS res;
00671   res.EventSymbolTablep(BASE::mpEventSymbolTable);
00672   return res;
00673 }
00674 */
00675 
00676 // NewP
00677 TEMP THIS* THIS::NewP(void) const {
00678   // allocate
00679   THIS* res = new THIS;
00680   // fix base data
00681   res->EventSymbolTablep(BASE::mpEventSymbolTable);
00682   res->mStateNamesEnabled=BASE::mStateNamesEnabled;
00683   return res;
00684 }
00685 
00686 // NewCGen
00687 TEMP THIS THIS::NewCGen(void) const {
00688   // call base (fixes by assignment constructor)
00689   THIS res= BASE::NewAGen();
00690   return res;
00691 }
00692 
00693 
00694   // Controllable(index)
00695   TEMP bool THIS::Controllable(Idx index) const {
00696     EventAttr attr=BASE::EventAttribute(index);
00697     return attr.Controllable();
00698   } 
00699   
00700   // Controllable(rName)
00701   TEMP bool THIS::Controllable(const std::string& rName) const {
00702     EventAttr attr=BASE::EventAttribute(rName);
00703     return attr.Controllable();
00704   } 
00705   
00706   // InsControllableEvent(index)
00707   TEMP void THIS::InsControllableEvent(Idx index) {
00708     FD_DG("TcGenerator(" << this << ")::InsControllableEvent(" << index << ")");
00709     EventAttr attr;
00710     attr.SetControllable();
00711     BASE::InsEvent(index,attr);
00712   } 
00713 
00714   // InsControllableEvent(rName)
00715   TEMP Idx THIS::InsControllableEvent(const std::string& rName) {
00716     FD_DG("TcGenerator(" << this << ")::InsControllableEvent(" << rName << ")");
00717     EventAttr attr;
00718     attr.SetControllable();
00719     return BASE::InsEvent(rName,attr);
00720   } 
00721 
00722   // InsUncontrollableEvent(index)
00723   TEMP void THIS::InsUncontrollableEvent(Idx index) {
00724     FD_DG("TcGenerator(" << this << ")::InsUncontrollableEvent(" << index << ")");
00725     EventAttr attr;
00726     attr.ClrControllable();
00727     BASE::InsEvent(index,attr);
00728   } 
00729 
00730   // InsUncontrollableEvent(rName)
00731   TEMP Idx THIS::InsUncontrollableEvent(const std::string& rName) {
00732     FD_DG("TcGenerator(" << this << ")::InsUncontrollableEvent(" << rName << ")");
00733     EventAttr attr;
00734     attr.ClrControllable();
00735     return BASE::InsEvent(rName,attr);
00736   } 
00737     
00738   // SetControllable(index)
00739   TEMP void THIS::SetControllable(Idx index) {
00740     FD_DG("TcGenerator(" << this << ")::SetControllable(" << index << ")");
00741     EventAttr attr=BASE::EventAttribute(index);
00742     attr.SetControllable();
00743     BASE::mAlphabet.Attribute(index,attr);
00744   } 
00745 
00746   // SetControllable(rName)
00747   TEMP void THIS::SetControllable(const std::string& rName) {
00748     FD_DG("TcGenerator(" << this << ")::SetControllable(" << rName << ")");
00749     Idx index;
00750     try{
00751       index = BASE::EventIndex(rName);
00752     }
00753     catch (Exception) {
00754       std::stringstream errstr;
00755       errstr << "event \"" << rName << "\" not found in generator \"" << BASE::Name() << "\"";
00756       throw Exception("TcGenerator::SetControllable", errstr.str(), 202);
00757     }
00758     SetControllable(index);
00759   }
00760 
00761   //SetControllable(rEvents)
00762   TEMP void THIS::SetControllable(const EventSet& rEvents) {
00763     FD_DG("TcGenerator(" << this << ")::SetControllable(rEvents)");
00764     EventSet::Iterator it;
00765     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00766       SetControllable(*it);
00767     }
00768   }
00769     
00770   // ClrControllable(index)
00771   TEMP void THIS::ClrControllable(Idx index) {
00772     FD_DG("TcGenerator(" << this << ")::ClrControllable(" << index << ")");
00773     EventAttr attr=BASE::EventAttribute(index);
00774     attr.ClrControllable();
00775     BASE::mAlphabet.Attribute(index,attr);
00776   } 
00777 
00778   // ClrControllable(rName)
00779   TEMP void THIS::ClrControllable(const std::string& rName) {
00780     FD_DG("TcGenerator(" << this << ")::ClrControllable(" << rName << ")");
00781     Idx index;
00782     try{
00783       index = BASE::EventIndex(rName);
00784     }
00785     catch (Exception) {
00786       std::stringstream errstr;
00787       errstr << "event \"" << rName << "\" not found in generator \"" << BASE::Name() << "\"";
00788       throw Exception("TcGenerator::ClrControllable", errstr.str(), 202);
00789     }
00790     ClrControllable(index);
00791   }
00792 
00793   //ClrControllable(rEvents)
00794   TEMP void THIS::ClrControllable(const EventSet& rEvents) {
00795     FD_DG("TcGenerator(" << this << ")::ClrControllable(rEvents)");
00796     EventSet::Iterator it;
00797     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00798       ClrControllable(*it);
00799     }
00800   }
00801 
00802   //ControllableEvents()
00803   TEMP EventSet THIS::ControllableEvents(void) const {
00804     FD_DG("TcGenerator(" << this << ")::ControllableEvents()");
00805     EventSet res;
00806     EventSet::Iterator it;
00807     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00808       if(Controllable(*it)) res.Insert(*it);
00809     }
00810     return res;
00811   }
00812   
00813   //UncontrollableEvents()
00814   TEMP
00815     EventSet THIS::UncontrollableEvents(void) const {
00816     FD_DG("TcGenerator(" << this << ")::UncontrollableEvents()");
00817     EventSet res;
00818     EventSet::Iterator it;
00819     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00820       if(!Controllable(*it)) res.Insert(*it);
00821     }
00822     return res;
00823   }
00824   
00825   // Observable(index)
00826   TEMP bool THIS::Observable(Idx index) const {
00827     EventAttr attr=BASE::EventAttribute(index);
00828     return attr.Observable();
00829   } 
00830   
00831   // Observable(rName)
00832   TEMP bool THIS::Observable(const std::string& rName) const {
00833     EventAttr attr=BASE::EventAttribute(rName);
00834     return attr.Observable();
00835   } 
00836   
00837   // InsObservableEvent(index)
00838   TEMP void THIS::InsObservableEvent(Idx index) {
00839     FD_DG("TcGenerator(" << this << ")::InsObservableEvent(" << index << ")");
00840     EventAttr attr;
00841     attr.SetObservable();
00842     BASE::InsEvent(index,attr);
00843   } 
00844 
00845   // InsObservableEvent(rName)
00846   TEMP Idx THIS::InsObservableEvent(const std::string& rName) {
00847     FD_DG("TcGenerator(" << this << ")::InsObservableEvent(" << rName << ")");
00848     EventAttr attr;
00849     attr.SetObservable();
00850     return BASE::InsEvent(rName,attr);
00851   } 
00852 
00853   // InsUnobservableEvent(index)
00854   TEMP void THIS::InsUnobservableEvent(Idx index) {
00855     FD_DG("TcGenerator(" << this << ")::InsUnobservableEvent(" << index << ")");
00856     EventAttr attr;
00857     attr.ClrObservable();
00858     BASE::InsEvent(index,attr);
00859   } 
00860 
00861   // InsUnobservableEvent(rName)
00862   TEMP Idx THIS::InsUnobservableEvent(const std::string& rName) {
00863     FD_DG("TcGenerator(" << this << ")::InsUnobservableEvent(" << rName << ")");
00864     EventAttr attr;
00865     attr.ClrObservable();
00866     return BASE::InsEvent(rName,attr);
00867   } 
00868     
00869   // SetObservable(index)
00870   TEMP void THIS::SetObservable(Idx index) {
00871     FD_DG("TcGenerator(" << this << ")::SetObservable(" << index << ")");
00872     EventAttr attr=BASE::EventAttribute(index);
00873     attr.SetObservable();
00874     BASE::mAlphabet.Attribute(index,attr);
00875   } 
00876 
00877   // SetObservable(rName)
00878   TEMP void THIS::SetObservable(const std::string& rName) {
00879     FD_DG("TcGenerator(" << this << ")::SetObservable(" << rName << ")");
00880     Idx index;
00881     try{
00882       index = BASE::EventIndex(rName);
00883     }
00884     catch (Exception) {
00885       std::stringstream errstr;
00886       errstr << "event \"" << rName << "\" not found in generator \"" << BASE::Name() << "\"";
00887       throw Exception("TcGenerator::SetObservable", errstr.str(), 202);
00888     }
00889     SetObservable(index);
00890   }
00891 
00892   //SetObservable(rEvents)
00893   TEMP void THIS::SetObservable(const EventSet& rEvents) {
00894     FD_DG("TcGenerator(" << this << ")::SetObservable(rEvents)");
00895     EventSet::Iterator it;
00896     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00897       SetObservable(*it);
00898     }
00899   }
00900     
00901   // ClrObservable(index)
00902   TEMP void THIS::ClrObservable(Idx index) {
00903     FD_DG("TcGenerator(" << this << ")::ClrObservable(" << index << ")");
00904     EventAttr attr=BASE::EventAttribute(index);
00905     attr.ClrObservable();
00906     BASE::mAlphabet.Attribute(index,attr);
00907   } 
00908 
00909   // ClrObservable(rName)
00910   TEMP void THIS::ClrObservable(const std::string& rName) {
00911     FD_DG("TcGenerator(" << this << ")::ClrObservable(" << rName << ")");
00912     Idx index;
00913     try{
00914       index = BASE::EventIndex(rName);
00915     }
00916     catch (Exception) {
00917       std::stringstream errstr;
00918       errstr << "event \"" << rName << "\" not found in generator \"" << BASE::Name() << "\"";
00919       throw Exception("TcGenerator::ClrObservable", errstr.str(), 202);
00920     }
00921     ClrObservable(index);
00922   }
00923 
00924   //ClrObservable(rEvents)
00925   TEMP void THIS::ClrObservable(const EventSet& rEvents) {
00926     FD_DG("TcGenerator(" << this << ")::ClrObservable(rEvents)");
00927     EventSet::Iterator it;
00928     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00929       ClrObservable(*it);
00930     }
00931   }
00932 
00933   //ObservableEvents()
00934   TEMP EventSet THIS::ObservableEvents(void) const {
00935     FD_DG("TcGenerator(" << this << ")::ObservableEvents()");
00936     EventSet res;
00937     EventSet::Iterator it;
00938     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00939       if(Observable(*it)) res.Insert(*it);
00940     }
00941     return res;
00942   }
00943   
00944   //UnobservableEvents()
00945   TEMP
00946     EventSet THIS::UnobservableEvents(void) const {
00947     FD_DG("TcGenerator(" << this << ")::UnobservableEvents()");
00948     EventSet res;
00949     EventSet::Iterator it;
00950     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00951       if(!Observable(*it)) res.Insert(*it);
00952     }
00953     return res;
00954   }
00955   
00956 
00957   // Forcible(index)
00958   TEMP bool THIS::Forcible(Idx index) const {
00959     EventAttr attr=BASE::EventAttribute(index);
00960     return attr.Forcible();
00961   } 
00962   
00963   // Forcible(rName)
00964   TEMP bool THIS::Forcible(const std::string& rName) const {
00965     EventAttr attr=BASE::EventAttribute(rName);
00966     return attr.Forcible();
00967   } 
00968   
00969   // InsForcibleEvent(index)
00970   TEMP void THIS::InsForcibleEvent(Idx index) {
00971     FD_DG("TcGenerator(" << this << ")::InsForcibleEvent(" << index << ")");
00972     EventAttr attr;
00973     attr.SetForcible();
00974     BASE::InsEvent(index,attr);
00975   } 
00976 
00977   // InsForcibleEvent(rName)
00978   TEMP Idx THIS::InsForcibleEvent(const std::string& rName) {
00979     FD_DG("TcGenerator(" << this << ")::InsForcibleEvent(" << rName << ")");
00980     EventAttr attr;
00981     attr.SetForcible();
00982     return BASE::InsEvent(rName,attr);
00983   } 
00984 
00985   // InsUnforcibleEvent(index)
00986   TEMP void THIS::InsUnforcibleEvent(Idx index) {
00987     FD_DG("TcGenerator(" << this << ")::InsUnforcibleEvent(" << index << ")");
00988     EventAttr attr;
00989     attr.ClrForcible();
00990     BASE::InsEvent(index,attr);
00991   } 
00992 
00993   // InsUnforcibleEvent(rName)
00994   TEMP Idx THIS::InsUnforcibleEvent(const std::string& rName) {
00995     FD_DG("TcGenerator(" << this << ")::InsUnforcibleEvent(" << rName << ")");
00996     EventAttr attr;
00997     attr.ClrForcible();
00998     return BASE::InsEvent(rName,attr);
00999   } 
01000     
01001   // SetForcible(index)
01002   TEMP void THIS::SetForcible(Idx index) {
01003     FD_DG("TcGenerator(" << this << ")::SetForcible(" << index << ")");
01004     EventAttr attr=BASE::EventAttribute(index);
01005     attr.SetForcible();
01006     BASE::mAlphabet.Attribute(index,attr);
01007   } 
01008 
01009   // SetForcible(rName)
01010   TEMP void THIS::SetForcible(const std::string& rName) {
01011     FD_DG("TcGenerator(" << this << ")::SetForcible(" << rName << ")");
01012     Idx index;
01013     try{
01014       index = BASE::EventIndex(rName);
01015     }
01016     catch (Exception) {
01017       std::stringstream errstr;
01018       errstr << "event \"" << rName << "\" not found in generator \"" << BASE::Name() << "\"";
01019       throw Exception("TcGenerator::SetForcible", errstr.str(), 202);
01020     }
01021     SetForcible(index);
01022   }
01023 
01024   //SetForcible(rEvents)
01025   TEMP void THIS::SetForcible(const EventSet& rEvents) {
01026     FD_DG("TcGenerator(" << this << ")::SetForcible(rEvents)");
01027     EventSet::Iterator it;
01028     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
01029       SetForcible(*it);
01030     }
01031   }
01032     
01033   // ClrForcible(index)
01034   TEMP void THIS::ClrForcible(Idx index) {
01035     FD_DG("TcGenerator(" << this << ")::ClrForcible(" << index << ")");
01036     EventAttr attr=BASE::EventAttribute(index);
01037     attr.ClrForcible();
01038     BASE::mAlphabet.Attribute(index,attr);
01039   } 
01040 
01041   // ClrForcible(rName)
01042   TEMP void THIS::ClrForcible(const std::string& rName) {
01043     FD_DG("TcGenerator(" << this << ")::ClrForcible(" << rName << ")");
01044     Idx index;
01045     try{
01046       index = BASE::EventIndex(rName);
01047     }
01048     catch (Exception) {
01049       std::stringstream errstr;
01050       errstr << "event \"" << rName << "\" not found in generator \"" << BASE::Name() << "\"";
01051       throw Exception("TcGenerator::ClrForcible", errstr.str(), 202);
01052     }
01053     ClrForcible(index);
01054   }
01055 
01056   //ClrForcible(rEvents)
01057   TEMP void THIS::ClrForcible(const EventSet& rEvents) {
01058     FD_DG("TcGenerator(" << this << ")::ClrForcible(rEvents)");
01059     EventSet::Iterator it;
01060     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
01061       ClrForcible(*it);
01062     }
01063   }
01064 
01065   //ForcibleEvents()
01066   TEMP EventSet THIS::ForcibleEvents(void) const {
01067     FD_DG("TcGenerator(" << this << ")::ForcibleEvents()");
01068     EventSet res;
01069     EventSet::Iterator it;
01070     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
01071       if(Forcible(*it)) res.Insert(*it);
01072     }
01073     return res;
01074   }
01075   
01076   //UnforcibleEvents()
01077   TEMP
01078     EventSet THIS::UnforcibleEvents(void) const {
01079     FD_DG("TcGenerator(" << this << ")::UnforcibleEvents()");
01080     EventSet res;
01081     EventSet::Iterator it;
01082     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
01083       if(!Forcible(*it)) res.Insert(*it);
01084     }
01085     return res;
01086   }
01087   
01088 #undef TEMP
01089 #undef BASE
01090 #undef THIS
01091 
01092  
01093 } // namespace faudes
01094 
01095 #define CGENERATOR_H
01096 #endif
01097 

Generated on Fri May 9 11:26:47 2008 for libFAUDES 2.09b by  doxygen 1.4.4