Mesh3dVertexVertexConstCirculator.h

// Mesh3dVertexVertexConstCirculator.h:
// ------------------------------------
//

#ifndef __IPSDKGEOMETRY_MESH3DVERTEXVERTEXCONSTCIRCULATOR_H__
#define __IPSDKGEOMETRY_MESH3DVERTEXVERTEXCONSTCIRCULATOR_H__

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3dTypes.h>
#include <IPSDKUtil/Tools/NumericLimits.h>
#include <IPSDKUtil/Tools/ForceInline.h>

namespace ipsdk {
namespace geom {


template <typename MeshType>
class Mesh3dVertexVertexConstCirculator
{
// predefined public types
public:
    typedef typename MeshType::DataType T;

    typedef typename MeshType::VertexType VertexType;

    typedef Mesh3dVertexVertexConstCirculator<MeshType> Iterator;

    typedef std::input_iterator_tag iterator_category;

    typedef VertexType value_type;

    // difference type for iterator
    typedef ipUInt32 difference_type;

    typedef const VertexType* pointer;

    // reference type associated to iterator
    typedef const VertexType& reference;

public:
    Mesh3dVertexVertexConstCirculator() :
        _pMesh(0),
        _startHalfEdgeIdx(NumericLimits<ipUInt32>::max()),
        _curHalfEdgeIdx(NumericLimits<ipUInt32>::max())

    {
    }
    Mesh3dVertexVertexConstCirculator(const MeshType* pMesh,
                                      const ipUInt32 startVertexIdx) :
        _pMesh(pMesh),
        _startHalfEdgeIdx(_pMesh->getVertexToHalfEdgeColl()[startVertexIdx]),
        _curHalfEdgeIdx(_startHalfEdgeIdx)
    {
        
    }
    Mesh3dVertexVertexConstCirculator(const Iterator& iter) :
        _pMesh(iter._pMesh),
        _startHalfEdgeIdx(iter._startHalfEdgeIdx),
        _curHalfEdgeIdx(iter._curHalfEdgeIdx)
    {
    }
    Mesh3dVertexVertexConstCirculator& operator= (const Iterator& iter)
    {
        _pMesh = iter._pMesh;
        _startHalfEdgeIdx = iter._startHalfEdgeIdx;
        _curHalfEdgeIdx = iter._curHalfEdgeIdx;
    }
    ~Mesh3dVertexVertexConstCirculator()
    {
    }

// methods
public:
    const ipUInt32              getStartHalfEdgeIdx() const;

    const ipUInt32              getCurHalfEdgeIdx() const;

    const VertexType&           getStartVertex() const;

    inline Iterator&            operator++();

    inline bool                 operator==(const Iterator& iter) const;
    inline bool                 operator!=(const Iterator& iter) const;

    inline const VertexType*    operator->() const;

    inline const VertexType&    operator*() const;

    void                        swap(Iterator& iter);

// attributes
protected:
    const MeshType*                 _pMesh;

    ipUInt32                        _startHalfEdgeIdx;

    ipUInt32                        _curHalfEdgeIdx;
};


template <typename MeshType>
IPSDK_FORCEINLINE const ipUInt32
Mesh3dVertexVertexConstCirculator<MeshType>::getStartHalfEdgeIdx() const
{
    return _startHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE const ipUInt32
Mesh3dVertexVertexConstCirculator<MeshType>::getCurHalfEdgeIdx() const
{
    return _curHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE const typename Mesh3dVertexVertexConstCirculator<MeshType>::VertexType&
Mesh3dVertexVertexConstCirculator<MeshType>::getStartVertex() const
{
    const Mesh3dHalfEdge& startHalfEdge = _pMesh->getHalfEdgeColl()[_startHalfEdgeIdx];
    const VertexType& startVertex = _pMesh->getVertexColl()[startHalfEdge._startVertexIdx];

    return startVertex;
}

template <typename MeshType>
IPSDK_FORCEINLINE typename Mesh3dVertexVertexConstCirculator<MeshType>::Iterator&
Mesh3dVertexVertexConstCirculator<MeshType>::operator++()
{
    // search for next half edge
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];
    const Mesh3dHalfEdge& oppositeHalfEdge = _pMesh->getHalfEdgeColl()[curHalfEdge._oppositeHalfEdgeIdx];
    _curHalfEdgeIdx = oppositeHalfEdge._nextHalfEdgeIdx;
    if (_curHalfEdgeIdx == _startHalfEdgeIdx)
        _curHalfEdgeIdx = NumericLimits<ipUInt32>::max();

    return *this;
}

template <typename MeshType>
IPSDK_FORCEINLINE bool
Mesh3dVertexVertexConstCirculator<MeshType>::operator==(const Iterator& iter) const
{
    return _curHalfEdgeIdx == iter._curHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE bool
Mesh3dVertexVertexConstCirculator<MeshType>::operator!=(const Iterator& iter) const
{
    return _curHalfEdgeIdx != iter._curHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE const typename Mesh3dVertexVertexConstCirculator<MeshType>::VertexType*
Mesh3dVertexVertexConstCirculator<MeshType>::operator->() const
{
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];
    const VertexType& curVertex = _pMesh->getVertexColl()[curHalfEdge._startVertexIdx];

    return &curVertex;
}

template <typename MeshType>
IPSDK_FORCEINLINE const typename Mesh3dVertexVertexConstCirculator<MeshType>::VertexType&
Mesh3dVertexVertexConstCirculator<MeshType>::operator*() const
{
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];
    const VertexType& curVertex = _pMesh->getVertexColl()[curHalfEdge._startVertexIdx];

    return curVertex;
}

template <typename MeshType>
inline void
Mesh3dVertexVertexConstCirculator<MeshType>::swap(Iterator& iter)
{
    std::swap(_pMesh, iter._pMesh);
    std::swap(_startHalfEdgeIdx, iter._startHalfEdgeIdx);
    std::swap(_curHalfEdgeIdx, iter._curHalfEdgeIdx);
}


} // end of namespace geom
} // end of namespace ipsdk

#endif // __IPSDKGEOMETRY_MESH3DVERTEXVERTEXCONSTCIRCULATOR_H__