EXPR_Environment.h

#ifndef EXPR_Environment_H
#define EXPR_Environment_H
 
//inherite class header
#include "EXPR_Object.h"
 
//varaible node header
#include "EXPR_VariableNode.h"
 
//class factory header
 #include "CORE_ClassFactory.h"
 
class EXPR_Environment : public virtual EXPR_Object {
 
    
private:
    //attributes
    //map of variable
    //string -> object
    std::map<tString,CORE_SharedPointer<EXPR_VariableNode>> mVariables;
    
private:
    //associations
protected:
    //builders
 
    EXPR_Environment() {
    }
    
    //deleters
    virtual ~EXPR_Environment() {
    }
    
public:
    //methods
    static inline  CORE_UniquePointer<EXPR_Environment> New() {
        CORE_UniquePointer<EXPR_Environment> p(new EXPR_Environment(),
                                               EXPR_Environment::Delete());
        return p;
    }
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=EXPR_Object::getContentsMemorySize();
        for(const auto& var:mVariables) {
            mem+=var.first.length()*sizeof(tUChar);
            mem+=var.second->getContentsMemorySize();
        }
        return mem;
    }
    inline CORE_SharedPointer<EXPR_VariableNode> lookUpSharedPointer(const tString& var) const {
        auto iter=mVariables.find(var);
        if (iter!= mVariables.cend()) return (iter->second);
        CORE_SharedPointer<EXPR_VariableNode> nullPtr;
        return nullPtr;
    }
    inline const EXPR_VariableNode* lookUp(const tString& var) const {
        auto iter=mVariables.find(var);
        if (iter!= mVariables.cend()) return (iter->second.get());
        return null;
    }
    inline EXPR_VariableNode* lookUp(const tString& var) {
        auto iter=mVariables.find(var);
        if (iter!= mVariables.cend()) return (iter->second.get());
        return null;
    }
 
   
    inline void record(const tString& varName,CORE_UniquePointer<EXPR_VariableNode> var) {
        mVariables[varName]=CORE_ClassFactory::NewSharedPointer(var);
    }
    inline void record(const tString& varName,CORE_SharedPointer<EXPR_VariableNode> var) {
        mVariables[varName]=var;
    }
   
    
    inline void adimensionize(const tReal& L,std::map<tString,tBoolean>& alreadyComputed) {
        EXPR_RootNode *node;
        for(auto& var:mVariables) {
            node=(var.second)->getExpression();
            if (node!=null) {
                if (alreadyComputed.find(node->getIdentityString())==alreadyComputed.end()) {
                    node->adimensionize(L,alreadyComputed);
                }
            }
        }
    }
    
    
   inline void computeBoundingBox(std::map<tString,tBoolean>& alreadyComputed)  {
       
       EXPR_RootNode *node;
       for(auto& var:mVariables) {
           node=(var.second)->getExpression();
           if (node!=null) {
               if (alreadyComputed.find(node->getIdentityString())==alreadyComputed.end()) {
                   node->computeBoundingBox(alreadyComputed);
               }        
           }
       }
   }
    
    inline tBoolean isConsistant() const {
        tBoolean ok=true;
        for(auto& var:mVariables) {
            ok=ok && ((var.second)->getExpression()!=null);
        }
        return ok;
    }
    
    virtual tString toString() const override {
        std::stringstream sout;
        const EXPR_RootNode *node;
        for(const auto& var:mVariables) {
                node=(var.second)->getExpression();
                sout <<var.second->toString()<<"=";
                if (node!=null) sout<<node->toString();
                sout<<"\n";
        }
        return sout.str();
    }
};
 
#endif