cfl_functions.cppGo to the documentation of this file.00001 /** @file cfl_functions.cpp Runtime interface, operations on faudes types */ 00002 00003 /* FAU Discrete Event Systems Library (libfaudes) 00004 00005 Copyright (C) 2009 Ruediger Berndt 00006 Copyright (C) 2009 Thomas Moor 00007 00008 This library is free software; you can redistribute it and/or 00009 modify it under the terms of the GNU Lesser General Public 00010 License as published by the Free Software Foundation; either 00011 version 2.1 of the License, or (at your option) any later version. 00012 00013 This library is distributed in the hope that it will be useful, 00014 but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00016 Lesser General Public License for more details. 00017 00018 You should have received a copy of the GNU Lesser General Public 00019 License along with this library; if not, write to the Free Software 00020 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ 00021 00022 00023 #include "cfl_functions.h" 00024 #include "cfl_registry.h" 00025 00026 00027 namespace faudes{ 00028 00029 /* 00030 ******************************************************************** 00031 ******************************************************************** 00032 ******************************************************************** 00033 00034 Implementation of class Parameter 00035 00036 ******************************************************************** 00037 ******************************************************************** 00038 ******************************************************************** 00039 */ 00040 00041 // constructor, default 00042 Parameter::Parameter(void) : 00043 mName(""), mTDName(""), mAttr(Parameter::UnDef), mCReturn(false) 00044 {} 00045 00046 // constructor, by member values 00047 Parameter::Parameter(const std::string& rName, const std::string& rTypeName, ParamAttr attr, bool cret) : 00048 mName(rName), mTDName(rTypeName), mAttr(attr), mCReturn(cret) 00049 {} 00050 00051 // Desctructor 00052 Parameter::~Parameter(void){} 00053 00054 // get name 00055 const std::string& Parameter::Name(void) const 00056 { return mName;} 00057 00058 // set name 00059 void Parameter::Name(const std::string& rName) 00060 { mName=rName;} 00061 00062 // get type 00063 const std::string& Parameter::Type(void) const 00064 { return mTDName;} 00065 00066 // set type 00067 void Parameter::Type(const std::string& rTypeName) 00068 { mTDName=rTypeName;} 00069 00070 // get attribute 00071 const Parameter::ParamAttr& Parameter::Attribute(void) const 00072 { return mAttr; } 00073 00074 // set attribute 00075 void Parameter::Attribute(const ParamAttr& rAttr) 00076 { mAttr=rAttr;} 00077 00078 // get c ret flag 00079 bool Parameter::CReturn(void) const 00080 { return mCReturn; } 00081 00082 // set c ret flag 00083 void Parameter::CReturn(bool cret) 00084 { mCReturn=cret;} 00085 00086 // set attribute 00087 void Parameter::Attribute(const std::string& rAttrStr) { 00088 mAttr=Parameter::UnDef; 00089 if(rAttrStr=="In") mAttr=Parameter::In; 00090 if(rAttrStr=="Out") mAttr=Parameter::Out; 00091 if(rAttrStr=="InOut") mAttr=Parameter::InOut; 00092 } 00093 00094 // textual attribute 00095 std::string Parameter::AStr(Parameter::ParamAttr attr){ 00096 switch(attr){ 00097 case Parameter::In: return "In"; 00098 case Parameter::Out: return "Out"; 00099 case Parameter::InOut: return "InOut"; 00100 default: break; 00101 } 00102 return "UnDef"; 00103 } 00104 00105 // textual parameter 00106 std::string Parameter::Str(void) const { 00107 std::string res = "+" + AStr(mAttr)+ "+ " + mTDName + " " + mName; 00108 return res; 00109 } 00110 00111 // set to "undefined" 00112 void Parameter::Clear(void){ 00113 mName = ""; 00114 mTDName = ""; 00115 mAttr = Parameter::UnDef; 00116 mCReturn=false; 00117 } 00118 00119 // test equality 00120 bool Parameter::operator==(const Parameter& rOther) const { 00121 if(mName!=rOther.mName) return false; 00122 if(mTDName!=rOther.mTDName) return false; 00123 if(mAttr!=rOther.mAttr) return false; 00124 if(mCReturn!=rOther.mCReturn) return false; 00125 return true; 00126 } 00127 00128 00129 00130 /* 00131 ******************************************************************** 00132 ******************************************************************** 00133 ******************************************************************** 00134 00135 Implementation of class Signature 00136 00137 ******************************************************************** 00138 ******************************************************************** 00139 ******************************************************************** 00140 */ 00141 00142 00143 // faudes type (cannot do autoregister) 00144 FAUDES_TYPE_IMPLEMENTATION_NEW(Void,Signature,Type) 00145 FAUDES_TYPE_IMPLEMENTATION_COPY(Void,Signature,Type) 00146 FAUDES_TYPE_IMPLEMENTATION_CAST(Void,Signature,Type) 00147 FAUDES_TYPE_IMPLEMENTATION_ASSIGN(Void,Signature,Type) 00148 FAUDES_TYPE_IMPLEMENTATION_EQUAL(Void,Signature,Type) 00149 00150 // constructor 00151 Signature::Signature(void) : Type() {} 00152 00153 // copy constructor 00154 Signature::Signature(const Signature& rSrc) : Type() 00155 { 00156 DoAssign(rSrc); 00157 } 00158 00159 // std faudes type 00160 void Signature::DoAssign(const Signature& rSrc) { 00161 // assign my members 00162 mName=rSrc.mName; 00163 mParameters=rSrc.mParameters; 00164 } 00165 00166 // std faudes type 00167 bool Signature::DoEqual(const Signature& rOther) const { 00168 // test my members 00169 if(mName!=rOther.mName) return false; 00170 if(mParameters!=rOther.mParameters) return false; 00171 return true; 00172 } 00173 00174 00175 // clear signature 00176 void Signature::Clear(void){ 00177 FD_DRTI("Signature::Clear()"); 00178 mName=""; 00179 mParameters.clear(); 00180 } 00181 00182 // get name 00183 const std::string& Signature::Name(void) const{ 00184 return mName; 00185 } 00186 00187 // set name 00188 void Signature::Name(const std::string& rName){ 00189 mName = rName; 00190 } 00191 00192 // get size 00193 int Signature::Size() const{ 00194 return mParameters.size(); 00195 } 00196 00197 // get parameter 00198 const Parameter& Signature::At(int n) const{ 00199 // check range 00200 if((n < 0) || (n >= Size())){ 00201 std::stringstream err; 00202 err << "Index out of range: " << n << std::endl; 00203 throw Exception("Signature::At()", err.str(), 47); 00204 } 00205 // return const ref 00206 return mParameters.at(n); 00207 } 00208 00209 // set parameter 00210 void Signature::At(int n, const Parameter& rParam) { 00211 // check range 00212 if((n < 0) || (n >= Size())){ 00213 std::stringstream err; 00214 err << "Index out of range: " << n << std::endl; 00215 throw Exception("Signature::At()", err.str(), 47); 00216 } 00217 // set ref 00218 mParameters[n]=rParam; 00219 } 00220 00221 // append parameter 00222 void Signature::Append(const Parameter& rParam){ 00223 mParameters.push_back(rParam); 00224 } 00225 00226 00227 00228 // token io 00229 void Signature::DoWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const{ 00230 // ignore 00231 (void) rLabel; 00232 (void) pContext; 00233 // write my tag 00234 Token btag; 00235 btag.SetBegin("Signature"); 00236 btag.InsAttribute("name",mName); 00237 rTw << btag; 00238 // parameter specs 00239 for(int i=0; i<Size(); i++){ 00240 Token par; 00241 par.SetEmpty("Parameter"); 00242 par.InsAttribute("name",mParameters.at(i).Name()); 00243 par.InsAttribute("ftype",mParameters.at(i).Type()); 00244 switch(mParameters.at(i).Attribute()){ 00245 case Parameter::In: par.InsAttribute("access","In"); break; 00246 case Parameter::Out: par.InsAttribute("access","Out"); break; 00247 case Parameter::InOut: par.InsAttribute("access","InOut"); break; 00248 default: break; 00249 } 00250 if(mParameters.at(i).CReturn()) par.InsAttribute("creturn","true"); 00251 rTw << par ; 00252 } 00253 // end section 00254 rTw.WriteEnd("Signature"); 00255 } 00256 00257 // token io 00258 void Signature::DoRead(TokenReader& rTr, const std::string& rLabel, const Type* pContext){ 00259 // ignore 00260 (void) rLabel; 00261 (void) pContext; 00262 // read my section 00263 FD_DRTI("Signature::DoRead(): file " << rTr.FileName()); 00264 Token token; 00265 rTr.ReadBegin("Signature",token); 00266 00267 // detect and digest old pre 2.16b file format 00268 // note: this section will eventually be removed 00269 if(!token.ExistsAttributeString("name")) { 00270 mName=rTr.ReadString(); 00271 FD_DRTI("Signature::DoRead(): found (pre 2.16b file)" << mName); 00272 while(!rTr.Eos("Signature")) { 00273 std::string pname=rTr.ReadString(); 00274 std::string ptype=rTr.ReadString(); 00275 Parameter::ParamAttr pattr= Parameter::UnDef; 00276 bool cret=false; 00277 Token token; 00278 rTr.Peek(token); 00279 while(token.Type()==Token::Option) { 00280 rTr.Get(token); 00281 if(token.StringValue()=="In") pattr= Parameter::In; 00282 if(token.StringValue()=="Out") pattr= Parameter::Out; 00283 if(token.StringValue()=="InOut") pattr= Parameter::InOut; 00284 if(token.StringValue()=="OutIn") pattr= Parameter::InOut; 00285 if(token.StringValue()=="CReturn") cret=true; 00286 rTr.Peek(token); 00287 } 00288 Append(Parameter(pname,ptype,pattr,cret)); 00289 } 00290 rTr.ReadEnd("Signature"); 00291 return; 00292 } // end pre 2.16b file format 00293 00294 // extract name 00295 mName=token.AttributeStringValue("name"); 00296 FD_DRTI("Signature::DoRead(): found " << mName); 00297 // loop parameters 00298 while(!rTr.Eos("Signature")) { 00299 Token par; 00300 rTr.ReadBegin("Parameter",par); 00301 // parameter name 00302 std::string pname=par.AttributeStringValue("name"); 00303 // parameter type 00304 std::string ptype=par.AttributeStringValue("ftype"); 00305 // parameter access 00306 Parameter::ParamAttr pattr= Parameter::UnDef; 00307 if(par.ExistsAttributeString("access")){ 00308 std::string paccess = par.AttributeStringValue("access"); 00309 if(paccess=="In") pattr= Parameter::In; 00310 if(paccess=="Out") pattr= Parameter::Out; 00311 if(paccess=="InOut") pattr= Parameter::InOut; 00312 if(paccess=="OutIn") pattr= Parameter::InOut; 00313 } 00314 // parameter cret 00315 bool cret=false; 00316 if(par.ExistsAttributeString("creturn")){ 00317 std::string pcret = par.AttributeStringValue("creturn"); 00318 if(pcret=="true") cret=true; 00319 if(pcret=="True") cret=true; 00320 if(pcret=="Yes") cret=true; 00321 if(pcret=="yes") cret=true; 00322 } 00323 // insert 00324 Append(Parameter(pname,ptype,pattr,cret)); 00325 rTr.ReadEnd("Parameter"); 00326 } 00327 // done 00328 rTr.ReadEnd("Signature"); 00329 FD_DRTI("Signature::DoRead(): done"); 00330 } 00331 00332 00333 00334 00335 /* 00336 ******************************************************************** 00337 ******************************************************************** 00338 ******************************************************************** 00339 00340 Implementation of class FunctionDefinition 00341 00342 ******************************************************************** 00343 ******************************************************************** 00344 ******************************************************************** 00345 */ 00346 00347 // faudes type (cannot do autoregister) 00348 FAUDES_TYPE_IMPLEMENTATION_NEW(Void,FunctionDefinition,Documentation) 00349 FAUDES_TYPE_IMPLEMENTATION_COPY(Void,FunctionDefinition,Documentation) 00350 FAUDES_TYPE_IMPLEMENTATION_ASSIGN(Void,FunctionDefinition,Documentation) 00351 FAUDES_TYPE_IMPLEMENTATION_CAST(Void,FunctionDefinition,Documentation) 00352 FAUDES_TYPE_IMPLEMENTATION_EQUAL(Void,FunctionDefinition,Documentation) 00353 00354 00355 // constructor 00356 FunctionDefinition::FunctionDefinition(const std::string& name) : 00357 Documentation(), 00358 mpFunction(NULL) 00359 { 00360 Name(name); 00361 } 00362 00363 // copy constructor 00364 FunctionDefinition::FunctionDefinition(const FunctionDefinition& rSrc) : 00365 Documentation(), 00366 mpFunction(NULL) 00367 { 00368 DoAssign(rSrc); 00369 } 00370 00371 // std faudes type 00372 void FunctionDefinition::DoAssign(const FunctionDefinition& rSrc) { 00373 // assign base members 00374 Documentation::DoAssign(rSrc); 00375 // assign my members 00376 mVariants=rSrc.mVariants; 00377 mVariantIndexMap=rSrc.mVariantIndexMap; 00378 // special member 00379 if(mpFunction) delete mpFunction; 00380 mpFunction=0; 00381 if(rSrc.mpFunction) { 00382 mpFunction=rSrc.mpFunction->New(); 00383 mpFunction->Definition(this); 00384 } 00385 } 00386 00387 // std faudes type 00388 bool FunctionDefinition::DoEqual(const FunctionDefinition& rOther) const { 00389 // test base members 00390 if(!Documentation::DoEqual(rOther)) return false; 00391 // test my members 00392 if(mVariants!=rOther.mVariants) return false; 00393 return true; 00394 } 00395 00396 // clear (all but prototype) 00397 void FunctionDefinition::Clear(){ 00398 FD_DRTI("FunctionDefinition::Clear(): " << Name()); 00399 // call base 00400 Documentation::Clear(); 00401 // clear my variants 00402 mVariants.clear(); 00403 mVariantIndexMap.clear(); 00404 } 00405 00406 // clear (variants only) 00407 void FunctionDefinition::ClearVariants(){ 00408 FD_DRTI("FunctionDefinition::ClearVariants(): " << Name()); 00409 // clear my variants 00410 mVariants.clear(); 00411 mVariantIndexMap.clear(); 00412 } 00413 00414 00415 // get prototype object 00416 const Function* FunctionDefinition::Prototype(void) const{ 00417 return(mpFunction); 00418 } 00419 00420 // set prototype object 00421 void FunctionDefinition::Prototype(Function* pFunc){ 00422 // delte any existing prototype 00423 if(mpFunction) delete mpFunction; 00424 // record new prototype 00425 mpFunction = pFunc; 00426 // bail out 00427 if(!mpFunction) return; 00428 // ensure that our prototype uses us as function definition 00429 mpFunction->Definition(this); 00430 } 00431 00432 // construct function on head 00433 Function* FunctionDefinition::NewFunction() const{ 00434 FD_DRTI("FunctionDefinition::NewFunction(): name " << Name()); 00435 if(!mpFunction) return NULL; 00436 return(mpFunction->New()); 00437 } 00438 00439 00440 // # of variants 00441 int FunctionDefinition::VariantsSize() const{ 00442 return(mVariants.size()); 00443 } 00444 00445 // existence of variant by name 00446 bool FunctionDefinition::ExistsVariant(const std::string& varname) const { 00447 return mVariantIndexMap.find(varname)!= mVariantIndexMap.end(); 00448 } 00449 00450 // get index by variant name 00451 int FunctionDefinition::VariantIndex(const std::string& rName) const { 00452 std::map<std::string,int>::const_iterator vit= mVariantIndexMap.find(rName); 00453 if(vit==mVariantIndexMap.end()) return -1; 00454 return vit->second; 00455 } 00456 00457 // extend variants 00458 void FunctionDefinition::AppendVariant(const Signature& rVariant){ 00459 FD_DRTI("FunctionDefinition::AppendVariant()"); 00460 // assure that no variant with the same name is yet contained in the list 00461 if(ExistsVariant(rVariant.Name())) { 00462 std::stringstream err; 00463 err << "Attempt to append variant with existing name: " << rVariant.Name() << " in " << Name() << std::endl; 00464 throw Exception("FunctionDefinition::AppendVariant()", err.str(), 47); 00465 } 00466 // do append 00467 mVariantIndexMap[rVariant.Name()]=mVariants.size(); 00468 mVariants.push_back(rVariant); 00469 } 00470 00471 00472 // get signature by variant name 00473 const Signature& FunctionDefinition::Variant(const std::string& rName) const{ 00474 std::map<std::string,int>::const_iterator vit= mVariantIndexMap.find(rName); 00475 if(vit==mVariantIndexMap.end()) { 00476 std::stringstream err; 00477 err << "Access to non existing variant " << rName << " in fnct " << Name() << std::endl; 00478 throw Exception("FunctionDefinition::Variant()", err.str(), 47); 00479 } 00480 return mVariants.at(vit->second); 00481 } 00482 00483 00484 // get signature by variant index 00485 const Signature& FunctionDefinition::Variant(int n) const{ 00486 // check range 00487 if((n < 0) || (n >= VariantsSize())){ 00488 std::stringstream err; 00489 err << "Index out of range: " << n << std::endl; 00490 throw Exception("FunctionDefinition::Variant()", err.str(), 47); 00491 } 00492 return mVariants.at(n); 00493 } 00494 00495 00496 // token io 00497 void FunctionDefinition::DoRead(TokenReader& rTr, const std::string& rLabel, const Type* pContext) { 00498 FD_DRTI("FunctionDefinition::DoRead()"); 00499 // ignore 00500 (void) pContext; 00501 // label 00502 std::string label=rLabel; 00503 if(label=="") label="FunctionDefinition"; 00504 // base can handle this 00505 Documentation::DoRead(rTr,label,pContext); 00506 } 00507 00508 00509 // token io 00510 void FunctionDefinition::DoReadCore(TokenReader& rTr) { 00511 FD_DRTI("FunctionDefinition::DoReadCore()"); 00512 // call base 00513 Documentation::DoReadCore(rTr); 00514 // do variants 00515 rTr.ReadBegin("VariantSignatures"); 00516 while(!rTr.Eos("VariantSignatures")) { 00517 Signature sig; 00518 sig.Read(rTr); 00519 // no doublets 00520 if(ExistsVariant(sig.Name())) continue; 00521 // append variant signature 00522 AppendVariant(sig); 00523 } // end: !EOS 00524 rTr.ReadEnd("VariantSignatures"); 00525 } 00526 00527 00528 // token io 00529 void FunctionDefinition::DoWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const { 00530 // label 00531 std::string label=rLabel; 00532 if(label=="") label="FunctionDefinition"; 00533 // base can handle 00534 Documentation::DoWrite(rTw,label,pContext); 00535 } 00536 00537 // token io 00538 void FunctionDefinition::DoWriteCore(TokenWriter& rTw) const { 00539 FD_DRTI("FunctionDefinition::DoWriteCore(): file " << rTw.FileName()); 00540 // call base core 00541 Documentation::DoWriteCore(rTw); 00542 // write signatures 00543 rTw.WriteBegin("VariantSignatures"); 00544 if(mVariants.size()>1) rTw << "\n"; 00545 for(unsigned int i=0; i<mVariants.size(); i++) { 00546 mVariants.at(i).Write(rTw); 00547 if(mVariants.size()>1) rTw << "\n"; 00548 } 00549 rTw.WriteEnd("VariantSignatures"); 00550 rTw << "\n"; 00551 } 00552 00553 00554 /* 00555 ******************************************************************** 00556 ******************************************************************** 00557 ******************************************************************** 00558 00559 Implementation of class Function 00560 00561 ******************************************************************** 00562 ******************************************************************** 00563 ******************************************************************** 00564 */ 00565 00566 // Constructor 00567 Function::Function(const FunctionDefinition* fdef) : 00568 pFuncDef(fdef), 00569 mVariantIndex(-1) 00570 { 00571 #ifdef FAUDES_DEBUG_RUNTIMEINTERFACE 00572 if(!pFuncDef) 00573 {FD_DRTI("Function::Function(): prototype object");} 00574 else 00575 {FD_DRTI("Function::Function(): " << pFuncDef->Name());} 00576 #endif 00577 // have default variant 00578 if(pFuncDef) 00579 if(pFuncDef->VariantsSize()>0) 00580 Variant(0); 00581 } 00582 00583 // set function definition 00584 void Function::Definition(const FunctionDefinition* fdef) { 00585 // invalidate variant 00586 mVariantIndex = -1; 00587 mParameterValues.clear(); 00588 // set 00589 pFuncDef=fdef; 00590 // report 00591 #ifdef FAUDES_DEBUG_RUNTIMEINTERFACE 00592 if(!pFuncDef) 00593 {FD_DRTI("Function::Definition(): prototype object");} 00594 else 00595 {FD_DRTI("Function::Definition(): " << pFuncDef->Name());} 00596 #endif 00597 } 00598 00599 // get function definition 00600 const FunctionDefinition* Function::Definition(void) const { 00601 return pFuncDef; 00602 } 00603 00604 00605 // get signature size 00606 int Function::VariantsSize(void) const { 00607 if(!pFuncDef) return 0; 00608 return pFuncDef->VariantsSize(); 00609 } 00610 00611 // set variant signature 00612 void Function::Variant(int n) { 00613 // pass on t o virtual interface 00614 DoVariant(n); 00615 } 00616 00617 // set variant signature 00618 void Function::DoVariant(int n) { 00619 // clear recent variant 00620 mVariantIndex=-1; 00621 mParameterValues.clear(); 00622 // prototype object can not have a variant 00623 if(!pFuncDef) { 00624 std::stringstream err; 00625 err << "No valid function definition available" << std::endl; 00626 throw Exception("Function::Variant(n)", err.str(), 47); 00627 } 00628 // index out of range 00629 if(n<0 || n >= VariantsSize()) { 00630 std::stringstream err; 00631 err << "Variant index out of range" << std::endl; 00632 throw Exception("Function::Variant(n)", err.str(), 48); 00633 } 00634 // set variant 00635 mVariantIndex=n; 00636 int nparam = pFuncDef->Variant(mVariantIndex).Size(); 00637 while((int) mParameterValues.size()<nparam) 00638 mParameterValues.push_back(0); 00639 } 00640 00641 // set variant signature 00642 void Function::Variant(const std::string& rVariantName) { 00643 // prototype object can not have a variant 00644 if(!pFuncDef) { 00645 std::stringstream err; 00646 err << "No valid function definition available" << std::endl; 00647 throw Exception("Function::Variant(name)", err.str(), 47); 00648 } 00649 // get index 00650 int varid = pFuncDef->VariantIndex(rVariantName); 00651 // detect invalid name 00652 if(varid<0) { 00653 std::stringstream err; 00654 err << "Unknown variant name " << rVariantName << std::endl; 00655 throw Exception("Function::Variant(name)", err.str(), 48); 00656 } 00657 // set by index 00658 DoVariant(varid); 00659 } 00660 00661 // get signature 00662 const Signature* Function::Variant(void) const { 00663 if(!pFuncDef) return 0; 00664 if(mVariantIndex<0) return 0; 00665 return &pFuncDef->Variant(mVariantIndex); 00666 } 00667 00668 // get signature size 00669 int Function::ParamsSize(void) const { 00670 return mParameterValues.size(); 00671 } 00672 00673 // set parameter value 00674 void Function::ParamValue(int n, Type* pVal){ 00675 if((n < 0) || (n >= ParamsSize())){ 00676 std::stringstream err; 00677 err << "Parameter index out of range: " << n << std::endl; 00678 throw Exception("Function::ParamValue()", err.str(), 47); 00679 } 00680 mParameterValues.at(n) = pVal; 00681 } 00682 00683 // get parameter 00684 Type* Function::ParamValue(int n) const{ 00685 if((n < 0) || (n >= ParamsSize())){ 00686 std::stringstream err; 00687 err << "Parameter index out of range: " << n << std::endl; 00688 throw Exception("Function::ParamValue()", err.str(), 47); 00689 } 00690 return(mParameterValues.at(n)); 00691 } 00692 00693 00694 // allocate parameter value 00695 void Function::AllocateValue(int n) { 00696 FD_DRTI("Function::AllocateValue()"); 00697 if(!Variant()) { 00698 std::stringstream err; 00699 err << "No variant specified"; 00700 throw Exception("Function::AllocateValue()", err.str(), 47); 00701 } 00702 if((n < 0) || (n >= ParamsSize())){ 00703 std::stringstream err; 00704 err << "Parameter index out of range: " << n << std::endl; 00705 throw Exception("Function::AllocateValue()", err.str(), 47); 00706 } 00707 ParamValue(n,TypeRegistry::G()->NewObject(Variant()->At(n).Type())); 00708 } 00709 00710 // allocate parameter value 00711 void Function::AllocateValues(void) { 00712 FD_DRTI("Function::AllocateValues()"); 00713 for(int i = 0; i < ParamsSize(); i++) 00714 AllocateValue(i); 00715 } 00716 00717 // allocate parameter value 00718 void Function::FreeValues(void) { 00719 FD_DRTI("Function::FreeValues()"); 00720 for(int i = 0; i < ParamsSize(); i++) { 00721 delete mParameterValues.at(i); 00722 mParameterValues.at(i) =0; 00723 } 00724 } 00725 00726 00727 // type check wrapper 00728 bool Function::TypeCheck(int n) { 00729 FD_DRTI("Function::TypeCheck()"); 00730 if(mVariantIndex<0) { 00731 std::stringstream err; 00732 err << "Variant not set" << std::endl; 00733 throw Exception("Function::TypeCheck(n)", err.str(), 48); 00734 } 00735 if(n<0 || n>= ParamsSize()) { 00736 std::stringstream err; 00737 err << "Parameter out of range" << std::endl; 00738 throw Exception("Function::Typechek(n)", err.str(), 48); 00739 } 00740 bool res=DoTypeCheck(n); 00741 FD_DRTI("Function::TypeCheck() done, ok=" << res); 00742 return res; 00743 } 00744 00745 // type check wrapper 00746 bool Function::TypeCheck(void) { 00747 FD_DRTI("Function::TypeCheck()"); 00748 if(mVariantIndex<0) { 00749 std::stringstream err; 00750 err << "Variant not set" << std::endl; 00751 throw Exception("Function::TypeCheck()", err.str(), 48); 00752 } 00753 for(int i=0; i<ParamsSize(); i++) 00754 if(!DoTypeCheck(i)) return false; 00755 FD_DRTI("Function::TypeCheck() done, ok"); 00756 return true; 00757 } 00758 00759 // exec wrapper 00760 void Function::Execute(void){ 00761 FD_DRTI("Function::Execute()"); 00762 if(!Variant()) { 00763 std::stringstream err; 00764 err << "Variant not set" << std::endl; 00765 throw Exception("Function::Execute()", err.str(), 48); 00766 } 00767 for(int n=0; n<ParamsSize(); n++) { 00768 if(!DoTypeCheck(n)) { 00769 std::stringstream err; 00770 err << "Cannot cast parameter \"" << Variant()->At(n).Name() << 00771 "\" to type \"" << Variant()->At(n).Type() << "\""; 00772 throw Exception("Function::Execute()", err.str(), 48); 00773 } 00774 } 00775 DoExecute(); 00776 FD_DRTI("Function::Execute() done"); 00777 } 00778 00779 00780 // token io (informative/debug) 00781 void Function::DoWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const{ 00782 (void) pContext; 00783 std::string label = rLabel; 00784 if(label == "") label = "Function"; 00785 FD_DRTI("Function::DoWrite(): file " << rTw.FileName() << " section " << label); 00786 rTw.Columns(1); 00787 rTw.WriteBegin(label); 00788 rTw << "\n"; 00789 rTw.WriteBegin("Parameters"); 00790 for(int i = 0; i < ParamsSize(); i++){ 00791 rTw << typeid(ParamValue(i)).name(); 00792 rTw << "\n"; 00793 } 00794 rTw.WriteEnd("Parameters"); 00795 rTw << "\n"; 00796 rTw.WriteEnd(label); 00797 FD_DRTI("Function::DoWrite(): done"); 00798 } 00799 00800 00801 } // namespace 00802 libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen |