Mesh3dVertexEdgeConstCirculator.h

// Mesh3dVertexEdgeConstCirculator.h:
// ----------------------------------
//

#ifndef __IPSDKGEOMETRY_MESH3DVERTEXEDGECONSTCIRCULATOR_H__
#define __IPSDKGEOMETRY_MESH3DVERTEXEDGECONSTCIRCULATOR_H__

// suppression warnings
// 
#pragma warning (push)
//#pragma warning (disable : 4251)

#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 Mesh3dVertexEdgeConstCirculator
{
// predefined public types
public:
    typedef typename MeshType::DataType T;

    typedef typename MeshType::VertexType VertexType;

    typedef Mesh3dVertexEdgeConstCirculator<MeshType> Iterator;

    typedef std::input_iterator_tag iterator_category;

    typedef Mesh3dHalfEdge value_type;

    // difference type for iterator
    typedef ipUInt32 difference_type;

    typedef const Mesh3dHalfEdge* pointer;

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

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

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

// 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 Mesh3dHalfEdge*    operator->() const;

    inline const Mesh3dHalfEdge&    operator*() const;

    void                            swap(Iterator& iter);
    
// attributes
protected:
    const MeshType*                 _pMesh;

    ipUInt32                        _startHalfEdgeIdx;

    ipUInt32                        _curHalfEdgeIdx;
};


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

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

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

    return startVertex;
}

template <typename MeshType>
IPSDK_FORCEINLINE typename Mesh3dVertexEdgeConstCirculator<MeshType>::Iterator&
Mesh3dVertexEdgeConstCirculator<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
Mesh3dVertexEdgeConstCirculator<MeshType>::operator==(const Iterator& iter) const
{
    return _curHalfEdgeIdx == iter._curHalfEdgeIdx;
}

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

template <typename MeshType>
IPSDK_FORCEINLINE const Mesh3dHalfEdge*
Mesh3dVertexEdgeConstCirculator<MeshType>::operator->() const
{
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];

    return &curHalfEdge;
}

template <typename MeshType>
IPSDK_FORCEINLINE const Mesh3dHalfEdge&
Mesh3dVertexEdgeConstCirculator<MeshType>::operator*() const
{
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];

    return curHalfEdge;
}

template <typename MeshType>
inline void
Mesh3dVertexEdgeConstCirculator<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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_MESH3DVERTEXEDGECONSTCIRCULATOR_H__