sp_simconditionset.cpp

Go to the documentation of this file.
00001 
00004 /* 
00005    Copyright (C) 2008  Thomas Moor
00006    Exclusive copyright is granted to Klaus Schmidt
00007 */
00008 
00009 #include "sp_simconditionset.h"
00010 #include "sp_lpexecutor.h"
00011 
00012 namespace faudes {
00013 
00014 /*
00015 ************************************************
00016 ************************************************
00017 ************************************************
00018 
00019 implementation of attributes
00020 
00021 ************************************************
00022 ************************************************
00023 ************************************************
00024 */
00025 
00026 
00027 
00028 //DoWrite(rTw);
00029 void SimConditionAttribute::DoWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const {
00030   (void) rLabel;
00031   Token token;
00032 
00033   // report context
00034   FD_DC("SimConditionAttribute::DoRead(rTr," << rLabel <<", " << pContext << "): cast " <<
00035      dynamic_cast<const ParallelExecutor*>(pContext));
00036 
00037   // write event condition
00038   if(mEventCondition) {
00039     rTw.WriteBegin("EventCondition");
00040     if(mEnabled) rTw.WriteOption("Enabled");
00041     if(mBreakCondition) rTw.WriteOption("Break");
00042     mEventConditionAttribute.mStart.Write(rTw,"StartEvents");
00043     mEventConditionAttribute.mStop.Write(rTw,"StopEvents");
00044     rTw.WriteEnd("EventCondition");
00045   }
00046 
00047   // write state condition
00048   if(mStateCondition) {
00049     rTw.WriteBegin("StateCondition");
00050     if(mEnabled) rTw.WriteOption("Enabled");
00051     if(mBreakCondition) rTw.WriteOption("Break");
00052     if(mStateConditionAttribute.mAllFlag) rTw.WriteOption("Conjunction");
00053     if(!mStateConditionAttribute.mAllFlag) rTw.WriteOption("Disjunction");
00054     // get context
00055     const ParallelExecutor* executor= dynamic_cast<const ParallelExecutor*>(pContext);
00056     Idx n=mStateConditionAttribute.mStateSets.size();
00057     // test context
00058     if(executor)
00059       if(executor->Size()!=n) {
00060         std::stringstream errstr;
00061         errstr << "Invalid ParalleExecutor context (dimension mismatch)";
00062         throw Exception("SimConditionAttribute::DoWrite", errstr.str(), 501);
00063       }
00064     // write the sets
00065     for(Idx i=0; i<n; i++) {
00066       const StateSet& set=mStateConditionAttribute.mStateSets.at(i);
00067       if(executor) executor->At(i).Generator().WriteStateSet(rTw,set);
00068       else set.Write(rTw,"StateSet");
00069     }
00070     rTw.WriteEnd("StateCondition");
00071   }
00072 }
00073 
00074 //DoRead(rTr)
00075 void SimConditionAttribute::DoRead(TokenReader& rTr, const std::string& rLabel, const Type* pContext) {
00076   (void) rLabel;
00077   bool err;
00078   Token token;
00079 
00080   // report context
00081   FD_DC("SimConditionAttribute::DoRead(rTr," << rLabel <<", " << pContext << "): cast " <<
00082      dynamic_cast<const ParallelExecutor*>(pContext));
00083 
00084   // clear myself
00085   err=false;
00086   mEventCondition=false;
00087   mStateCondition=false;
00088   mEnabled=true;
00089   mBreakCondition=false;
00090   mEventConditionAttribute.mStart.Clear();
00091   mEventConditionAttribute.mStop.Clear();
00092   mStateConditionAttribute.mStateSets.clear();
00093   mStateConditionAttribute.mAllFlag=false;
00094 
00095   // switch by toke
00096   rTr.Peek(token);
00097 
00098   // read event condition
00099   if(token.Type()==Token::Begin && token.StringValue()=="EventCondition") {
00100     rTr.ReadBegin("EventCondition");
00101     mEventCondition=true;
00102     while(!rTr.Eos("EventCondition")) {
00103       rTr.Peek(token);
00104       if((token.Type()==Token::Option) && (token.StringValue()=="Enabled")) {
00105   mEnabled=true;
00106   rTr.Get(token);
00107         continue;
00108       }
00109       if((token.Type()==Token::Option) && (token.StringValue()=="Break")) {
00110   mBreakCondition=true;
00111   rTr.Get(token);
00112         continue;
00113       }
00114       if((token.Type()==Token::Begin) && (token.StringValue()=="StartEvents")) {
00115         mEventConditionAttribute.mStart.Read(rTr,"StartEvents");
00116         continue;
00117       }
00118       if((token.Type()==Token::Begin) && (token.StringValue()=="StopEvents")) {
00119         mEventConditionAttribute.mStop.Read(rTr,"StopEvents");
00120         continue;
00121       }
00122       // ignore errors
00123       rTr.Get(token);
00124     }
00125     rTr.ReadEnd("EventCondition");
00126   }
00127 
00128   // read state condition
00129   if(token.Type()==Token::Begin && token.StringValue()=="StateCondition") {
00130     rTr.ReadBegin("StateCondition");
00131     mStateCondition=true;
00132     while(!rTr.Eos("StateCondition")) {
00133       rTr.Peek(token);
00134       if((token.Type()==Token::Option) && (token.StringValue()=="Enabled")) {
00135   mEnabled=true;
00136   rTr.Get(token);
00137         continue;
00138       }
00139       if((token.Type()==Token::Option) && (token.StringValue()=="Break")) {
00140   mBreakCondition=true;
00141   rTr.Get(token);
00142         continue;
00143       }
00144       if((token.Type()==Token::Option) && (token.StringValue()=="Conjunction")) {
00145   mStateConditionAttribute.mAllFlag=true;
00146   rTr.Get(token);
00147         continue;
00148       }
00149       if((token.Type()==Token::Begin) && (token.StringValue()=="StateSet")) {
00150         // get context
00151         const ParallelExecutor* executor= dynamic_cast<const ParallelExecutor*>(pContext);
00152         Idx i=mStateConditionAttribute.mStateSets.size();
00153         // test context
00154         if(executor)
00155           if(executor->Size()<=i) {
00156             std::stringstream errstr;
00157             errstr << "Invalid ParalleExecutor context (dimension mismatch)";
00158             throw Exception("SimConditionAttribute::DoRead", errstr.str(), 501);
00159           }
00160         // read the set
00161         StateSet set;
00162         if(executor) executor->At(i).Generator().ReadStateSet(rTr,"StateSet",set);
00163         else set.Read(rTr,"StateSet");
00164         set.Name("StateSet");
00165         mStateConditionAttribute.mStateSets.push_back(set);
00166         continue;
00167       }
00168       // ignore errors
00169       rTr.Get(token);
00170     }
00171     rTr.ReadEnd("StateCondition");
00172   }
00173   // report error
00174   if(err) {
00175     std::stringstream errstr;
00176     errstr << "invalid simulation condition" << rTr.FileLine();
00177     throw Exception("SimConditionAttribute::Read", errstr.str(), 52);
00178   }
00179 }
00180 
00181 // condition state: sample
00182 void SimConditionAttribute::Satisfied(bool on, tpTime::Type now) {
00183   if(on==mSatisfied) return;
00184   mSatisfied=on;
00185   // newly activated
00186   if(mSatisfied) {
00187     if(mActivationTime>0) mSamplesPeriod.Sample(now-mActivationTime); 
00188     mActivationTime=now;
00189   }
00190   // newly deactivated
00191   if(!mSatisfied) {
00192     mSamplesDuration.Sample(now-mActivationTime); 
00193   }
00194 }
00195 
00196 
00197 /*
00198 ************************************************
00199 ************************************************
00200 ************************************************
00201 
00202 implementation of condition set
00203 
00204 ************************************************
00205 ************************************************
00206 ************************************************
00207 */
00208 
00209 // get enabled set
00210 SimConditionSet SimConditionSet::EnabledConditions(void) {
00211   SimConditionSet result;
00212   for(Iterator cit=Begin(); cit != End(); ++cit) 
00213     if(Enabled(*cit)) result.Insert(*cit,Attribute(*cit));
00214   return result;
00215 }
00216 
00217 // condition state: reset alls
00218 void SimConditionSet::Reset(void) {
00219   for(Iterator cit=Begin(); cit != End(); ++cit) {
00220     SimConditionAttribute* pattr=Attributep(*cit);
00221     pattr->Reset();
00222     pattr->mSamplesPeriod.Name(SymbolicName(*cit)+" - Period");
00223     pattr->mSamplesDuration.Name(SymbolicName(*cit)+" - Duration");
00224   }
00225 }
00226 
00227 
00228 
00229 } // namespace faudes
00230 

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