Class that can contain all control elements. Can identify (using RTTI) the elements from a generic list and store them separately. More...

#include <ControlElementContainer.h>

Public Member Functions
virtual void	FillContainer (ControlEditor *editor)

virtual void	FillContainer (std::vector< std::shared_ptr< ControlElement > > controlElementList, std::vector< std::shared_ptr< ConnectionLine > > connectionLineList)

virtual void	GetContainerCopy (std::vector< std::shared_ptr< ControlElement > > &controlElementList, std::vector< std::shared_ptr< ConnectionLine > > &connectionLineList)

virtual void	ClearContainer ()

std::vector< std::shared_ptr< ControlElement > >	GetControlElementsList () const

std::vector< std::shared_ptr< ConnectionLine > >	GetConnectionLineList () const

std::vector< Constant * >	GetConstantList () const

std::vector< Exponential * >	GetExponentialList () const

std::vector< Gain * >	GetGainList () const

std::vector< IOControl * >	GetIOControlList () const

std::vector< Limiter * >	GetLimiterList () const

std::vector< Multiplier * >	GetMultiplierList () const

std::vector< RateLimiter * >	GetRateLimiterList () const

std::vector< Sum * >	GetSumList () const

std::vector< TransferFunction * >	GetTFList () const

std::vector< Divider * >	GetDividerList () const

std::vector< MathExpression * >	GetMathExprList () const

Protected Attributes
std::vector< std::shared_ptr< ControlElement > >	m_ctrlElementsList

std::vector< std::shared_ptr< ConnectionLine > >	m_cLineList

std::vector< Constant * >	m_constantList

std::vector< Exponential * >	m_exponentialList

std::vector< Gain * >	m_gainList

std::vector< IOControl * >	m_ioControlList

std::vector< Limiter * >	m_limiterList

std::vector< Multiplier * >	m_multiplierList

std::vector< RateLimiter * >	m_rateLimiterList

std::vector< Sum * >	m_sumList

std::vector< TransferFunction * >	m_tfList

std::vector< Divider * >	m_dividerList

std::vector< MathExpression * >	m_mathExprList

Detailed Description

Class that can contain all control elements. Can identify (using RTTI) the elements from a generic list and store them separately.

Author: Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br

Date: 05/10/2017

Definition at line 47 of file ControlElementContainer.h.

Constructor & Destructor Documentation

◆ ControlElementContainer()

ControlElementContainer::ControlElementContainer ( )

Definition at line 26 of file ControlElementContainer.cpp.

{
    ClearContainer();
}

◆ ~ControlElementContainer()

ControlElementContainer::~ControlElementContainer ( )

Definition at line 30 of file ControlElementContainer.cpp.

{
    //for (auto* cElement : m_cLineList) delete cElement;
    //for (auto* cElement : m_constantList) delete cElement;
    //for (auto* cElement : m_exponentialList) delete cElement;
    //for (auto* cElement : m_gainList) delete cElement;
    //for (auto* cElement : m_ioControlList) delete cElement;
    //for (auto* cElement : m_limiterList) delete cElement;
    //for (auto* cElement : m_multiplierList) delete cElement;
    //for (auto* cElement : m_rateLimiterList) delete cElement;
    //for (auto* cElement : m_sumList) delete cElement;
    //for (auto* cElement : m_tfList) delete cElement;
    //for (auto* cElement : m_dividerList) delete cElement;
    //for (auto* cElement : m_mathExprList) delete cElement;
    //ClearContainer();
}

Member Function Documentation

◆ ClearContainer()

void ControlElementContainer::ClearContainer ( )

virtual

Definition at line 89 of file ControlElementContainer.cpp.

{
    m_cLineList.clear();
    m_constantList.clear();
    m_exponentialList.clear();
    m_gainList.clear();
    m_ioControlList.clear();
    m_limiterList.clear();
    m_multiplierList.clear();
    m_rateLimiterList.clear();
    m_sumList.clear();
    m_tfList.clear();
    m_dividerList.clear();
    m_mathExprList.clear();
}

◆ FillContainer() [1/2]

void ControlElementContainer::FillContainer ( ControlEditor * editor )

virtual

Definition at line 46 of file ControlElementContainer.cpp.

