hio_constraint.cpp

Go to the documentation of this file.
00001 /** @file hio_constraint.cpp Generator with I/O-constraint attributes */
00002 
00003 /* Hierarchical IO Systems Plug-In for FAU Discrete Event Systems Library (libfaudes)
00004 
00005    Copyright (C) 2006  Sebastian Perk 
00006    Copyright (C) 2006  Thomas Moor 
00007    Copyright (C) 2006  Klaus Schmidt
00008 
00009 */
00010      
00011 #include "hio_constraint.h"
00012 
00013 namespace faudes {
00014 
00015 // IsHioConstraintForm()
00016 bool IsHioConstraintForm(HioConstraint& rHioConstraint,
00017             StateSet& rQY,
00018             StateSet& rQU,
00019             EventSet& rErrEvSet,
00020             TransSet& rErrTrSet,
00021             StateSet& rErrStSet,
00022             std::string& rReportStr)
00023     {
00024     FD_DF("IsHioConstraintForm("<< rHioConstraint.Name() << ",...)");
00025     
00026     // prepare results
00027     rQY.Clear();
00028     rQU.Clear();
00029     
00030     rErrEvSet.Clear();
00031     rErrEvSet.Name("rErrEvSet");
00032     
00033     rErrTrSet.Clear();
00034     rErrTrSet.Name("rErrTrSet");
00035     
00036     rErrStSet.Clear();
00037     rErrStSet.Name("rErrStSet");
00038   
00039   // used to locally store error states/transitions on each condition
00040   StateSet locErrStSet;
00041   TransSet locErrTrSet;
00042     
00043     rReportStr.clear();
00044     
00045     // meant to be set false on violation of any condition:
00046     bool finalResult = true;
00047     // used to locally store result on each condition
00048     bool localResult = true;
00049     
00050     // helpers
00051     
00052     EventSet y = rHioConstraint.YEvents();
00053     EventSet u = rHioConstraint.UEvents();
00054     
00055     StateSet initStates = rHioConstraint.InitStates();
00056     StateSet accessibleStates = rHioConstraint.AccessibleSet();
00057     StateSet deadEnds;
00058 
00059     EventSet::Iterator evit;
00060     StateSet::Iterator sit;
00061     TransSet::Iterator tit;
00062     
00063     // Info string header
00064     rReportStr.append("#########################################################\n");
00065     rReportStr.append("########## IsHioConstraintForm("+rHioConstraint.Name()+",...) - test results:\n");
00066 
00067     /**************************** Precondition: determinism ***********************/
00068     // HioConstraint must be deterministic
00069     if(!rHioConstraint.IsDeterministic()){
00070         rReportStr.append("##### fail: generator is not deterministic!\n");
00071         if(initStates.Size()>1) {
00072        rErrStSet = initStates;
00073        rReportStr.append("##### (amongst others, there is more than one initial state)\n");
00074       }
00075         finalResult = false;
00076     }
00077 
00078     rReportStr.append("#####\n");
00079     
00080     // test all conditions verifying I/O-constraint form:
00081     
00082     /**************************** Condition (i) ***********************/
00083     localResult = true;
00084     rReportStr.append("########## Condition (i):\n");
00085     
00086     //YP, UP, YE, UE nonempty?
00087     if (y.Empty()) {
00088        rReportStr.append("##### fail: empty Y alphabet.\n");
00089        localResult=false;
00090        finalResult = false;
00091     }
00092     if (u.Empty()) {
00093        rReportStr.append("##### fail: empty U alphabet.\n");
00094        localResult=false;
00095        finalResult = false;
00096     }
00097     
00098     // check for disjoint eventsets Y and U and for 
00099     // Y u U == Sigma, ie unique HioEventFlags.
00100     // note: by construction, any event has the exclusive property U or Y.
00101   //      thus, condition (i) is always met at this point.
00102         
00103     rReportStr.append("##### Condition (i) passed.\n");
00104     rReportStr.append("#####\n");
00105     /*************************** Condition (i) finished *****************************/
00106     
00107     
00108     /*************************** Condition (ii) ***********************/ 
00109     localResult = true;
00110     rReportStr.append("########## Condition (ii):\n");
00111     
00112     // check if in states QYpYe, QUp and QUe only Y-, UP- and UE-events are active, respectively.
00113     for(sit = accessibleStates.Begin(); sit != accessibleStates.End(); ++sit) {
00114          
00115             bool isY  = false;
00116             bool isU = false;
00117             bool goodState = true;
00118                
00119             EventSet activeEv = rHioConstraint.ActiveEventSet(*sit);
00120             
00121             if(activeEv.Empty()) {
00122                 //dead ends violate condition (vii)
00123                 deadEnds.Insert(*sit);
00124             }
00125             else {
00126                 
00127                 // get attribute of first event and compare with remaining events
00128                 evit = activeEv.Begin();
00129                 isY  = rHioConstraint.IsY(*evit);
00130                 isU  = rHioConstraint.IsU(*evit);
00131                 
00132                 for(; evit != activeEv.End(); evit++) {
00133                     if( (isY &&  !rHioConstraint.IsY(*evit)) || 
00134                         (isU && !rHioConstraint.IsU(*evit))) {
00135                         goodState = false;
00136                         localResult = false;
00137                         finalResult = false;
00138                         // add state to error set, go to next state
00139                         locErrStSet.Insert(*sit);
00140                         rErrStSet.Insert(*sit);
00141                         break; // leave loop over active events
00142                     }
00143                 }
00144                 
00145                 activeEv.Clear();
00146                 
00147                 if(!goodState) continue; // if undecidable go on with next state
00148                 
00149                 // set state attribute
00150                 if(isY) {
00151                    rQY.Insert(*sit);
00152                    rHioConstraint.SetQY(*sit);
00153                 }
00154                 else if(isU) {
00155                    rQU.Insert(*sit);
00156                    rHioConstraint.SetQU(*sit);
00157                 }
00158             }
00159         }
00160             
00161     if(localResult) rReportStr.append("##### Condition (ii) passed.\n");
00162      // In case of failing condition (ii) further inspection is omitted, as too many consecutive faults are expected.
00163     else {
00164         rReportStr.append("##### fail: found states with undecidable attribute:\n");
00165         rReportStr.append(locErrStSet.ToString()+"\n");
00166     locErrStSet.Clear();
00167         rReportStr.append("##### Condition (ii) failed.\n");
00168         rReportStr.append("########## Termination due to crucial failure. ##########\n");
00169         rReportStr.append("###################### No success. ######################\n");
00170         rReportStr.append("#########################################################\n");
00171         return false;
00172     }
00173     rReportStr.append("#####\n");
00174     /*************************** Condition (ii) finished ****************************/  
00175     
00176     
00177     /*************************** Condition (iii) **********************/
00178     localResult = true;
00179     rReportStr.append("########## Condition (iii):\n");
00180     
00181     //check if the initial state is a QY-state
00182     if(!(initStates <= rQY)) {
00183         rReportStr.append("##### fail: some init state(s) is (are) not a QY-state:\n");
00184     locErrStSet=initStates-rQY;
00185     rReportStr.append(locErrStSet.ToString()+"\n");
00186         rErrStSet.SetUnion(locErrStSet);
00187     locErrStSet.Clear();
00188         localResult = false;
00189         finalResult = false;
00190     }
00191     if(localResult) rReportStr.append("##### Condition (iii) passed.\n");
00192     else rReportStr.append("##### Condition (iii) failed.\n");
00193     rReportStr.append("#####\n");
00194     
00195     /*************************** Condition (iii) finished ***************************/
00196     
00197     
00198     /*************************** Condition (iv) ***********************/
00199     localResult = true; 
00200     rReportStr.append("########## Condition (iv):\n");
00201     
00202     // Y-events have to lead to a QU-state
00203     for(sit = rQY.Begin(); sit != rQY.End(); ++sit) {
00204         for(tit = rHioConstraint.TransRelBegin(*sit); tit != rHioConstraint.TransRelEnd(*sit); ++tit) {
00205             // Y-event to QU-state
00206             if( (rHioConstraint.IsY(tit->Ev) && !rQU.Exists(tit->X2)) ) {
00207                 // add transition to error transition set
00208                 locErrTrSet.Insert(*tit);
00209                 rErrTrSet.Insert(*tit);
00210                 finalResult = false;
00211                 localResult = false;
00212             }
00213         }
00214     }
00215     
00216     if(localResult) rReportStr.append("##### Condition (iv) passed.\n");
00217     else {
00218         rReportStr.append("##### fail: found Y-transitions leading to wrong states:\n");
00219         rReportStr.append(locErrTrSet.ToString()+"\n");
00220     locErrTrSet.Clear();
00221         rReportStr.append("##### Condition (iv) failed.\n");
00222     }
00223     rReportStr.append("#####\n");
00224     /*************************** Condition (iv) finished ****************************/
00225     
00226     
00227     /*************************** Condition (v) ************************/
00228     localResult = true;
00229     rReportStr.append("########## Condition (v):\n");
00230     
00231     // U-events have to lead to a QY-state
00232     for(sit = rQU.Begin(); sit != rQU.End(); ++sit) {
00233         for(tit = rHioConstraint.TransRelBegin(*sit); tit != rHioConstraint.TransRelEnd(*sit); ++tit) {
00234             if(!rQY.Exists(tit->X2)) {
00235                 locErrTrSet.Insert(*tit);
00236                 rErrTrSet.Insert(*tit);
00237                 finalResult = false;
00238                 localResult = false;
00239             } 
00240         }
00241     }
00242     
00243     if(localResult) rReportStr.append("##### Condition (v) passed.\n");
00244     else {
00245         rReportStr.append("##### fail: found U-transitions leading to wrong states:\n");
00246         rReportStr.append(locErrTrSet.ToString()+"\n");
00247     locErrTrSet.Clear();
00248         rReportStr.append("##### Condition (v) failed.\n");
00249     }
00250     rReportStr.append("#####\n");
00251     /*************************** Condition (v) finished *****************************/
00252     
00253     
00254     /*************************** Condition (vi) **********************/    
00255     localResult = true;
00256     rReportStr.append("########## Condition (vi):\n");
00257     
00258     // Y must be free in QY-states
00259     for(sit = rQY.Begin(); sit != rQY.End(); ++sit) {
00260         
00261         if(!(y <= rHioConstraint.ActiveEventSet(*sit))) {
00262                locErrStSet.Insert(*sit);
00263                rErrStSet.Insert(*sit);
00264                finalResult = false;
00265                localResult = false;
00266         }
00267     }
00268     
00269     if(localResult) rReportStr.append("##### Condition (vi) passed.\n");
00270     else {
00271         rReportStr.append("##### fail: found QY-states with inactive Y-events:\n");
00272         rReportStr.append(locErrStSet.ToString()+"\n");
00273     locErrStSet.Clear();
00274         rReportStr.append("##### Condition (vi) failed.\n");
00275     }
00276     rReportStr.append("#####\n");
00277     /*************************** Condition (vi) finished ***************************/
00278     
00279     
00280     /*************************** Condition (vii) ************************/
00281     localResult = true;
00282     rReportStr.append("########## Condition (vii):\n");
00283     
00284     // found dead ends?
00285     if(!deadEnds.Empty()) {
00286         finalResult = false;
00287         localResult = false;
00288         rErrStSet.SetUnion(deadEnds);
00289         rReportStr.append("##### fail: found dead ends:\n");
00290     rReportStr.append(deadEnds.ToString()+"\n");
00291         deadEnds.Clear();
00292         rReportStr.append("##### Condition (vii) failed.\n");
00293     }
00294     rReportStr.append("##### Condition (vii) passed.\n");
00295     /*************************** Condition (vii) finished *****************************/
00296     
00297     
00298     /*************************** Condition (viii) ***********************/
00299     localResult = true;
00300     rReportStr.append("########## Condition (viii):\n");
00301     
00302     // Qm==Q?
00303     if(!(accessibleStates<=rHioConstraint.MarkedStates())) {
00304         finalResult = false;
00305         localResult = false;
00306     }
00307     
00308     if(localResult) rReportStr.append("##### Condition (viii) passed.\n");
00309     else {
00310         rReportStr.append("##### fail: not all accessible states are marked:\n");
00311         locErrStSet=accessibleStates - rHioConstraint.MarkedStates();
00312     rErrStSet.SetUnion(locErrStSet);
00313         rReportStr.append(locErrStSet.ToString()+"\n");
00314     locErrStSet.Clear();
00315         rReportStr.append("##### Condition (viii) failed.\n");
00316     }
00317     rReportStr.append("#####\n");       
00318     /*************************** Condition (viii) finished ****************************/
00319     
00320     
00321     /*************************** Condition (ix) ************************/
00322     rReportStr.append("########## Condition (ix):\n");
00323     
00324     // make accessible if necessary    
00325     if(!rHioConstraint.IsAccessible()) {
00326         rHioConstraint.Accessible();
00327         rReportStr.append("##### warning: non-accessible states have been removed.\n");
00328     rReportStr.append("##### Condition (ix) repaired.\n");
00329     }
00330     else rReportStr.append("##### Condition (ix) passed.\n");
00331     /*************************** Condition (ix) finished *****************************/
00332     
00333     
00334     
00335     /*************************** Final Result ************************/
00336     
00337     rReportStr.append("##################### Final result: #####################\n");
00338     if(finalResult) {
00339         rReportStr.append("############ Generator is in HioConstraintForm. ###########\n");
00340         rReportStr.append("#########################################################\n");
00341         return true;
00342     }
00343     else {
00344         rReportStr.append("############## Generator is NOT in HioConstraintForm. ##############\n");
00345         rReportStr.append("#########################################################\n");
00346         return false;
00347     }
00348 
00349 }// END OF IsHioConstraintForm()
00350     
00351 //IsHioConstraintForm wrapper functions
00352 bool IsHioConstraintForm(HioConstraint& rHioConstraint, std::string& rReportStr)
00353 {
00354      StateSet rQY, rQU;
00355      EventSet rErrEvSet;
00356      TransSet rErrTrSet;
00357      StateSet rErrStSet;
00358     
00359     return IsHioConstraintForm(rHioConstraint, rQY, rQU, rErrEvSet, rErrTrSet, rErrStSet,rReportStr);
00360 }
00361     
00362 bool IsHioConstraintForm(HioConstraint& rHioConstraint)
00363 {
00364      StateSet rQY, rQU;
00365      EventSet rErrEvSet;
00366      TransSet rErrTrSet;
00367      StateSet rErrStSet;
00368      std::string rReportStr;
00369      
00370      return IsHioConstraintForm(rHioConstraint, rQY, rQU, rErrEvSet, rErrTrSet, rErrStSet, rReportStr);
00371 }
00372 
00373 // rti function interface
00374 void HioStatePartition(HioConstraint& rHioConstraint) {
00375  IsHioConstraintForm(rHioConstraint);
00376 }
00377 
00378 
00379 
00380 } // end namespace

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen