EXPR_Parser.h

#ifndef EXPR_Parser_H
#define EXPR_Parser_H
 
#include "EXPR_Object.h"
 
#include "EXPR_Tokenizer.h"
#include "EXPR_RootNode.h"
#include "EXPR_Environment.h"
 
#include "EXPR_OperatorNode.h"
#include "EXPR_GroupNode.h"
#include "EXPR_ElementaryGeometryNode.h"
#include "EXPR_Function.h"
 
 
class EXPR_Parser : public virtual EXPR_Object {
    
private:
    //attributes
   
    
private:
    //associations
 
    CORE_UniquePointer<EXPR_Tokenizer> mTokenizer;
    CORE_UniquePointer<EXPR_Environment> mEnvironment;
    CORE_UniquePointer<EXPR_RootNode> mTree;
    
    //list of unary operators
    std::vector<CORE_UniquePointer<EXPR_OperatorNode>> mLeftUnaryOperators;
    
    //list of binary operators withith priority 1
    std::vector<CORE_UniquePointer<EXPR_OperatorNode>> m1OrderBinaryOperators;
    //list of binary operators withith priority 2
    std::vector<CORE_UniquePointer<EXPR_OperatorNode>> m2OrderBinaryOperators;
 
    //list of leaf geometries
    std::vector<CORE_UniquePointer<EXPR_ElementaryGeometryNode>> mGeometries;
 
    //list of predeifined functions
    std::vector<CORE_UniquePointer<EXPR_Function>> mFunctions;
 
    //expression to parse
    tString mParseExpression;
    
protected:
    //builders
 
    EXPR_Parser();
    
    //deleters
    virtual ~EXPR_Parser();
public:
    //methods
 
    inline static CORE_UniquePointer<EXPR_Parser> New() {
        CORE_UniquePointer<EXPR_Parser> p(new EXPR_Parser(),EXPR_Parser::Delete());
        return p;
    };
    
    const EXPR_RootNode * getTree() const {
        return mTree.get();
    }
    const EXPR_RootNode * getTree(const tString& name) const {
        const EXPR_VariableNode* var=mEnvironment->lookUp(name);
        if (var==null) return null;
        return var->getExpression();
    }
    const EXPR_Environment * getEnvironment() const {
        return mEnvironment.get();
    }
    EXPR_Environment * getEnvironment()  {
        return mEnvironment.get();
    }
 
 
    tBoolean parse(const tString& expr);
    
    inline tBoolean parse() {
        return parse(mParseExpression);
    }
    
    inline const tString& getParseExpression() const {
        return mParseExpression;
    }
 
    inline void computeBoundingBox()  {
        std::map<tString,tBoolean>  alreadyComputed;
        mEnvironment->computeBoundingBox(alreadyComputed);
        mTree->computeBoundingBox(alreadyComputed);
    }
    
    inline void adimensionize(const tReal& L) {
        if (L==0) {
            std::cout << "adimenionsionization failed when L=0. Ignored \n";
            return;
        }
        std::map<tString,tBoolean>  alreadyComputed;
        mEnvironment->adimensionize(L,alreadyComputed);
        mTree->adimensionize(L,alreadyComputed);
    }
    
private:
    tBoolean readAssignement(EXPR_Environment& env);
    
    tBoolean readExpression(EXPR_ParentNode& node);
 
    CORE_SharedPointer<EXPR_ChildNode> read2OrderBinaryOperator();
    CORE_SharedPointer<EXPR_ChildNode> read1OrderBinaryOperator();
 
    CORE_SharedPointer<EXPR_OperatorNode> readLeftUnaryOperator();
    
    CORE_SharedPointer<EXPR_ChildNode> readTerm();
    
    CORE_SharedPointer<EXPR_GroupNode> readGroup();
    
    CORE_SharedPointer<EXPR_ChildNode> readFunction();
 
    CORE_SharedPointer<EXPR_ChildNode> apply(const tString& name,
                                             const std::vector<tString>& args,
                                             EXPR_Environment& env);
    
    CORE_SharedPointer<EXPR_ChildNode> readFactor();
 
public:
    virtual tString toString() const override;
 
};
 
 
 
 
#endif