{
    ClearContainer();
    m_ctrlElementsList = editor->GetControlElementList();
    m_cLineList = editor->GetConnectionLineList();
 
    for (auto& cElement : m_ctrlElementsList) {
        if (Constant* constant = dynamic_cast<Constant*>(cElement.get())) {
            m_constantList.push_back(constant);
        }
        else if (Exponential* exponential = dynamic_cast<Exponential*>(cElement.get())) {
            m_exponentialList.push_back(exponential);
        }
        else if (Gain* gain = dynamic_cast<Gain*>(cElement.get())) {
            m_gainList.push_back(gain);
        }
        else if (IOControl* ioControl = dynamic_cast<IOControl*>(cElement.get())) {
            m_ioControlList.push_back(ioControl);
        }
        else if (Limiter* limiter = dynamic_cast<Limiter*>(cElement.get())) {
            m_limiterList.push_back(limiter);
        }
        else if (Multiplier* multiplier = dynamic_cast<Multiplier*>(cElement.get())) {
            m_multiplierList.push_back(multiplier);
        }
        else if (RateLimiter* rateLimiter = dynamic_cast<RateLimiter*>(cElement.get())) {
            m_rateLimiterList.push_back(rateLimiter);
        }
        else if (Sum* sum = dynamic_cast<Sum*>(cElement.get())) {
            m_sumList.push_back(sum);
        }
        else if (TransferFunction* tf = dynamic_cast<TransferFunction*>(cElement.get())) {
            m_tfList.push_back(tf);
        }
        else if (Divider* divider = dynamic_cast<Divider*>(cElement.get())) {
            m_dividerList.push_back(divider);
        }
        else if (MathExpression* mathExpr = dynamic_cast<MathExpression*>(cElement.get())) {
            m_mathExprList.push_back(mathExpr);
        }
    }
}

◆ FillContainer() [2/2]

void ControlElementContainer::FillContainer	(	std::vector< std::shared_ptr< ControlElement > >	controlElementList,
		std::vector< std::shared_ptr< ConnectionLine > >	connectionLineList
	)

virtual

Definition at line 105 of file ControlElementContainer.cpp.

{
    ClearContainer();
    m_ctrlElementsList = controlElementList;
    m_cLineList = connectionLineList;
 
    for (auto it = controlElementList.begin(), itEnd = controlElementList.end(); it != itEnd; ++it) {
        if (Constant* constant = dynamic_cast<Constant*>(it->get())) {
            m_constantList.push_back(constant);
        }
        else if (Exponential* exponential = dynamic_cast<Exponential*>(it->get())) {
            m_exponentialList.push_back(exponential);
        }
        else if (Gain* gain = dynamic_cast<Gain*>(it->get())) {
            m_gainList.push_back(gain);
        }
        else if (IOControl* ioControl = dynamic_cast<IOControl*>(it->get())) {
            m_ioControlList.push_back(ioControl);
        }
        else if (Limiter* limiter = dynamic_cast<Limiter*>(it->get())) {
            m_limiterList.push_back(limiter);
        }
        else if (Multiplier* multiplier = dynamic_cast<Multiplier*>(it->get())) {
            m_multiplierList.push_back(multiplier);
        }
        else if (RateLimiter* rateLimiter = dynamic_cast<RateLimiter*>(it->get())) {
            m_rateLimiterList.push_back(rateLimiter);
        }
        else if (Sum* sum = dynamic_cast<Sum*>(it->get())) {
            m_sumList.push_back(sum);
        }
        else if (TransferFunction* tf = dynamic_cast<TransferFunction*>(it->get())) {
            m_tfList.push_back(tf);
        }
        else if (Divider* divider = dynamic_cast<Divider*>(it->get())) {
            m_dividerList.push_back(divider);
        }
        else if (MathExpression* mathExpr = dynamic_cast<MathExpression*>(it->get())) {
            m_mathExprList.push_back(mathExpr);
        }
    }
}

◆ GetConnectionLineList()

std::vector< std::shared_ptr< ConnectionLine > > ControlElementContainer::GetConnectionLineList ( ) const

inline

Definition at line 61 of file ControlElementContainer.h.

61{ return m_cLineList; }

◆ GetConstantList()

std::vector< Constant * > ControlElementContainer::GetConstantList ( ) const

inline

Definition at line 62 of file ControlElementContainer.h.

62{ return m_constantList; }

◆ GetContainerCopy()

void ControlElementContainer::GetContainerCopy	(	std::vector< std::shared_ptr< ControlElement > > &	controlElementList,
		std::vector< std::shared_ptr< ConnectionLine > > &	connectionLineList
	)

virtual

Definition at line 149 of file ControlElementContainer.cpp.

