libFAUDES

Sections

Index

vgenerator.cpp

Go to the documentation of this file.
00001 /** @file vgenerator.cpp Class vGenerator */
00002 
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 FITNES 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 #include "vgenerator.h"
00025 
00026 
00027 namespace faudes {
00028 
00029 // msObjectCount (static) 
00030 Idx vGenerator::msObjectCount = 0;
00031 
00032 // msObjectCount (static) 
00033 bool vGenerator::msStateNamesEnabledDefault = true;
00034 
00035 // default prototypes (static)
00036 const EventSet vGenerator::msAlphabetVoid;
00037 const StateSet vGenerator::msStatesVoid;
00038 const TransSet vGenerator::msTransRelVoid;
00039 const AttributeVoid vGenerator::msGlobalVoid;
00040 
00041 
00042 // constructor
00043 vGenerator::vGenerator(void) : 
00044   // my name
00045   mMyName("Generator"),
00046   // have std symboltables
00047   mpStateSymbolTable(&mStateSymbolTable),
00048   mpEventSymbolTable(GlobalEventSymbolTablep()),
00049   // other members
00050   mStateNamesEnabled(msStateNamesEnabledDefault),  
00051   // initialise heap members
00052   mpAlphabet(0),
00053   mpStates(0),
00054   mpTransRel(0),
00055   mpGlobalAttribute(0),
00056   // initialise prototypes
00057   pAlphabetPrototype(&msAlphabetVoid),
00058   pStatesPrototype(&msStatesVoid),
00059   pTransRelPrototype(&msTransRelVoid),
00060   pGlobalPrototype(&msGlobalVoid)
00061 {
00062   FAUDES_OBJCOUNT_INC("Generator");
00063   FD_DG("vGenerator(" << this << ")::vGenerator()");
00064   // track generator objects
00065   msObjectCount++; 
00066   mId = msObjectCount;
00067   // allocate core members
00068   NewCore();
00069   // fix std names
00070   mInitStates.Name("InitStates");
00071   mMarkedStates.Name("MarkedStates");
00072 }
00073 
00074 // copy constructor
00075 vGenerator::vGenerator(const vGenerator& rOtherGen) :
00076   // my name
00077   mMyName("Generator"),
00078   // have std symboltables
00079   mpStateSymbolTable(&mStateSymbolTable),
00080   mpEventSymbolTable(GlobalEventSymbolTablep()),
00081   // other members
00082   mStateNamesEnabled(msStateNamesEnabledDefault),  
00083   // initialise heap members
00084   mpAlphabet(0),
00085   mpStates(0),
00086   mpTransRel(0),
00087   mpGlobalAttribute(0),
00088   // initialise prototypes
00089   pAlphabetPrototype(&msAlphabetVoid),
00090   pStatesPrototype(&msStatesVoid),
00091   pTransRelPrototype(&msTransRelVoid),
00092   pGlobalPrototype(&msGlobalVoid)
00093 {
00094   FAUDES_OBJCOUNT_INC("Generator");
00095   FD_DG("vGenerator(" << this << ")::vGenerator(" << &rOtherGen << ")");
00096   // track generator objects
00097   msObjectCount++; 
00098   mId = msObjectCount;
00099   // allocate core members
00100   NewCore();
00101   // perform copy
00102   Assign(rOtherGen);
00103 }
00104 
00105 // construct from file
00106 vGenerator::vGenerator(const std::string& rFileName) : 
00107   // my name
00108   mMyName("Generator"),
00109   // have std symboltables
00110   mpStateSymbolTable(&mStateSymbolTable),
00111   mpEventSymbolTable(GlobalEventSymbolTablep()),
00112   // other members
00113   mStateNamesEnabled(msStateNamesEnabledDefault),  
00114   // initialise heap members
00115   mpAlphabet(0),
00116   mpStates(0),
00117   mpTransRel(0),
00118   mpGlobalAttribute(0),
00119   // initialise prototypes
00120   pAlphabetPrototype(&msAlphabetVoid),
00121   pStatesPrototype(&msStatesVoid),
00122   pTransRelPrototype(&msTransRelVoid),
00123   pGlobalPrototype(&msGlobalVoid)
00124 {
00125   FAUDES_OBJCOUNT_INC("Generator");
00126   FD_DG("vGenerator(" << this << ")::vGenerator(" << rFileName << ")");
00127   // track generator objects
00128   msObjectCount++; 
00129   mId = msObjectCount;
00130   // allocate core members
00131   NewCore();
00132   // fix std names
00133   mInitStates.Name("InitStates");
00134   mMarkedStates.Name("MarkedStates");
00135   // set defaults for file io
00136   mStateNamesEnabled=true;
00137   // do read
00138   Read(rFileName);
00139   // restore defaults
00140   mStateNamesEnabled=msStateNamesEnabledDefault;
00141 }
00142 
00143 // construct on heap
00144 vGenerator* vGenerator::New(void) const {
00145   FD_DG("vGenerator(" << this << ")::New()");
00146   // allocate
00147   vGenerator* res = new vGenerator();
00148   // fix configuration
00149   res->EventSymbolTablep(mpEventSymbolTable);
00150   res->mStateNamesEnabled=mStateNamesEnabled;
00151   return res;
00152 }
00153 
00154 // construct on heap
00155 vGenerator* vGenerator::Copy(void) const {
00156   FD_DG("vGenerator(" << this << ")::Copy()");
00157   // copy construct
00158   vGenerator* res = new vGenerator(*this);
00159   return res;
00160 }
00161 
00162 // destruct
00163 vGenerator::~vGenerator(void) {
00164   FAUDES_OBJCOUNT_DEC("Generator");
00165   // free my members
00166   DeleteCore();
00167 }
00168 
00169 // configure attribute types
00170 void vGenerator::ConfigureAttributeTypes(const AttributeVoid* pNewGlobalPrototype, 
00171     const StateSet* pNewStatesPrototype, const EventSet* pNewAlphabetPrototype, 
00172     const TransSet* pNewTransRelPrototype) {
00173   FD_DG("vGenerator(" << this << ")::ConfigureAtributes(..)");
00174   pGlobalPrototype= pNewGlobalPrototype;
00175   pStatesPrototype= pNewStatesPrototype;
00176   pAlphabetPrototype= pNewAlphabetPrototype;
00177   pTransRelPrototype= pNewTransRelPrototype;
00178   FD_DG("vGenerator(" << this << ")::ConfigureAtributes(): done");
00179 }
00180 
00181 // indicate new core
00182 void vGenerator::UpdateCore(void) {
00183   // fix std names
00184   if(mpAlphabet) mpAlphabet->Name("Alphabet");
00185   if(mpStates) mpStates->Name("States");
00186   if(mpTransRel) mpTransRel->Name("TransRel");
00187   // fix symbol table
00188   if(mpAlphabet) EventSymbolTablep(mpEventSymbolTable);
00189 }
00190 
00191 // protected helper: allocate core on heap
00192 void vGenerator::NewCore(void) {
00193   FD_DG("vGenerator(" << this << ")::NewCore()");
00194   DeleteCore();
00195   // allocate (use prototypes, fallback to void attributes)
00196   if(pAlphabetPrototype) mpAlphabet= pAlphabetPrototype->New();
00197   else mpAlphabet = new EventSet();
00198   if(pStatesPrototype) mpStates=pStatesPrototype->New();
00199   else mpStates = new StateSet();
00200   if(pTransRelPrototype) mpTransRel= pTransRelPrototype->New();
00201   else mpTransRel = new TransSet();
00202   if(pGlobalPrototype) mpGlobalAttribute=pGlobalPrototype->New();
00203   else mpGlobalAttribute = new AttributeVoid();
00204   // update callback
00205   UpdateCore();
00206 }
00207   
00208 // protected helper: free core from heap
00209 void vGenerator::DeleteCore(void) {
00210   if(mpAlphabet) delete mpAlphabet; 
00211   if(mpStates) delete mpStates; 
00212   if(mpTransRel) delete mpTransRel; 
00213   if(mpGlobalAttribute) delete mpGlobalAttribute;   
00214   mpAlphabet=0;
00215   mpStates=0;
00216   mpTransRel=0;
00217   mpGlobalAttribute=0;
00218   // update callback
00219   UpdateCore();
00220 }
00221 
00222 
00223 
00224 // copy from other vGenerator (try to convert attributes)
00225 vGenerator& vGenerator::Assign(const vGenerator& rGen) {
00226   FD_DG("vGenerator(" << this << ")::Assign(" << &rGen << ")");
00227   // prepare result (call clear for virtual stuff)
00228   Clear();
00229   // have same event symboltable
00230   EventSymbolTablep(rGen.mpEventSymbolTable);
00231   // copy state symboltable
00232   StateSymbolTable(rGen.mStateSymbolTable);
00233   // set other members
00234   Name(rGen.Name());
00235   StateNamesEnabled(rGen.StateNamesEnabled());
00236   InjectInitStates(rGen.mInitStates);
00237   InjectMarkedStates(rGen.mMarkedStates);
00238   // core members, try attributes
00239   InjectStates(*rGen.mpStates);
00240   InjectAlphabet(*rGen.mpAlphabet);
00241   InjectTransRel(*rGen.mpTransRel);
00242   GlobalAttributeTry(*rGen.mpGlobalAttribute);
00243 #ifdef FAUDES_DEBUG_CODE
00244   if(!Valid()) {
00245     FD_DG("vGenerator()::Copy(): invalid generator");
00246     DWrite(); 
00247     abort();
00248   }
00249 #endif
00250   return *this;
00251 } 
00252 
00253 
00254 // copy from other vGenerator (clear attributes)
00255 vGenerator& vGenerator::AssignWithoutAttributes(const vGenerator& rGen) {
00256   FD_DG("vGenerator(" << this << ")::Assign(" << &rGen << ")");
00257   // prepare result (call clear for virtual stuff)
00258   Clear();
00259   // have same event symboltable
00260   EventSymbolTablep(rGen.mpEventSymbolTable);
00261   // copy state symboltable
00262   StateSymbolTable(rGen.mStateSymbolTable);
00263   // set other members
00264   Name(rGen.Name());
00265   StateNamesEnabled(rGen.StateNamesEnabled());
00266   InjectInitStates(rGen.mInitStates);
00267   InjectMarkedStates(rGen.mMarkedStates);
00268   // core members, ignore attributes
00269   mpStates->AssignWithoutAttributes(rGen.States());
00270   mpAlphabet->AssignWithoutAttributes(rGen.Alphabet());
00271   mpTransRel->AssignWithoutAttributes(rGen.TransRel());
00272 #ifdef FAUDES_DEBUG_CODE
00273   if(!Valid()) {
00274     FD_DG("vGenerator()::Copy(): invalid generator");
00275     DWrite(); 
00276     abort();
00277   }
00278 #endif
00279   return *this;
00280 } 
00281 
00282 
00283 // Move(gen) destructive copy 
00284 void vGenerator::Move(vGenerator& rGen) {
00285   FD_DG("vGenerator(" << this << ")::Move(" << &rGen << ")");
00286   // test types
00287   bool tmm=false;
00288   if(typeid(rGen.Alphabet())!=typeid(Alphabet())) tmm=true;
00289   if(typeid(rGen.States())!=typeid(States())) tmm=true;
00290   if(typeid(rGen.TransRel())!=typeid(TransRel())) tmm=true;
00291   if(typeid(rGen.GlobalAttribute())!=typeid(GlobalAttribute())) tmm=true;
00292   if(tmm) { 
00293     FD_DG("vGenerator(" << this << ")::Move(" << &rGen << "): using std copy");
00294     rGen.Assign(*this);
00295     Clear();
00296     return;
00297   }
00298   // prepare result (call clear for virtual stuff)
00299   rGen.Clear();
00300   // have same event symboltable
00301   rGen.EventSymbolTablep(mpEventSymbolTable);
00302   // copy state symboltable (todo: make this pointer based?)
00303   rGen.StateSymbolTable(mStateSymbolTable);
00304   // copy members
00305   rGen.Name(Name());
00306   rGen.StateNamesEnabled(StateNamesEnabled());
00307   rGen.InjectInitStates(InitStates());
00308   rGen.InjectMarkedStates(MarkedStates());
00309   // delete destination core
00310   if(rGen.mpStates) delete rGen.mpStates;
00311   if(rGen.mpAlphabet) delete rGen.mpAlphabet;
00312   if(rGen.mpTransRel) delete rGen.mpTransRel;
00313   if(rGen.mpGlobalAttribute) delete rGen.mpGlobalAttribute;
00314   // move and invalidate core members
00315   rGen.mpStates=mpStates;
00316   rGen.mpAlphabet=mpAlphabet;
00317   rGen.mpTransRel=mpTransRel;
00318   rGen.mpGlobalAttribute=mpGlobalAttribute;
00319   mpStates=0;
00320   mpAlphabet=0;
00321   mpTransRel=0;
00322   mpGlobalAttribute=0;
00323   // register core update
00324   rGen.UpdateCore();
00325   // install new empty core members
00326   NewCore();
00327   // clear myself (incl derived classes members)
00328   Clear();
00329 }
00330 
00331 // operator =
00332 vGenerator& vGenerator::operator = (const vGenerator& rOtherGen) {
00333   FD_DG("vGenerator(" << this << ")::operator = " << &rOtherGen);
00334   return Assign(rOtherGen);
00335 }
00336 
00337 // Version(idx)
00338 void vGenerator::Version(Idx version, vGenerator& rResGen) const {
00339   FD_DG("vGenerator(" << this << ")::Version(" << version << ")");
00340   std::ostringstream o;
00341   o << version;
00342   Version(o.str(),rResGen);
00343 }
00344 
00345 // Version(string)
00346 void vGenerator::Version(const std::string& rVersion, vGenerator& rResGen) const {
00347   FD_DG("vGenerator(" << this << ")::Version(" << rVersion << ")");
00348   // second arg must not be us 
00349   if(this==&rResGen) {
00350     std::stringstream errstr;
00351     errstr << "Destination must not match source.";
00352     throw Exception("vGenerator::Version(string)", errstr.str(), 96);
00353   }
00354   // prepare Empty generator
00355   rResGen.Clear();
00356   rResGen.GlobalAttribute(GlobalAttribute());
00357   EventSet::Iterator eit;
00358   StateSet::Iterator lit;
00359   TransSet::Iterator tit;
00360   std::map<Idx,Idx> eventoldnewmap;
00361   rResGen.Name(Name()+"_"+rVersion);
00362   // create versioned mAlphabet
00363   for (eit = AlphabetBegin(); eit != AlphabetEnd(); ++eit) {
00364     Idx newevent= rResGen.InsEvent(EventName(*eit)+"_"+rVersion); 
00365     eventoldnewmap[*eit] = newevent;
00366     rResGen.EventAttribute(newevent,EventAttribute(*eit));
00367   }
00368   // create new stateset
00369   for (lit = StatesBegin(); lit != StatesEnd(); ++lit) {
00370     rResGen.InsState(*lit);
00371     rResGen.StateAttribute(*lit,StateAttribute(*lit)); //would be faster if directly copied ?
00372     if (StateName(*lit) != "") rResGen.StateName(*lit,StateName(*lit));
00373   }
00374   // created versioned transrel
00375   for (tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
00376     Transition trans=Transition(tit->X1, eventoldnewmap[tit->Ev], tit->X2);
00377     rResGen.SetTransition(trans);
00378     rResGen.TransAttribute(trans, TransAttribute(*tit));
00379   }
00380   // set i/m states
00381   rResGen.mInitStates=mInitStates;
00382   rResGen.mMarkedStates=mMarkedStates;
00383   // behavioural flags
00384   rResGen.mStateNamesEnabled = mStateNamesEnabled;
00385 }
00386 
00387 
00388 // Version(string,string)
00389 void vGenerator::Version(const std::string& rPattern, const std::string& rReplacement, vGenerator& rResGen) const {
00390   FD_DG("vGenerator(" << this << ")::Version(" << rVersion << ")");
00391   // second arg must not be us 
00392   if(this==&rResGen) {
00393     std::stringstream errstr;
00394     errstr << "Destination must not match source.";
00395     throw Exception("vGenerator::Version(string,string)", errstr.str(), 96);
00396   }
00397   // ignore invalid pattern
00398   if(rPattern.empty()) {
00399     rResGen.Assign(*this);
00400     return;
00401   }
00402   // trivial case
00403   if (rPattern==rReplacement) {
00404     rResGen.Assign(*this);
00405     return;
00406   }
00407   // prepare Empty generator
00408   rResGen.Clear();
00409   rResGen.GlobalAttribute(GlobalAttribute());
00410   rResGen.Name(Name()+"_"+rReplacement);
00411   EventSet::Iterator eit;
00412   StateSet::Iterator lit;
00413   TransSet::Iterator tit;
00414   std::map<Idx,Idx> eventoldnewmap;
00415   // create versioned mAlphabet
00416   std::string newstring;
00417   std::string::size_type pos = 0;
00418   int patternlength=rPattern.size();
00419   int replacementlength=rReplacement.size();
00420   for (eit = AlphabetBegin(); eit != AlphabetEnd(); ++eit) {
00421     // search for all pattern occurences in event name and replace
00422     newstring=EventName(*eit);
00423     while ( (pos = newstring.find(rPattern, pos)) != std::string::npos ) {
00424         newstring.replace(pos, patternlength, rReplacement);
00425         //pos++;
00426         pos=pos+replacementlength;
00427     }
00428       Idx newevent= rResGen.InsEvent(newstring); 
00429       eventoldnewmap[*eit] = newevent;
00430       rResGen.EventAttribute(newevent,EventAttribute(*eit));
00431   }
00432   // create new stateset
00433   for (lit = StatesBegin(); lit != StatesEnd(); ++lit) {
00434     rResGen.InsState(*lit);
00435     rResGen.StateAttribute(*lit,StateAttribute(*lit)); //would be faster if directly copied ?
00436     if (StateName(*lit) != "") rResGen.StateName(*lit,StateName(*lit));
00437   }
00438   // created versioned transrel
00439   for (tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
00440     Transition trans=Transition(tit->X1, eventoldnewmap[tit->Ev], tit->X2);
00441     rResGen.SetTransition(trans);
00442     rResGen.TransAttribute(trans, TransAttribute(*tit));
00443   }
00444   // set i/m states
00445   rResGen.mInitStates=mInitStates;
00446   rResGen.mMarkedStates=mMarkedStates;
00447   // behavioural flags
00448   rResGen.mStateNamesEnabled = mStateNamesEnabled;
00449 }
00450 
00451 
00452 // Name(rName)
00453 void vGenerator::Name(const std::string& rName) {
00454   FD_DV("vGenerator(" << this << ")::Name(\"" << rName << "\")");
00455   mMyName = rName;
00456 }
00457 
00458 // Name()
00459 const std::string& vGenerator::Name(void) const {
00460   return mMyName;
00461 }
00462 
00463 // Valid()
00464 bool vGenerator::Valid(void) {
00465   FD_DG("vGenerator(" << this << ")::Valid()");
00466   // core members on heap
00467   if(mpAlphabet==0) return false;
00468   if(mpStates==0) return false;
00469   if(mpTransRel==0) return false;
00470   if(mpGlobalAttribute==0) return false;
00471   // transitions to be known
00472   TransSet::Iterator tit;
00473   StateSet::Iterator lit;
00474   for(tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
00475     if(! ExistsState(tit->X1)) return false;
00476     if(! ExistsEvent(tit->Ev)) return false;
00477     if(! ExistsState(tit->X2)) return false;
00478   }
00479   // init states to be known
00480   for(lit = InitStatesBegin(); lit != InitStatesEnd(); ++lit) 
00481     if(! ExistsState(static_cast<Idx>(*lit))) return false;
00482   for(lit = MarkedStatesBegin(); lit != MarkedStatesEnd(); ++lit) 
00483     if(! ExistsState(static_cast<Idx>(*lit))) return false;
00484   // sets to have proper names
00485   if(mpAlphabet->Name() != "Alphabet") return false;
00486   if(mpStates->Name() != "States") return false;
00487   if(mInitStates.Name() != "InitStates") return false;
00488   if(mMarkedStates.Name() != "MarkedStates") return false;
00489   // event symbol table
00490   NameSet::Iterator eit;
00491   for(eit = AlphabetBegin(); eit != AlphabetEnd(); eit ++) {
00492     if(EventName(*eit)=="") return false;
00493   }
00494   // done
00495   return true;
00496 }
00497 
00498 // AlphabetSize()
00499 Idx vGenerator::AlphabetSize(void) const {
00500   return mpAlphabet->Size();
00501 }
00502 
00503 // Size()
00504 Idx vGenerator::Size(void) const {
00505   return mpStates->Size();
00506 }
00507 
00508 // Clear()
00509 void vGenerator::Clear(void) {
00510   FD_DG("vGenerator(" << this << ")::Clear()");
00511   mpAlphabet->Clear();
00512   mpStates->Clear();
00513   mpStateSymbolTable->Clear();
00514   mpTransRel->Clear();
00515   mInitStates.Clear();
00516   mMarkedStates.Clear();
00517   ClearGlobalAttribute();
00518 }
00519 
00520 // ClearGlobalAttribute()
00521 void vGenerator::ClearGlobalAttribute(void) {
00522   mpGlobalAttribute->Clear(); 
00523 }
00524 
00525 // ClearStateAttributes()
00526 void vGenerator::ClearStateAttributes(void) {
00527   mpStates->ClearAttributes();
00528 }
00529 
00530 // ClearEventAttributes()
00531 void vGenerator::ClearEventAttributes(void) {
00532   mpAlphabet->ClearAttributes();
00533 }
00534 
00535 // ClearTransAttributes()
00536 void vGenerator::ClearTransAttributes(void) {
00537   mpTransRel->ClearAttributes();
00538 }
00539 
00540 // ClearAttributes()
00541 void vGenerator::ClearAttributes(void) {
00542   ClearGlobalAttribute();
00543   ClearStateAttributes();
00544   ClearEventAttributes();
00545   ClearTransAttributes();
00546 }
00547 
00548 
00549 // ClearStates()
00550 void vGenerator::ClearStates(void) {
00551   mpStates->Clear();
00552   mpTransRel->Clear();
00553   mInitStates.Clear();
00554   mMarkedStates.Clear();
00555   mpStateSymbolTable->Clear();
00556 }
00557 
00558 // TransRelSize()
00559 Idx vGenerator::TransRelSize(void) const {
00560   return mpTransRel->Size();
00561 }
00562 
00563 // InitStatesSize()
00564 Idx vGenerator::InitStatesSize(void) const {
00565   return mInitStates.Size();
00566 }
00567 
00568 // MarkedStatesSize()
00569 Idx vGenerator::MarkedStatesSize(void) const {
00570   return mMarkedStates.Size();
00571 }
00572 
00573 // AlphabetEmpty()
00574 bool vGenerator::AlphabetEmpty(void) const {
00575   return mpAlphabet->Empty();
00576 }
00577 
00578 // Empty()
00579 bool vGenerator::Empty(void) const {
00580   return mpStates->Empty();
00581 }
00582 
00583 // TransRelEmpty()
00584 bool vGenerator::TransRelEmpty(void) const {
00585   return mpTransRel->Empty();
00586 }
00587 
00588 // InitStatesEmpty()
00589 bool vGenerator::InitStatesEmpty(void) const {
00590   return mInitStates.Empty();
00591 }
00592 
00593 // MarkedStatesEmpty()
00594 bool vGenerator::MarkedStatesEmpty(void) const {
00595   return mMarkedStates.Empty();
00596 }
00597 
00598 
00599 // ClearMinStateIndexMap()
00600 void vGenerator::ClearMinStateIndexMap(void) const {
00601   FD_DG("vGenerator::ClearMinStateIndexMap()");
00602   // fake const
00603   vGenerator* fakeconst = const_cast<vGenerator*>(this);
00604   fakeconst->mMinStateIndexMap.clear();
00605 }
00606 
00607 // MinStateIndex(index)
00608 Idx vGenerator::MinStateIndex(Idx index) const {
00609   std::map<Idx,Idx>::const_iterator minit;
00610   minit = mMinStateIndexMap.find(index);
00611   Idx fidx;
00612   if(minit != mMinStateIndexMap.end()) {
00613     fidx= minit->second;
00614   } else {
00615     fidx=index;
00616   }
00617   return fidx;
00618 }
00619 
00620 // MinStateIndex()
00621 const std::map<Idx,Idx>& vGenerator::MinStateIndexMap(void) const {
00622   return mMinStateIndexMap;
00623 }
00624 
00625 
00626 // SetMinStateIndexMap()
00627 void vGenerator::SetMinStateIndexMap(void) const {
00628   FD_DG("vGenerator::SetMinStateIndexMap()");
00629   // fake const
00630   vGenerator* fakeconst = const_cast<vGenerator*>(this);
00631   // clear map
00632   fakeconst->ClearMinStateIndexMap();
00633   StateSet::Iterator it;
00634   Idx minindex = 0;
00635   // if generator states get names
00636   if(StateNamesEnabled()) {
00637     // named initial states first
00638     for(it = InitStatesBegin(); it != InitStatesEnd(); ++it) {
00639       if(StateName(static_cast<Idx>(*it)) != "") {
00640   fakeconst->mMinStateIndexMap[*it] = ++minindex;
00641       }
00642     }
00643     // then all other named states
00644     for(it = StatesBegin(); it != StatesEnd(); ++it) {
00645       if(mMinStateIndexMap.count(*it) == 0) {
00646   if(StateName(static_cast<Idx>(*it)) != "") {
00647     fakeconst->mMinStateIndexMap[*it] = ++minindex;
00648   }
00649       }
00650     }
00651     // at last all anonymous states
00652     for(it = StatesBegin(); it != StatesEnd(); ++it) {
00653       if(mMinStateIndexMap.count(*it) == 0) {
00654   fakeconst->mMinStateIndexMap[*it] = ++minindex;
00655       }
00656     }
00657   }
00658   // if generator states are all anonymous
00659   else {
00660     // all initial states first
00661     for(it = InitStatesBegin(); it != InitStatesEnd(); ++it) {
00662       fakeconst->mMinStateIndexMap[*it] = ++minindex;
00663     }
00664     // then the rest
00665     for(it = StatesBegin(); it != StatesEnd(); ++it) {
00666       if(mMinStateIndexMap.count(*it) == 0) {
00667   fakeconst->mMinStateIndexMap[*it] = ++minindex;
00668       }
00669     }
00670   }
00671 #ifdef FAUDES_DEBUG_CONTAINER
00672   std::map<Idx,Idx>::const_iterator _it;
00673   for(_it = mMinStateIndexMap.begin(); _it != mMinStateIndexMap.end(); ++_it) {
00674     FD_DC("vGenerator::MinStateIndexMap: " << _it->first
00675     << " <-- " << SStr(_it->second));
00676   }
00677 #endif
00678 }
00679 
00680 // EventSymbolTablep() const
00681 SymbolTable* vGenerator::EventSymbolTablep(void) const {
00682   return mpEventSymbolTable;
00683 }
00684 
00685 // GlobalEventSymbolTablep() const
00686 SymbolTable* vGenerator::GlobalEventSymbolTablep(void) {
00687   return SymbolTable::GlobalEventSymbolTablep();
00688 }
00689 
00690 // EventSymbolTablep(pSymTab) 
00691 void vGenerator::EventSymbolTablep(SymbolTable* pSymTab) {
00692   mpEventSymbolTable=pSymTab;
00693   // todo: set symboltable in mpAlphabet
00694 }
00695 
00696 // EventSymbolTablep(rOtherGen) 
00697 void vGenerator::EventSymbolTablep(const vGenerator& rOtherGen) {
00698   EventSymbolTablep(rOtherGen.EventSymbolTablep());
00699 }
00700 
00701 // EventIndex(rName)
00702 Idx vGenerator::EventIndex(const std::string& rName) const {
00703   return mpEventSymbolTable->Index(rName);
00704 }
00705 
00706 // EventName(index)
00707 std::string vGenerator::EventName(Idx index) const {
00708   return mpEventSymbolTable->Symbol(index);
00709 }
00710 
00711 // EventName(index, name)
00712 void vGenerator::EventName(Idx index, const std::string& rName) {
00713   FD_DG("vGenerator(" << this << ")::EventName(" 
00714       << index << ",\"" << rName << "\")");
00715 #ifdef FAUDES_CHECKED
00716   if (! ExistsEvent(index)) {
00717     std::stringstream errstr;
00718     errstr << "event \"" << index << "\" not found in generator \""
00719      << Name() << "\"";
00720     throw Exception("vGenerator::EventName(name)", errstr.str(), 89);
00721   }
00722 #endif
00723   mpEventSymbolTable->SetEntry(index, rName);
00724 }
00725 
00726 // UniqueEventName(rName)
00727 std::string vGenerator::UniqueEventName(const std::string& rName) const {
00728   std::string name=rName;
00729   if(name=="") name="ev";
00730   return mpEventSymbolTable->UniqueSymbol(name) ;
00731 }
00732 
00733 
00734 // EventRename
00735 bool vGenerator::EventRename(Idx event, const std::string& rNewName) {
00736   // consistency
00737   FD_DG("vGenerator(" << this << ")::EventRename(" << EStr(event) << ", " << rNewName << ")");
00738 #ifdef FAUDES_CHECKED
00739   if (! ExistsEvent(event)) {
00740     std::stringstream errstr;
00741     errstr << "event \"" << event << "\" not found in generator \""
00742      << Name() << "\"";
00743     throw Exception("vGenerator::EventReame(name)", errstr.str(), 89);
00744   }
00745 #endif
00746   // prepare formal result
00747   bool res=ExistsEvent(rNewName);
00748   // insert new event
00749   Idx newidx=InsEvent(rNewName);
00750   // bail out if events are the same
00751   if(newidx==event) return true;
00752   // copy event attribute
00753   if(!res) EventAttribute(newidx,EventAttribute(event));
00754   // store new transitions (with their attributes)
00755   TransSet* newtrans= TransRel().New();
00756   // iterate over transitions
00757   TransSet::Iterator tit;
00758   for (tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
00759     if(tit->Ev!=event) continue;
00760     Transition trans= Transition(tit->X1, newidx, tit->X2);
00761     newtrans->Insert(trans);
00762     newtrans->Attribute(trans,TransAttribute(*tit));
00763     tit=ClrTransition(tit);
00764   }
00765   // merge transitions
00766   for(tit=newtrans->Begin(); tit!=newtrans->End(); tit++) {
00767     SetTransition(*tit);
00768     TransAttribute(*tit,newtrans->Attribute(*tit));
00769   }
00770   // free temp
00771   delete newtrans;
00772   // remore original event
00773   DelEvent(event);
00774   // done
00775   return res;
00776 }
00777 
00778 
00779 
00780 // NewEventSet()
00781 EventSet vGenerator::NewEventSet(void) const {
00782   EventSet res;
00783   res.SymbolTablep(mpEventSymbolTable);
00784   return res;
00785 }
00786 
00787 // NewEventSetp()
00788 EventSet* vGenerator::NewEventSetp(void) const {
00789   EventSet* res = new EventSet();
00790   res->SymbolTablep(mpEventSymbolTable);
00791   return res;
00792 }
00793 
00794 
00795 // StateSymbolTable() const
00796 const SymbolTable& vGenerator::StateSymbolTable(void) const {
00797   return mStateSymbolTable;
00798 }
00799 
00800 // StateSymbolTable(rSymTab) 
00801 void vGenerator::StateSymbolTable(const SymbolTable& rSymTab) {
00802   mStateSymbolTable=rSymTab;
00803   mpStateSymbolTable=&mStateSymbolTable;
00804 }
00805 
00806 // StateIndex(rName)
00807 Idx vGenerator::StateIndex(const std::string& rName) const {
00808    return mpStateSymbolTable->Index(rName);
00809 }
00810 
00811 // StateName(index)
00812 std::string vGenerator::StateName(Idx index) const {
00813   return mpStateSymbolTable->Symbol(index);
00814 }
00815 
00816 // StateName(index, name)
00817 void vGenerator::StateName(Idx index, const std::string& rName) {
00818   FD_DG("vGenerator(" << this << ")::StateName(" 
00819       << index << ",\"" << rName << "\")");
00820 #ifdef FAUDES_CHECKED
00821   if (! ExistsState(index)) {
00822     std::stringstream errstr;
00823     errstr << "state name \"" << rName << "\" not found in generator \""
00824      << Name() << "\"";
00825     throw Exception("vGenerator::StateName(name)", errstr.str(), 90);
00826   }
00827 #endif
00828   mpStateSymbolTable->SetEntry(index, rName);
00829 }
00830 
00831 
00832 // ClearStateNames()
00833 void vGenerator::ClearStateNames(void) {
00834   FD_DG("vGenerator(" << this << ")::ClearStateNames()");
00835   mpStateSymbolTable->Clear();
00836   mStateNamesEnabled = false;
00837 }
00838 
00839 
00840 // ClrStateName(index)
00841 void vGenerator::ClrStateName(Idx index) {
00842   FD_DG("Generator(" << this << ")::ClrStateName(\"" << index << "\")");
00843 #ifdef FAUDES_CHECKED
00844   if (! ExistsState(index)) {
00845     std::stringstream errstr;
00846     errstr << "state \"" << index << "\" not found in generator \""
00847      << Name() << "\"";
00848     throw Exception("vGenerator::ClrStateName(name)", errstr.str(), 90);
00849   }
00850 #endif
00851   mpStateSymbolTable->ClrEntry(index);
00852 }
00853 
00854 // ClrStateName(rName)
00855 void vGenerator::ClrStateName(const std::string& rName) {
00856   FD_DG("vGenerator(" << this << ")::ClrStateName(\"" << rName << "\")");
00857   Idx index = StateIndex(rName);
00858   ClrStateName(index);
00859 }
00860 
00861 
00862 // StateNamesEnabled()
00863 bool vGenerator::StateNamesEnabled(void) const {
00864   return mStateNamesEnabled;
00865 }
00866 
00867 // StateNamesEnabled(flag)
00868 void vGenerator::StateNamesEnabled(bool flag) {
00869   mStateNamesEnabled = flag;
00870 }
00871 
00872 // StateNamesEnabled(flag)
00873 void vGenerator::StateNamesEnabledDefault(bool flag) {
00874   msStateNamesEnabledDefault = flag;
00875 }
00876 
00877 // SetDefaultStateNames()
00878 void vGenerator::SetDefaultStateNames(void) {
00879   FD_DG("vGenerator(" << this << ")::SetDefaultStateNames()");
00880   StateSet::Iterator it;
00881   for (it = StatesBegin(); it != StatesEnd(); ++it) {
00882     mpStateSymbolTable->SetDefaultSymbol(*it);
00883   }
00884 }
00885 
00886 // EnforceStateNames(rTemplate)
00887 void vGenerator::EnforceStateNames(const std::string& rTemplate) {
00888   FD_DG("vGenerator(" << this << ")::EnforceStateNames(temp)");
00889   StateSet::Iterator it;
00890   for (it = StatesBegin(); it != StatesEnd(); ++it) {
00891     if(StateName(*it)=="") {
00892       std::string name=UniqueStateName(rTemplate + "_1");
00893       StateName(*it,name);
00894     }
00895   }
00896 }
00897 
00898 // UniqueStateName(rName)
00899 std::string vGenerator::UniqueStateName(const std::string& rName) const {
00900   std::string name=rName;
00901   if(name=="") name="st";
00902   return mpStateSymbolTable->UniqueSymbol(name) ;
00903 }
00904 
00905 
00906 // iterator AlphabetBegin() const
00907 EventSet::Iterator vGenerator::AlphabetBegin(void) const {
00908   return mpAlphabet->Begin();
00909 }
00910 
00911 // iterator AlphabetEnd() const
00912 EventSet::Iterator vGenerator::AlphabetEnd(void) const {
00913   return mpAlphabet->End();
00914 }
00915 
00916 // iterator StatesBegin() const
00917 StateSet::Iterator vGenerator::StatesBegin(void) const {
00918   return mpStates->Begin();
00919 }
00920 
00921 // iterator StatesEnd() const
00922 StateSet::Iterator vGenerator::StatesEnd(void) const {
00923   return mpStates->End();
00924 }
00925 
00926 // iterator TransRelBegin() const
00927 TransSet::Iterator vGenerator::TransRelBegin(void) const {
00928   return mpTransRel->Begin();
00929 }
00930 
00931 // iterator TransRelEnd() const
00932 TransSet::Iterator vGenerator::TransRelEnd(void) const {
00933   return mpTransRel->End();
00934 }
00935 
00936 // iterator TransRelBegin(x1) const
00937 TransSet::Iterator vGenerator::TransRelBegin(Idx x1) const {
00938   return mpTransRel->Begin(x1);
00939 }
00940 
00941 // iterator TransRelEnd(x1) const
00942 TransSet::Iterator vGenerator::TransRelEnd(Idx x1) const {
00943   return mpTransRel->End(x1);
00944 }
00945 
00946 // iterator TransRelBegin(x1, ev) const
00947 TransSet::Iterator vGenerator::TransRelBegin(Idx x1, Idx ev) const {
00948   return mpTransRel->Begin(x1, ev);
00949 }
00950 
00951 // iterator TransRelEnd(x1, ev) const
00952 TransSet::Iterator vGenerator::TransRelEnd(Idx x1, Idx ev) const {
00953   return mpTransRel->End(x1, ev);
00954 }
00955 
00956 // iterator FindTransition(trans)
00957 TransSet::Iterator vGenerator::FindTransition(const Transition& rTrans) const {
00958   return mpTransRel->Find(rTrans);
00959 }
00960 
00961 // iterator FindTransition(x1, ex x2)
00962 TransSet::Iterator vGenerator::FindTransition(Idx x1, Idx ev, Idx x2) const {
00963   return mpTransRel->Find(Transition(x1, ev, x2));
00964 }
00965 
00966 // iterator FindTransition(x1, ev, x2) 
00967 TransSet::Iterator vGenerator::FindTransition(
00968    const std::string& rX1, const std::string& rEv, const std::string& rX2) const 
00969 {
00970   return mpTransRel->Find(StateIndex(rX1), EventIndex(rEv), StateIndex(rX2));
00971 }
00972 
00973 // iterator ExistsTransition(trans)
00974 bool vGenerator::ExistsTransition(const Transition& rTrans) const {
00975   return mpTransRel->Exists(rTrans);
00976 }
00977 
00978 // iterator ExistsTransition(x1, ex x2)
00979 bool vGenerator::ExistsTransition(Idx x1, Idx ev, Idx x2) const {
00980   return mpTransRel->Exists(Transition(x1, ev, x2));
00981 }
00982 
00983 // iterator ExistsTransition(x1, ev, x2)
00984 bool vGenerator::ExistsTransition(
00985   const std::string& rX1, const std::string& rEv, const std::string& rX2) const 
00986 {
00987   return mpTransRel->Exists(StateIndex(rX1), EventIndex(rEv), StateIndex(rX2));
00988 }
00989 
00990 
00991 // idx InitState() const
00992 Idx vGenerator::InitState(void) const {
00993 #ifdef FAUDES_CHECKED
00994   if(mInitStates.Size()!=1) {    
00995     std::stringstream errstr;
00996     errstr << "init state does not exist uniquely" << std::endl;
00997     throw Exception("vGenerator::InitSTate", errstr.str(), 92);
00998   }
00999 #endif
01000   return *mInitStates.Begin();
01001 }
01002 
01003 // iterator InitStatesBegin() const
01004 StateSet::Iterator vGenerator::InitStatesBegin(void) const {
01005   return mInitStates.Begin();
01006 }
01007 
01008 // iterator InitStatesEnd() const
01009 StateSet::Iterator vGenerator::InitStatesEnd(void) const {
01010   return mInitStates.End();
01011 }
01012 
01013 // iterator MarkedStatesBegin()
01014 StateSet::Iterator vGenerator::MarkedStatesBegin(void) const {
01015   return mMarkedStates.Begin();
01016 }
01017 
01018 // iterator MarkedStatesEnd() const
01019 StateSet::Iterator vGenerator::MarkedStatesEnd(void) const {
01020   return mMarkedStates.End(); 
01021 }
01022 
01023 // InjectAlphabet(newalphabet)
01024 void vGenerator::InjectAlphabet(const EventSet& rNewAlphabet) {
01025   FD_DG("vGenerator::InjectAlphabet()  " << rNewAlphabet.ToString());
01026 #ifdef FAUDES_CHECKED
01027   if(rNewAlphabet.SymbolTablep()!=mpEventSymbolTable) {
01028     std::stringstream errstr;
01029     errstr << "symboltable mismatch aka not implemented" << std::endl;
01030     throw Exception("vGenerator::InjectAlphabet", errstr.str(), 88);
01031   }
01032 #endif
01033   *mpAlphabet = rNewAlphabet;
01034   mpAlphabet->Name("Alphabet");
01035 }
01036 
01037 // RestrictAlphabet(newalphabet)
01038 void vGenerator::RestrictAlphabet(const EventSet& rNewAlphabet) {
01039   FD_DG("vGenerator::RestrictAlphabet()  " << rNewAlphabet.ToString());
01040 #ifdef FAUDES_CHECKED
01041   if(rNewAlphabet.SymbolTablep()!=mpEventSymbolTable) {
01042     std::stringstream errstr;
01043     errstr << "symboltable mismatch aka not implemented" << std::endl;
01044     throw Exception("vGenerator::RestrictAlphabet", errstr.str(), 88);
01045   }
01046 #endif
01047   mpAlphabet->RestrictSet(rNewAlphabet);
01048 }
01049 
01050 // InsEvent(index)
01051 bool vGenerator::InsEvent(Idx index) {
01052   FD_DG("vGenerator(" << this << ")::InsEvent(" << index << ")");
01053   return mpAlphabet->Insert(index);
01054 }
01055 
01056 // InsEvent(rName)
01057 Idx vGenerator::InsEvent(const std::string& rName) {
01058   FD_DG("vGenerator(" << this << ")::InsEvent(\"" << rName << "\")");
01059   return mpAlphabet->Insert(rName);
01060 }
01061 
01062 // InsEvents(events)
01063 void vGenerator::InsEvents(const EventSet& events) {
01064   mpAlphabet->InsertSet(events);
01065 }
01066 
01067 // DelEvent(index)
01068 bool vGenerator::DelEvent(Idx index) {
01069   FD_DG("vGenerator(" << this << ")::DelEvent(" << index << ")");
01070   mpTransRel->EraseByEv(index);
01071   return mpAlphabet->Erase(index);
01072 }
01073 
01074 // DelEvent(rName)
01075 bool vGenerator::DelEvent(const std::string& rName) {
01076   FD_DG("vGenerator(" << this << ")::DelEvent(\"" << rName << "\")");
01077   Idx index = mpAlphabet->Index(rName);
01078   mpTransRel->EraseByEv(index);
01079   return mpAlphabet->Erase(index);
01080 }
01081 
01082 // DelEvents(events)
01083 void vGenerator::DelEvents(const EventSet& rEvents) {
01084   FD_DG("vGenerator(" << this << ")::DelEvents(\"" 
01085   << rEvents.ToString() << "\")");
01086   EventSet::Iterator it;
01087   for (it = rEvents.Begin(); it != rEvents.End(); ++it) {
01088     DelEvent(*it);
01089   }
01090 }
01091 
01092 // DelEventFromAlphabet(index)
01093 bool vGenerator::DelEventFromAlphabet(Idx index) {
01094   FD_DG("vGenerator(" << this << ")::DelEventFromAlphabet(" 
01095   << index << ")");
01096   return mpAlphabet->Erase(index);
01097 }
01098 
01099 // InsState()
01100 Idx vGenerator::InsState(void) {
01101   FD_DG("vGenerator(" << this << ")::InsState()");
01102   return mpStates->Insert();
01103 }
01104 
01105 // InsState(index)
01106 bool vGenerator::InsState(Idx index) {
01107   FD_DG("vGenerator(" << this << ")::InsState(" << index << ")");
01108   return mpStates->Insert(index);
01109 }
01110 
01111 // InsState(rName)
01112 Idx vGenerator::InsState(const std::string& rName) {
01113   FD_DG("vGenerator(" << this << ")::InsState(\"" << rName << "\")");
01114   Idx index=mpStates->Insert();
01115   StateName(index,rName);
01116   return index;
01117 }
01118 
01119 // InjectState(index)
01120 void vGenerator::InjectState(Idx index) {
01121   FD_DG("vGenerator(" << this << ")::InjectState(\"" << SStr(index) << "\")");
01122   mpStates->Insert(index);
01123 }
01124 
01125 // InjectStates(rNewStates)
01126 void vGenerator::InjectStates(const StateSet& rNewStates) {
01127   FD_DG("vGenerator(" << this << ")::InjectStates(" << rNewStates.ToString() << ")");
01128   *mpStates=rNewStates;
01129   mpStates->Name("States");
01130   mpStateSymbolTable->RestrictDomain(*mpStates);
01131   FD_DG("vGenerator(" << this << ")::InjectStates(): report " << mpStates->ToString());
01132 }
01133 
01134 // InsInitState()
01135 Idx vGenerator::InsInitState(void) {
01136   FD_DG("vGenerator(" << this << ")::InsInitState()");
01137   Idx index;
01138   index = InsState();
01139   mInitStates.Insert(index);
01140   return index;
01141 }
01142 
01143 // InsInitState(name)
01144 Idx vGenerator::InsInitState(const std::string& rName) {
01145   FD_DG("vGenerator(" << this << ")::InsInitState(\"" << rName << "\")");
01146   Idx index;
01147   index = InsState(rName);
01148   mInitStates.Insert(index);
01149   return index;
01150 }
01151 
01152 // InsInitState(name)
01153 bool vGenerator::InsInitState(Idx index) {
01154   bool res=InsState(index);
01155   mInitStates.Insert(index);
01156   return res;
01157 }
01158 
01159 // InsMarkedState()
01160 Idx vGenerator::InsMarkedState(void) {
01161   FD_DG("vGenerator(" << this << ")::InsMarkedState()");
01162   Idx index;
01163   index = InsState();
01164   mMarkedStates.Insert(index);
01165   return index;
01166 }
01167 
01168 // InsInitState(name)
01169 bool vGenerator::InsMarkedState(Idx index) {
01170   bool res=InsState(index);
01171   mMarkedStates.Insert(index);
01172   return res;
01173 }
01174 
01175 // InsMarkedState(rName)
01176 Idx vGenerator::InsMarkedState(const std::string& rName) {
01177   FD_DG("vGenerator(" << this << ")::InsMarkedState(\"" << rName << "\")");
01178   Idx index;
01179   index = InsState(rName);
01180   mMarkedStates.Insert(index);
01181   return index;
01182 }
01183 
01184 // DelState(index)
01185 bool vGenerator::DelState(Idx index) {
01186   FD_DG("vGenerator(" << this << ")::DelState(" << index << ")");
01187   // mInitStates
01188   mInitStates.Erase(index);
01189   // mstates
01190   mMarkedStates.Erase(index);
01191   // transrel 
01192   mpTransRel->EraseByX1OrX2(index);
01193   // symbolic name
01194   mpStateSymbolTable->ClrEntry(index);
01195   // finally ... remove the state
01196   return mpStates->Erase(index);
01197 }
01198 
01199 // DelState(rName)
01200 bool vGenerator::DelState(const std::string& rName) {
01201   FD_DG("vGenerator(" << this << ")::DelState(\"" << rName << "\")");
01202   Idx index;
01203   index = StateIndex(rName);
01204 #ifdef FAUDES_CHECKED
01205   if (index == 0) {
01206     std::stringstream errstr;
01207     errstr << "state name \"" << rName << "\" not found in generator \""
01208      << Name() << "\"";
01209     throw Exception("vGenerator::DelState(name)", errstr.str(), 90);
01210   }
01211 #endif
01212   return DelState(index);
01213 }
01214 
01215 // DelStates(rDelStates)
01216 void vGenerator::DelStates(const StateSet& rDelStates) {
01217   FD_DG("vGenerator(" << this << ")::DelStates(" 
01218   << rDelStates.ToString() << ")");
01219   StateSet::Iterator cit;
01220   StateSet::Iterator cit_end;
01221   // symbolic state names
01222   if (StateNamesEnabled()) {
01223     for (cit = rDelStates.Begin(); cit != rDelStates.End(); ++cit) {
01224       mpStateSymbolTable->ClrEntry(*cit);
01225     }
01226   }
01227   // statesets
01228   mpStates->EraseSet(rDelStates);
01229   mInitStates.EraseSet(rDelStates);
01230   mMarkedStates.EraseSet(rDelStates);
01231   // mpTransRel:
01232   mpTransRel->EraseByX1OrX2(rDelStates);
01233   // original (slow)
01234   //for (cit = rDelStates.Begin(); cit != rDelStates.End(); ++cit) {
01235   //  mpTransRel->EraseByX1OrX2(*cit);
01236   //}
01237 }
01238 
01239 // DelStateFromStates(index)
01240 bool vGenerator::DelStateFromStates(Idx index) {
01241   FD_DG("vGenerator(" << this << ")::DelStateFromStates(" << index << ")");
01242   // mStates + global
01243   return mpStates->Erase(index);
01244 }
01245 
01246 // DelStateFromStates(pos)
01247 StateSet::Iterator vGenerator::DelStateFromStates(StateSet::Iterator pos) {
01248   FD_DG("vGenerator(" << this << ")::DelState(" << *pos << ")");
01249   return mpStates->Erase(pos);
01250 }
01251 
01252 // SetInitState(index)
01253 void vGenerator::SetInitState(Idx index) {
01254   FD_DG("vGenerator(" << this << ")::SetInitState(" << index << ")");
01255 #ifdef FAUDES_CHECKED
01256   if (! mpStates->Exists(index)) {
01257     std::stringstream errstr;
01258     errstr << "vGenerator::SetMarkedState: index " << index 
01259      << " not in stateset";
01260     throw Exception("vGenerator::SetInitState(..)", errstr.str(), 91);
01261   }
01262 #endif
01263   mInitStates.Insert(index);
01264 }
01265 
01266 // SetInitState(rName)
01267 void vGenerator::SetInitState(const std::string& rName) {
01268   FD_DG("vGenerator(" << this << ")::SetInitState(\"" << rName << "\")");
01269   Idx index = StateIndex(rName);
01270 #ifdef FAUDES_CHECKED
01271   if (index == 0) {
01272     std::stringstream errstr;
01273     errstr << "State name \"" << rName << "\" not known in Generator";
01274     throw Exception("vGenerator::SetInitState(..)", errstr.str(), 90);
01275   }
01276 #endif
01277   SetInitState(index);
01278 }
01279 
01280 // InjectInitStates(rNewInitStates)
01281 void vGenerator::InjectInitStates(const StateSet& rNewInitStates) {
01282   FD_DG("vGenerator(" << this << ")::InjectInitStates(" 
01283   << rNewInitStates.ToString() << ")");
01284   mInitStates = rNewInitStates;
01285   mInitStates.Name("InitStates");
01286 }
01287 
01288 // ClrInitState(index)
01289 void vGenerator::ClrInitState(Idx index) {
01290   FD_DG("vGenerator(" << this << ")::ClrInitState(" << index << ")");
01291 #ifdef FAUDES_CHECKED
01292   if (! mpStates->Exists(index)) {
01293     std::stringstream errstr;
01294     errstr << "vGenerator::SetMarkedState: index " << index 
01295      << " not in stateset";
01296     throw Exception("vGenerator::ClrInitState(..)", errstr.str(), 91);
01297   }
01298 #endif
01299   mInitStates.Erase(index);
01300 }
01301 
01302 // ClrInitState(rName)
01303 void vGenerator::ClrInitState(const std::string& rName) {
01304   FD_DG("vGenerator(" << this << ")::ClrInitState(\"" << rName << "\")");
01305   Idx index = StateIndex(rName);
01306 #ifdef FAUDES_CHECKED
01307   if (index == 0) {
01308     std::stringstream errstr;
01309     errstr << "State name \"" << rName << "\" not known in Generator";
01310     throw Exception("vGenerator::ClrInitState(..)", errstr.str(), 90);
01311   }
01312 #endif
01313   ClrInitState(index);
01314 }
01315 
01316 // ClrInitState(pos)
01317 StateSet::Iterator vGenerator::ClrInitState(StateSet::Iterator pos) {
01318   FD_DG("vGenerator(" << this << ")::ClrInitState(" << *pos << ")");
01319   return mInitStates.Erase(pos);
01320 }
01321 
01322 // ClearInitStates()
01323 void vGenerator::ClearInitStates(void) {
01324   mInitStates.Clear();
01325 }
01326 
01327 // SetMarkedState(index)
01328 void vGenerator::SetMarkedState(Idx index) {
01329   FD_DG("vGenerator(" << this << ")::SetMarkedState(" << index << ")");
01330 #ifdef FAUDES_CHECKED
01331   if (! mpStates->Exists(index)) {
01332     std::stringstream errstr;
01333     errstr << "vGenerator::SetMarkedState: index " << index 
01334      << " not in stateset";
01335     throw Exception("vGenerator::SetMarkedState(..)", errstr.str(), 91);
01336   }
01337 #endif
01338   mMarkedStates.Insert(index);
01339 }
01340 
01341 // SetMarkedState(rName)
01342 void vGenerator::SetMarkedState(const std::string& rName) {
01343   FD_DG("vGenerator(" << this << ")::SetMarkedState(\"" << rName << "\")");
01344   Idx index = StateIndex(rName);
01345 #ifdef FAUDES_CHECKED
01346   if (index == 0) {
01347     std::stringstream errstr;
01348     errstr << "State name \"" << rName << "\" not known in Generator";
01349     throw Exception("vGenerator::SetMarkedState(..)", errstr.str(), 90);
01350   }
01351 #endif
01352   SetMarkedState(index);
01353 }
01354 
01355 // InjectMarkedStates(rNewMarkedStates)
01356 void vGenerator::InjectMarkedStates(const StateSet& rNewMarkedStates) {
01357   FD_DG("vGenerator(" << this << ")::InjectMarkedStates(" 
01358   << rNewMarkedStates.ToString() << ")");
01359   mMarkedStates = rNewMarkedStates;
01360   mMarkedStates.Name("MarkedStates");
01361 }
01362 
01363 // ClrMarkedState(index)
01364 void vGenerator::ClrMarkedState(Idx index) {
01365   FD_DG("vGenerator(" << this << ")::ClrMarkedState(" << index << ")");
01366 #ifdef FAUDES_CHECKED
01367   if (! mpStates->Exists(index)) {
01368     std::stringstream errstr;
01369     errstr << "vGenerator::ClrMarkedState: index " << index 
01370      << " not in stateset";
01371     throw Exception("vGenerator::ClrMarkedState(..)", errstr.str(), 91);
01372   }
01373 #endif
01374   mMarkedStates.Erase(index);
01375 }
01376 
01377 // ClrMarkedState(rName)
01378 void vGenerator::ClrMarkedState(const std::string& rName) {
01379   FD_DG("vGenerator(" << this << ")::ClrMarkedState(\"" << rName << "\")");
01380   Idx index = StateIndex(rName);
01381 #ifdef FAUDES_CHECKED
01382   if (index == 0) {
01383     std::stringstream errstr;
01384     errstr << "State name \"" << rName << "\" not known in Generator";
01385     throw Exception("vGenerator::ClrMarkedState(..)", errstr.str(), 90);
01386   }
01387 #endif
01388   ClrMarkedState(index);
01389 }
01390 
01391 // ClrMarkedState(pos)
01392 StateSet::Iterator vGenerator::ClrMarkedState(StateSet::Iterator pos) {
01393   FD_DG("vGenerator(" << this << ")::ClrMarkedState(" << *pos << ")");
01394   return mMarkedStates.Erase(pos);
01395 }
01396 
01397 // ClearMarkedStates()
01398 void vGenerator::ClearMarkedStates(void) {
01399   mMarkedStates.Clear();
01400 }
01401 
01402 // InjectTransition(newtrans)
01403 void vGenerator::InjectTransition(const Transition& rTrans) {
01404   FD_DG("vGenerator::InjectTransition(" << TStr(rTrans) << ")");
01405   mpTransRel->Insert(rTrans);
01406 }
01407 
01408 // InjectTransRel(newtransrel)
01409 void vGenerator::InjectTransRel(const TransSet& rNewTransrel) {
01410   FD_DG("vGenerator::InjectTransRel(...)");
01411   *mpTransRel=rNewTransrel;
01412   mpTransRel->Name("TransRel");
01413 }
01414 
01415 // SetTransition(rX1, rEv, rX2)
01416 bool vGenerator::SetTransition(const std::string& rX1, const std::string& rEv, const std::string& rX2) {
01417   FD_DG("vGenerator(" << this << ")::SetTransition(\""
01418   << rX1 << "\", \"" << rEv << "\", \"" << rX2 << "\")");
01419   Idx x1 = StateIndex(rX1);
01420   Idx x2 = StateIndex(rX2);
01421 #ifdef FAUDES_CHECKED
01422   if (x1 == 0) {
01423     FD_ERR("vGenerator::SetTransition: state " << rX1 
01424      << " not in stateset");
01425     std::stringstream errstr;
01426     errstr << "State name " << rX1 << " not found in Generator";
01427     throw Exception("vGenerator::SetTransition(..)", errstr.str(), 90);
01428   }
01429   if (! mpAlphabet->Exists(rEv)) {
01430     FD_ERR("vGenerator::SetTransition: event " << rEv << " not in alphabet");
01431     std::stringstream errstr;
01432     errstr << "Event name " << rEv << " not found in event domain of Generator";
01433     throw Exception("vGenerator::SetTransition(..)", errstr.str(), 95);
01434   }
01435   if (x2 == 0) {
01436     FD_ERR("vGenerator::SetTransition: state " << rX2 << " not in stateset");
01437     std::stringstream errstr;
01438     errstr << "State name " << rX2 << " not found in Generator";
01439     throw Exception("vGenerator::SetTransition(..)", errstr.str(), 90);
01440   }
01441 #endif
01442   return SetTransition(Transition(x1, EventIndex(rEv), x2));
01443 }
01444 
01445 
01446 // SetTransition(x1, ev, x2)
01447 bool vGenerator::SetTransition(Idx x1, Idx ev, Idx x2) {
01448   return SetTransition(Transition(x1,ev,x2));
01449 }
01450 
01451 // SetTransition(rTransition)
01452 bool vGenerator::SetTransition(const Transition& rTransition) {
01453   FD_DG("vGenerator(" << this << ")::SetTransition(" << rTransition.X1 << "," 
01454   << rTransition.Ev << "," << rTransition.X2 << ")");
01455 #ifdef FAUDES_CHECKED
01456   if (! mpStates->Exists(rTransition.X1)) {
01457     std::stringstream errstr;
01458     errstr << "vGenerator::SetTransition: state " << rTransition.X1 
01459      << " not in stateset";
01460     throw Exception("vGenerator::SetTransition(..)", errstr.str(), 95);
01461   }
01462   if (! mpAlphabet->Exists(rTransition.Ev)) {
01463     std::stringstream errstr;
01464     errstr << "vGenerator::SetTransition: event " << rTransition.Ev 
01465      << " not in alphabet ";
01466     throw Exception("vGenerator::SetTransition(..)", errstr.str(), 95);
01467   }
01468   if (! mpStates->Exists(rTransition.X2)) {
01469     std::stringstream errstr;
01470     errstr << "vGenerator::SetTransition: state " << rTransition.X2 
01471      << " not in stateset";
01472     throw Exception("vGenerator::SetTransition(..)", errstr.str(), 95);
01473   }
01474 #endif
01475   return mpTransRel->Insert(rTransition);
01476 }
01477 
01478 // ClrTransition.X1, ev, x2)
01479 void vGenerator::ClrTransition(Idx x1, Idx ev, Idx x2) {
01480   FD_DG("vGenerator(" << this << ")::ClrTransition(" 
01481   << x1 << "," << ev << "," << x2 << ")");
01482   mpTransRel->Erase(x1, ev, x2);
01483 }
01484 
01485 // ClrTransition(rTransition)
01486 void vGenerator::ClrTransition(const Transition& rTransition) {
01487   FD_DG("vGenerator(" << this << ")::ClrTransition(" << TStr(rTransition) << ")");
01488   mpTransRel->Erase(rTransition);
01489 }
01490 
01491 // ClrTransition(it)
01492 TransSet::Iterator vGenerator::ClrTransition(TransSet::Iterator it) {
01493   FD_DG("vGenerator(" << this << ")::ClrTransition(" << TStr(*it)<< ")" );
01494   return mpTransRel->Erase(it);
01495 }
01496 
01497 // TransAttribute(trans, attr)
01498 void vGenerator::TransAttribute(const Transition& rTrans, const Type& rAttr) {
01499   FD_DG("vGenerator(" << this << ")::TransAttribute(" 
01500   << TStr(rTrans) << ",\"" << rAttr.ToString() << "\")");
01501   mpTransRel->Attribute(rTrans, rAttr);
01502 }
01503 
01504 // TransAttributep(trans)
01505 AttributeVoid* vGenerator::TransAttributep(const Transition& rTrans)  {
01506   return mpTransRel->Attributep(rTrans);
01507 }
01508 
01509 
01510 // TransAttribute(trans)
01511 const AttributeVoid& vGenerator::TransAttribute(const Transition& rTrans) const {
01512   return mpTransRel->Attribute(rTrans);
01513 }
01514 
01515 // ClrTransAttribute(trans)
01516 void vGenerator::ClrTransAttribute(const Transition& rTrans)  {
01517   mpTransRel->ClrAttribute(rTrans);
01518 }
01519 
01520 
01521 // ClearTransRel()
01522 void vGenerator::ClearTransRel(void) {
01523   mpTransRel->Clear();
01524 }
01525 
01526 // EventAttribute(index, attr)
01527 void vGenerator::EventAttribute(Idx index, const Type& rAttr) {
01528   FD_DG("vGenerator(" << this << ")::EventAttribute(" 
01529   << EStr(index) << ",\"" << rAttr.ToString() << "\")");
01530   mpAlphabet->Attribute(index, rAttr);
01531 }
01532 
01533 // EventAttributes(set)
01534 void vGenerator::EventAttributes(const EventSet& rEventSet) {
01535   FD_DG("vGenerator(" << this << ")::EventAttributes(" 
01536   << rEventSet.ToString() << "\")");
01537   mpAlphabet->Attributes(rEventSet);
01538 }
01539 
01540 // ClrEventAttribute(index)
01541 void vGenerator::ClrEventAttribute(Idx index) {
01542   FD_DG("vGenerator(" << this << ")::ClrEventAttribute(\"" << EStr(index) << "\")");
01543   mpAlphabet->ClrAttribute(index);
01544 }
01545 
01546 // StateAttribute(index, attr)
01547 void vGenerator::StateAttribute(Idx index, const Type& rAttr) {
01548   FD_DG("vGenerator(" << this << ")::StateAttribute(" 
01549   << SStr(index) << ",\"" << rAttr.ToString() << "\")");
01550   mpStates->Attribute(index, rAttr);
01551 }
01552 
01553 // ClrStateAttribute(index)
01554 void vGenerator::ClrStateAttribute(Idx index) {
01555   FD_DG("vGenerator(" << this << ")::ClrStateAttribute(\"" << index << "\")");
01556   mpStates->ClrAttribute(index);
01557 }
01558 
01559 // ExistsEvent(index)
01560 bool vGenerator::ExistsEvent(Idx index) const {
01561   return mpAlphabet->Exists(index);
01562 }
01563 
01564 // ExistsEvent(rName)
01565 bool vGenerator::ExistsEvent(const std::string& rName) const {
01566   return mpAlphabet->Exists(rName);
01567 }
01568 
01569 // FindEvent(index) const
01570 EventSet::Iterator vGenerator::FindEvent(Idx index) const {
01571   return mpAlphabet->Find(index);
01572 }
01573 
01574 // FindEvent(rName)
01575 EventSet::Iterator vGenerator::FindEvent(const std::string& rName) const {
01576   return mpAlphabet->Find(rName);
01577 }
01578 
01579 // ExistsState(index)
01580 bool vGenerator::ExistsState(Idx index) const {
01581   return mpStates->Exists(index);
01582 }
01583 
01584 // ExistsName(name)
01585 bool vGenerator::ExistsState(const std::string& rName) const {
01586   return ExistsState(StateIndex(rName));
01587 }
01588 
01589 // FindState(rName) const
01590 StateSet::Iterator vGenerator::FindState(const std::string& rName) const {
01591   return mpStates->Find(mpStateSymbolTable->Index(rName));
01592 }
01593 
01594 // FindState(index) const
01595 StateSet::Iterator vGenerator::FindState(Idx index) const {
01596   return mpStates->Find(index);
01597 }
01598 
01599 // ExistsInitState(index)
01600 bool vGenerator::ExistsInitState(Idx index) const {
01601   return mInitStates.Exists(index);
01602 }
01603 
01604 // FindInitState(index)
01605 StateSet::Iterator vGenerator::FindInitState(Idx index) const {
01606   return mInitStates.Find(index);
01607 }
01608 
01609 // ExistsMarkedState(index)
01610 bool vGenerator::ExistsMarkedState(Idx index) const {
01611   return mMarkedStates.Exists(index);
01612 }
01613 
01614 // FindMarkedState(index)
01615 StateSet::Iterator vGenerator::FindMarkedState(Idx index) const {
01616   return mMarkedStates.Find(index);
01617 }
01618 
01619 // EventAttribute(index)
01620 const AttributeVoid&  vGenerator::EventAttribute(Idx index) const {
01621   return mpAlphabet->Attribute(index);
01622 }
01623 
01624 // EventAttributep(index)
01625 AttributeVoid* vGenerator::EventAttributep(Idx index) {
01626   return mpAlphabet->Attributep(index);
01627 }
01628 
01629 // EventAttribute(rName)
01630 const AttributeVoid&  vGenerator::EventAttribute(const std::string& rName) const {
01631   return EventAttribute(EventIndex(rName));
01632 }
01633 
01634 // EventAttributep(rName)
01635 AttributeVoid* vGenerator::EventAttributep(const std::string& rName) {
01636   return EventAttributep(EventIndex(rName));
01637 }
01638 
01639 // StateAttribute(index)
01640 const AttributeVoid&  vGenerator::StateAttribute(Idx index) const {
01641   return mpStates->Attribute(index);
01642 }
01643 
01644 // StateAttributep(index)
01645 AttributeVoid*  vGenerator::StateAttributep(Idx index) {
01646   return mpStates->Attributep(index);
01647 }
01648 
01649 // GlobalAttribute(attr)
01650 void vGenerator::GlobalAttribute(const Type& rAttr) {
01651   FD_DG("vGenerator(" << this << ")::GlobalAttribute(" 
01652   << rAttr.ToString() << "\")");
01653   // set to void is ok for silient ignore
01654   if(typeid(rAttr)==typeid(AttributeVoid)) return;
01655   // error:
01656   std::stringstream errstr;
01657   errstr << "cannot cast global attribute " << rAttr.ToString() << " for generator " << Name();
01658   throw Exception("vGenerator::GlobalAttribute", errstr.str(), 63);
01659 }
01660 
01661 // GlobalAttributeTry(attr)
01662 void vGenerator::GlobalAttributeTry(const Type& rAttr) {
01663   FD_DG("vGenerator(" << this << ")::GlobalAttributeTry(" 
01664   << rAttr.ToString() << "\")");
01665   // ignore
01666 }
01667 
01668 // GlobalAttribute()
01669 const AttributeVoid& vGenerator::GlobalAttribute(void) const {
01670   FD_DG("vGenerator(" << this << ")::GlobalAttribute()");
01671   return *mpGlobalAttribute;
01672 }
01673 
01674 // GlobalAttributep()
01675 AttributeVoid* vGenerator::GlobalAttributep(void) {
01676   FD_DG("vGenerator(" << this << ")::GlobalAttributep()");
01677   return mpGlobalAttribute;
01678 }
01679 
01680 
01681 // Alphabet()
01682 const EventSet& vGenerator::Alphabet(void) const {
01683   return *mpAlphabet;
01684 }
01685 
01686 // States()
01687 const StateSet& vGenerator::States(void) const {
01688   return *mpStates;
01689 }
01690 
01691 // TransRel()
01692 const TransSet& vGenerator::TransRel(void) const {
01693   return *mpTransRel;
01694 }
01695 
01696 
01697 // TransRel(res)
01698 void vGenerator::TransRel(TransSetX1EvX2& res) const { mpTransRel->ReSort(res); }
01699 void vGenerator::TransRel(TransSetEvX1X2& res) const { mpTransRel->ReSort(res); }
01700 void vGenerator::TransRel(TransSetEvX2X1& res) const { mpTransRel->ReSort(res); }
01701 void vGenerator::TransRel(TransSetX2EvX1& res) const { mpTransRel->ReSort(res); }
01702 void vGenerator::TransRel(TransSetX2X1Ev& res) const { mpTransRel->ReSort(res); }
01703 void vGenerator::TransRel(TransSetX1X2Ev& res) const { mpTransRel->ReSort(res); }
01704 
01705 
01706 // InitStates()
01707 const StateSet& vGenerator::InitStates(void) const {
01708   return mInitStates;
01709 }
01710 
01711 // MarkedStates()
01712 const StateSet& vGenerator::MarkedStates(void) const {
01713   return mMarkedStates;
01714 }
01715 
01716 // MinimizeAlphabet()
01717 void vGenerator::MinimizeAlphabet(void) {
01718   mpAlphabet->NameSet::EraseSet(UnusedEvents());
01719 }
01720 
01721 // UsedEvents()
01722 EventSet vGenerator::UsedEvents(void) const {
01723   EventSet resultset = NewEventSet();
01724   TransSet::Iterator it;
01725   for (it = mpTransRel->Begin(); it != mpTransRel->End(); ++it) {
01726     resultset.Insert(it->Ev);
01727   }
01728   return resultset;
01729 }
01730 
01731 // UnusedEvents()
01732 EventSet vGenerator::UnusedEvents(void) const {
01733   return *mpAlphabet - UsedEvents();
01734 }
01735 
01736 // ActiveEventSet(x1)
01737 EventSet vGenerator::ActiveEventSet(Idx x1) const {
01738   EventSet result = NewEventSet();
01739   TransSet::Iterator it;
01740   for (it = TransRelBegin(x1); it != TransRelEnd(x1); ++it) {
01741     result.Insert(it->Ev);
01742   }
01743   return result;
01744 }
01745 
01746 // ActiveTransSet(x1)
01747 TransSet vGenerator::ActiveTransSet(Idx x1) const {
01748   TransSet result;
01749   TransSet::Iterator it;
01750   for (it = TransRelBegin(x1); it != TransRelEnd(x1); ++it) {
01751     result.Insert(*it);
01752   }
01753   return result;
01754 }
01755 
01756 // TransRelStateSpace()
01757 StateSet vGenerator::TransRelStateSpace(void) const {
01758   StateSet states = StateSet();
01759   TransSet::Iterator it;
01760   for (it=mpTransRel->Begin(); it != mpTransRel->End(); ++it) {
01761     states.Insert(it->X1);
01762     states.Insert(it->X2);
01763   }
01764   return states;
01765 }
01766 
01767 // TransRelStateSpace(x1)
01768 StateSet vGenerator::TransRelStateSpace(Idx x1) const {
01769   StateSet states = StateSet();
01770   TransSet::Iterator it = mpTransRel->Begin(x1);
01771   TransSet::Iterator it_end = mpTransRel->End(x1);
01772   for (; it != it_end; ++it) {
01773     states.Insert(it->X2);
01774   }
01775   return states;
01776 }
01777 
01778 
01779 // CheckAccessible(accessibleset, startState)
01780 void vGenerator::CheckAccessible(StateSet& accessibleset, Idx startState) const {
01781   if (! accessibleset.Exists(startState)) {
01782     accessibleset.Insert(startState);
01783     TransSet::Iterator it = TransRelBegin(startState);
01784     TransSet::Iterator it_end = TransRelEnd(startState);
01785     for (; it != it_end; ++it) {
01786       CheckAccessible(accessibleset, it->X2);
01787     }
01788   }
01789 }
01790 
01791 // CheckCoaccessible(coaccessibleset, rtransrel, startState)
01792 void vGenerator::CheckCoaccessible(StateSet& coaccessibleset, const TransSetX2EvX1& rtrel, Idx startState) const {
01793   if (! coaccessibleset.Exists(startState)) {
01794     coaccessibleset.Insert(startState);
01795     TransSetX2EvX1::Iterator it = rtrel.BeginByX2(startState);
01796     TransSetX2EvX1::Iterator it_end = rtrel.EndByX2(startState);
01797     for (; it != it_end; ++it) {
01798       CheckCoaccessible(coaccessibleset, rtrel, it->X1);
01799     }
01800   }
01801 }
01802 
01803 // AccessibleSet()
01804 StateSet vGenerator::AccessibleSet(void) const {
01805   StateSet accessibleset = StateSet();
01806   StateSet::Iterator it;
01807   for (it = InitStatesBegin(); it != InitStatesEnd(); ++it) {
01808     CheckAccessible(accessibleset, *it);
01809   }
01810   accessibleset.Name("accessibleset");
01811   return accessibleset;
01812 }
01813 
01814 // Accessible()
01815 bool vGenerator::Accessible(void) {
01816   StateSet accessibleset = AccessibleSet();
01817   StateSet not_accessible = *mpStates - accessibleset;
01818   DelStates(not_accessible);
01819   // return true if there is an initial state
01820   if (!mInitStates.Empty()) {
01821     FD_DF("vGenerator::accessible: generator is accessible");
01822     return true;
01823   }
01824   else {
01825     FD_DF("vGenerator::accessible: generator is accessible but empty");
01826     return false;
01827   }
01828 
01829 }
01830 
01831 // IsAccessible()
01832 bool vGenerator::IsAccessible(void) const {
01833   if ((AccessibleSet() == *mpStates) && (! mInitStates.Empty())) {
01834     FD_DF("vGenerator::accessible: generator is accessible");
01835     return true;
01836   }
01837   else {
01838     FD_DF("vGenerator::accessible: generator is not accessible");
01839     return false;
01840   }
01841 }
01842 
01843 // CoaccessibleSet()
01844 StateSet vGenerator::CoaccessibleSet(void) const {
01845   StateSet coaccessibleset = StateSet();
01846   StateSet::Iterator it;
01847   // build reverse transition relation
01848   TransSetX2EvX1 rtrel;
01849   TransRel(rtrel);
01850   for (it = MarkedStatesBegin(); it != MarkedStatesEnd(); ++it) {
01851     CheckCoaccessible(coaccessibleset, rtrel, *it);
01852   }
01853   coaccessibleset.Name("coaccessibleset");
01854   return coaccessibleset;
01855 }
01856 
01857 // Coaccessible()
01858 bool vGenerator::Coaccessible(void) {
01859   StateSet coaccessibleset = CoaccessibleSet();
01860   StateSet not_coaccessible = *mpStates - coaccessibleset;
01861   DelStates(not_coaccessible);
01862   // return true if there is a marked state
01863   if (! mMarkedStates.Empty()) {
01864     FD_DF("vGenerator::coaccessible: generator is coaccessible");
01865     return true;
01866   }
01867   else {
01868     FD_DF("vGenerator::coaccessible: generator is not coaccessible");
01869     return false;
01870   }
01871 }
01872 
01873 // IsCoaccessible()
01874 bool vGenerator::IsCoaccessible(void) const {
01875   if ((CoaccessibleSet() == *mpStates) && (! mMarkedStates.Empty())) {
01876     FD_DF("vGenerator::coaccessible: generator is coaccessible");
01877     return true;
01878   }
01879   else {
01880     FD_DF("vGenerator::coaccessible: generator is not coaccessible");
01881     return false;
01882   }
01883 }
01884 
01885 // TrimSet()
01886 StateSet vGenerator::TrimSet(void) const {
01887   FD_DF("vGenerator::trimset: trim states: " 
01888   << StateSet(AccessibleSet() * CoaccessibleSet()).ToString());
01889   return AccessibleSet() * CoaccessibleSet();
01890 }
01891 
01892 // Trim()
01893 bool vGenerator::Trim(void) {
01894   FD_DF("vGenerator::trim: generator states: " << mpStates->ToString());
01895   // better: compute sets and do one state delete
01896   bool accessiblebool = Accessible();
01897   bool coaccessiblebool = Coaccessible();
01898   FD_DF("vGenerator::trim: trim states: " << mpStates->ToString());
01899   if (accessiblebool && coaccessiblebool) {
01900     FD_DF("vGenerator::trim: generator is trim");
01901     return true;
01902   }
01903   FD_DF("vGenerator::trim: generator is not trim");
01904   return false;
01905 }
01906 
01907 // IsTrim()
01908 bool vGenerator::IsTrim(void) const {
01909   if (IsAccessible() && IsCoaccessible()) {
01910     FD_DF("vGenerator::trim: generator is trim");
01911     return true;
01912   }
01913   else {
01914     FD_DF("vGenerator::trim: generator is not trim");
01915     return false;
01916   }
01917 }
01918 
01919 // BlockingStates()
01920 StateSet vGenerator::BlockingStates(void) const {
01921   FD_DF("vGenerator::BlockingSet: blocking states: " 
01922   << StateSet(AccessibleSet() - CoaccessibleSet()).ToString());
01923   return AccessibleSet() - CoaccessibleSet();
01924 }
01925 
01926 
01927 
01928 // IsComplete
01929 bool vGenerator::IsComplete(const StateSet& rStates) const {
01930   FD_DG("IsComplete(" << Name() << ")");
01931   
01932   // loop accessible states
01933   StateSet::Iterator sit=rStates.Begin();
01934   StateSet::Iterator sit_end=rStates.End();
01935   for(;sit!=sit_end;sit++){
01936     TransSet::Iterator tit=TransRelBegin(*sit);
01937     TransSet::Iterator tit_end=TransRelEnd(*sit);
01938     if(tit==tit_end) break;
01939   }
01940   // return true if no terminal state has been found
01941   return sit==sit_end;
01942 }
01943 
01944 // IsComplete
01945 bool vGenerator::IsComplete(void) const {
01946   return IsComplete(StateSet());
01947 }
01948 
01949 // TerminalStates()
01950 StateSet vGenerator::TerminalStates(const StateSet& rStates) const {
01951   FD_DG("Terminal(" << Name() << ")");
01952   
01953   // prepare result
01954   StateSet res;
01955   
01956   // loop states
01957   StateSet::Iterator sit=rStates.Begin();
01958   StateSet::Iterator sit_end=rStates.End();
01959   for(;sit!=sit_end;sit++){
01960     TransSet::Iterator tit=TransRelBegin(*sit);
01961     TransSet::Iterator tit_end=TransRelEnd(*sit);
01962     if(tit==tit_end) res.Insert(*sit);
01963   }
01964   // return terminal states
01965   return res;
01966 }
01967 
01968 // TerminalStates()
01969 StateSet vGenerator::TerminalStates(void) const {
01970   return TerminalStates(StateSet());
01971 }
01972 
01973 // IsDeterministic()
01974 bool vGenerator::IsDeterministic(void) const {
01975   // if there is more than one initial state ... nondet
01976   if (InitStatesSize() != 1) {
01977     FD_DG("vGenerator::IsDeterministic: number of initial states not 1");
01978     return false;
01979   }
01980   // if there is a state/event pair with non-unique successor ... nondet
01981   if (TransRelSize() < 2) return true;
01982   TransSet::Iterator it1;
01983   TransSet::Iterator it2;
01984   for (it1 = TransRelBegin(), it2 = it1++; it1 != TransRelEnd(); it2 = it1++) {
01985     if ((it1->X1 == it2->X1) && (it1->Ev == it2->Ev)) {
01986       FD_WP("IsDeterministic: nondeterministic generator. at least one state "
01987       << "contains more than on transition with same event: " 
01988       << SStr(it1->X1) << ", event " << EStr(it1->Ev));
01989       return false;
01990     }
01991   }
01992   // in all other cases generator is deterministic
01993   return true;
01994 }
01995 
01996 // DoWrite()
01997 void vGenerator::DoWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const {
01998   (void) pContext;
01999   // figure section
02000   std::string label=rLabel;
02001   if(label=="") label="Generator"; 
02002   FD_DG("vGenerator(" << this << ")::DoWrite(): section " << label);
02003   // reindex for file output
02004   if(rTw.DestMode()==TokenWriter::File) SetMinStateIndexMap();
02005   // write generator
02006   rTw.WriteBegin(label);
02007   rTw << mMyName;
02008   rTw << "\n";
02009   rTw << "\n";
02010   SWrite(rTw);
02011   rTw << "\n";
02012   mpAlphabet->Write(rTw);
02013   rTw << "\n";
02014   WriteStateSet(rTw, *mpStates);
02015   rTw << "\n";
02016   WriteTransRel(rTw);
02017   rTw << "\n";
02018   WriteStateSet(rTw, mInitStates);
02019   rTw << "\n";
02020   WriteStateSet(rTw, mMarkedStates);
02021   rTw << "\n";
02022   mpGlobalAttribute->Write(rTw);
02023   rTw << "\n";
02024   rTw.WriteEnd(label);
02025   // end of reindex
02026   ClearMinStateIndexMap();
02027 }
02028 
02029 // DoDWrite()
02030 void vGenerator::DoDWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const {
02031   (void) pContext;
02032   // figure section
02033   std::string label=rLabel;
02034   if(label=="") label="Generator"; 
02035   FD_DG("vGenerator(" << this << ")::DoDWrite(): section " << label);
02036   // write generator
02037   rTw.WriteBegin(label);
02038   rTw << mMyName;
02039   rTw << "\n";
02040   rTw << "\n";
02041   SWrite(rTw);
02042   rTw << "\n";
02043   mpAlphabet->DWrite(rTw);
02044   rTw << "\n";
02045   DWriteStateSet(rTw, *mpStates);
02046   rTw << "\n";
02047   DWriteTransRel(rTw);
02048   rTw << "\n";
02049   DWriteStateSet(rTw, mInitStates);
02050   rTw << "\n";
02051   DWriteStateSet(rTw, mMarkedStates);
02052   rTw << "\n";
02053   mpGlobalAttribute->Write(rTw);
02054   rTw << "\n";
02055   rTw.WriteEnd(label);
02056   rTw << "\n";
02057 }
02058 
02059 // WriteAlphabet() 
02060 void vGenerator::WriteAlphabet(void) const {
02061   TokenWriter tw(TokenWriter::Stdout);
02062   WriteAlphabet(tw);
02063 }
02064 
02065 // AlphabetToString()
02066 std::string vGenerator::AlphabetToString(void) const {
02067   TokenWriter tw(TokenWriter::String);
02068   WriteAlphabet(tw);
02069   return tw.Str();
02070 }
02071 
02072 // WriteAlphabet(rTw&) 
02073 void vGenerator::WriteAlphabet(TokenWriter& rTw) const { 
02074   mpAlphabet->Write(rTw);
02075 }
02076 
02077 // WriteStateSet(rStateSet&) 
02078 void vGenerator::WriteStateSet(const StateSet&  rStateSet) const {
02079   TokenWriter tw(TokenWriter::Stdout);
02080   WriteStateSet(tw,rStateSet);
02081 }
02082 
02083 // StateSetToString()
02084 std::string vGenerator::StateSetToString(const StateSet&  rStateSet) const {
02085   TokenWriter tw(TokenWriter::String);
02086   WriteStateSet(tw,rStateSet);
02087   return tw.Str();
02088 }
02089 
02090 // StateSetToText()
02091 std::string vGenerator::StateSetToText(const StateSet&  rStateSet) const {
02092   TokenWriter tw(TokenWriter::String);
02093   tw.Endl(true);
02094   WriteStateSet(tw,rStateSet);
02095   return tw.Str();
02096 }
02097 
02098 
02099 // WriteStateSet(rTw&, rStateSet&) 
02100 void vGenerator::WriteStateSet(TokenWriter& rTw, const StateSet&  rStateSet) const {
02101   rTw.WriteBegin(rStateSet.Name());
02102   // build reverse index map of states to write ( fileidx->idx )
02103   // (this ensures named states to be written first; see SetMinStateIndexMap())
02104   std::map<Idx,Idx> reversemap;
02105   std::map<Idx,Idx>::const_iterator minit;
02106   StateSet::Iterator sit;
02107   for (sit = rStateSet.Begin(); sit != rStateSet.End(); ++sit) {
02108     reversemap[MinStateIndex(*sit)] = *sit;
02109   }
02110   // iterate states to write 
02111   for(minit = reversemap.begin(); minit != reversemap.end(); ++minit) {
02112     // identify anonymous block (consecutive state indices)
02113     std::map<Idx,Idx>::const_iterator conit=minit;
02114     Idx start = conit->first;
02115     Idx anoncount = 0;
02116     for(; conit != reversemap.end(); ++conit) {
02117       if(StateName(conit->second) != "") break;
02118       if(!StateAttribute(conit->second).IsDefault()) break;
02119       if(conit->first != start+anoncount) break;
02120       ++anoncount;
02121     }
02122     // write anonymous block
02123     if (anoncount > FD_CONSECUTIVE) {
02124       rTw.WriteBegin("Consecutive");
02125       rTw << start;
02126       rTw << start+anoncount-1;
02127       rTw.WriteEnd("Consecutive");
02128       minit=conit;
02129     } 
02130     // break loop
02131     if(minit == reversemap.end() )
02132       break;
02133     // write non anonymous state name/idx
02134     std::string statename = StateName(minit->second);
02135     if (statename != "") {
02136       rTw << statename;
02137     } else {
02138       rTw << minit->first;
02139     }
02140     // write state attribute
02141     const AttributeVoid& attr=rStateSet.Attribute(minit->second);
02142     attr.Write(rTw);
02143   }
02144   rTw.WriteEnd(rStateSet.Name());
02145 }
02146 
02147 
02148 // DWriteStateSet(rTw&, rStateSet&) 
02149 void vGenerator::DWriteStateSet(TokenWriter& rTw, const StateSet& rStateSet) const {
02150   rTw.WriteBegin(rStateSet.Name());
02151   StateSet::Iterator lit;
02152   std::map<Idx,Idx>::const_iterator minit;
02153   for(lit = rStateSet.Begin(); lit != rStateSet.End(); ++lit) {
02154     rTw << SStr(*lit);
02155     const AttributeVoid& attr=rStateSet.Attribute(*lit);
02156     attr.Write(rTw);
02157   }
02158   rTw.WriteEnd(rStateSet.Name());
02159 }
02160 
02161 
02162 // StatesToString()
02163 std::string vGenerator::StatesToString(void) const {
02164   return StateSetToString(*mpStates);
02165 }
02166 
02167 // StatesToText()
02168 std::string vGenerator::StatesToText(void) const {
02169   return StateSetToText(*mpStates);
02170 }
02171 
02172 // MarkedStatesToString()
02173 std::string vGenerator::MarkedStatesToString(void) const {
02174   return StateSetToString(mMarkedStates);
02175 }
02176 
02177 // InitStatesToString()
02178 std::string vGenerator::InitStatesToString(void) const {
02179   return StateSetToString(mInitStates);
02180 }
02181 
02182 
02183 // WriteTransRel() 
02184 void vGenerator::WriteTransRel(void) const {
02185   TokenWriter tw(TokenWriter::Stdout);
02186   WriteTransRel(tw);
02187 }
02188 
02189 // TransRelToString()
02190 std::string vGenerator::TransRelToString(void) const {
02191   TokenWriter tw(TokenWriter::String);
02192   WriteTransRel(tw);
02193   return tw.Str();
02194 }
02195 
02196 // TransRelToText()
02197 std::string vGenerator::TransRelToText(void) const {
02198   TokenWriter tw(TokenWriter::String);
02199   tw.Endl(true);
02200   WriteTransRel(tw);
02201   return tw.Str();
02202 }
02203 
02204 // WriteTransRel(rTw&)
02205 void vGenerator::WriteTransRel(TokenWriter& rTw) const {
02206   TransSet::Iterator tit;
02207   int oldcolumns = rTw.Columns();
02208   rTw.Columns(3);
02209   rTw.WriteBegin("TransRel");
02210   bool smalltransrel = (Size() < FD_SMALLTRANSREL);
02211 
02212   // loop all transitions
02213   for(tit = mpTransRel->Begin(); tit != mpTransRel->End(); ++tit) {
02214 
02215     // write x1
02216     Idx x1=MinStateIndex(tit->X1);
02217     if (smalltransrel) {
02218       std::string x1name = StateName(tit->X1);
02219       if (x1name != "") {
02220   rTw << x1name;
02221       } else {
02222   rTw << x1;
02223       }
02224     } else {
02225       rTw << x1;
02226     }
02227 
02228     // write ev
02229     rTw << EventName(tit->Ev);
02230 
02231     // write x2
02232     Idx x2=MinStateIndex(tit->X2);
02233     if (smalltransrel) {
02234       std::string x2name = StateName(tit->X2);
02235       if (x2name != "") {
02236   rTw << x2name;
02237       } else {
02238   rTw << x2;
02239       }
02240     } else {
02241       rTw << x2;
02242     }
02243 
02244     // write attributes
02245     TransAttribute(*tit).Write(rTw);
02246 
02247   }
02248   rTw.WriteEnd("TransRel");
02249   rTw.Columns(oldcolumns);
02250 }
02251 
02252 // DWriteTransRel(rTw&)
02253 void vGenerator::DWriteTransRel(TokenWriter& rTw) const {
02254   TransSet::Iterator tit;
02255   int oldcolumns = rTw.Columns();
02256   rTw.Columns(1);
02257   rTw.WriteBegin("TransRel");
02258   for (tit = mpTransRel->Begin(); tit != mpTransRel->End(); ++tit) {
02259     rTw << TStr(*tit);
02260     mpTransRel->Attribute(*tit).Write(rTw);
02261   }
02262   rTw.WriteEnd("TransRel");
02263   rTw.Columns(oldcolumns);
02264 }
02265 
02266 
02267 // DoSWrite(rTw&)
02268 void vGenerator::DoSWrite(TokenWriter& rTw) const
02269 {
02270   Type::DoSWrite(rTw);
02271   rTw.WriteComment(" States:        " + ToStringInteger(Size()) );
02272   rTw.WriteComment(" Init/Marked:   " + ToStringInteger(mInitStates.Size()) 
02273         + "/" + ToStringInteger(mMarkedStates.Size()));
02274   rTw.WriteComment(" Events:        " + ToStringInteger(mpAlphabet->Size()) );
02275   rTw.WriteComment(" Transitions:   " + ToStringInteger(mpTransRel->Size()) );
02276   rTw.WriteComment(" StateSymbols:  " + ToStringInteger(mpStateSymbolTable->Size()) );
02277   rTw.WriteComment(" Attrib. E/S/T: " + ToStringInteger(mpAlphabet->AttributesSize()) 
02278         + "/" + ToStringInteger(mpStates->AttributesSize())
02279         + "/" + ToStringInteger(mpTransRel->AttributesSize()) );
02280   rTw.WriteComment("");
02281 }
02282 
02283 // DotWrite(rFileName)
02284 void vGenerator::DotWrite(const std::string& rFileName) const {
02285   FD_DG("vGenerator(" << this << ")::DotWrite(" << rFileName << ")");
02286   SetMinStateIndexMap();
02287   StateSet::Iterator lit;
02288   TransSet::Iterator tit;
02289   try {
02290     std::ofstream stream;
02291     stream.exceptions(std::ios::badbit|std::ios::failbit);
02292     stream.open(rFileName.c_str());
02293     stream << "// dot output generated by libFAUDES vGenerator" << std::endl;
02294     stream << "digraph \"" << Name() << "\" {" << std::endl;
02295     stream << "  rankdir=LR" << std::endl;
02296     stream << "  node [shape=circle];" << std::endl;
02297     stream << std::endl;
02298     stream << "  // initial states" << std::endl;
02299     int i = 1;
02300     for (lit = InitStatesBegin(); lit != InitStatesEnd(); ++lit) {
02301       std::string xname= StateName(*lit);
02302       if(xname=="") xname=ToStringInteger(MinStateIndex(*lit));
02303       stream << "  dot_dummyinit_" << i << " [shape=none, label=\"\" ];" << std::endl;
02304       stream << "  dot_dummyinit_" << i << " -> \"" << xname << "\";" << std::endl; 
02305       i++;
02306     }
02307     stream << std::endl;
02308     stream << "  // mstates" << std::endl;
02309     for (lit = MarkedStatesBegin(); lit != MarkedStatesEnd(); ++lit) {
02310       std::string xname= StateName(*lit);
02311       if(xname=="") xname=ToStringInteger(MinStateIndex(*lit));
02312       stream << "  \"" << xname << "\" [shape=doublecircle];" << std::endl;
02313     }
02314     stream << std::endl;
02315     stream << "  // rest of stateset" << std::endl;
02316     for (lit = StatesBegin(); lit != StatesEnd(); ++lit) {
02317       if (! (ExistsInitState(*lit) || ExistsMarkedState(*lit)) ) {
02318   std::string xname= StateName(*lit);
02319   if(xname=="") xname=ToStringInteger(MinStateIndex(*lit));
02320   stream << "  \"" << xname << "\";" << std::endl;
02321       }
02322     }
02323     stream << std::endl;
02324     stream << "  // transition relation" << std::endl;
02325     for(tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
02326       std::string x1name= StateName(tit->X1);
02327       if(x1name=="") x1name=ToStringInteger(MinStateIndex(tit->X1));
02328       std::string x2name= StateName(tit->X2);
02329       if(x2name=="") x2name=ToStringInteger(MinStateIndex(tit->X2));
02330       stream << "  \"" << x1name  << "\" -> \"" << x2name
02331        << "\" [label=\"" << EventName(tit->Ev) << "\"];" << std::endl;
02332     }
02333     stream << "};" << std::endl;
02334     stream.close();
02335   }
02336   catch (std::ios::failure&) {
02337     throw Exception("vGenerator::DotWrite", 
02338         "Exception opening/writing dotfile \""+rFileName+"\"", 2);
02339   }
02340   ClearMinStateIndexMap();
02341 }
02342 
02343 // DDotWrite(rFileName)
02344 void vGenerator::DDotWrite(const std::string& rFileName) const {
02345   FD_DG("vGenerator(" << this << ")::DDotWrite(" << rFileName << ")");
02346   StateSet::Iterator lit;
02347   TransSet::Iterator tit;
02348   try {
02349     std::ofstream stream;
02350     stream.exceptions(std::ios::badbit|std::ios::failbit);
02351     stream.open(rFileName.c_str());
02352     stream << "digraph \"" << Name() << "\" {" << std::endl;
02353     stream << "  rankdir=LR" << std::endl;
02354     stream << "  node [shape=circle];" << std::endl;
02355     stream << std::endl;
02356     stream << "  // istates" << std::endl;
02357     int i = 1;
02358     for (lit = InitStatesBegin(); lit != InitStatesEnd(); ++lit) {
02359       stream << "  dot_dummyinit_" << i << " [shape=none, label=\"\" ];" << std::endl;
02360       stream << "  dot_dummyinit_" << i << " -> \"" 
02361        << SStr(*lit)  << "\";" << std::endl; 
02362       i++;
02363     }
02364     stream << std::endl;
02365     stream << "  // mstates" << std::endl;
02366     for (lit = MarkedStatesBegin(); lit != MarkedStatesEnd(); ++lit) {
02367       stream << "  \"" << SStr(*lit) << "\" [shape=doublecircle];" << std::endl;
02368     }
02369     stream << std::endl;
02370     stream << "  // rest of stateset" << std::endl;
02371     for (lit = StatesBegin(); lit != StatesEnd(); ++lit) {
02372       // if not in mInitStates or mMarkedStates
02373       if (! (ExistsInitState(*lit) || ExistsMarkedState(*lit)) ) {
02374   stream << "  \"" << SStr(*lit) << "\";" << std::endl;
02375       }
02376     }
02377     stream << std::endl;
02378     stream << "  // transition relation" << std::endl;
02379     for (tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
02380       stream << "  \"" << SStr(tit->X1) 
02381        << "\" -> \"" << SStr(tit->X2)
02382        << "\" [label=\"" << EventName(tit->Ev) << "\"];" << std::endl;
02383     }
02384     stream << "};" << std::endl;
02385     stream.close();
02386   }
02387   catch (std::ios::failure&) {
02388     throw Exception("vGenerator::DotWrite", 
02389         "Exception opening/writing dotfile \""+rFileName+"\"", 2);
02390   }
02391 }
02392 
02393 
02394 // XDotWrite(rFileName)
02395 void vGenerator::XDotWrite(const std::string& rFileName) const {
02396   FD_DG("vGenerator(" << this << ")::XDotWrite(" << rFileName << ")");
02397   StateSet::Iterator lit;
02398   TransSet::Iterator tit;
02399   try {
02400     std::ofstream stream;
02401     stream.exceptions(std::ios::badbit|std::ios::failbit);
02402     stream.open(rFileName.c_str());
02403     stream << "digraph \"___" << Name() << "___\" {" << std::endl;
02404     stream << "  rankdir=LR" << std::endl;
02405     stream << "  node [shape=circle];" << std::endl;
02406     stream << std::endl;
02407     stream << "  // stateset" << std::endl;
02408     for (lit = StatesBegin(); lit != StatesEnd(); ++lit) {
02409       stream << "  \"s" << *lit << "\";" << std::endl;
02410     }
02411     stream << std::endl;
02412     stream << "  // transition relation" << std::endl;
02413     for (tit = TransRelBegin(); tit != TransRelEnd(); ++tit) {
02414       stream << "  \"s" << tit->X1 
02415        << "\" -> \"s" << tit->X2
02416        << "\" [label=\"e" << tit->Ev << "\" " << "polyline" << "];" << std::endl;
02417     }
02418     stream << "};" << std::endl;
02419     stream.close();
02420   }
02421   catch (std::ios::failure&) {
02422     throw Exception("vGenerator::XDotWrite", 
02423         "Exception opening/writing dotfile \""+rFileName+"\"", 2);
02424   }
02425 }
02426 
02427 // DoRead(tr)
02428 void vGenerator::DoRead(TokenReader& rTr,  const std::string& rLabel, const Type* pContext) {
02429   (void) pContext;
02430   std::string label=rLabel;
02431   if(label=="") label="Generator"; 
02432   FD_DG("vGenerator(" << this << ")::DoRead(): file " << rTr.FileName() << "  section " << label);
02433   // Clear old stuff
02434   Clear();
02435   // find Genertor in any of our current file formats
02436   rTr.SeekBegin(label);
02437   // get the Generator "name" token
02438   ReadGeneratorName(rTr);
02439   // read mAlphabet
02440   ReadAlphabet(rTr);
02441   // read stateset
02442   ReadStates(rTr);
02443   // read transrel
02444   ReadTransRel(rTr);
02445   // read istates
02446   ReadStateSet(rTr, "InitStates", mInitStates);
02447   // read mstates
02448   ReadStateSet(rTr, "MarkedStates", mMarkedStates);
02449   // read attribute
02450   mpGlobalAttribute->Read(rTr);
02451   // skip unknown global attributes
02452   AttributeVoid::Skip(rTr);
02453   // read end 
02454   rTr.SeekEnd(label);
02455   FD_DG("vGenerator(" << this << ")::DoRead(): done");
02456 }
02457 
02458 // ReadGeneratorName(rFileName)
02459 void vGenerator::ReadGeneratorName(const std::string& rFileName) {
02460   TokenReader tr(rFileName);
02461   tr.SeekBegin("Generator");  // mimique old behaviour .. use "ReadBegin" instead   
02462   ReadGeneratorName(tr);
02463 }
02464 
02465 // ReadGeneratorName(tr)
02466 void vGenerator::ReadGeneratorName(TokenReader& rTr) {
02467   FD_DG("vGenerator(" << this << ")::ReadGeneratorName(\"" 
02468   << rTr.FileName() << "\")");
02469    mMyName=rTr.ReadString();
02470 }
02471 
02472 // ReadAlphabet(rFileName)
02473 void vGenerator::ReadAlphabet(const std::string& rFileName) {
02474   FD_DG("vGenerator(" << this << ")::ReadAlphabet(\"" << rFileName << "\")");
02475   mpAlphabet->Read(rFileName,"Alphabet");
02476 }
02477 
02478 // ReadAlphabet(rTr) 
02479 void vGenerator::ReadAlphabet(TokenReader& rTr) {
02480   FD_DG("vGenerator(" << this << ")::ReadAlphabet(\"" 
02481   << rTr.FileName() << "\")");
02482   mpAlphabet->Read(rTr,"Alphabet");
02483 }
02484 
02485 // ReadStates(rFileName) 
02486 void vGenerator::ReadStates(const std::string& rFileName) {
02487   TokenReader tr(rFileName);
02488   ReadStates(tr);
02489 }
02490 
02491 // ReadStates(tr) 
02492 void vGenerator::ReadStates(TokenReader& rTr) {
02493   FD_DG("vGenerator(" << this << ")::ReadStates(\"" << rTr.FileName() << "\")");
02494   // HELPERS:
02495   Token token;
02496   AttributeVoid* attrp = mpStates->Attribute().New();
02497   FD_DG("vGenerator(" << this << ")::ReadStates(..): attribute type " << typeid(*attrp).name());
02498   // ALGORITHM:
02499   mpStates->Clear();
02500   mpStates->Name("States");
02501   mStateSymbolTable.Clear();
02502   rTr.SeekBegin("States");  
02503   while(rTr.Peek(token)) {
02504     // break end of section
02505     if (token.Type() == Token::End) {
02506       break;
02507     }
02508     // read state by index
02509     if (token.Type() == Token::Integer) {
02510       rTr.Get(token);
02511       Idx index = token.IntegerValue();
02512       FD_DG("vGenerator(" << this << ")::ReadStates(\"" << rTr.FileName() << "\"): by index " << index);
02513       if(mpStates->Exists(index)) {
02514         delete attrp;
02515   std::stringstream errstr;
02516   errstr << "Token " << token.IntegerValue() << " appears twice in stateset"
02517          << rTr.FileLine();
02518   throw Exception("vGenerator::ReadStates", errstr.str(), 80);
02519       }
02520       // read attribute
02521       attrp->Read(rTr,"",this);
02522       // skip unknown attributes
02523       AttributeVoid::Skip(rTr);
02524       // insert element with attribute
02525       InsState(index); 
02526       StateAttribute(index,*attrp);
02527       continue;
02528     } 
02529     // read state by name
02530     if (token.Type() == Token::String) {
02531       rTr.Get(token);
02532       FD_DG("vGenerator(" << this << ")::ReadStates(\"" << rTr.FileName() << "\"): by name " << token.StringValue());
02533       if(ExistsState(token.StringValue())) {
02534         delete attrp;
02535   std::stringstream errstr;
02536   errstr << "Token " << token.StringValue() << " appears twice in stateset"
02537          << rTr.FileLine();
02538   throw Exception("vGenerator::ReadStates", errstr.str(), 80);
02539       }
02540       // read attribute
02541       attrp->Read(rTr,"",this);
02542       // skip unknown attributes
02543       AttributeVoid::Skip(rTr);
02544       // insert element with attribute
02545       Idx index=InsState(token.StringValue()); 
02546       StateAttribute(index,*attrp);
02547       continue;
02548     } 
02549     // read consecutive block of anonymous states
02550     if (token.Type() == Token::Begin && token.StringValue() == "Consecutive") {
02551       rTr.ReadBegin("Consecutive");
02552       Token token1,token2;
02553       rTr.Get(token1);
02554       rTr.Get(token2);
02555       FD_DG("vGenerator(" << this << ")::ReadStates(\"" << rTr.FileName() << "\"): consecutive range");
02556       if ((token1.Type() != Token::Integer) || (token2.Type() != Token::Integer)) {
02557         delete attrp;
02558   std::stringstream errstr;
02559   errstr << "Invalid range of consecutive states"  << rTr.FileLine();
02560   throw Exception("vGenerator::ReadStates", errstr.str(), 80);
02561       }
02562       for(Idx index = (Idx) token1.IntegerValue(); index <= (Idx) token2.IntegerValue(); ++index) {
02563   if(mpStates->Exists(index)) {
02564           delete attrp;
02565     std::stringstream errstr;
02566     errstr << "Index " << index << " appears twice in stateset"
02567      << rTr.FileLine();
02568     throw Exception("vGenerator::ReadStates", errstr.str(), 80);
02569   }
02570   InsState(index);
02571       }
02572       rTr.ReadEnd("Consecutive");
02573       continue;
02574     }
02575     // cannot process token
02576     delete attrp;
02577     std::stringstream errstr;
02578     errstr << "Invalid token" << rTr.FileLine();
02579     throw Exception("vGenerator::ReadStates", errstr.str(), 80);
02580   }
02581   rTr.SeekEnd("States");
02582   // dispose attribute
02583   delete attrp;
02584   FD_DG("vGenerator(" << this << ")::ReadStates(\"" << rTr.FileName() << "\"): done");
02585 }
02586 
02587 
02588 // ReadStateSet(tr, rLabel, rStateSet) 
02589 void vGenerator::ReadStateSet(TokenReader& rTr, const std::string& rLabel, StateSet& rStateSet)  const {
02590   FD_DG("vGenerator(" << this << ")::ReadStateSet(\"" << rLabel<< "\")");
02591   // HELPERS:
02592   Token token;
02593   AttributeVoid* attrp = rStateSet.Attribute().New();
02594   FD_DG("vGenerator(" << this << ")::ReadStateSet(..): attribute type " << typeid(*attrp).name());
02595   // ALGORITHM:
02596   rStateSet.Clear();
02597   rTr.SeekBegin(rLabel);  
02598   rStateSet.Name(rLabel);
02599   while(rTr.Peek(token)) {
02600     // break end of section
02601     if (token.Type() == Token::End) {
02602       break;
02603     }
02604     // read state by index
02605     if (token.Type() == Token::Integer) {
02606       rTr.Get(token);
02607       Idx index = token.IntegerValue();
02608       if(!ExistsState(index)) {
02609         delete attrp;
02610   std::stringstream errstr;
02611   errstr << "Token " << token.IntegerValue() << " not in stateset"
02612          << rTr.FileLine();
02613   throw Exception("vGenerator::ReadStateSet", errstr.str(), 80);
02614       }
02615       // read attribute
02616       attrp->Read(rTr,"",this);
02617       // skip unknown attributes
02618       AttributeVoid::Skip(rTr);
02619       // insert element with attribute
02620       rStateSet.Insert(index); 
02621       rStateSet.Attribute(index,*attrp);
02622       continue;
02623     } 
02624     // read state by name
02625     if (token.Type() == Token::String) {
02626       rTr.Get(token);
02627       Idx index =StateIndex(token.StringValue());
02628       if(index==0) {
02629         delete attrp;
02630   std::stringstream errstr;
02631   errstr << "Token " << token.StringValue() << " not in stateset"
02632          << rTr.FileLine();
02633   throw Exception("vGenerator::ReadStateSet", errstr.str(), 80);
02634       }
02635       // read attribute
02636       attrp->Read(rTr,"",this);
02637       // skip unknown attributes
02638       AttributeVoid::Skip(rTr);
02639       // insert element with attribute
02640       rStateSet.Insert(index); 
02641       rStateSet.Attribute(index,*attrp);
02642       continue;
02643     } 
02644     // read consecutve block of anonymous states
02645     if (token.Type() == Token::Begin && token.StringValue() == "Consecutive") {
02646       rTr.ReadBegin("Consecutive");
02647       Token token1,token2;
02648       rTr.Get(token1);
02649       rTr.Get(token2);
02650       if ((token1.Type() != Token::Integer) || (token2.Type() != Token::Integer)) {
02651         delete attrp;
02652   std::stringstream errstr;
02653   errstr << "Invalid range of consecutive states"  << rTr.FileLine();
02654   throw Exception("vGenerator::ReadStateSet", errstr.str(), 80);
02655       }
02656       for(Idx index = (Idx) token1.IntegerValue(); index <= (Idx) token2.IntegerValue(); ++index) {
02657   if(!ExistsState(index)) {
02658     std::stringstream errstr;
02659     errstr << "Token " << token.IntegerValue() << " not in stateset"
02660      << rTr.FileLine();
02661     throw Exception("vGenerator::ReadStateSet", errstr.str(), 80);
02662   }
02663   rStateSet.Insert(index);
02664       }
02665       rTr.ReadEnd("Consecutive");
02666       continue;
02667     }
02668     // cannot process token
02669     delete attrp;
02670     std::stringstream errstr;
02671     errstr << "Invalid token" << rTr.FileLine();
02672     throw Exception("vGenerator::ReadStateSet", errstr.str(), 50);
02673   }
02674   rTr.SeekEnd(rLabel);
02675   // dispose attribute
02676   delete attrp;
02677 }
02678 
02679 // ReadTransRel(rFileName)
02680 void vGenerator::ReadTransRel(const std::string& rFileName) {
02681   TokenReader tr(rFileName);
02682   ReadTransRel(tr);
02683 }
02684 
02685 // ReadTransRel(tr) 
02686 void vGenerator::ReadTransRel(TokenReader& rTr) {
02687   FD_DG("vGenerator(" << this << ")::ReadTransRel(\"" << rTr.FileName() << "\")");
02688   AttributeVoid* attrp = mpTransRel->Attribute().New();
02689   FD_DG("vGenerator(" << this << ")::ReadTransRel(..): attribute type " << typeid(*attrp).name());
02690   try {
02691     Token token;
02692     Idx x1 = 0, ev = 0, x2 = 0;
02693     rTr.SeekBegin("TransRel");
02694     // Read tokens
02695     while (rTr.Peek(token)) {
02696       // 0: end of transition relation
02697       if ((token.Type() == Token::End)) break;
02698 
02699       // 1: the x1 token
02700       rTr >> token;
02701       if (token.Type() == Token::Integer) {
02702   x1=token.IntegerValue();
02703       } else if (token.Type() == Token::String) {
02704   token.StringValue();
02705   x1=StateIndex(token.StringValue());
02706       } else break;
02707 
02708       // 2: the event token
02709       rTr >> token;
02710       if (token.Type() == Token::Integer) {
02711   ev=token.IntegerValue();
02712       } else if (token.Type() == Token::String) {
02713   token.StringValue();
02714   ev=EventIndex(token.StringValue());
02715       } else break;
02716 
02717       // 3: the x1 token
02718       rTr >> token;
02719       if (token.Type() == Token::Integer) {
02720   x2=token.IntegerValue();
02721       } else if (token.Type() == Token::String) {
02722   token.StringValue();
02723   x2=StateIndex(token.StringValue());
02724       } else break;
02725 
02726       // 4: attributes
02727       attrp->Read(rTr,"",this);
02728 
02729       // 5: skip unknown attributes
02730       AttributeVoid::Skip(rTr);
02731 
02732       // check values
02733       if( (!ExistsState(x1)) || (!ExistsState(x2)) ){
02734   std::stringstream errstr;
02735   errstr << "invalid state" << rTr.FileLine();
02736   throw Exception("vGenerator::ReadTransRel", errstr.str(), 85);
02737       } 
02738       if(!ExistsEvent(ev)) {
02739   std::stringstream errstr;
02740   errstr << "invalid event" << rTr.FileLine();
02741   throw Exception("vGenerator::ReadTransRel", errstr.str(), 85);
02742       } 
02743 
02744       // insert transition
02745       Transition trans=Transition(x1,ev,x2);
02746       SetTransition(trans);
02747       TransAttribute(trans,*attrp);
02748 
02749     } // end while
02750     rTr.SeekEnd("TransRel");   
02751   }
02752   catch (faudes::Exception&) {
02753     delete attrp;
02754     std::stringstream errstr;
02755     errstr << "Reading TransRel failed in " << rTr.FileLine();
02756     throw Exception("vGenerator::ReadTransRel", errstr.str(), 50); 
02757   }
02758   FD_DG("vGenerator(" << this << ")::ReadTransRel(\"" << rTr.FileName() << "\"): sone");
02759   // dispose attribute
02760   delete attrp;
02761 }
02762 
02763 
02764 // EStr(index)
02765 std::string vGenerator::EStr(Idx index) const {
02766   return EventName(index);
02767 }
02768 
02769 // SStr(index)
02770 std::string vGenerator::SStr(Idx index) const {
02771   std::string name = StateName(index);
02772   if(name == "") name=ToStringInteger(index);
02773   return name+"["+faudes::ToStringInteger(index)+"]";
02774 }
02775 
02776 // TStr(index)
02777 std::string vGenerator::TStr(const Transition& trans) const {
02778   return SStr(trans.X1) + "--(" + EStr(trans.Ev) + ")-->" + SStr(trans.X2);
02779 }
02780 
02781 
02782 // GraphWrite(rFileName,rOutFormat)
02783 void vGenerator::GraphWrite(const std::string& rFileName, const std::string& rOutFormat,
02784    const std::string& rDotExec) const {
02785   FD_DG("vGenerator::GraphWrite(...): " << typeid(*this).name());
02786   // generate temp dot ibput file
02787   std::string dotin = CreateTempFile();
02788   if(dotin == "") {
02789     std::stringstream errstr;
02790     errstr << "Exception opening temp file";
02791     throw Exception("vGenerator::GraphWrite", errstr.str(), 2);
02792   }
02793   try{
02794     DotWrite(dotin);
02795   } 
02796   catch (faudes::Exception& exception) {  
02797     RemoveFile(dotin);
02798     std::stringstream errstr;
02799     errstr << "Exception writing dot input file";
02800     throw Exception("vGenerator::GraphWrite", errstr.str(), 2);
02801   }
02802   try{
02803     faudes::ProcessDot(dotin,rFileName,rOutFormat,rDotExec);
02804   } 
02805   catch (faudes::Exception& exception) {  
02806     RemoveFile(dotin);
02807     std::stringstream errstr;
02808     errstr << "Exception processing dot file";
02809     throw Exception("vGenerator::GraphWrite", errstr.str(), 3);
02810   }
02811   RemoveFile(dotin);
02812 }
02813 
02814 // rti wrapper
02815 void IsAccessible(const vGenerator& rGen, bool& rRes) {
02816   rRes=rGen.IsAccessible();
02817 }
02818 
02819 // rti wrapper
02820 void IsCoaccessible(const vGenerator& rGen, bool& rRes) {
02821   rRes=rGen.IsCoaccessible();
02822 }
02823 
02824 // rti wrapper
02825 void IsTrim(const vGenerator& rGen, bool& rRes) {
02826   rRes=rGen.IsTrim();
02827 }
02828 
02829 // rti wrapper
02830 void IsComplete(const vGenerator& rGen, bool& rRes) {
02831   rRes=rGen.IsComplete();
02832 }
02833 
02834 // rti wrapper
02835 void IsComplete(const vGenerator& rGen, const StateSet& rStateSet, bool& rRes) {
02836   rRes=rGen.IsComplete(rStateSet);
02837 }
02838 
02839 // rti wrapper
02840 void IsDeterministic(const vGenerator& rGen, bool& rRes) {
02841   rRes=rGen.IsDeterministic();
02842 }
02843 
02844 
02845 // rti wrapper
02846 void Accessible(vGenerator& rGen) {
02847   rGen.Accessible();
02848 }
02849 
02850 // rti wrapper
02851 void Accessible(const vGenerator& rGen, vGenerator& rRes) {
02852   rRes=rGen;
02853   rRes.Accessible();
02854 }  
02855 
02856 // rti wrapper
02857 void Coaccessible(vGenerator& rGen) {
02858   rGen.Coaccessible();
02859 }
02860 
02861 // rti wrapper
02862 void Coaccessible(const vGenerator& rGen, vGenerator& rRes) {
02863   rRes=rGen;
02864   rRes.Coaccessible();
02865 }  
02866 
02867 // rti wrapper
02868 void Trim(vGenerator& rGen) {
02869   rGen.Trim();
02870 }
02871 
02872 // rti wrapper
02873 void Trim(const vGenerator& rGen, vGenerator& rRes) {
02874   rRes=rGen;
02875   rRes.Trim();
02876 }  
02877 
02878 // rti wrapper
02879 void MarkAllStates(vGenerator& rGen) {
02880   rGen.InjectMarkedStates(rGen.States());
02881 }
02882 
02883 } // name space
02884 
02885 

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