libFAUDES
Sections
Index
|
cfl_functions.hGo to the documentation of this file.00001 /** @file cfl_functions.h Runtime interface, operations on faudes types */ 00002 00003 /* FAU Discrete Event Systems Library (libfaudes) 00004 00005 Copyright (C) 2009 Ruediger Berndt 00006 Copyright (C) 2010 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 #ifndef FAUDES_RTIFNCTS_H 00024 #define FAUDES_RTIFNCTS_H 00025 00026 // todo: fix/hide copy constructor 00027 00028 #include "cfl_types.h" 00029 00030 namespace faudes{ 00031 00032 /** 00033 * Structure to model a parameter type within the Signature of a 00034 * Function. 00035 * A Parameter is made of a descriptive name, a faudes type and 00036 * an io-attribute. The latter specifies whether the parameter 00037 * is a const argument (<tt>In</tt>), a result (<tt>Out</tt>) or a both-ways 00038 * parameter (<tt>InOut</tt>). To support the code generators of the run-time-interface, 00039 * you may use the CReturn flag to indicate that the parameter is implemented 00040 * as the return value in the corresponding C function. The current version of the 00041 * code generators will handle this case for the elementary types Integer, Boolean and 00042 * String. They will, however, fail on any other faudes types. 00043 */ 00044 00045 class Parameter { 00046 00047 public: 00048 00049 /** 00050 * A function parameter has has one out of four so called io-attrributes; 00051 */ 00052 enum ParamAttr{ 00053 In, //// Input parameter, aka argument, remains constant while execution 00054 Out, //// Output parameter, aka result, is generated during function execution 00055 InOut, //// InOut parameter, is interpreted and possibly altered during execution 00056 UnDef //// UnDef parameter indicates unconfigured signature 00057 }; 00058 00059 /** Constructor, default */ 00060 Parameter(void); 00061 00062 /** Constructor, by member values */ 00063 Parameter(const std::string& rName, const std::string& rTypeName, 00064 ParamAttr attr=UnDef, bool cret=false); 00065 00066 /** Desctructor */ 00067 ~Parameter(void); 00068 00069 /** 00070 * Get name 00071 * 00072 * @return 00073 * Name of parameter 00074 */ 00075 const std::string& Name(void) const; 00076 00077 /** 00078 * Set name 00079 * 00080 * @param rName 00081 * New name of parameter 00082 */ 00083 void Name(const std::string& rName); 00084 00085 /** 00086 * Get type 00087 * 00088 * @return 00089 * Faudes type of parameter 00090 */ 00091 const std::string& Type(void) const; 00092 00093 /** 00094 * Set type 00095 * 00096 * @param rTypeName 00097 * New faudes type of parameter 00098 */ 00099 void Type(const std::string& rTypeName); 00100 00101 /** 00102 * Get Attribute 00103 * 00104 * @return 00105 * In/Out/InOut attribute of parameter. 00106 */ 00107 const ParamAttr& Attribute(void) const; 00108 00109 /** 00110 * Set Attribute 00111 * 00112 * @param rAttr 00113 * In/Out/InOut attribute of parameter. 00114 */ 00115 void Attribute(const ParamAttr& rAttr); 00116 00117 /** 00118 * Set Attribute by string. 00119 * Convenience method, defaults to UnDef. 00120 * 00121 * @param rAttrStr 00122 * In/Out/InOut attribute of parameter. 00123 */ 00124 void Attribute(const std::string& rAttrStr); 00125 00126 /** 00127 * Get C-Return flag. 00128 * 00129 * @return 00130 * C-Return flag 00131 */ 00132 bool CReturn(void) const; 00133 00134 /** 00135 * Set C-Return flag. 00136 * 00137 * @param cret 00138 * New value of C-Return flag. 00139 */ 00140 void CReturn(bool cret); 00141 00142 /** 00143 * Convenience method to produce a textual representation of an io attribute. 00144 * 00145 * @param attr 00146 * Enum value denoting the attribute. 00147 * @return 00148 * Parameter IO attribute as std::string 00149 */ 00150 static std::string AStr(Parameter::ParamAttr attr); 00151 00152 /** 00153 * Convenience method to produce a textual representation of a parameter. 00154 * 00155 */ 00156 std::string Str(void) const; 00157 00158 /** 00159 * Set to "undefined" 00160 */ 00161 void Clear(); 00162 00163 /** 00164 * Test equality 00165 * 00166 * @param rOther 00167 * Other signature to compare with. 00168 */ 00169 bool operator==(const Parameter& rOther) const; 00170 00171 protected: 00172 00173 /** Name */ 00174 std::string mName; 00175 00176 /** Faudes type */ 00177 std::string mTDName; 00178 00179 /** IO-Attribute */ 00180 ParamAttr mAttr; 00181 00182 /** C-Return flag */ 00183 bool mCReturn; 00184 00185 }; // Parameter 00186 00187 00188 00189 00190 /** 00191 * Signature of a Function. 00192 * 00193 * A Signature describes the faudes types of the positional 00194 * parameters. Tecnically, a Signature is a vector of Parameters. 00195 * Each Function may execute serveral variants indicated by setting 00196 * a particular Signature. A list of valid Signatures is maintained in 00197 * the coresponding FunctionDefinition. 00198 * 00199 * Core members are 00200 * - mName: string to identify ths signature 00201 * - mParameters: vector of Paramters. 00202 * 00203 * The Signature is formally derived from Type to inherit the std token io 00204 * interface. It is not meant to be registered as a faudes type. 00205 * The token io format is demonstrated by the following example: 00206 * 00207 * @code 00208 * <Signature name="Sum of two integers"> 00209 * <Parameter name="arg1" ftype="Integer" access="InOut"/> 00210 * <Parameter name="arg2" ftype="Integer" access="In"/> 00211 * <Parameter name="res" ftype="String" access="Out" creturn="true"/> 00212 * </Signature> 00213 * @endcode 00214 * 00215 * Technical note: the variable parameter feature offered by FunctionDefinition is a purely 00216 * cosmetic hack implemented in FunctionDefinition:MergeDocumentation. It is superseeded 00217 * by vector parameters and will hence disappear in a future implementation. 00218 */ 00219 00220 class Signature : public Type { 00221 00222 // std faudes type interface (cannot autoregister) 00223 FAUDES_TYPE_DECLARATION_NEW(Void,Signature,Type) 00224 FAUDES_TYPE_DECLARATION_COPY(Void,Signature,Type) 00225 FAUDES_TYPE_DECLARATION_CAST(Void,Signature,Type) 00226 FAUDES_TYPE_DECLARATION_ASSIGN(Void,Signature,Type) 00227 FAUDES_TYPE_DECLARATION_EQUAL(Void,Signature,Type) 00228 00229 public: 00230 00231 /** Constructor */ 00232 Signature(void); 00233 00234 /** Copy constructor */ 00235 Signature(const Signature& rSrc); 00236 00237 /** Destructor */ 00238 ~Signature(void){}; 00239 00240 /** 00241 * Return signature name. 00242 * 00243 * @return 00244 * Name 00245 */ 00246 const std::string& Name(void) const; 00247 00248 /** 00249 * Set signature name. 00250 * 00251 * @param 00252 * rName 00253 */ 00254 void Name(const std::string& rName); 00255 00256 /** 00257 * Clear signature 00258 */ 00259 void Clear(void); 00260 00261 /** 00262 * Return number of parameters. 00263 * 00264 * @return 00265 * int 00266 */ 00267 int Size(void) const; 00268 00269 /** 00270 * Get parameter type by position. 00271 * 00272 * @param n 00273 * Position of patameter. 00274 * 00275 * @exception Exception 00276 * - Index out of range 00277 */ 00278 const Parameter& At(int n) const; 00279 00280 /** 00281 * Set parameter type by position. 00282 * 00283 * @param n 00284 * Position of patameter. 00285 * @param rParam 00286 * Paraeter value 00287 * 00288 * @exception Exception 00289 * - Index out of range 00290 */ 00291 void At(int n,const Parameter& rParam); 00292 00293 /** 00294 * Append positional parameter. 00295 * 00296 * @param rParam 00297 * Parameter to append 00298 */ 00299 void Append(const Parameter& rParam); 00300 00301 00302 protected: 00303 00304 /** 00305 * Std faudes type interface: assignment. 00306 * 00307 * @param rSrc 00308 * Source to copy from 00309 * @return Reference to this object. 00310 */ 00311 virtual void DoAssign(const Signature& rSrc); 00312 00313 /** 00314 * Std faudes type interface: test equality 00315 * 00316 * @param rOther 00317 * Other object to compare with. 00318 * @return 00319 * True on match. 00320 */ 00321 virtual bool DoEqual(const Signature& rOther) const; 00322 00323 /** 00324 * Read signature from from TokenReader. 00325 * 00326 * The section is hardcoded to "Signature", context is ignored. 00327 * 00328 * @param rTr 00329 * TokenReader to read from 00330 * @param rLabel 00331 * Section to read 00332 * @param pContext 00333 * Read context to provide contextual information (ignored) 00334 * 00335 * @exception Exception 00336 * - IO error (id 1) 00337 * - Token mismatch (id 50, 51, 52) 00338 */ 00339 virtual void DoRead(TokenReader& rTr, const std::string& rLabel = "", const Type* pContext=0); 00340 00341 /** 00342 * Write configuration data of this object to TokenWriter. 00343 * 00344 * The section is hardcoded to "Signature", context is ignored. 00345 * 00346 * @param rTw 00347 * Reference to TokenWriter 00348 * @param rLabel 00349 * Label of section to write 00350 * @param pContext 00351 * Write context to provide contextual information 00352 * 00353 * @exception Exception 00354 * - IO errors (id 2) 00355 */ 00356 virtual void DoWrite(TokenWriter& rTw, const std::string& rLabel="",const Type* pContext=0) const; 00357 00358 /** Variable to store name */ 00359 std::string mName; 00360 00361 /** Vector of Parameter-objects */ 00362 std::vector<Parameter> mParameters; 00363 00364 }; // Signature 00365 00366 00367 00368 // forward 00369 class Function; 00370 00371 00372 /** 00373 * A FunctionDefinition defines the interface to a faudes-function. 00374 * The latter consists of a descriptive name to identify the function and 00375 * a list of Signatures the function can operate on. 00376 * Technically, the class FunctionDefinition is derived from Documentation and 00377 * thereby inherits members for additional 00378 * documentation-data. 00379 * 00380 * Similar to Type and TypeDefinition, a FunctionDefinition uses a prototype object to 00381 * provide the method NewFunction() which instantiates the corresponding Function object. 00382 * 00383 * FunctionDefinition inherits the token io interface from Type, however, the class is 00384 * not intended to register as a faudes type. The token io format is demonstrated by the 00385 * following example: 00386 * 00387 * @code 00388 * <FunctionDefinition name="CoreFaudes::IntegerSum" ctype="faudes::IntegerSum"> 00389 * 00390 * <Documentation ref="integersum.html"> 00391 * Returns the sum of integer arguments. 00392 * <Documentation/> 00393 * 00394 * <Keywords> "integer" "elemetary types" </Keywords> 00395 * 00396 * <VariantSignatures> 00397 * 00398 * <Signature name="Two arguments"> 00399 * <Parameter name="Arg1" ftype="Integer" access="In"> 00400 * <Parameter name="Arg2" ftype="Integer" access="In"> 00401 * <Parameter name="Res" ftype="Integer" access="Out" creturn="true"> 00402 * </Signature> 00403 * 00404 * <Signature name="Three arguments"> 00405 * <Parameter name="Arg1" ftype="Integer" access="In"> 00406 * <Parameter name="Arg2" ftype="Integer" access="In"> 00407 * <Parameter name="Arg3" ftype="Integer" access="In"> 00408 * <Parameter name="Res" ftype="Integer" access="Out" creturn="true"> 00409 * </Signature> 00410 * 00411 * </VariantSignatures> 00412 * 00413 * </FunctionDefinition> 00414 * @endcode 00415 * 00416 * 00417 * @ingroup RunTimeInterface 00418 */ 00419 00420 class FunctionDefinition : public Documentation { 00421 00422 // std faudes type interface (cannot autoregister) 00423 FAUDES_TYPE_DECLARATION_NEW(Void,FunctionDefinition,Documentation) 00424 FAUDES_TYPE_DECLARATION_COPY(Void,FunctionDefinition,Documentation) 00425 FAUDES_TYPE_DECLARATION_CAST(Void,FunctionDefinition,Documentation) 00426 FAUDES_TYPE_DECLARATION_ASSIGN(Void,FunctionDefinition,Documentation) 00427 FAUDES_TYPE_DECLARATION_EQUAL(Void,FunctionDefinition,Documentation) 00428 00429 public: 00430 00431 /** 00432 * Constructor 00433 * 00434 * The default constructor instantiates an invalid function definition 00435 * without prototype. To construct a valid function definition, use the static 00436 * Constructor() template function. 00437 */ 00438 FunctionDefinition(const std::string& name=""); 00439 00440 /** 00441 * Copy Constructor 00442 * 00443 * The copy constructor copies all members one-to-one, except for 00444 * the prototype object. The latter is re-created using its factory function. 00445 */ 00446 FunctionDefinition(const FunctionDefinition& rSrc); 00447 00448 /** 00449 * Destructor 00450 */ 00451 virtual ~FunctionDefinition(){ Prototype(NULL);}; 00452 00453 /** 00454 * Construct empty FunctionDefinition object. 00455 * The given template parameter denotes a Function class. 00456 * Member variable (mpFunction) is set to a new instance of that class 00457 * whereas the name is set as specified. No further documentation 00458 * or signatures are recorded. 00459 * 00460 * @tparam T 00461 * Actual function class, derived from Function 00462 * @param rFunctName 00463 * Name to identify this faudes-function 00464 * @return 00465 * Newly constructed function definition. 00466 */ 00467 template<class T> 00468 static FunctionDefinition* Constructor(const std::string& rFunctName=""); 00469 00470 /** 00471 * Construct FunctionDefinition object and get name and docu from file. 00472 * 00473 * The member variable mpFunction is set to a new instance of class T. 00474 * which must be derived from Function. The function name, any documentation 00475 * as well as supported signatures are read from the specified file. 00476 * 00477 * @tparam T 00478 * Actual function class, derived from Function 00479 * @param rFileName 00480 * File to read documentation and signatures from. 00481 * @return 00482 * Newly constructed function definition. 00483 */ 00484 template<class T> 00485 static FunctionDefinition* FromFile(const std::string& rFileName); 00486 00487 /** 00488 * Clear documentation-data and signature (keep prototype) 00489 */ 00490 virtual void Clear(void); 00491 00492 00493 /** 00494 * Clear variants (keep docu and prototype) 00495 */ 00496 virtual void ClearVariants(void); 00497 00498 /** 00499 * Return pointer to function object prototype 00500 * 00501 * Note: this method is meant for inspection only, control over 00502 * the prototype remains with the FunctionDefinition. Use 00503 * NewFunction() to instantiate a new function object. 00504 * 00505 * @return 00506 * Reference to prototype function. 00507 */ 00508 const Function* Prototype(void) const; 00509 00510 /** 00511 * Construct function on heap. 00512 * Return pointer to new instance of assigned Function class. 00513 * 00514 * Note: If no prototype is installed, NULL is returned. 00515 * 00516 * @return 00517 * Pointer to new Function instance. 00518 */ 00519 Function* NewFunction() const; 00520 00521 00522 /** 00523 * Return number of supported Signature instances. 00524 * 00525 * @return 00526 * Size of signature vector. 00527 */ 00528 int VariantsSize(void) const; 00529 00530 /** 00531 * Test existence of variant by its name. 00532 * 00533 * @return 00534 * True if variant exists 00535 */ 00536 bool ExistsVariant(const std::string& varname) const; 00537 00538 /** 00539 * Return index of Signature by name. 00540 * 00541 * @param rName 00542 * Name of signature to search. 00543 * @return 00544 * Index of signature, or -1 if not existant 00545 */ 00546 int VariantIndex(const std::string& rName) const; 00547 00548 /** 00549 * Return reference to Signature by name. 00550 * 00551 * @param rName 00552 * Name of signature to search. 00553 * @return 00554 * Reference to Signature 00555 * @exception Exception 00556 * - No such signature (id 47) 00557 */ 00558 const Signature& Variant(const std::string& rName) const; 00559 00560 /** 00561 * Return reference to Signature by index. 00562 * 00563 * @param n 00564 * Index to look up 00565 * @return 00566 * Reference to Signature 00567 * @exception Exception 00568 * - Index out of range (id 47) 00569 */ 00570 const Signature& Variant(int n) const; 00571 00572 /** 00573 * Add Signature to function definition. 00574 * 00575 * @param pVar 00576 * Signature to insert 00577 * @exception Exception 00578 * - Signature with same name exists (id 47) 00579 */ 00580 virtual void AppendVariant(const Signature& pVar); 00581 00582 protected: 00583 00584 /** 00585 * Std faudes type interface: assignment. 00586 * 00587 * @param rSrc 00588 * Source to copy from 00589 * @return Reference to this object. 00590 */ 00591 virtual void DoAssign(const FunctionDefinition& rSrc); 00592 00593 /** 00594 * Std faudes type interface: test equality 00595 * 00596 * @param rOther 00597 * Other object to compare with. 00598 * @return 00599 * True on match. 00600 */ 00601 virtual bool DoEqual(const FunctionDefinition& rOther) const; 00602 00603 /** 00604 * Read configuration data of this object from TokenReader. 00605 * Actual reading is done by DoReadCore. 00606 * 00607 * The section defaults to "FunctionDefinition", context ignored. 00608 * 00609 * @param rTr 00610 * TokenReader to read from 00611 * @param rLabel 00612 * Section to read 00613 * @param pContext 00614 * Read context to provide contextual information (ignored) 00615 * 00616 * @exception Exception 00617 * - Token mismatch (id 50, 51, 52) 00618 * - IO error (id 1) 00619 */ 00620 virtual void DoRead(TokenReader& rTr, const std::string& rLabel = "", const Type* pContext=0); 00621 00622 /** 00623 * Read configuration data of this object from TokenReader. 00624 * 00625 * This method reads members only, it does not read the section. 00626 * 00627 * @param rTr 00628 * TokenReader to read from 00629 * 00630 * @exception Exception 00631 * - Token mismatch (id 50, 51, 52) 00632 * - IO error (id 1) 00633 */ 00634 virtual void DoReadCore(TokenReader& rTr); 00635 00636 /** 00637 * Write configuration data of this object to TokenWriter. 00638 * 00639 * The section defaults to "FunctionDefinition", context ignored. 00640 * 00641 * @param rTw 00642 * Reference to TokenWriter 00643 * @param rLabel 00644 * Label of section to write 00645 * @param pContext 00646 * Write context to provide contextual information 00647 * 00648 * @exception Exception 00649 * - IO errors (id 2) 00650 */ 00651 virtual void DoWrite(TokenWriter& rTw, const std::string& rLabel="",const Type* pContext=0) const; 00652 00653 /** 00654 * Write configuration data of this object to TokenWriter. 00655 * 00656 * This method writes plain member data, the section lables are not 00657 * written. 00658 * 00659 * @param rTw 00660 * Reference to TokenWriter 00661 * 00662 * @exception Exception 00663 * - IO errors (id 2) 00664 */ 00665 virtual void DoWriteCore(TokenWriter& rTw) const; 00666 00667 /** 00668 * Assign prototype object 00669 * 00670 * @param pFunc 00671 * Function instance 00672 * 00673 */ 00674 virtual void Prototype(Function* pFunc); 00675 00676 /** Prototype instance */ 00677 Function* mpFunction; 00678 00679 /** Vector containing all supported Signatures */ 00680 std::vector<faudes::Signature> mVariants; 00681 00682 /** Variant name to index map */ 00683 std::map<std::string,int> mVariantIndexMap; 00684 00685 }; // FunctionDefinition 00686 00687 00688 00689 /** 00690 * A faudes-function hosts parameter values of some faudes type and provides 00691 * a method to perform an operation on the specified paramters, e.g. the 00692 * parallel composition on two generators. The class Function is the base 00693 * for all faudes-functions, which essenitally differ in the operation method. 00694 * 00695 * The base class provides an application interface to 00696 * - select a variant signature, see Variant(); 00697 * - set and get parameter values of any faudes type, see ParamValue(); 00698 * - type check the provided parameter values, see TypeCheck(); 00699 * - perform the operation, see Execute(). 00700 * 00701 * Derivates of the base class, that acually implement an operation, 00702 * are required to cast the parameter values to the corresponding c types and then 00703 * call the respective c function. To derive a class from Function, one will 00704 * reimplment three virtual functions: 00705 * - DoTypeCheck() to perform the cast 00706 * - DoExecute() to call the c function. 00707 * - the constructor New() to replicate the function object. 00708 * 00709 * See IntegerSum in the autogenerated ./include/rtiautoload.h" for a simple example 00710 * of a derived faudes-function. 00711 * 00712 * 00713 * Technichal note: In contrast to faudes objects (derivates from Type), a faudes-function 00714 * must be provided a reference to the corresponding FunctionDefinition. This is because 00715 * a function must be aware of its signature(s). You must not delete 00716 * the FunctionDefinition object during the lifetime of a faudes-function. 00717 * 00718 * 00719 * @ingroup RunTimeInterface 00720 */ 00721 00722 class Function : public Type { 00723 00724 public: 00725 /** 00726 * Constructor 00727 * For the function to be operational, a valid reference to the corresponding 00728 * FunctionDefinition is required. The only exception is the prototype function 00729 * object used in the FunctionDefinition itself. 00730 */ 00731 Function(const FunctionDefinition* fdef); 00732 00733 /** Destructor */ 00734 ~Function(){} 00735 00736 /** 00737 * Construct on heap. 00738 * Create a new instance of this function class and return pointer. 00739 * The new instance will use the same function definition as this instance. 00740 * 00741 * @return 00742 * Pointer to faudes::Function instance. 00743 * 00744 */ 00745 virtual Function* New() const = 0; 00746 00747 00748 /** 00749 * Set function definition. 00750 * Normally, functions are provided with a function definition on construction. 00751 * The only exception are prototype objects used in function definitions themselfs 00752 * and in the function registry. 00753 * 00754 * @param fdef 00755 * Function definition to set. 00756 * 00757 */ 00758 virtual void Definition(const FunctionDefinition* fdef); 00759 00760 00761 /** 00762 * Get function definition. 00763 * 00764 * @return 00765 * Function definition used by this function. 00766 * 00767 */ 00768 const FunctionDefinition* Definition(void) const; 00769 00770 00771 /** 00772 * Return number of variants. 00773 * 00774 * @return 00775 * Size of vector. 00776 */ 00777 int VariantsSize(void) const; 00778 00779 /** 00780 * Set signature from function definition. 00781 * 00782 * The index n refers this function's FunctionDefinition. 00783 * An exception is thrown if no such FunctionDefinition is set, as it 00784 * is the case for prototype instances. 00785 * 00786 * @param n 00787 * Variant index 00788 * 00789 * @exception Exception 00790 * - No function definition available (id 47) 00791 */ 00792 void Variant(int n); 00793 00794 00795 /** 00796 * Set signature from function definition. 00797 * 00798 * The name refers to this function's FunctionDefinition. 00799 * An exception is thrown if no such FunctionDefinition is set, as it 00800 * is the case for prototype instances. 00801 * 00802 * @param rVariantName 00803 * Variant name 00804 * 00805 * @exception Exception 00806 * - No function definition available (id 47) 00807 */ 00808 void Variant(const std::string& rVariantName); 00809 00810 00811 /** 00812 * Return pointer to assigned faudes::Signature. 00813 * 00814 * @return 00815 * Pointer to faudes::Signature. 00816 */ 00817 const Signature* Variant(void) const; 00818 00819 00820 /** 00821 * Return number of parameters with current signature. 00822 * 00823 * @return 00824 * Size of vector. 00825 */ 00826 int ParamsSize(void) const; 00827 00828 /** 00829 * Set parameter at certain position. 00830 * 00831 * Sets the internal refernce of the parameter value 00832 * at the spcefied index. The ownership of the value remains with 00833 * the caller, ie it will not be deleted in the destructor of the 00834 * function object. 00835 * You may set the parameter value to any faudes type 00836 * (classes derived from Type). A type check will be performed before the function 00837 * is executed. 00838 * 00839 * @param n 00840 * Position index of parameter 00841 * @param param 00842 * Pointer to faudes object. 00843 * 00844 * @exception Exception 00845 * - Index out of range (id 47) 00846 * - No variant set (id 47) 00847 */ 00848 void ParamValue(int n, Type* param); 00849 00850 /** 00851 * Get parameter value. 00852 * Returns a reference to the parameter value at the specified position. 00853 * 00854 * @param n 00855 * Position index of parameter. 00856 * 00857 * @exception Exception 00858 * - Index out of range (id 47) 00859 */ 00860 Type* ParamValue(int n) const; 00861 00862 /** 00863 * Construct parameter values. 00864 * 00865 * This is a convenience method to allocate faudes objects for 00866 * parameter values with the type specified by the current signature. 00867 * Note that the function does not take ownetship of the parameter values and 00868 * it is the callers responsibility to delete them when no longer required. 00869 * 00870 */ 00871 void AllocateValues(void); 00872 void AllocateValue(int i); 00873 00874 /** 00875 * Destruct parameter values. 00876 * 00877 * This is a convenience method to delete the assigned paramer values. 00878 * 00879 */ 00880 void FreeValues(void); 00881 00882 /** 00883 * Perform a type check one parameter value. 00884 * 00885 * The type check is based on c type cast and should accept any types 00886 * derived from the type given in the signature. 00887 * 00888 * @param n 00889 * Position of parameter to check 00890 * @return 00891 * True if type matches 00892 * 00893 * @exception Exception 00894 * - No variant specified (id 48) 00895 * - Number of parameter is outside the specified signature (id 48) 00896 * 00897 */ 00898 bool TypeCheck(int n); 00899 00900 /** 00901 * Perform a type check on the list of current parameter values. 00902 * 00903 * The type check is based on c type cast and should accept any types 00904 * derived from those given in the signature. 00905 * 00906 * @return 00907 * True if all parameter types matche the signature 00908 * 00909 * @exception Exception 00910 * - No variant specified (id 48) 00911 * - Number of parameters does not match signature (id 48) 00912 * 00913 */ 00914 bool TypeCheck(void); 00915 00916 /** 00917 * Perform operation. 00918 * 00919 * Runs a type check and then the actual function. 00920 * 00921 * @exception Exception 00922 * - No variant specified (id 48) 00923 * - Parameter position out of range (id 48) 00924 * - Type mismatch (id 48) 00925 * - Any other exception thrown ba the actual function (id xxx) 00926 */ 00927 void Execute(void); 00928 00929 00930 protected: 00931 00932 /** 00933 * Helper: generate typed reference for parameter. 00934 * 00935 * @param n 00936 * Parameter position to cast 00937 * @param rTypedRef 00938 * Typed reference to generyte 00939 * @tparam T 00940 * c type to use for cast 00941 * @return 00942 * True if cast succeeded. 00943 * @exception Exception 00944 * - No variant specified (id 48) 00945 * - Parameter position out of range (id 48) 00946 */ 00947 template<class T> 00948 bool DoTypeCast(int n, T*& rTypedRef) { 00949 if(!Variant()) { 00950 std::stringstream err; 00951 err << "No variant specified"; 00952 throw Exception("Function::DoTypeCast()", err.str(), 48); 00953 } 00954 if(n<0 || n >= ParamsSize()) { 00955 std::stringstream err; 00956 err << "Parameter position out of range"; 00957 throw Exception("Function::DoTypeCast()", err.str(), 48); 00958 } 00959 rTypedRef=dynamic_cast<T*>(ParamValue(n)); 00960 return rTypedRef!=NULL; 00961 } 00962 00963 /** 00964 * Method to test the type of an assigned parameter with the 00965 * specified faudes::Signature (i.e. their TypeDefinition label). 00966 * 00967 * Note: this method is called by Function::Execute() before actual function 00968 * execution via DoExecute(). It may be used to perform a dynamic cast in 00969 * preparation of DoExecute(). The latter is only called, if all types match. 00970 * 00971 * @param n 00972 * Position of parameter to check 00973 * @return 00974 * True if type matches signature. 00975 * 00976 * @exception Exception 00977 * - Signature undefined (id 48) 00978 * - Parameter number out of range (id 48) 00979 */ 00980 virtual bool DoTypeCheck(int n) = 0; 00981 00982 /** 00983 * Executes code of reimplemented method of child class(es). 00984 */ 00985 virtual void DoExecute() = 0; 00986 00987 /** 00988 * Write function-data (typeid-name of arguments) to TokenWriter. 00989 * 00990 * @param rTw 00991 * Reference to Tokenwriter. 00992 * @param rLabel 00993 * Label of section to write. 00994 * @param pContext 00995 * Context pointer, ignored 00996 * 00997 * @exception Exception 00998 * - IO Error 00999 */ 01000 void DoWrite(TokenWriter& rTw, const std::string& rLabel = "", const Type* pContext=0) const; 01001 01002 /** corresponding function definition */ 01003 const FunctionDefinition* pFuncDef; 01004 01005 /** current variant aka signature as index w.r.t. the function definition */ 01006 int mVariantIndex; 01007 01008 /** Vector of arguments. */ 01009 std::vector<Type*> mParameterValues; 01010 01011 }; // Function 01012 01013 01014 01015 /********************************************************************************************** 01016 *********************************************************************************************** 01017 *********************************************************************************************** 01018 01019 Implemention of template members functions 01020 01021 *********************************************************************************************** 01022 *********************************************************************************************** 01023 **********************************************************************************************/ 01024 01025 01026 // typedefinition constructor function 01027 template<class T> 01028 FunctionDefinition* FunctionDefinition::Constructor(const std::string& rFunctionName){ 01029 FD_DRTI("FunctionDefinition::Construct<" << typeid(T).name() << ">()"); 01030 // construct void definition 01031 FunctionDefinition* td = new FunctionDefinition(); 01032 // set its prototype object (note the 0 param in the new constructor) 01033 td->Prototype(new T(0)); 01034 // set minmum values ie the function name 01035 std::string name=rFunctionName; 01036 if(name=="") name=typeid(T).name(); 01037 td->Name(name); 01038 FD_DRTI("FunctionDefinition::Constructor<" << typeid(T).name() << ">(): done"); 01039 return(td); 01040 } 01041 01042 01043 // function definition constructor function 01044 template<class T> 01045 FunctionDefinition* FunctionDefinition::FromFile(const std::string& rFileName){ 01046 FD_DRTI("FunctionDefinition::FromFile<" << typeid(T).name() << ">()"); 01047 // construct with fallback name 01048 FunctionDefinition* td = Constructor<T>(); 01049 // read docu, incl actual name 01050 td->Read(rFileName); 01051 // done 01052 FD_DRTI("FunctionDefinition::FromFile<" << typeid(T).name() << ">(): done"); 01053 return(td); 01054 } 01055 01056 01057 } // namespace 01058 01059 01060 #endif /* FAUDES_FUNCTIONS_H */ |
libFAUDES 2.20d --- 2011.04.26 --- c++ source docu by doxygen