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 FAUDES_CGENERATOR_H
00025 #define FAUDES_CGENERATOR_H
00026 
00027 #include "definitions.h"
00028 #include "agenerator.h"
00029 
00030 namespace faudes {
00031 
00032 
00051 class AttributeCFlags : public AttributeFlags {
00052  public:
00056   AttributeCFlags(void) {mFlags=mDefCFlags;}
00057 
00059   virtual ~AttributeCFlags(void) {};
00060 
00065   void SetControllable(void) { mFlags |= mControllableFlag; }
00066 
00071   void ClrControllable(void) { mFlags &= ~mControllableFlag; };
00072      
00077   bool Controllable(void) const {return ( (mFlags & mControllableFlag) != 0 ); }
00078 
00079 
00084   void SetObservable(void) { mFlags |= mObservableFlag; }
00085 
00090   void ClrObservable(void) { mFlags &= ~mObservableFlag; };
00091      
00096   bool Observable(void) const {return ( (mFlags & mObservableFlag) != 0 ); }
00097 
00098 
00103   void SetForcible(void) { mFlags |= mForcibleFlag; }
00104 
00109   void ClrForcible(void) { mFlags &= ~mForcibleFlag; };
00110      
00115   bool Forcible(void) const {return ( (mFlags & mForcibleFlag) != 0 ); }
00116 
00117 
00121   bool  IsDefault(void) const {return mFlags==mDefCFlags;};
00122 
00123   // flag masks for the three properties
00124   const static fType mControllableFlag=0x01;
00125   const static fType mObservableFlag  =0x02;
00126   const static fType mForcibleFlag    =0x04;
00127 
00128  private:
00130   const static fType mDefCFlags         =0x02;
00131 
00133   const static fType mAllCFlags         =0x07;
00134 
00135  protected:
00136 
00153   virtual void DoRead(TokenReader& rTr, const std::string& rLabel="", const Type* pContext=0);
00154  
00169   virtual void DoWrite(TokenWriter& rTw,const std::string& rLabel="", const Type* pContext=0) const;
00170 
00171 
00172 
00173 }; // class AttributeCFlags
00174 
00175 
00193 template <class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
00194     class TcGenerator : public TaGenerator<GlobalAttr, StateAttr, EventAttr, TransAttr> {    
00195   public:
00199     TcGenerator(void);
00200 
00206     TcGenerator(const vGenerator& rOtherGen);
00207         
00213     TcGenerator(const TcGenerator& rOtherGen);
00214 
00224     TcGenerator(const std::string& rFileName);
00225 
00232      TcGenerator* NewP(void) const;
00233 
00240      TcGenerator NewCGen(void) const;
00241 
00249     void InsControllableEvent(Idx index);
00250 
00261     Idx InsControllableEvent(const std::string& rName);
00262     
00270     void InsUncontrollableEvent(Idx index);
00271 
00282     Idx InsUncontrollableEvent(const std::string& rName);
00283         
00290     void SetControllable(Idx index);
00291 
00298     void SetControllable(const std::string& rName);
00299 
00306     void SetControllable(const EventSet& rEvents);
00307         
00314     void ClrControllable(Idx index);
00315 
00322     void ClrControllable(const std::string& rName);
00323 
00330     void ClrControllable(const EventSet& rEvents);
00331           
00341     bool Controllable(Idx index) const;
00342 
00352     bool Controllable(const std::string& rName) const;
00353 
00360     EventSet ControllableEvents(void) const;
00361 
00368     EventSet UncontrollableEvents(void) const;
00369 
00377     void InsObservableEvent(Idx index);
00378 
00389     Idx InsObservableEvent(const std::string& rName);
00390     
00398     void InsUnobservableEvent(Idx index);
00399 
00410     Idx InsUnobservableEvent(const std::string& rName);
00411         
00418     void SetObservable(Idx index);
00419 
00426     void SetObservable(const std::string& rName);
00427 
00434     void SetObservable(const EventSet& rEvents);
00435         
00442     void ClrObservable(Idx index);
00443 
00450     void ClrObservable(const std::string& rName);
00451 
00458     void ClrObservable(const EventSet& rEvents);
00459           
00469     bool Observable(Idx index) const;
00470 
00480     bool Observable(const std::string& rName) const;
00481 
00488     EventSet ObservableEvents(void) const;
00489 
00496     EventSet UnobservableEvents(void) const;
00497 
00505     void InsForcibleEvent(Idx index);
00506 
00517     Idx InsForcibleEvent(const std::string& rName);
00518     
00526     void InsUnforcibleEvent(Idx index);
00527 
00538     Idx InsUnforcibleEvent(const std::string& rName);
00539         
00546     void SetForcible(Idx index);
00547 
00554     void SetForcible(const std::string& rName);
00555 
00562     void SetForcible(const EventSet& rEvents);
00563         
00570     void ClrForcible(Idx index);
00571 
00578     void ClrForcible(const std::string& rName);
00579 
00586     void ClrForcible(const EventSet& rEvents);
00587           
00597     bool Forcible(Idx index) const;
00598 
00608     bool Forcible(const std::string& rName) const;
00609 
00616     EventSet ForcibleEvents(void) const;
00617 
00624     EventSet UnforcibleEvents(void) const;
00625 
00626   private:
00627 
00628   protected:
00629 }; // end class TcGeneraator
00630 
00631     
00633 typedef TcGenerator<AttributeVoid, AttributeVoid, AttributeCFlags,AttributeVoid> cGenerator;
00634 
00636 typedef TaNameSet<AttributeCFlags> cEventSet;
00637 
00638 /* convenience access to relevant scopes */
00639 #define THIS TcGenerator<GlobalAttr, StateAttr, EventAttr, TransAttr>
00640 #define BASE TaGenerator<GlobalAttr, StateAttr, EventAttr, TransAttr>
00641 #define TEMP template <class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
00642 
00643 
00644 // TcGenerator(void)
00645 TEMP THIS::TcGenerator(void) : BASE() {
00646   FD_DG("TcGenerator(" << this << ")::TcGenerator()");
00647 }
00648 
00649 // TcGenerator(rOtherGen)
00650 TEMP THIS::TcGenerator(const TcGenerator& rOtherGen) : BASE(rOtherGen) {
00651   FD_DG("TcGenerator(" << this << ")::TcGenerator(rOtherGen)");
00652 }
00653 
00654 // TcGenerator(rOtherGen)
00655 TEMP THIS::TcGenerator(const vGenerator& rOtherGen) : BASE(rOtherGen) {
00656   FD_DG("TcGenerator(" << this << ")::TcGenerator(rOtherGen)");
00657 }
00658 
00659 // TcGenerator(rFilename)
00660 TEMP THIS::TcGenerator(const std::string& rFileName) : BASE(rFileName) {
00661   FD_DG("TcGenerator(" << this << ")::TcGenerator(rFilename) : done");
00662 }
00663 
00664 /*
00665 // NewcGenerator()
00666 TEMP THIS THIS::NewcGenerator(void) const {
00667   THIS res;
00668   res.EventSymbolTablep(BASE::mpEventSymbolTable);
00669   return res;
00670 }
00671 */
00672 
00673 // NewP
00674 TEMP THIS* THIS::NewP(void) const {
00675   // allocate
00676   THIS* res = new THIS;
00677   // fix base data
00678   res->EventSymbolTablep(BASE::mpEventSymbolTable);
00679   res->mStateNamesEnabled=BASE::mStateNamesEnabled;
00680   return res;
00681 }
00682 
00683 // NewCGen
00684 TEMP THIS THIS::NewCGen(void) const {
00685   // call base (fixes by assignment constructor)
00686   THIS res= BASE::NewAGen();
00687   return res;
00688 }
00689 
00690 
00691   // Controllable(index)
00692   TEMP bool THIS::Controllable(Idx index) const {
00693     EventAttr attr=BASE::EventAttribute(index);
00694     return attr.Controllable();
00695   } 
00696   
00697   // Controllable(rName)
00698   TEMP bool THIS::Controllable(const std::string& rName) const {
00699     EventAttr attr=BASE::EventAttribute(rName);
00700     return attr.Controllable();
00701   } 
00702   
00703   // InsControllableEvent(index)
00704   TEMP void THIS::InsControllableEvent(Idx index) {
00705     FD_DG("TcGenerator(" << this << ")::InsControllableEvent(" << index << ")");
00706     EventAttr attr;
00707     attr.SetControllable();
00708     BASE::InsEvent(index,attr);
00709   } 
00710 
00711   // InsControllableEvent(rName)
00712   TEMP Idx THIS::InsControllableEvent(const std::string& rName) {
00713     FD_DG("TcGenerator(" << this << ")::InsControllableEvent(" << rName << ")");
00714     EventAttr attr;
00715     attr.SetControllable();
00716     return BASE::InsEvent(rName,attr);
00717   } 
00718 
00719   // InsUncontrollableEvent(index)
00720   TEMP void THIS::InsUncontrollableEvent(Idx index) {
00721     FD_DG("TcGenerator(" << this << ")::InsUncontrollableEvent(" << index << ")");
00722     EventAttr attr;
00723     attr.ClrControllable();
00724     BASE::InsEvent(index,attr);
00725   } 
00726 
00727   // InsUncontrollableEvent(rName)
00728   TEMP Idx THIS::InsUncontrollableEvent(const std::string& rName) {
00729     FD_DG("TcGenerator(" << this << ")::InsUncontrollableEvent(" << rName << ")");
00730     EventAttr attr;
00731     attr.ClrControllable();
00732     return BASE::InsEvent(rName,attr);
00733   } 
00734     
00735   // SetControllable(index)
00736   TEMP void THIS::SetControllable(Idx index) {
00737     FD_DG("TcGenerator(" << this << ")::SetControllable(" << index << ")");
00738     EventAttr attr=BASE::EventAttribute(index);
00739     attr.SetControllable();
00740     BASE::mAlphabet.Attribute(index,attr);
00741   } 
00742 
00743   // SetControllable(rName)
00744   TEMP void THIS::SetControllable(const std::string& rName) {
00745     FD_DG("TcGenerator(" << this << ")::SetControllable(" << rName << ")");
00746     Idx index = BASE::EventIndex(rName);
00747     SetControllable(index);
00748   }
00749 
00750   //SetControllable(rEvents)
00751   TEMP void THIS::SetControllable(const EventSet& rEvents) {
00752     FD_DG("TcGenerator(" << this << ")::SetControllable(rEvents)");
00753     EventSet::Iterator it;
00754     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00755       SetControllable(*it);
00756     }
00757   }
00758     
00759   // ClrControllable(index)
00760   TEMP void THIS::ClrControllable(Idx index) {
00761     FD_DG("TcGenerator(" << this << ")::ClrControllable(" << index << ")");
00762     EventAttr attr=BASE::EventAttribute(index);
00763     attr.ClrControllable();
00764     BASE::mAlphabet.Attribute(index,attr);
00765   } 
00766 
00767   // ClrControllable(rName)
00768   TEMP void THIS::ClrControllable(const std::string& rName) {
00769     FD_DG("TcGenerator(" << this << ")::ClrControllable(" << rName << ")");
00770     Idx index = BASE::EventIndex(rName);
00771     ClrControllable(index);
00772   }
00773 
00774   //ClrControllable(rEvents)
00775   TEMP void THIS::ClrControllable(const EventSet& rEvents) {
00776     FD_DG("TcGenerator(" << this << ")::ClrControllable(rEvents)");
00777     EventSet::Iterator it;
00778     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00779       ClrControllable(*it);
00780     }
00781   }
00782 
00783   //ControllableEvents()
00784   TEMP EventSet THIS::ControllableEvents(void) const {
00785     FD_DG("TcGenerator(" << this << ")::ControllableEvents()");
00786     EventSet res;
00787     EventSet::Iterator it;
00788     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00789       if(Controllable(*it)) res.Insert(*it);
00790     }
00791     return res;
00792   }
00793   
00794   //UncontrollableEvents()
00795   TEMP
00796     EventSet THIS::UncontrollableEvents(void) const {
00797     FD_DG("TcGenerator(" << this << ")::UncontrollableEvents()");
00798     EventSet res;
00799     EventSet::Iterator it;
00800     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00801       if(!Controllable(*it)) res.Insert(*it);
00802     }
00803     return res;
00804   }
00805   
00806   // Observable(index)
00807   TEMP bool THIS::Observable(Idx index) const {
00808     EventAttr attr=BASE::EventAttribute(index);
00809     return attr.Observable();
00810   } 
00811   
00812   // Observable(rName)
00813   TEMP bool THIS::Observable(const std::string& rName) const {
00814     EventAttr attr=BASE::EventAttribute(rName);
00815     return attr.Observable();
00816   } 
00817   
00818   // InsObservableEvent(index)
00819   TEMP void THIS::InsObservableEvent(Idx index) {
00820     FD_DG("TcGenerator(" << this << ")::InsObservableEvent(" << index << ")");
00821     EventAttr attr;
00822     attr.SetObservable();
00823     BASE::InsEvent(index,attr);
00824   } 
00825 
00826   // InsObservableEvent(rName)
00827   TEMP Idx THIS::InsObservableEvent(const std::string& rName) {
00828     FD_DG("TcGenerator(" << this << ")::InsObservableEvent(" << rName << ")");
00829     EventAttr attr;
00830     attr.SetObservable();
00831     return BASE::InsEvent(rName,attr);
00832   } 
00833 
00834   // InsUnobservableEvent(index)
00835   TEMP void THIS::InsUnobservableEvent(Idx index) {
00836     FD_DG("TcGenerator(" << this << ")::InsUnobservableEvent(" << index << ")");
00837     EventAttr attr;
00838     attr.ClrObservable();
00839     BASE::InsEvent(index,attr);
00840   } 
00841 
00842   // InsUnobservableEvent(rName)
00843   TEMP Idx THIS::InsUnobservableEvent(const std::string& rName) {
00844     FD_DG("TcGenerator(" << this << ")::InsUnobservableEvent(" << rName << ")");
00845     EventAttr attr;
00846     attr.ClrObservable();
00847     return BASE::InsEvent(rName,attr);
00848   } 
00849     
00850   // SetObservable(index)
00851   TEMP void THIS::SetObservable(Idx index) {
00852     FD_DG("TcGenerator(" << this << ")::SetObservable(" << index << ")");
00853     EventAttr attr=BASE::EventAttribute(index);
00854     attr.SetObservable();
00855     BASE::mAlphabet.Attribute(index,attr);
00856   } 
00857 
00858   // SetObservable(rName)
00859   TEMP void THIS::SetObservable(const std::string& rName) {
00860     FD_DG("TcGenerator(" << this << ")::SetObservable(" << rName << ")");
00861     Idx index = BASE::EventIndex(rName);
00862     SetObservable(index);
00863   }
00864 
00865   //SetObservable(rEvents)
00866   TEMP void THIS::SetObservable(const EventSet& rEvents) {
00867     FD_DG("TcGenerator(" << this << ")::SetObservable(rEvents)");
00868     EventSet::Iterator it;
00869     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00870       SetObservable(*it);
00871     }
00872   }
00873     
00874   // ClrObservable(index)
00875   TEMP void THIS::ClrObservable(Idx index) {
00876     FD_DG("TcGenerator(" << this << ")::ClrObservable(" << index << ")");
00877     EventAttr attr=BASE::EventAttribute(index);
00878     attr.ClrObservable();
00879     BASE::mAlphabet.Attribute(index,attr);
00880   } 
00881 
00882   // ClrObservable(rName)
00883   TEMP void THIS::ClrObservable(const std::string& rName) {
00884     FD_DG("TcGenerator(" << this << ")::ClrObservable(" << rName << ")");
00885     Idx index = BASE::EventIndex(rName);
00886     ClrObservable(index);
00887   }
00888 
00889   //ClrObservable(rEvents)
00890   TEMP void THIS::ClrObservable(const EventSet& rEvents) {
00891     FD_DG("TcGenerator(" << this << ")::ClrObservable(rEvents)");
00892     EventSet::Iterator it;
00893     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00894       ClrObservable(*it);
00895     }
00896   }
00897 
00898   //ObservableEvents()
00899   TEMP EventSet THIS::ObservableEvents(void) const {
00900     FD_DG("TcGenerator(" << this << ")::ObservableEvents()");
00901     EventSet res;
00902     EventSet::Iterator it;
00903     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00904       if(Observable(*it)) res.Insert(*it);
00905     }
00906     return res;
00907   }
00908   
00909   //UnobservableEvents()
00910   TEMP
00911     EventSet THIS::UnobservableEvents(void) const {
00912     FD_DG("TcGenerator(" << this << ")::UnobservableEvents()");
00913     EventSet res;
00914     EventSet::Iterator it;
00915     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
00916       if(!Observable(*it)) res.Insert(*it);
00917     }
00918     return res;
00919   }
00920   
00921 
00922   // Forcible(index)
00923   TEMP bool THIS::Forcible(Idx index) const {
00924     EventAttr attr=BASE::EventAttribute(index);
00925     return attr.Forcible();
00926   } 
00927   
00928   // Forcible(rName)
00929   TEMP bool THIS::Forcible(const std::string& rName) const {
00930     EventAttr attr=BASE::EventAttribute(rName);
00931     return attr.Forcible();
00932   } 
00933   
00934   // InsForcibleEvent(index)
00935   TEMP void THIS::InsForcibleEvent(Idx index) {
00936     FD_DG("TcGenerator(" << this << ")::InsForcibleEvent(" << index << ")");
00937     EventAttr attr;
00938     attr.SetForcible();
00939     BASE::InsEvent(index,attr);
00940   } 
00941 
00942   // InsForcibleEvent(rName)
00943   TEMP Idx THIS::InsForcibleEvent(const std::string& rName) {
00944     FD_DG("TcGenerator(" << this << ")::InsForcibleEvent(" << rName << ")");
00945     EventAttr attr;
00946     attr.SetForcible();
00947     return BASE::InsEvent(rName,attr);
00948   } 
00949 
00950   // InsUnforcibleEvent(index)
00951   TEMP void THIS::InsUnforcibleEvent(Idx index) {
00952     FD_DG("TcGenerator(" << this << ")::InsUnforcibleEvent(" << index << ")");
00953     EventAttr attr;
00954     attr.ClrForcible();
00955     BASE::InsEvent(index,attr);
00956   } 
00957 
00958   // InsUnforcibleEvent(rName)
00959   TEMP Idx THIS::InsUnforcibleEvent(const std::string& rName) {
00960     FD_DG("TcGenerator(" << this << ")::InsUnforcibleEvent(" << rName << ")");
00961     EventAttr attr;
00962     attr.ClrForcible();
00963     return BASE::InsEvent(rName,attr);
00964   } 
00965     
00966   // SetForcible(index)
00967   TEMP void THIS::SetForcible(Idx index) {
00968     FD_DG("TcGenerator(" << this << ")::SetForcible(" << index << ")");
00969     EventAttr attr=BASE::EventAttribute(index);
00970     attr.SetForcible();
00971     BASE::mAlphabet.Attribute(index,attr);
00972   } 
00973 
00974   // SetForcible(rName)
00975   TEMP void THIS::SetForcible(const std::string& rName) {
00976     FD_DG("TcGenerator(" << this << ")::SetForcible(" << rName << ")");
00977     Idx index = BASE::EventIndex(rName);
00978     SetForcible(index);
00979   }
00980 
00981   //SetForcible(rEvents)
00982   TEMP void THIS::SetForcible(const EventSet& rEvents) {
00983     FD_DG("TcGenerator(" << this << ")::SetForcible(rEvents)");
00984     EventSet::Iterator it;
00985     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
00986       SetForcible(*it);
00987     }
00988   }
00989     
00990   // ClrForcible(index)
00991   TEMP void THIS::ClrForcible(Idx index) {
00992     FD_DG("TcGenerator(" << this << ")::ClrForcible(" << index << ")");
00993     EventAttr attr=BASE::EventAttribute(index);
00994     attr.ClrForcible();
00995     BASE::mAlphabet.Attribute(index,attr);
00996   } 
00997 
00998   // ClrForcible(rName)
00999   TEMP void THIS::ClrForcible(const std::string& rName) {
01000     FD_DG("TcGenerator(" << this << ")::ClrForcible(" << rName << ")");
01001     Idx index = BASE::EventIndex(rName);
01002     ClrForcible(index);
01003   }
01004 
01005   //ClrForcible(rEvents)
01006   TEMP void THIS::ClrForcible(const EventSet& rEvents) {
01007     FD_DG("TcGenerator(" << this << ")::ClrForcible(rEvents)");
01008     EventSet::Iterator it;
01009     for(it=rEvents.Begin(); it!=rEvents.End(); it++) {
01010       ClrForcible(*it);
01011     }
01012   }
01013 
01014   //ForcibleEvents()
01015   TEMP EventSet THIS::ForcibleEvents(void) const {
01016     FD_DG("TcGenerator(" << this << ")::ForcibleEvents()");
01017     EventSet res;
01018     EventSet::Iterator it;
01019     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
01020       if(Forcible(*it)) res.Insert(*it);
01021     }
01022     return res;
01023   }
01024   
01025   //UnforcibleEvents()
01026   TEMP
01027     EventSet THIS::UnforcibleEvents(void) const {
01028     FD_DG("TcGenerator(" << this << ")::UnforcibleEvents()");
01029     EventSet res;
01030     EventSet::Iterator it;
01031     for(it=BASE::AlphabetBegin(); it!=BASE::AlphabetEnd(); it++) {
01032       if(!Forcible(*it)) res.Insert(*it);
01033     }
01034     return res;
01035   }
01036   
01037 #undef TEMP
01038 #undef BASE
01039 #undef THIS
01040 
01041  
01042 } // namespace faudes
01043 
01044 #endif
01045 

Generated on Mon Nov 10 08:13:14 2008 for libFAUDES 2.11v by  doxygen 1.4.4