source: XIOS/trunk/src/parse_expr/expr_node.hpp @ 458

Last change on this file since 458 was 458, checked in by ymipsl, 10 years ago

Add new parsing expression functionnalities
adding new files

YM
File size: 10.7 KB
Line 
1#ifndef __XIOS_EXPR_NODE_HPP__
2#define __XIOS_EXPR_NODE_HPP__
3
4#include "variable.hpp"
5#include "simple_node_expr.hpp"
6#include "operator_expr.hpp"
7#include "lex_parser.hpp"
8
9namespace xios
10{
11  class CField ;
12///////////////////////////////////////
13//         class CNodeExpr           //
14///////////////////////////////////////
15 
16  class CNodeExpr 
17  {
18    public:
19    CNodeExpr(void) : reduced(false) {};
20   
21    bool reduced ;
22    bool isReduced(void) { return reduced ; } 
23    virtual ~CNodeExpr() {}
24  } ;
25
26////////////////////////////////////////////////////////////////////////
27
28///////////////////////////////////////
29//         class CScalarNode           //
30///////////////////////////////////////
31
32  class CScalarNode : public CNodeExpr
33  {
34    public:
35    CScalarNode(void) : CNodeExpr() {}
36    static CScalarNode* newNode(CSimpleNodeExpr* simpleNode) ;
37    virtual void reduce(void)=0 ; 
38     
39    double val ;
40    virtual ~CScalarNode() {}
41  } ;
42
43////////////////////////////////////////////////////////////////////////
44
45///////////////////////////////////////
46//      class CScalarDouble          //
47///////////////////////////////////////
48
49  class CScalarDouble : public CScalarNode
50  {
51    public :
52   
53    CScalarDouble(CSimpleNodeExpr* simpleNode) : CScalarNode()
54    {
55      strVal=simpleNode->id ;
56    }
57   
58    virtual void reduce(void)
59    {
60      if (!reduced)
61      {
62        CType<double> tval ;
63        tval.fromString(strVal) ;
64        val=tval ;
65        reduced=true ;
66      }
67    }
68   
69    virtual ~CScalarDouble() {}
70    string strVal ;
71  } ;
72
73
74////////////////////////////////////////////////////////////////////////
75
76///////////////////////////////////////
77//       class CScalarVariable       //
78///////////////////////////////////////
79
80
81
82  class CScalarVariable : public CScalarNode
83  {
84    public :
85    CScalarVariable(CSimpleNodeExpr* simpleNode) : CScalarNode()
86    {
87      varId=simpleNode->id ;
88    }
89   
90    void reduce(void)
91    {
92      if (!reduced)
93      {
94        if (CVariable::has(varId)) 
95        {
96          val=CVariable::get(varId)->getData<double>() ;
97          reduced=true ;
98        }
99        else ERROR("void CScalarVariable::reduce(void)",<<" Variable "<<varId<<" does not exist")
100      }
101    }
102    virtual ~CScalarVariable() {}
103    string varId ;
104  } ;
105
106////////////////////////////////////////////////////////////////////////
107
108///////////////////////////////////////
109//      class COperatorScalarNode    //
110///////////////////////////////////////
111
112
113  class COperatorScalarNode : public CScalarNode
114  {
115    public :
116    COperatorScalarNode(CSimpleNodeExpr* simpleNode) : CScalarNode()
117    {
118      opId=simpleNode->id ;
119      child=newNode(simpleNode->children[0]) ;
120    }
121   
122    void reduce(void)
123    {
124      child->reduce() ;
125      op=operatorExpr.getOpScalar(opId) ;
126      if (child->isReduced())
127      {
128       val=op(child->val) ;
129       reduced=true ;
130      }
131    }
132       
133    virtual ~COperatorScalarNode() { delete child; }
134   
135    CScalarNode* child ;
136    string opId ;
137    double (*op)(double) ;
138  } ;
139
140////////////////////////////////////////////////////////////////////////
141
142
143/////////////////////////////////////////////
144//   class COperatorScalarScalarNode       //
145/////////////////////////////////////////////
146
147  class COperatorScalarScalarNode : public CScalarNode
148  {
149    public : 
150    COperatorScalarScalarNode(CSimpleNodeExpr* simpleNode) : CScalarNode()
151    {
152      opId=simpleNode->id ;
153      child1=newNode(simpleNode->children[0]) ;
154      child2=newNode(simpleNode->children[1]) ;
155    }
156   
157    void reduce(void)
158    {
159      child1->reduce() ;
160      child2->reduce() ;
161      op=operatorExpr.getOpScalarScalar(opId) ;
162      if (child1->isReduced() && child2->isReduced())
163      {
164        op=operatorExpr.getOpScalarScalar(opId) ;
165        val=op(child1->val,child2->val) ;
166        reduced=true ;
167      }
168    }
169   
170    virtual ~COperatorScalarScalarNode()
171    {
172      delete child1 ;
173      delete child2 ;
174    }
175   
176    CScalarNode* child1 ;
177    CScalarNode* child2 ;
178    double (*op)(double,double) ;
179    string opId ;
180  } ;
181
182 
183////////////////////////////////////////////////////////////////////////
184
185///////////////////////////////////////
186//         class CFieldNode          //
187///////////////////////////////////////
188
189
190  class CFieldNode : public CNodeExpr
191  {
192    public:
193    CFieldNode(void) : CNodeExpr() {}
194    static CFieldNode* newNode(CSimpleNodeExpr* simpleNode) ;
195    virtual void reduce(CField* thisField = NULL) =0 ; 
196    virtual CArray<double,1> compute(void)=0 ;
197    virtual void getFieldIds(set<string>& fieldIds)=0 ;
198    virtual void getFields(set<CField*>& fields)=0 ;
199     
200    virtual ~CFieldNode() {}
201  } ;
202
203
204////////////////////////////////////////////////////////////////////////
205
206///////////////////////////////////////
207//       class CInstantFieldNode     //
208/////////////////////////////////////// 
209
210  class CInstantFieldNode : public CFieldNode
211  {
212    public:
213    CInstantFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), fieldId(simpleNode->id) {}
214    virtual void reduce(CField* thisField = NULL) ;
215    virtual CArray<double,1> compute(void) { return CArray<double,1>(*array);}
216    virtual ~CInstantFieldNode() { }
217    virtual void getFieldIds(set<string>& fieldIds) { fieldIds.insert(fieldId) ;}
218    virtual void getFields(set<CField*>& fields) { fields.insert(field) ;}
219       
220    string fieldId;
221    CField* field ;
222    CArray<double,1>* array ;
223  };
224
225
226
227////////////////////////////////////////////////////////////////////////
228
229///////////////////////////////////////
230//       class CAverageFieldNode     //
231///////////////////////////////////////
232
233
234  class CAverageFieldNode : public CFieldNode
235  {
236    public:
237   
238    CAverageFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), fieldId(simpleNode->id) {}
239   
240    virtual void reduce(CField* thisField = NULL) ;
241    virtual CArray<double,1> compute(void) { return CArray<double,1>(*array); }
242    virtual void getFieldIds(set<string>& fieldIds) { fieldIds.insert(fieldId) ;}
243    virtual void getFields(set<CField*>& fields) { fields.insert(field) ;}
244    virtual ~CAverageFieldNode() {}
245    string fieldId;
246    CField* field ;
247    CArray<double,1>* array ;
248  };
249
250
251////////////////////////////////////////////////////////////////////////
252
253///////////////////////////////////////
254//         class COperatorFieldNode  //
255///////////////////////////////////////
256 
257  class COperatorFieldNode : public CFieldNode
258  {
259    public:
260   
261    COperatorFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), opId(simpleNode->id)
262    {
263      child=newNode(simpleNode->children[0]) ;
264    }
265   
266    virtual void reduce(CField* thisField = NULL)
267    {
268      child->reduce(thisField) ;
269      op=operatorExpr.getOpField(opId) ;
270      reduced=true ;
271    }
272   
273    virtual void getFieldIds(set<string>& fieldIds) {child-> getFieldIds(fieldIds);}
274    virtual void getFields(set<CField*>& fields) {child-> getFields(fields);}
275   
276    virtual CArray<double,1> compute(void)
277    {
278      return op(child->compute()) ;
279    }
280    virtual ~COperatorFieldNode() { delete child; }
281     
282    CFieldNode* child ;
283    string opId ;
284    CArray<double,1> (*op)( const CArray<double,1>&) ;
285  };
286
287
288////////////////////////////////////////////////////////////////////////
289
290///////////////////////////////////////
291//     COperatorFieldFieldNode       //
292///////////////////////////////////////
293
294 
295  class COperatorFieldFieldNode : public CFieldNode
296  {
297    public:
298   
299    COperatorFieldFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(),opId(simpleNode->id) 
300    {
301      child1=newNode(simpleNode->children[0]) ;
302      child2=newNode(simpleNode->children[1]) ;
303    }
304   
305    virtual void reduce(CField* thisField = NULL)
306    {
307      child1->reduce(thisField) ;
308      child2->reduce(thisField) ;
309      op=operatorExpr.getOpFieldField(opId) ;
310      reduced=true ;
311    }
312
313    virtual void getFieldIds(set<string>& fieldIds) {child1-> getFieldIds(fieldIds); child2-> getFieldIds(fieldIds);}
314    virtual void getFields(set<CField*>& fields) {child1-> getFields(fields); child2-> getFields(fields);}
315
316    virtual CArray<double,1> compute(void)
317    {
318      return op(child1->compute(),child2->compute()) ;
319    }
320   
321    virtual ~COperatorFieldFieldNode() { delete child1; delete child2 ; }
322
323    CFieldNode* child1 ;
324    CFieldNode* child2 ;
325    string opId ;
326    CArray<double,1> (*op)( const CArray<double,1>&,const CArray<double,1>&) ;   
327  };
328
329
330////////////////////////////////////////////////////////////////////////
331
332////////////////////////////////////////////
333//   class COperatorScalarFieldNode       //
334////////////////////////////////////////////
335 
336  class COperatorScalarFieldNode : public CFieldNode
337  {
338    public:
339   
340    COperatorScalarFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), opId(simpleNode->id)
341    {
342      child1=CScalarNode::newNode(simpleNode->children[0]) ;
343      child2=newNode(simpleNode->children[1]) ;
344    }
345   
346    virtual void reduce(CField* thisField = NULL)
347    {
348      child1->reduce() ;
349      child2->reduce(thisField) ;
350      op=operatorExpr.getOpScalarField(opId) ;
351      reduced=true ;
352    }
353   
354    virtual void getFieldIds(set<string>& fieldIds) {child2-> getFieldIds(fieldIds);}
355    virtual void getFields(set<CField*>& fields) {child2-> getFields(fields);}
356
357    virtual CArray<double,1> compute(void)
358    {
359      return op(child1->val,child2->compute()) ;
360    }   
361   
362    ~COperatorScalarFieldNode() { delete child1 ; delete child2 ; }
363   
364    CScalarNode* child1 ;
365    CFieldNode* child2 ;
366    string opId ;
367    CArray<double,1> (*op)(double,const CArray<double,1>&) ;       
368  };
369
370
371////////////////////////////////////////////////////////////////////////
372
373///////////////////////////////////////////
374//    class COperatorFieldScalarNode     //
375///////////////////////////////////////////
376 
377  class COperatorFieldScalarNode : public CFieldNode
378  {
379    public:
380   
381    COperatorFieldScalarNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), opId(simpleNode->id)
382    {
383      child1=newNode(simpleNode->children[0]) ;
384      child2=CScalarNode::newNode(simpleNode->children[1]) ;
385    }
386   
387    virtual void reduce(CField* thisField = NULL)
388    {
389      child1->reduce(thisField) ;
390      child2->reduce() ;
391      op=operatorExpr.getOpFieldScalar(opId) ;
392      reduced=true ;
393    }
394   
395    virtual CArray<double,1> compute(void)
396    {
397      return op(child1->compute(),child2->val) ;
398    }
399   
400    virtual void getFieldIds(set<string>& fieldIds) {child1-> getFieldIds(fieldIds);}
401    virtual void getFields(set<CField*>& fields) {child1-> getFields(fields);}
402
403    ~COperatorFieldScalarNode() {delete child1, delete child2; }
404         
405    CFieldNode* child1 ;
406    CScalarNode* child2 ;
407    string opId ;
408    CArray<double,1> (*op)( const CArray<double,1>&, double) ;   
409  };
410 
411}
412
413#endif
Note: See TracBrowser for help on using the repository browser.