diff --git a/src/OpenMesh/Core/Mesh/IteratorsT.hh b/src/OpenMesh/Core/Mesh/IteratorsT.hh index 4eb0f0df..1048e692 100644 --- a/src/OpenMesh/Core/Mesh/IteratorsT.hh +++ b/src/OpenMesh/Core/Mesh/IteratorsT.hh @@ -67,192 +67,24 @@ namespace Iterators { //== FORWARD DECLARATIONS ===================================================== -template class VertexIterT; template class ConstVertexIterT; -template class HalfedgeIterT; +template class VertexIterT; template class ConstHalfedgeIterT; -template class EdgeIterT; +template class HalfedgeIterT; template class ConstEdgeIterT; -template class FaceIterT; +template class EdgeIterT; template class ConstFaceIterT; +template class FaceIterT; //== CLASS DEFINITION ========================================================= - /** \class VertexIterT IteratorsT.hh Linear iterator. */ -template -class VertexIterT -{ -public: - - - //--- Typedefs --- - - typedef typename Mesh::Vertex value_type; - typedef typename Mesh::VertexHandle value_handle; - -#if 0 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - - - /// Default constructor. - VertexIterT() - : mesh_(0), skip_bits_(0) - {} - - - /// Construct with mesh and a target handle. - VertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) - : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) - { - if (_skip) enable_skipping(); - - // Set vertex handle invalid if the mesh contains no vertex - if(_mesh.n_vertices() == 0) hnd_ = value_handle(-1); - } - - - /// Copy constructor - VertexIterT(const VertexIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - VertexIterT& operator=(const VertexIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 0 - - /// Construct from a non-const iterator - VertexIterT(const VertexIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - VertexIterT& operator=(const VertexIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstVertexIterT; -#endif - - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } - - /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } - - /// Get the handle of the item the iterator refers to. - value_handle handle() const { return hnd_; } - - /// Cast to the handle of the item the iterator refers to. - operator value_handle() const { return hnd_; } - - /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const VertexIterT& _rhs) const - { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } - - /// Not equal? - bool operator!=(const VertexIterT& _rhs) const - { return !operator==(_rhs); } - - /// Standard pre-increment operator - VertexIterT& operator++() - { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } - - /// Standard pre-decrement operator - VertexIterT& operator--() - { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void enable_skipping() - { - if (mesh_ && mesh_->has_vertex_status()) - { - Attributes::StatusInfo status; - status.set_deleted(true); - status.set_hidden(true); - skip_bits_ = status.bits(); - skip_fwd(); - } - else skip_bits_ = 0; - } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void disable_skipping() { skip_bits_ = 0; } - - - -private: - - void skip_fwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() < (signed) mesh_->n_vertices()) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__increment(); - } - - - void skip_bwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() >= 0) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__decrement(); - } - - - -private: - mesh_ptr mesh_; - value_handle hnd_; - unsigned int skip_bits_; -}; - - -//== CLASS DEFINITION ========================================================= - - -/** \class ConstVertexIterT IteratorsT.hh - Linear iterator. -*/ - template class ConstVertexIterT { @@ -261,36 +93,23 @@ public: //--- Typedefs --- - typedef typename Mesh::Vertex value_type; - typedef typename Mesh::VertexHandle value_handle; - -#if 1 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - - - + typedef typename Mesh::VertexHandle value_handle; + typedef value_handle value_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef const Mesh* mesh_ptr; + typedef const Mesh& mesh_ref; /// Default constructor. - ConstVertexIterT() + ConstVertexIterT() : mesh_(0), skip_bits_(0) {} /// Construct with mesh and a target handle. - ConstVertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) + ConstVertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) { if (_skip) enable_skipping(); @@ -299,50 +118,11 @@ public: if(_mesh.n_vertices() == 0) hnd_ = value_handle(-1); } - - /// Copy constructor - ConstVertexIterT(const ConstVertexIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - ConstVertexIterT& operator=(const ConstVertexIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 1 - - /// Construct from a non-const iterator - ConstVertexIterT(const VertexIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - ConstVertexIterT& operator=(const VertexIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstVertexIterT; -#endif - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } + reference operator*() const { return hnd_; } /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } + pointer operator->() const { return &hnd_; } /// Get the handle of the item the iterator refers to. value_handle handle() const { return hnd_; } @@ -351,19 +131,19 @@ public: operator value_handle() const { return hnd_; } /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const ConstVertexIterT& _rhs) const + bool operator==(const ConstVertexIterT& _rhs) const { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } /// Not equal? - bool operator!=(const ConstVertexIterT& _rhs) const + bool operator!=(const ConstVertexIterT& _rhs) const { return !operator==(_rhs); } /// Standard pre-increment operator - ConstVertexIterT& operator++() + ConstVertexIterT& operator++() { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } /// Standard pre-decrement operator - ConstVertexIterT& operator--() + ConstVertexIterT& operator--() { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } @@ -408,12 +188,21 @@ private: -private: +protected: mesh_ptr mesh_; value_handle hnd_; unsigned int skip_bits_; }; +// We would prefer a templated typedef here but that's C++11. +template +class VertexIterT: public ConstVertexIterT { + public: + VertexIterT() {} + VertexIterT(typename ConstVertexIterT::mesh_ref _mesh, + typename ConstVertexIterT::value_handle _hnd, bool _skip = false) : + ConstVertexIterT(_mesh, _hnd, _skip) {} +}; //== CLASS DEFINITION ========================================================= @@ -422,175 +211,6 @@ private: Linear iterator. */ -template -class HalfedgeIterT -{ -public: - - - //--- Typedefs --- - - typedef typename Mesh::Halfedge value_type; - typedef typename Mesh::HalfedgeHandle value_handle; - -#if 0 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - - - - - /// Default constructor. - HalfedgeIterT() - : mesh_(0), skip_bits_(0) - {} - - - /// Construct with mesh and a target handle. - HalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) - : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) - { - if (_skip) enable_skipping(); - - // Set halfedge handle invalid if the mesh contains no edge - if(_mesh.n_edges() == 0) hnd_ = value_handle(-1); - } - - - /// Copy constructor - HalfedgeIterT(const HalfedgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - HalfedgeIterT& operator=(const HalfedgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 0 - - /// Construct from a non-const iterator - HalfedgeIterT(const HalfedgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - HalfedgeIterT& operator=(const HalfedgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstHalfedgeIterT; -#endif - - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } - - /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } - - /// Get the handle of the item the iterator refers to. - value_handle handle() const { return hnd_; } - - /// Cast to the handle of the item the iterator refers to. - operator value_handle() const { return hnd_; } - - /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const HalfedgeIterT& _rhs) const - { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } - - /// Not equal? - bool operator!=(const HalfedgeIterT& _rhs) const - { return !operator==(_rhs); } - - /// Standard pre-increment operator - HalfedgeIterT& operator++() - { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } - - /// Standard pre-decrement operator - HalfedgeIterT& operator--() - { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void enable_skipping() - { - if (mesh_ && mesh_->has_halfedge_status()) - { - Attributes::StatusInfo status; - status.set_deleted(true); - status.set_hidden(true); - skip_bits_ = status.bits(); - skip_fwd(); - } - else skip_bits_ = 0; - } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void disable_skipping() { skip_bits_ = 0; } - - - -private: - - void skip_fwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() < (signed) mesh_->n_halfedges()) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__increment(); - } - - - void skip_bwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() >= 0) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__decrement(); - } - - - -private: - mesh_ptr mesh_; - value_handle hnd_; - unsigned int skip_bits_; -}; - - -//== CLASS DEFINITION ========================================================= - - -/** \class ConstHalfedgeIterT IteratorsT.hh - Linear iterator. -*/ - template class ConstHalfedgeIterT { @@ -599,36 +219,27 @@ public: //--- Typedefs --- - typedef typename Mesh::Halfedge value_type; - typedef typename Mesh::HalfedgeHandle value_handle; + typedef typename Mesh::HalfedgeHandle value_handle; + typedef value_handle value_type; -#if 1 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif + typedef std::bidirectional_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef const Mesh* mesh_ptr; + typedef const Mesh& mesh_ref; /// Default constructor. - ConstHalfedgeIterT() + ConstHalfedgeIterT() : mesh_(0), skip_bits_(0) {} /// Construct with mesh and a target handle. - ConstHalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) + ConstHalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) { if (_skip) enable_skipping(); @@ -637,50 +248,11 @@ public: if(_mesh.n_edges() == 0) hnd_ = value_handle(-1); } - - /// Copy constructor - ConstHalfedgeIterT(const ConstHalfedgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - ConstHalfedgeIterT& operator=(const ConstHalfedgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 1 - - /// Construct from a non-const iterator - ConstHalfedgeIterT(const HalfedgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - ConstHalfedgeIterT& operator=(const HalfedgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstHalfedgeIterT; -#endif - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } + reference operator*() const { return hnd_; } /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } + pointer operator->() const { return &hnd_; } /// Get the handle of the item the iterator refers to. value_handle handle() const { return hnd_; } @@ -689,19 +261,19 @@ public: operator value_handle() const { return hnd_; } /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const ConstHalfedgeIterT& _rhs) const + bool operator==(const ConstHalfedgeIterT& _rhs) const { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } /// Not equal? - bool operator!=(const ConstHalfedgeIterT& _rhs) const + bool operator!=(const ConstHalfedgeIterT& _rhs) const { return !operator==(_rhs); } /// Standard pre-increment operator - ConstHalfedgeIterT& operator++() + ConstHalfedgeIterT& operator++() { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } /// Standard pre-decrement operator - ConstHalfedgeIterT& operator--() + ConstHalfedgeIterT& operator--() { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } @@ -753,179 +325,22 @@ private: }; -//== CLASS DEFINITION ========================================================= +// We would prefer a templated typedef here but that's C++11. +template +class HalfedgeIterT: public ConstHalfedgeIterT { + public: + HalfedgeIterT() {} - -/** \class EdgeIterT IteratorsT.hh - Linear iterator. -*/ - -template -class EdgeIterT -{ -public: - - - //--- Typedefs --- - - typedef typename Mesh::Edge value_type; - typedef typename Mesh::EdgeHandle value_handle; - -#if 0 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - - - - - /// Default constructor. - EdgeIterT() - : mesh_(0), skip_bits_(0) - {} - - - /// Construct with mesh and a target handle. - EdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) - : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) - { - if (_skip) enable_skipping(); - - // Set halfedge handle invalid if the mesh contains no edge - if(_mesh.n_edges() == 0) hnd_ = value_handle(-1); - } - - - /// Copy constructor - EdgeIterT(const EdgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - EdgeIterT& operator=(const EdgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 0 - - /// Construct from a non-const iterator - EdgeIterT(const EdgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - EdgeIterT& operator=(const EdgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstEdgeIterT; -#endif - - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } - - /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } - - /// Get the handle of the item the iterator refers to. - value_handle handle() const { return hnd_; } - - /// Cast to the handle of the item the iterator refers to. - operator value_handle() const { return hnd_; } - - /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const EdgeIterT& _rhs) const - { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } - - /// Not equal? - bool operator!=(const EdgeIterT& _rhs) const - { return !operator==(_rhs); } - - /// Standard pre-increment operator - EdgeIterT& operator++() - { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } - - /// Standard pre-decrement operator - EdgeIterT& operator--() - { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void enable_skipping() - { - if (mesh_ && mesh_->has_edge_status()) - { - Attributes::StatusInfo status; - status.set_deleted(true); - status.set_hidden(true); - skip_bits_ = status.bits(); - skip_fwd(); - } - else skip_bits_ = 0; - } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void disable_skipping() { skip_bits_ = 0; } - - - -private: - - void skip_fwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() < (signed) mesh_->n_edges()) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__increment(); - } - - - void skip_bwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() >= 0) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__decrement(); - } - - - -private: - mesh_ptr mesh_; - value_handle hnd_; - unsigned int skip_bits_; + HalfedgeIterT(typename ConstHalfedgeIterT::mesh_ref _mesh, + typename ConstHalfedgeIterT::value_handle _hnd, bool _skip = false) : + ConstHalfedgeIterT(_mesh, _hnd, _skip) {} }; //== CLASS DEFINITION ========================================================= -/** \class ConstEdgeIterT IteratorsT.hh +/** \class EdgeIterT IteratorsT.hh Linear iterator. */ @@ -937,36 +352,24 @@ public: //--- Typedefs --- - typedef typename Mesh::Edge value_type; - typedef typename Mesh::EdgeHandle value_handle; - -#if 1 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - - + typedef typename Mesh::EdgeHandle value_handle; + typedef value_handle value_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef const Mesh* mesh_ptr; + typedef const Mesh& mesh_ref; /// Default constructor. - ConstEdgeIterT() + ConstEdgeIterT() : mesh_(0), skip_bits_(0) {} /// Construct with mesh and a target handle. - ConstEdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) + ConstEdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) { if (_skip) enable_skipping(); @@ -976,49 +379,11 @@ public: } - /// Copy constructor - ConstEdgeIterT(const ConstEdgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - ConstEdgeIterT& operator=(const ConstEdgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 1 - - /// Construct from a non-const iterator - ConstEdgeIterT(const EdgeIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - ConstEdgeIterT& operator=(const EdgeIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstEdgeIterT; -#endif - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } + reference operator*() const { return hnd_; } /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } + pointer operator->() const { return &hnd_; } /// Get the handle of the item the iterator refers to. value_handle handle() const { return hnd_; } @@ -1027,19 +392,19 @@ public: operator value_handle() const { return hnd_; } /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const ConstEdgeIterT& _rhs) const + bool operator==(const ConstEdgeIterT& _rhs) const { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } /// Not equal? - bool operator!=(const ConstEdgeIterT& _rhs) const + bool operator!=(const ConstEdgeIterT& _rhs) const { return !operator==(_rhs); } /// Standard pre-increment operator - ConstEdgeIterT& operator++() + ConstEdgeIterT& operator++() { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } /// Standard pre-decrement operator - ConstEdgeIterT& operator--() + ConstEdgeIterT& operator--() { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } @@ -1090,6 +455,16 @@ private: unsigned int skip_bits_; }; +// We would prefer a templated typedef here but that's C++11. +template +class EdgeIterT: public ConstEdgeIterT { + public: + EdgeIterT() {} + + EdgeIterT(typename ConstEdgeIterT::mesh_ref _mesh, + typename ConstEdgeIterT::value_handle _hnd, bool _skip = false) : + ConstEdgeIterT(_mesh, _hnd, _skip) {} +}; //== CLASS DEFINITION ========================================================= @@ -1098,175 +473,6 @@ private: Linear iterator. */ -template -class FaceIterT -{ -public: - - - //--- Typedefs --- - - typedef typename Mesh::Face value_type; - typedef typename Mesh::FaceHandle value_handle; - -#if 0 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - - - - - /// Default constructor. - FaceIterT() - : mesh_(0), skip_bits_(0) - {} - - - /// Construct with mesh and a target handle. - FaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) - : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) - { - if (_skip) enable_skipping(); - - // Set face handle invalid if the mesh contains no faces - if(_mesh.n_faces() == 0) hnd_ = value_handle(-1); - } - - - /// Copy constructor - FaceIterT(const FaceIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - FaceIterT& operator=(const FaceIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 0 - - /// Construct from a non-const iterator - FaceIterT(const FaceIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - FaceIterT& operator=(const FaceIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstFaceIterT; -#endif - - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } - - /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } - - /// Get the handle of the item the iterator refers to. - value_handle handle() const { return hnd_; } - - /// Cast to the handle of the item the iterator refers to. - operator value_handle() const { return hnd_; } - - /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const FaceIterT& _rhs) const - { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } - - /// Not equal? - bool operator!=(const FaceIterT& _rhs) const - { return !operator==(_rhs); } - - /// Standard pre-increment operator - FaceIterT& operator++() - { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } - - /// Standard pre-decrement operator - FaceIterT& operator--() - { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void enable_skipping() - { - if (mesh_ && mesh_->has_face_status()) - { - Attributes::StatusInfo status; - status.set_deleted(true); - status.set_hidden(true); - skip_bits_ = status.bits(); - skip_fwd(); - } - else skip_bits_ = 0; - } - - - /// Turn on skipping: automatically skip deleted/hidden elements - void disable_skipping() { skip_bits_ = 0; } - - - -private: - - void skip_fwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() < (signed) mesh_->n_faces()) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__increment(); - } - - - void skip_bwd() - { - assert(mesh_ && skip_bits_); - while ((hnd_.idx() >= 0) && - (mesh_->status(hnd_).bits() & skip_bits_)) - hnd_.__decrement(); - } - - - -private: - mesh_ptr mesh_; - value_handle hnd_; - unsigned int skip_bits_; -}; - - -//== CLASS DEFINITION ========================================================= - - -/** \class ConstFaceIterT IteratorsT.hh - Linear iterator. -*/ - template class ConstFaceIterT { @@ -1275,36 +481,25 @@ public: //--- Typedefs --- - typedef typename Mesh::Face value_type; - typedef typename Mesh::FaceHandle value_handle; - -#if 1 - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef const value_type& reference; - typedef const value_type* pointer; - typedef const Mesh* mesh_ptr; - typedef const Mesh& mesh_ref; -#else - typedef std::bidirectional_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - typedef value_type& reference; - typedef value_type* pointer; - typedef Mesh* mesh_ptr; - typedef Mesh& mesh_ref; -#endif - + typedef typename Mesh::FaceHandle value_handle; + typedef value_handle value_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef const Mesh* mesh_ptr; + typedef const Mesh& mesh_ref; /// Default constructor. - ConstFaceIterT() + ConstFaceIterT() : mesh_(0), skip_bits_(0) {} /// Construct with mesh and a target handle. - ConstFaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) + ConstFaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) { if (_skip) enable_skipping(); @@ -1314,49 +509,11 @@ public: } - /// Copy constructor - ConstFaceIterT(const ConstFaceIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment operator - ConstFaceIterT& operator=(const ConstFaceIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - - -#if 1 - - /// Construct from a non-const iterator - ConstFaceIterT(const FaceIterT& _rhs) - : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) - {} - - - /// Assignment from non-const iterator - ConstFaceIterT& operator=(const FaceIterT& _rhs) - { - mesh_ = _rhs.mesh_; - hnd_ = _rhs.hnd_; - skip_bits_ = _rhs.skip_bits_; - return *this; - } - -#else - friend class ConstFaceIterT; -#endif - - /// Standard dereferencing operator. - reference operator*() const { return mesh_->deref(hnd_); } + reference operator*() const { return hnd_; } /// Standard pointer operator. - pointer operator->() const { return &(mesh_->deref(hnd_)); } + pointer operator->() const { return &hnd_; } /// Get the handle of the item the iterator refers to. value_handle handle() const { return hnd_; } @@ -1365,19 +522,19 @@ public: operator value_handle() const { return hnd_; } /// Are two iterators equal? Only valid if they refer to the same mesh! - bool operator==(const ConstFaceIterT& _rhs) const + bool operator==(const ConstFaceIterT& _rhs) const { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); } /// Not equal? - bool operator!=(const ConstFaceIterT& _rhs) const + bool operator!=(const ConstFaceIterT& _rhs) const { return !operator==(_rhs); } /// Standard pre-increment operator - ConstFaceIterT& operator++() + ConstFaceIterT& operator++() { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; } /// Standard pre-decrement operator - ConstFaceIterT& operator--() + ConstFaceIterT& operator--() { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; } @@ -1428,6 +585,16 @@ private: unsigned int skip_bits_; }; +// We would prefer a templated typedef here but that's C++11. +template +class FaceIterT: public ConstFaceIterT { + public: + FaceIterT() {} + + FaceIterT(typename ConstFaceIterT::mesh_ref _mesh, + typename ConstFaceIterT::value_handle _hnd, bool _skip = false) : + ConstFaceIterT(_mesh, _hnd, _skip) {} +}; //============================================================================= } // namespace Iterators