cfl_functions.cpp

Go 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