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
This commit is contained in:
Hans-Christian Ebke
@@ -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
|
||||
{
|
||||
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_; }
|
||||
reference operator*() const {
|
||||
return hnd_;
|
||||
}
|
||||
|
||||
/// Standard pointer operator.
|
||||
pointer operator->() const { return &hnd_; }
|
||||
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 ConstVertexIterT& _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 ConstVertexIterT& _rhs) const
|
||||
{ return !operator==(_rhs); }
|
||||
bool operator!=(const GenericIteratorT& _rhs) const {
|
||||
return !operator==(_rhs);
|
||||
}
|
||||
|
||||
/// Standard pre-increment operator
|
||||
ConstVertexIterT& operator++()
|
||||
{ hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
|
||||
GenericIteratorT& 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; }
|
||||
|
||||
GenericIteratorT& 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())
|
||||
{
|
||||
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:
|
||||
|
||||
void skip_fwd()
|
||||
{
|
||||
void skip_fwd() {
|
||||
assert(mesh_ && skip_bits_);
|
||||
while ((hnd_.idx() < (signed) mesh_->n_vertices()) &&
|
||||
(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();
|
||||
}
|
||||
|
||||
|
||||
|
||||
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();
|
||||
}
|
||||
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_; }
|
||||
|
||||
/// 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 ConstEdgeIterT& _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;
|
||||
}
|
||||
|
||||
|
||||
/// 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_;
|
||||
};
|
||||
|
||||
// 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())
|
||||
{
|
||||
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_;
|
||||
};
|
||||
|
||||
// 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::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 Iterators::ConstVertexIterT<This> ConstVertexIter;
|
||||
typedef Iterators::ConstHalfedgeIterT<This> ConstHalfedgeIter;
|
||||
typedef Iterators::ConstEdgeIterT<This> ConstEdgeIter;
|
||||
typedef Iterators::ConstFaceIterT<This> ConstFaceIter;
|
||||
typedef VertexIter ConstVertexIter;
|
||||
typedef HalfedgeIter ConstHalfedgeIter;
|
||||
typedef EdgeIter ConstEdgeIter;
|
||||
typedef FaceIter ConstFaceIter;
|
||||
//@}
|
||||
|
||||
//--- circulators ---
|
||||
|
||||
Reference in New Issue
Block a user