| |
libFAUDES
Sections
Index
|
vgenerator.cppGo 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