EXPR_VariableNode.h

#ifndef EXPR_VariableNode_H
#define EXPR_VariableNode_H
 
#include "EXPR_LeafNode.h"
 
#include "EXPR_RootNode.h"
 
class EXPR_VariableNode : public virtual EXPR_LeafNode {
    
private:
    //attributes
    
    tString mName;
    CORE_UniquePointer<EXPR_RootNode> mTree;
    
private:
    //associations
protected:
    //builders
    
    EXPR_VariableNode() {
    }
    
    //deleters
    virtual ~EXPR_VariableNode() {
    }
    
public:
    static inline CORE_UniquePointer<EXPR_VariableNode> New() {
        CORE_UniquePointer<EXPR_VariableNode> p(new EXPR_VariableNode(),
                                                EXPR_VariableNode::Delete());
       
        return p;
    }
 
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=EXPR_LeafNode::getContentsMemorySize();
        mem+=(mTree.get()==null)?0:mTree->getContentsMemorySize();
        mem+=mName.size()*sizeof(tUChar);
        return mem;
    }
    inline void setName(const tString& name) {
        mName=name;
    }
 
    inline void setExpression(CORE_UniquePointer<EXPR_RootNode> node) {
        mTree=std::move(node);
    }
    inline  const EXPR_RootNode* getExpression() const {
        return mTree.get();
    }
    inline  EXPR_RootNode* getExpression()  {
        return mTree.get();
    }
 
   
    virtual tBoolean isInside(std::array<tReal,3> P) const override  {
        if (mTree.get()==null) return false;
        
        //test if the point p is in the box
        if (!isInsideBoundingBox(P)) {
            return false;
        }
        
        //test if the transform point is inside the geometry
        applyInverse(P);
        return mTree->isInside(P);
    }
    
    virtual void computeBoundingBox(std::map<tString,tBoolean>& alreadyComputed) override {
        if (alreadyComputed.find(getIdentityString())==alreadyComputed.end()) {
            
            if (mTree.get()==null) return;
            
            mTree->computeBoundingBox(alreadyComputed);
            
            //get the value of the bounding box of thee tree
            
            const std::array<tReal,3>& P=mTree->getBoundingBoxMinPoint();
            const std::array<tReal,3>& Q=mTree->getBoundingBoxMaxPoint();
            
            //copy it to point of variable
            std::array<tReal,3>& minPoint=getBoundingBoxMinPoint();
            std::array<tReal,3>& maxPoint=getBoundingBoxMaxPoint();
            
            memcpy(minPoint.data(),P.data(),P.size()*sizeof(tReal));
            memcpy(maxPoint.data(),Q.data(),Q.size()*sizeof(tReal));
            
            alreadyComputed[getIdentityString()]=true;
        }
    }
 
    virtual void adimensionize(const tReal& L,std::map<tString,tBoolean>& alreadyComputed) override {
        //cout << getIdentityString()<<"::EXPR_VariableNode::adimensionize("<<L<<") \n";
        if (alreadyComputed.find(getIdentityString())==alreadyComputed.end()) {
            if (mTree.get()!=null) {
                //adimensionize the variable which has not been already adimensionized
                mTree->adimensionize(L,alreadyComputed);
            }
            EXPR_LeafNode::adimensionize(L,alreadyComputed);
        }
    }
    
public:
    
    virtual tString toString() const override {
        return mName;
    }
};
 
 
 
 
 
#endif