EXPR_ParentNode.h

#ifndef EXPR_ParentNode_H
#define EXPR_ParentNode_H
 
//inherited class header
#include "EXPR_Node.h"
 
//class factory header
#include "CORE_ClassFactory.h"
 
//child node
#include "EXPR_ChildNode.h"
 
//strings functions headers
#include "core_string.h"
 
class EXPR_ParentNode : public  virtual EXPR_Node {
   
    
private:
 
 
    
private:
    //associations
    std::vector<CORE_SharedPointer<EXPR_ChildNode>> mChildren;
    
    
protected:
    //builders
 
    EXPR_ParentNode(); 
    
    //deleters
    virtual ~EXPR_ParentNode();
    
public:
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=EXPR_Node::getContentsMemorySize();
        for(const auto& child: mChildren) mem+=child->getContentsMemorySize();
        return mem;
    }
 
    //methods
 
    inline void addChild(CORE_SharedPointer<EXPR_ChildNode> cNode) {
        mChildren.push_back(cNode);
    }
    inline void addChild(CORE_UniquePointer<EXPR_ChildNode> cNode) {
        CORE_SharedPointer<EXPR_ChildNode> sharedChild=CORE_ClassFactory::NewSharedPointer(cNode);
        mChildren.push_back(sharedChild);
    }
    
    inline const std::vector<CORE_SharedPointer<EXPR_ChildNode>>& getChildren() const {
        return mChildren;
    }
    inline std::vector<CORE_SharedPointer<EXPR_ChildNode>>& getChildren()  {
        return mChildren;
    }
 
    inline CORE_SharedPointer<EXPR_ChildNode> getSharedChild(const tIndex& i) {
        if (i>=mChildren.size())  {
            CORE_SharedPointer<EXPR_ChildNode> nullChild;
            return nullChild;
        }
        return mChildren[i];
    }
    
    inline EXPR_ChildNode* getChild(const tIndex& i) {
        if (i>=mChildren.size()) return null;
        return mChildren[i].get();
    }
    
    inline const EXPR_ChildNode* getChild(const tIndex& i) const {
        if (i>=mChildren.size()) return null;
        return mChildren[i].get();
    }
    
   
    virtual void adimensionize(const tReal& L,std::map<tString,tBoolean>& alreadyComputed) override {
        //cout << getIdentityString()<<"::EXPR_ParentNode::adimensionize("<<L<<") \n";
        if (alreadyComputed.find(getIdentityString())==alreadyComputed.end()) {
            for(auto& child:mChildren) {
                child->adimensionize(L,alreadyComputed);
            }
            
            EXPR_Node::adimensionize(L,alreadyComputed);
        }
    }
    
    virtual void computeBoundingBox(std::map<tString,tBoolean>& alreadyComputed) override;
    
    virtual tBoolean isInside(std::array<tReal,3> M) const override ;
    
    
    virtual tString toString() const override {
        tString ret="";
        if (mChildren.size()>0) {
            ret=mChildren[0]->toString();
            core_string::trim(ret);
        }
        return ret;
    }
};
 
 
 
 
#endif