{
    controlElementList.clear();
    connectionLineList.clear();
 
    std::map<Element*, Element*> cLineMap;
    std::map<Element*, Element*> cElementMap;
 
    // Copy connection lines
    for (auto& cLine : m_cLineList) {
        ConnectionLine* copyLine = static_cast<ConnectionLine*>(cLine->GetCopy());
        connectionLineList.emplace_back(copyLine);
        cLineMap[cLine.get()] = copyLine;
    }
 
    // Copy elements (exept connection line).
    std::map<Node*, Node*> nodeMap;
    for (auto& cElement : m_ctrlElementsList) {
        ControlElement* copyElement = static_cast<ControlElement*>(cElement->GetCopy());
        cElementMap[cElement.get()] = copyElement;
        controlElementList.emplace_back(copyElement);
        // Copy nodes.
        std::vector<Node*> nodeListCopy;
        for (Node* node : copyElement->GetNodeList()) {
            Node* copyNode = node->GetCopy();
            nodeMap[node] = copyNode;
            nodeListCopy.push_back(copyNode);
        }
        copyElement->SetNodeList(nodeListCopy);
    }
 
    // Correct the parent and child pointers
    for (auto& copyElement : controlElementList) {
        // Child
        for (Element* child : copyElement->GetChildList()) {
            auto it = cLineMap.find(child);
            if (it != cLineMap.end())
                copyElement->ReplaceChild(child, it->second);
        }
    }
    for (auto& copyLine : connectionLineList) {
        // Nodes
        for (Node* node : copyLine->GetNodeList()) {
            auto it = nodeMap.find(node);
            if (it != nodeMap.end())
                copyLine->ReplaceNode(node, it->second);
        }
 
        // Parent element
        for (Element* parent : copyLine->GetParentList()) {
            auto it = cElementMap.find(parent);
            if (it != cElementMap.end())
                copyLine->ReplaceParent(parent, it->second);
        }
        // Parent cLine
        Element* parentLine = static_cast<Element*>(copyLine->GetParentLine());
        auto it = cLineMap.find(parentLine);
        if (it != cLineMap.end())
            copyLine->SetParentLine(static_cast<ConnectionLine*>(it->second));
        else
            copyLine->SetParentLine(nullptr);
 
        // Childs
        for (Element* child : copyLine->GetChildList()) {
            auto it = cLineMap.find(child);
 
            if (it != cLineMap.end())
                copyLine->ReplaceChild(child, it->second);
        }
    }
 
    //int nodeID = 0;
    //for (auto it = m_ctrlElementsList.begin(), itEnd = m_ctrlElementsList.end(); it != itEnd; ++it) {
    //  ControlElement* oldElement = *it;
    //  ControlElement* copy = static_cast<ControlElement*>(oldElement->GetCopy());
    //  controlElementList.push_back(copy);
    //  // Copy nodes.
    //  std::vector<Node*> nodeList = copy->GetNodeList();
    //  std::vector<Node*> nodeListCopy;
    //  for (auto itN = nodeList.begin(), itEndN = nodeList.end(); itN != itEndN; ++itN) {
    //      Node* node = *itN;
    //      node->SetID(nodeID);
    //      Node* copyNode = new Node();
    //      *copyNode = *node;
    //      nodeListCopy.push_back(copyNode);
    //      nodeID++;
    //  }
    //  copy->SetNodeList(nodeListCopy);
    //
    //  // Replace children to copies.
    //  auto childList = copy->GetChildList();
    //  for (auto itC = childList.begin(), itEndC = childList.end(); itC != itEndC; ++itC) {
    //      ConnectionLine* child = static_cast<ConnectionLine*>(*itC);
    //      // Replace child's parent to copy.
    //      for (auto itCL = connectionLineList.begin(), itEndCL = connectionLineList.end(); itCL != itEndCL; ++itCL) {
    //          ConnectionLine* copyLine = *itCL;
    //          if (copyLine->GetID() == child->GetID()) {
    //              // Replace node.
    //              nodeList = child->GetNodeList();
    //              for (auto itN = nodeList.begin(), itEndN = nodeList.end(); itN != itEndN; ++itN) {
    //                  Node* node = *itN;
    //                  for (auto itCN = nodeListCopy.begin(), itEndCN = nodeListCopy.end(); itCN != itEndCN; ++itCN) {
    //                      Node* nodeCopy = *itCN;
    //                      if (node->GetID() == nodeCopy->GetID()) {
    //                          copyLine->ReplaceNode(node, nodeCopy);
    //                          break;
    //                      }
    //                  }
    //              }
    //              copyLine->ReplaceParent(oldElement, copy);
    //              copy->ReplaceChild(child, copyLine);
    //          }
    //      }
    //  }
    //}
}

◆ GetControlElementsList()

std::vector< std::shared_ptr< ControlElement > > ControlElementContainer::GetControlElementsList ( ) const

inline

Definition at line 60 of file ControlElementContainer.h.

60{ return m_ctrlElementsList; }

◆ GetDividerList()

std::vector< Divider * > ControlElementContainer::GetDividerList ( ) const

inline

Definition at line 71 of file ControlElementContainer.h.

71{ return m_dividerList; }

◆ GetExponentialList()

std::vector< Exponential * > ControlElementContainer::GetExponentialList ( ) const

inline

Definition at line 63 of file ControlElementContainer.h.

63{ return m_exponentialList; }

◆ GetGainList()

std::vector< Gain * > ControlElementContainer::GetGainList ( ) const

inline

Definition at line 64 of file ControlElementContainer.h.

