TDataNodePolyline.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// STL includes
#include <vector>
 
// ICF includes
#include <istd/CChangeNotifier.h>
#include <istd/CChangeGroup.h>
#include <i2d/CDataNodePolylineBase.h>
 
 
namespace i2d
{
 
 
template<class NodeData>
class TDataNodePolyline: public CDataNodePolylineBase
{
public:
    typedef CDataNodePolylineBase BaseClass;
 
    const NodeData& GetTNodeData(int nodeIndex) const;
 
    NodeData& GetTNodeDataRef(int nodeIndex);
 
    // reimplemented (i2d::CDataNodePolylineBase)
    const iser::ISerializable& GetNodeData(int nodeIndex) const override;
    iser::ISerializable& GetNodeDataRef(int nodeIndex) override;
 
    // reimplemented (i2d::CPolypoint)
    void Clear() override;
    void SetNodesCount(int nodesCount) override;
    bool InsertNode(const i2d::CVector2d& position) override;
    bool InsertNode(int index, const i2d::CVector2d& position) override;
    bool RemoveNode(int index) override;
 
    // reimplemented istd::IChangeable
    bool CopyFrom(const IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
 
private:
    typedef std::vector<NodeData> NodesData;
    NodesData m_nodesData;
};
 
 
template<class NodeData>
inline const NodeData& TDataNodePolyline<NodeData>::GetTNodeData(int nodeIndex) const
{
    Q_ASSERT(nodeIndex >= 0);
    Q_ASSERT(nodeIndex < int(m_nodesData.size()));
 
    return m_nodesData[nodeIndex];
}
 
 
template<class NodeData>
inline NodeData& TDataNodePolyline<NodeData>::GetTNodeDataRef(int nodeIndex)
{
    Q_ASSERT(nodeIndex >= 0);
    Q_ASSERT(nodeIndex < int(m_nodesData.size()));
 
    return m_nodesData[nodeIndex];
}
 
 
// reimplemented (i2d::CDataNodePolylineBase)
 
template<class NodeData>
inline const iser::ISerializable& TDataNodePolyline<NodeData>::GetNodeData(int nodeIndex) const
{
    Q_ASSERT(nodeIndex >= 0);
    Q_ASSERT(nodeIndex < int(m_nodesData.size()));
 
    return m_nodesData[nodeIndex];
}
 
 
template<class NodeData>
inline iser::ISerializable& TDataNodePolyline<NodeData>::GetNodeDataRef(int nodeIndex)
{
    Q_ASSERT(nodeIndex >= 0);
    Q_ASSERT(nodeIndex < int(m_nodesData.size()));
 
    return m_nodesData[nodeIndex];
}
 
 
// reimplemented (i2d::CPolypoint)
 
template<class NodeData>
inline void TDataNodePolyline<NodeData>::Clear()
{
    if (!m_nodesData.empty()) {
        istd::CChangeNotifier changeNotifier(this, &s_clearAllNodesChange);
 
        m_nodesData.clear();
 
        BaseClass::Clear();
    }
}
 
 
template<class NodeData>
void TDataNodePolyline<NodeData>::SetNodesCount(int nodesCount)
{
    istd::CChangeNotifier changeNotifier(this, &s_createPolygonNodesChange);
 
    m_nodesData.resize(nodesCount);
 
    BaseClass::SetNodesCount(nodesCount);
}
 
 
template<class NodeData>
inline bool TDataNodePolyline<NodeData>::InsertNode(const i2d::CVector2d& position)
{
    istd::CChangeNotifier changeNotifier(this, &s_insertPolygonNodeChange);
 
    m_nodesData.insert(m_nodesData.end(), NodeData());
 
    return BaseClass::InsertNode(position);
}
 
 
template<class NodeData>
inline bool TDataNodePolyline<NodeData>::InsertNode(int index, const i2d::CVector2d& position)
{
    istd::CChangeNotifier changeNotifier(this, &s_insertPolygonNodeChange);
 
    typename NodesData::iterator iter = m_nodesData.begin();
    iter += index;
    m_nodesData.insert(iter, NodeData());
 
    return BaseClass::InsertNode(index, position);
}
 
 
template<class NodeData>
bool TDataNodePolyline<NodeData>::RemoveNode(int index)
{
    istd::CChangeNotifier changeNotifier(this, &s_removePolygonNodeChange);
 
    typename NodesData::iterator iter = m_nodesData.begin();
    iter += index;
    m_nodesData.erase(iter);
 
    return BaseClass::RemoveNode(index);
}
 
 
// reimplemented istd::IChangeable
 
template<class NodeData>
bool TDataNodePolyline<NodeData>::CopyFrom(const IChangeable& object, CompatibilityMode mode)
{
    istd::CChangeGroup changeGroup(this);
 
    Clear();
 
    const TDataNodePolyline<NodeData>* polygonPtr = dynamic_cast<const TDataNodePolyline<NodeData>*>(&object);
 
    if (polygonPtr != nullptr) {
        istd::CChangeNotifier changeNotifier(this);
 
        int sourceNodesCount = polygonPtr->GetNodesCount();
        for (int nodesIndex = 0; nodesIndex < sourceNodesCount; nodesIndex++) {
            InsertNode(polygonPtr->GetNodePos(nodesIndex));
 
            m_nodesData[nodesIndex] = polygonPtr->m_nodesData[nodesIndex];
        }
 
        CObject2dBase::CopyFrom(object, mode);
 
        return true;
    }
 
    return false;
}
 
 
} // namespace i2d