/lib/libtvubase/tvu_calculate.h Source File

00001 
00011 #ifndef __TVU_CALCULATE_H__
00012 #define __TVU_CALCULATE_H__
00013 
00014 #ifndef __TVU_TYPESDEF_H__
00015 #include "tvu_typesdef.h"
00016 #endif 
00017 
00018 /*--------------------------------------------------------*/
00020 #define CLASSNAME_VAR_ID                300
00021 #define CLASSNAME_VAR                   "Var"
00022 #define CLASSNAME_EXPRESSION_ID         301
00023 #define CLASSNAME_EXPRESSION            "Expression"
00024 #define CLASSNAME_FUNCTIONCALLER_ID     302
00025 #define CLASSNAME_FUNCTIONCALLER        "FunctionCaller"
00026 #define CLASSNAME_FUNCTIONMODEL_ID      303
00027 #define CLASSNAME_FUNCTIONMODEL         "Function"
00028 #define CLASSNAME_CONSTRAINTMODEL       "Constraint"
00029 #define CLASSNAME_RULEMODEL             "Rule"
00030 /*--------------------------------------------------------*/
00033 #define ENAME_VAR_NAMEOBJECT          "ObjectName"
00034 
00035 #define ENAME_FUNCTIONMODEL_VARS      "Vars"
00036 /*--------------------------------------------------------*/
00037 // Function names
00038 #define FN_CALCULATE_HOLDS               "Holds"
00039 #define FN_CALCULATE_DEBUG               "Debug"
00040 #define FN_CALCULATE_GETRECURRENTNUMBER  "GetRecurrentNumber"
00041 #define FN_CALCULATE_SETRECURRENTNUMBER  "SetRecurrentNumber"
00042 /*--------------------------------------------------------*/
00044 typedef struct tagOPDESCRIPTOR
00045 {
00046     CTInt* m_pOP;
00047     TINT   m_Pos;
00048     TINT   m_Length;
00049     TINT   m_Priority;
00050 } OPDESCRIPTOR, *LPOPDESCRIPTOR;
00051 /*--------------------------------------------------------*/
00052 class CTVar;
00053 class CTExpression;
00054 class CTFunctionCaller;
00055 class CTFunctionModel;
00056 /*--------------------------------------------------------*/
00057 typedef CTVar*             LPCTVar;
00058 typedef CTExpression*      LPCTExpression;
00059 typedef CTFunctionCaller*  LPCTFunctionCaller;
00060 typedef CTFunctionModel*   LPCTFunctionModel;
00061 /*--------------------------------------------------------*/
00062 // Function caller
00063 typedef CTObject* (*FUNCTION_CALLER)(CTList);
00064 /*--------------------------------------------------------*/
00065 #define ADD_CODED_FUNCTION(name, code) \
00066 { \
00067         /* First time */ \
00068         if (!CTFunctionModel::m_CodedFunctions) \
00069                 CTFunctionModel::m_CodedFunctions = new CTItemList(); \
00070         /* Add a new function model object */ \
00071         CTFunctionModel* pNewFunction = new CTFunctionModel(code); \
00072         pNewFunction->SetName(name); \
00073         CTFunctionModel::m_CodedFunctions->Add(pNewFunction); \
00074 }
00075 /*========================================================*/
00078 class CTVar : public CTObject
00079 {
00080     public:
00082         CTVar();
00083         ~CTVar();
00085                 DEFINE_ID_FUNCTIONS(CTVar, CTObject, CLASSNAME_VAR_ID, CLASSNAME_VAR)
00086         public:
00087                 virtual CTList  GetSaveLoadObjects(TBOOL bOnLoad = TTRUE);
00089                 virtual TBOOL Save(LPCTFile pFile, TINT Marge)
00090                         { return SaveExpression(pFile, Marge); };
00092                 virtual TBOOL SaveExpression(LPCTFile pFile, TINT Marge);
00093         public:
00095                 virtual LPCTObject GetValue();
00098                 virtual CTObject* Calculate(TINT iOperator, CTObject* Object);
00100                 virtual TBOOL SetObject(LPCTObject Object) { return (m_pObject = Object) != TNULL; };
00102                 virtual TBOOL Build(CTList Objects, TLPCSTR lpCreateClass = TNULL);
00104                 virtual TBOOL IsWellBuilt(TBOOL bTestOnly = TFALSE);
00105                 // ! Verify if the expression contains an object of the given name
00106                 virtual TBOOL IsContains(TLPCSTR ObjectName);
00107         public:
00109                 CTVar& operator = (CTVar& Object);
00110     public:
00112                 CTString m_Name;
00114                 LPCTObject m_pObject;
00115     public:
00118                 static CTObject* Holds(CTList pObjects);
00119 };
00120 /*--------------------------------------------------------*/
00123 class CTExpression : public CTItemList
00124 {
00125     public:
00127         CTExpression();
00128         CTExpression(CTObject* Object);
00129         ~CTExpression();
00131                 DEFINE_ID_FUNCTIONS(CTExpression, CTItemList, CLASSNAME_EXPRESSION_ID, CLASSNAME_EXPRESSION)
00133                 virtual CTItemList* CreateNewItem() { return new CTExpression(); };
00134                 virtual CTItemList* CreateNewItem(LPCTObject Object) { return new CTExpression(Object); };
00135         public:
00137                 virtual TBOOL Save(LPCTFile pFile, TINT Marge);
00139                 virtual TBOOL SaveExpression(LPCTFile pFile, TINT Marge);
00141                 virtual TBOOL Load(LPTBYTE* lpBuffers);         
00142         public:
00144                 virtual TBOOL Build(CTList Objects, TLPCSTR lpCreateClass = TNULL, TBOOL bBuildFunctions = TTRUE, CTList pExpression = TNULL);
00146                 virtual TBOOL IsWellBuilt(TBOOL bTestOnly = TFALSE, CTList pExpression = TNULL);
00147                 // ! Verify if the expression contains an object of the given name
00148                 virtual TBOOL IsContains(TLPCSTR ObjectName, CTList pExpression = TNULL);
00150                 virtual CTObject* GetValue();
00153                 virtual CTObject* Calculate(TINT iOperator, CTObject* Object);
00154     protected:
00156                 CTObject* Analyse(LPTBYTE lpBuffers, TINT Len);
00157                 CTObject* Analyse(LPTBYTE lpBuffers, TINT Left, TINT Right, LPOPDESCRIPTOR* OPs, TBOOL bFirstTime = TFALSE);
00165                 TINT FindBreakingPos(LPTBYTE lpBuffers, TINT Left, TINT Right, LPOPDESCRIPTOR* OPs, TINT* Pos, TBOOL* bContainsPoint, TBOOL* bContainsParentheses);
00167                 CTObject* AnalyseFunctionCall(LPTBYTE lpBuffers, TINT Left, TINT Right, LPOPDESCRIPTOR* OPs);
00170                 CTObject* AnalyseAtom(LPTBYTE lpBuffers, TINT Left, TINT Right, LPOPDESCRIPTOR* OPs, TBOOL bContainsPoint);
00173                 CTObject* AnalyseComplexExpresion(LPTBYTE lpBuffers, TINT Left, TINT Right, LPOPDESCRIPTOR* OPs, TINT nPos, TINT* Pos, TBOOL bFirstTime = TFALSE);
00176                 TINT FindOP(LPTBYTE lpBuffers, TINT Left, TINT Right, LPOPDESCRIPTOR* OPs);
00178                 TINT FirstPos(LPTBYTE lpBuffers, TINT StartPos, TINT Inc = 1);
00180                 TINT Priority(TINT op);
00182                 TBOOL IsValidCharacter(char c);
00183         public:
00185                 CTExpression& operator = (CTExpression& Object);
00186     public:
00188                 static CTExpression* CreateExpression(CTObject* Object1, CTInt* OP, CTObject* Object2);
00189                 static CTExpression* CreateExpression(CTObject* Object1, TLPCSTR OP, CTObject* Object2);
00191                 static CTExpression* CreateAttributeExpression(CTObject* Object, CTInt* idAttribute);
00192                 static CTExpression* CreateAttributeExpression(CTObject* Object, TLPCSTR strAttribute);
00194                 static CTObject* CF_Debug(CTList Objects);
00195     public:
00196                 static CTBool m_Debug;
00197                 static TINT   m_Level;
00198 };
00199 /*--------------------------------------------------------*/
00202 class CTFunctionCaller : public CTObject
00203 {
00204     public:
00206         CTFunctionCaller();
00207         ~CTFunctionCaller();
00209                 DEFINE_ID_FUNCTIONS(CTFunctionCaller, CTObject, CLASSNAME_FUNCTIONCALLER_ID, CLASSNAME_FUNCTIONCALLER)
00210         public:
00212                 virtual TBOOL Save(LPCTFile pFile, TINT Marge)
00213                         { return SaveExpression(pFile, Marge); };
00215                 virtual TBOOL SaveExpression(LPCTFile pFile, TINT Marge);
00216         public:
00218                 virtual LPCTObject GetValue();
00221                 virtual CTObject* Calculate(TINT iOperator, CTObject* Object);
00223                 virtual TBOOL Build(CTList Objects, TLPCSTR lpCreateClass = TNULL, TBOOL bBuildFunctions = TTRUE);
00225                 virtual TBOOL IsWellBuilt(TBOOL bTestOnly = TFALSE);
00226                 // ! Verify if the expression contains an object of the given name
00227                 virtual TBOOL IsContains(TLPCSTR ObjectName);
00228         public:
00230                 CTFunctionCaller& operator = (CTFunctionCaller& Object);
00231     public:
00233                 CTString m_FunctionName;
00234                 CTFunctionModel* m_Function;
00236                 CTExpression* m_Values;
00237 };
00238 /*--------------------------------------------------------*/
00241 class CTFunctionModel : public CTObject
00242 {
00243     public:
00245         CTFunctionModel();
00246         CTFunctionModel(FUNCTION_CALLER Function);
00247         ~CTFunctionModel();
00249                 DEFINE_ID_FUNCTIONS(CTFunctionModel, CTObject, CLASSNAME_FUNCTIONMODEL_ID, CLASSNAME_FUNCTIONMODEL)
00250         public:
00252                 virtual TBOOL OnLoading(LPTBYTE* lpBuffers);
00254                 virtual TBOOL LoadVariableBlock(LPTBYTE* lpBuffers);
00255         public:
00257                 virtual TBOOL Build(CTList Objects, TLPCSTR lpCreateClass = TNULL);
00259                 virtual TBOOL IsWellBuilt(TBOOL bTestOnly = TFALSE);
00260                 // ! Verify if the expression contains an object of the given name
00261                 virtual TBOOL IsContains(TLPCSTR ObjectName);
00264                 virtual CTObject* GetValue(CTList Values);
00265                 virtual CTObject* GetValue();
00266         public:
00268                 CTFunctionModel& operator = (CTFunctionModel& Object);
00269     public:
00271                 CTList m_Vars;
00274                 CTExpression* m_Expressions;
00275     protected:
00277                 TBOOL m_IsBuilt;
00279                 TINT m_nParameters;
00281                 TINT* m_VaribelTypes;
00283                 TINT m_nCalls;
00284     public:
00285                 // List of all coded function: sin, cos,...
00286                 static CTList m_CodedFunctions;
00287                 // Maximal number of loop for recurrent functions
00288                 static CTInt m_nMaxCallNumber;
00289    public:
00291                 static CTObject* CF_GetRecurrentNumber(CTList Objects);
00292                 static CTObject* CF_SetRecurrentNumber(CTList Objects);
00293 };
00294 /*========================================================*/
00295 #endif