64{ return m_gainList; }

◆ GetIOControlList()

std::vector< IOControl * > ControlElementContainer::GetIOControlList ( ) const

inline

Definition at line 65 of file ControlElementContainer.h.

65{ return m_ioControlList; }

◆ GetLimiterList()

std::vector< Limiter * > ControlElementContainer::GetLimiterList ( ) const

inline

Definition at line 66 of file ControlElementContainer.h.

66{ return m_limiterList; }

◆ GetMathExprList()

std::vector< MathExpression * > ControlElementContainer::GetMathExprList ( ) const

inline

Definition at line 72 of file ControlElementContainer.h.

72{ return m_mathExprList; }

◆ GetMultiplierList()

std::vector< Multiplier * > ControlElementContainer::GetMultiplierList ( ) const

inline

Definition at line 67 of file ControlElementContainer.h.

67{ return m_multiplierList; }

◆ GetRateLimiterList()

std::vector< RateLimiter * > ControlElementContainer::GetRateLimiterList ( ) const

inline

Definition at line 68 of file ControlElementContainer.h.

68{ return m_rateLimiterList; }

◆ GetSumList()

std::vector< Sum * > ControlElementContainer::GetSumList ( ) const

inline

Definition at line 69 of file ControlElementContainer.h.

69{ return m_sumList; }

◆ GetTFList()

std::vector< TransferFunction * > ControlElementContainer::GetTFList ( ) const

inline

Definition at line 70 of file ControlElementContainer.h.

70{ return m_tfList; }

Member Data Documentation

◆ m_cLineList

std::vector< std::shared_ptr<ConnectionLine> > ControlElementContainer::m_cLineList

protected

Definition at line 75 of file ControlElementContainer.h.

◆ m_constantList

std::vector<Constant*> ControlElementContainer::m_constantList

protected

Definition at line 77 of file ControlElementContainer.h.

◆ m_ctrlElementsList

std::vector< std::shared_ptr<ControlElement> > ControlElementContainer::m_ctrlElementsList

protected

Definition at line 74 of file ControlElementContainer.h.

◆ m_dividerList

std::vector<Divider*> ControlElementContainer::m_dividerList

protected

Definition at line 86 of file ControlElementContainer.h.

◆ m_exponentialList

std::vector<Exponential*> ControlElementContainer::m_exponentialList

protected

Definition at line 78 of file ControlElementContainer.h.

◆ m_gainList

std::vector<Gain*> ControlElementContainer::m_gainList

protected

Definition at line 79 of file ControlElementContainer.h.

◆ m_ioControlList

std::vector<IOControl*> ControlElementContainer::m_ioControlList

protected

Definition at line 80 of file ControlElementContainer.h.

◆ m_limiterList

std::vector<Limiter*> ControlElementContainer::m_limiterList

protected

Definition at line 81 of file ControlElementContainer.h.

◆ m_mathExprList

std::vector<MathExpression*> ControlElementContainer::m_mathExprList

protected

Definition at line 87 of file ControlElementContainer.h.

◆ m_multiplierList

std::vector<Multiplier*> ControlElementContainer::m_multiplierList

protected

Definition at line 82 of file ControlElementContainer.h.

◆ m_rateLimiterList

std::vector<RateLimiter*> ControlElementContainer::m_rateLimiterList

protected

Definition at line 83 of file ControlElementContainer.h.

◆ m_sumList

std::vector<Sum*> ControlElementContainer::m_sumList

protected

Definition at line 84 of file ControlElementContainer.h.

◆ m_tfList

std::vector<TransferFunction*> ControlElementContainer::m_tfList

protected

Definition at line 85 of file ControlElementContainer.h.

The documentation for this class was generated from the following files:

Project/elements/controlElement/ControlElementContainer.h
Project/elements/controlElement/ControlElementContainer.cpp

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ControlElementContainer()

◆ ~ControlElementContainer()

Member Function Documentation

◆ ClearContainer()

◆ FillContainer() [1/2]

◆ FillContainer() [2/2]

◆ GetConnectionLineList()

◆ GetConstantList()

◆ GetContainerCopy()

◆ GetControlElementsList()

◆ GetDividerList()

◆ GetExponentialList()

◆ GetGainList()

◆ GetIOControlList()

◆ GetLimiterList()

◆ GetMathExprList()

◆ GetMultiplierList()

◆ GetRateLimiterList()

◆ GetSumList()

◆ GetTFList()

Member Data Documentation

◆ m_cLineList

◆ m_constantList

◆ m_ctrlElementsList

◆ m_dividerList

◆ m_exponentialList

◆ m_gainList

◆ m_ioControlList

◆ m_limiterList

◆ m_mathExprList

◆ m_multiplierList

◆ m_rateLimiterList

◆ m_sumList

◆ m_tfList