Commit d3c38202 authored by Hans-Christian Ebke's avatar Hans-Christian Ebke
Browse files

Consolidated iterator code. Functionally equivalent but way cleaner than before.


git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@548 fdac6126-5c0c-442c-9429-916003d36597
parent ddcf2f46
......@@ -77,23 +77,12 @@ template <class Mesh> class ConstFaceIterT;
template <class Mesh> class FaceIterT;
//== CLASS DEFINITION =========================================================
/** \class VertexIterT IteratorsT.hh <OpenMesh/Mesh/Iterators/IteratorsT.hh>
Linear iterator.
*/
template <class Mesh>
class ConstVertexIterT
{
public:
template <class Mesh, class ValueHandle>
class GenericIteratorT {
public:
//--- Typedefs ---
typedef typename Mesh::VertexHandle value_handle;
typedef ValueHandle value_handle;
typedef value_handle value_type;
typedef std::bidirectional_iterator_tag iterator_category;
typedef std::ptrdiff_t difference_type;
......@@ -103,13 +92,12 @@ public:
typedef const Mesh& mesh_ref;
/// Default constructor.
ConstVertexIterT()
GenericIteratorT()
: mesh_(0), skip_bits_(0)
{}
/// Construct with mesh and a target handle.
ConstVertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
GenericIteratorT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
: mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
{
if (_skip) enable_skipping();
......@@ -119,483 +107,89 @@ public:
}
/// Standard dereferencing operator.
reference operator*() const { return hnd_; }
/// Standard pointer operator.
pointer operator->() const { return &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 ConstVertexIterT& _rhs) const
{ return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
/// Not equal?
bool operator!=(const ConstVertexIterT& _rhs) const
{ return !operator==(_rhs); }
/// Standard pre-increment operator
ConstVertexIterT& operator++()
{ hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
/// Standard pre-decrement operator
ConstVertexIterT& 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();
reference operator*() const {
return hnd_;
}
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 Mesh>
class VertexIterT: public ConstVertexIterT<Mesh> {
public:
VertexIterT() {}
VertexIterT(typename ConstVertexIterT<Mesh>::mesh_ref _mesh,
typename ConstVertexIterT<Mesh>::value_handle _hnd, bool _skip = false) :
ConstVertexIterT<Mesh>(_mesh, _hnd, _skip) {}
};
//== CLASS DEFINITION =========================================================
/** \class HalfedgeIterT IteratorsT.hh <OpenMesh/Mesh/Iterators/IteratorsT.hh>
Linear iterator.
*/
template <class Mesh>
class ConstHalfedgeIterT
{
public:
//--- Typedefs ---
typedef typename Mesh::HalfedgeHandle 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.
ConstHalfedgeIterT()
: mesh_(0), skip_bits_(0)
{}
/// Construct with mesh and a target handle.
ConstHalfedgeIterT(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);
}
/// Standard dereferencing operator.
reference operator*() const { return hnd_; }
/// Standard pointer operator.
pointer operator->() const { return &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 ConstHalfedgeIterT& _rhs) const
{ return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
/// Not equal?
bool operator!=(const ConstHalfedgeIterT& _rhs) const
{ return !operator==(_rhs); }
/// Standard pre-increment operator
ConstHalfedgeIterT& operator++()
{ hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
/// Standard pre-decrement operator
ConstHalfedgeIterT& 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();
pointer operator->() const {
return &hnd_;
}
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_;
};
// We would prefer a templated typedef here but that's C++11.
template<class Mesh>
class HalfedgeIterT: public ConstHalfedgeIterT<Mesh> {
public:
HalfedgeIterT() {}
HalfedgeIterT(typename ConstHalfedgeIterT<Mesh>::mesh_ref _mesh,
typename ConstHalfedgeIterT<Mesh>::value_handle _hnd, bool _skip = false) :
ConstHalfedgeIterT<Mesh>(_mesh, _hnd, _skip) {}
};
//== CLASS DEFINITION =========================================================
/** \class EdgeIterT IteratorsT.hh <OpenMesh/Mesh/Iterators/IteratorsT.hh>
Linear iterator.
*/
template <class Mesh>
class ConstEdgeIterT
{
public:
//--- Typedefs ---
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()
: mesh_(0), skip_bits_(0)
{}
/// Construct with mesh and a target handle.
ConstEdgeIterT(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);
}
/// Standard dereferencing operator.
reference operator*() const { return hnd_; }
/// Standard pointer operator.
pointer operator->() const { return &hnd_; }
/// Get the handle of the item the iterator refers to.
value_handle handle() const { return hnd_; }
value_handle handle() const {
return hnd_;
}
/// Cast to the handle of the item the iterator refers to.
operator value_handle() const { return hnd_; }
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
{ return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
bool operator==(const GenericIteratorT& _rhs) const {
return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_));
}
/// Not equal?
bool operator!=(const ConstEdgeIterT& _rhs) const
{ return !operator==(_rhs); }
/// Standard pre-increment operator
ConstEdgeIterT& operator++()
{ hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
/// Standard pre-decrement operator
ConstEdgeIterT& 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;
bool operator!=(const GenericIteratorT& _rhs) const {
return !operator==(_rhs);
}
/// 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_))
/// Standard pre-increment operator
GenericIteratorT& operator++() {
hnd_.__increment();
if (skip_bits_)
skip_fwd();
return *this;
}
void skip_bwd()
{
assert(mesh_ && skip_bits_);
while ((hnd_.idx() >= 0) &&
(mesh_->status(hnd_).bits() & skip_bits_))
/// Standard pre-decrement operator
GenericIteratorT& operator--() {
hnd_.__decrement();
if (skip_bits_)
skip_bwd();
return *this;
}
private:
mesh_ptr mesh_;
value_handle hnd_;
unsigned int skip_bits_;
};
// We would prefer a templated typedef here but that's C++11.
template<class Mesh>
class EdgeIterT: public ConstEdgeIterT<Mesh> {
public:
EdgeIterT() {}
EdgeIterT(typename ConstEdgeIterT<Mesh>::mesh_ref _mesh,
typename ConstEdgeIterT<Mesh>::value_handle _hnd, bool _skip = false) :
ConstEdgeIterT<Mesh>(_mesh, _hnd, _skip) {}
};
//== CLASS DEFINITION =========================================================
/** \class FaceIterT IteratorsT.hh <OpenMesh/Mesh/Iterators/IteratorsT.hh>
Linear iterator.
*/
template <class Mesh>
class ConstFaceIterT
{
public:
//--- Typedefs ---
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()
: mesh_(0), skip_bits_(0)
{}
/// Construct with mesh and a target handle.
ConstFaceIterT(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);
}
/// Standard dereferencing operator.
reference operator*() const { return hnd_; }
/// Standard pointer operator.
pointer operator->() const { return &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 ConstFaceIterT& _rhs) const
{ return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
/// Not equal?
bool operator!=(const ConstFaceIterT& _rhs) const
{ return !operator==(_rhs); }
/// Standard pre-increment operator
ConstFaceIterT& operator++()
{ hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
/// Standard pre-decrement operator
ConstFaceIterT& 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())
{
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;
}
else skip_bits_ = 0;
}
/// Turn on skipping: automatically skip deleted/hidden elements
void disable_skipping() { skip_bits_ = 0; }
void disable_skipping() {
skip_bits_ = 0;
}
private:
private:
void skip_fwd()
{
void skip_fwd() {
assert(mesh_ && skip_bits_);
while ((hnd_.idx() < (signed) mesh_->n_faces()) &&
(mesh_->status(hnd_).bits() & skip_bits_))
while ((hnd_.idx() < (signed) mesh_->n_vertices())
&& (mesh_->status(hnd_).bits() & skip_bits_))
hnd_.__increment();
}
void skip_bwd()
{
void skip_bwd() {
assert(mesh_ && skip_bits_);
while ((hnd_.idx() >= 0) &&
(mesh_->status(hnd_).bits() & skip_bits_))
while ((hnd_.idx() >= 0) && (mesh_->status(hnd_).bits() & skip_bits_))
hnd_.__decrement();
}
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 Mesh>
class FaceIterT: public ConstFaceIterT<Mesh> {
public:
FaceIterT() {}
FaceIterT(typename ConstFaceIterT<Mesh>::mesh_ref _mesh,
typename ConstFaceIterT<Mesh>::value_handle _hnd, bool _skip = false) :
ConstFaceIterT<Mesh>(_mesh, _hnd, _skip) {}
};
//=============================================================================
} // namespace Iterators
} // namespace OpenMesh
......
......@@ -76,15 +76,15 @@ public:
*/
//@{
/// Linear iterator
typedef Iterators::VertexIterT<This> VertexIter;
typedef Iterators::HalfedgeIterT<This> HalfedgeIter;
typedef Iterators::EdgeIterT<This> EdgeIter;
typedef Iterators::FaceIterT<This> FaceIter;
typedef Iterators::ConstVertexIterT<This> ConstVertexIter;
typedef Iterators::ConstHalfedgeIterT<This> ConstHalfedgeIter;
typedef Iterators::ConstEdgeIterT<This> ConstEdgeIter;
typedef Iterators::ConstFaceIterT<This> ConstFaceIter;
typedef Iterators::GenericIteratorT<This, This::VertexHandle> VertexIter;
typedef Iterators::GenericIteratorT<This, This::HalfedgeHandle> HalfedgeIter;
typedef Iterators::GenericIteratorT<This, This::EdgeHandle> EdgeIter;
typedef Iterators::GenericIteratorT<This, This::FaceHandle> FaceIter;
typedef VertexIter ConstVertexIter;
typedef HalfedgeIter ConstHalfedgeIter;
typedef EdgeIter ConstEdgeIter;
typedef FaceIter ConstFaceIter;
//@}
//--- circulators ---
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment