00001
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
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
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 };
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 };
00633
00634
00636 typedef TcGenerator<AttributeVoid, AttributeVoid, AttributeCFlags,AttributeVoid> cGenerator;
00637
00639 typedef TaNameSet<AttributeCFlags> cEventSet;
00640
00641
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
00648 TEMP THIS::TcGenerator(void) : BASE() {
00649 FD_DG("TcGenerator(" << this << ")::TcGenerator()");
00650 }
00651
00652
00653 TEMP THIS::TcGenerator(const TcGenerator& rOtherGen) : BASE(rOtherGen) {
00654 FD_DG("TcGenerator(" << this << ")::TcGenerator(rOtherGen)");
00655 }
00656
00657
00658 TEMP THIS::TcGenerator(const vGenerator& rOtherGen) : BASE(rOtherGen) {
00659 FD_DG("TcGenerator(" << this << ")::TcGenerator(rOtherGen)");
00660 }
00661
00662
00663 TEMP THIS::TcGenerator(const char* pFileName) : BASE(pFileName) {
00664 FD_DG("TcGenerator(" << this << ")::TcGenerator(pFilename) : done");
00665 }
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677 TEMP THIS* THIS::NewP(void) const {
00678
00679 THIS* res = new THIS;
00680
00681 res->EventSymbolTablep(BASE::mpEventSymbolTable);
00682 res->mStateNamesEnabled=BASE::mStateNamesEnabled;
00683 return res;
00684 }
00685
00686
00687 TEMP THIS THIS::NewCGen(void) const {
00688
00689 THIS res= BASE::NewAGen();
00690 return res;
00691 }
00692
00693
00694
00695 TEMP bool THIS::Controllable(Idx index) const {
00696 EventAttr attr=BASE::EventAttribute(index);
00697 return attr.Controllable();
00698 }
00699
00700
00701 TEMP bool THIS::Controllable(const std::string& rName) const {
00702 EventAttr attr=BASE::EventAttribute(rName);
00703 return attr.Controllable();
00704 }
00705
00706
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
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
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
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
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
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
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
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
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
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
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
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
00826 TEMP bool THIS::Observable(Idx index) const {
00827 EventAttr attr=BASE::EventAttribute(index);
00828 return attr.Observable();
00829 }
00830
00831
00832 TEMP bool THIS::Observable(const std::string& rName) const {
00833 EventAttr attr=BASE::EventAttribute(rName);
00834 return attr.Observable();
00835 }
00836
00837
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
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
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
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
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
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
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
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
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
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
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
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
00958 TEMP bool THIS::Forcible(Idx index) const {
00959 EventAttr attr=BASE::EventAttribute(index);
00960 return attr.Forcible();
00961 }
00962
00963
00964 TEMP bool THIS::Forcible(const std::string& rName) const {
00965 EventAttr attr=BASE::EventAttribute(rName);
00966 return attr.Forcible();
00967 }
00968
00969
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
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
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
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
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
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
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
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
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
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
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
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 }
01094
01095 #define CGENERATOR_H
01096 #endif
01097