src/OpenMesh/Core/Mesh/IteratorsT.hh

/*===========================================================================*\
 *                                                                           *
 *                               OpenMesh                                    *
 *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openmesh.org                                *
 *                                                                           *
 *---------------------------------------------------------------------------* 
 *  This file is part of OpenMesh.                                           *
 *                                                                           *
 *  OpenMesh is free software: you can redistribute it and/or modify         * 
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenMesh is distributed in the hope that it will be useful,              *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *  GNU Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenMesh.  If not,                                    *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/ 

/*===========================================================================*\
 *                                                                           *             
 *   $Revision: 251 $                                                         *
 *   $Date: 2009-12-07 14:14:16 +0100 (Mo, 07. Dez 2009) $                   *
 *                                                                           *
\*===========================================================================*/

#ifndef OPENMESH_ITERATORS_HH
#define OPENMESH_ITERATORS_HH

//=============================================================================
//
//  Iterators for PolyMesh/TriMesh
//
//=============================================================================



//== INCLUDES =================================================================

#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Mesh/Status.hh>
#include <assert.h>


//== NAMESPACES ===============================================================

namespace OpenMesh {
namespace Iterators {


//== FORWARD DECLARATIONS =====================================================


template <class Mesh> class VertexIterT;
template <class Mesh> class ConstVertexIterT;
template <class Mesh> class HalfedgeIterT;
template <class Mesh> class ConstHalfedgeIterT;
template <class Mesh> class EdgeIterT;
template <class Mesh> class ConstEdgeIterT;
template <class Mesh> class FaceIterT;
template <class Mesh> class ConstFaceIterT;




//== CLASS DEFINITION =========================================================

              
template <class Mesh>
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 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif


  VertexIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  VertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  VertexIterT(const VertexIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  VertexIterT& operator=(const VertexIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 0

  VertexIterT(const VertexIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  VertexIterT& operator=(const VertexIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstVertexIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const VertexIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const VertexIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  VertexIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  VertexIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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 =========================================================

              
template <class Mesh>
class ConstVertexIterT
{
public:
  

  //--- Typedefs ---

  typedef typename Mesh::Vertex           value_type;
  typedef typename Mesh::VertexHandle         value_handle;

#if 1
  typedef std::bidirectional_iterator_tag iterator_category;
  typedef 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  ConstVertexIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  ConstVertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  ConstVertexIterT(const ConstVertexIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  ConstVertexIterT& operator=(const ConstVertexIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 1

  ConstVertexIterT(const VertexIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  ConstVertexIterT& operator=(const VertexIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstVertexIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const ConstVertexIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const ConstVertexIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  ConstVertexIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  ConstVertexIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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 =========================================================

              
template <class Mesh>
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 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  HalfedgeIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  HalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  HalfedgeIterT(const HalfedgeIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  HalfedgeIterT& operator=(const HalfedgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 0

  HalfedgeIterT(const HalfedgeIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  HalfedgeIterT& operator=(const HalfedgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstHalfedgeIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const HalfedgeIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const HalfedgeIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  HalfedgeIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  HalfedgeIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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 =========================================================

              
template <class Mesh>
class ConstHalfedgeIterT
{
public:
  

  //--- Typedefs ---

  typedef typename Mesh::Halfedge           value_type;
  typedef typename Mesh::HalfedgeHandle         value_handle;

#if 1
  typedef std::bidirectional_iterator_tag iterator_category;
  typedef 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  ConstHalfedgeIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  ConstHalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  ConstHalfedgeIterT(const ConstHalfedgeIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  ConstHalfedgeIterT& operator=(const ConstHalfedgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 1

  ConstHalfedgeIterT(const HalfedgeIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  ConstHalfedgeIterT& operator=(const HalfedgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstHalfedgeIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const ConstHalfedgeIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const ConstHalfedgeIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  ConstHalfedgeIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  ConstHalfedgeIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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 =========================================================

              
template <class Mesh>
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 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  EdgeIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  EdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  EdgeIterT(const EdgeIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  EdgeIterT& operator=(const EdgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 0

  EdgeIterT(const EdgeIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  EdgeIterT& operator=(const EdgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstEdgeIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const EdgeIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const EdgeIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  EdgeIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  EdgeIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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_;
};


//== CLASS DEFINITION =========================================================

              
template <class Mesh>
class ConstEdgeIterT
{
public:
  

  //--- Typedefs ---

  typedef typename Mesh::Edge           value_type;
  typedef typename Mesh::EdgeHandle         value_handle;

#if 1
  typedef std::bidirectional_iterator_tag iterator_category;
  typedef 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  ConstEdgeIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  ConstEdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  ConstEdgeIterT(const ConstEdgeIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  ConstEdgeIterT& operator=(const ConstEdgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 1

  ConstEdgeIterT(const EdgeIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  ConstEdgeIterT& operator=(const EdgeIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstEdgeIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const ConstEdgeIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const ConstEdgeIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  ConstEdgeIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  ConstEdgeIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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_;
};


//== CLASS DEFINITION =========================================================

              
template <class Mesh>
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 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  FaceIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  FaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  FaceIterT(const FaceIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  FaceIterT& operator=(const FaceIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 0

  FaceIterT(const FaceIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  FaceIterT& operator=(const FaceIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstFaceIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const FaceIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const FaceIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  FaceIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  FaceIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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 =========================================================

              
template <class Mesh>
class ConstFaceIterT
{
public:
  

  //--- Typedefs ---

  typedef typename Mesh::Face           value_type;
  typedef typename Mesh::FaceHandle         value_handle;

#if 1
  typedef std::bidirectional_iterator_tag iterator_category;
  typedef 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 ptrdiff_t            difference_type;
  typedef value_type&          reference;
  typedef value_type*          pointer;
  typedef Mesh*                mesh_ptr;
  typedef Mesh&                mesh_ref;
#endif




  ConstFaceIterT() 
    : mesh_(0), skip_bits_(0) 
  {}


  ConstFaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
  {
    if (_skip) enable_skipping();
  }


  ConstFaceIterT(const ConstFaceIterT& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
  {}
  

  ConstFaceIterT& operator=(const ConstFaceIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }


#if 1

  ConstFaceIterT(const FaceIterT<Mesh>& _rhs) 
    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
  {}
  

  ConstFaceIterT& operator=(const FaceIterT<Mesh>& _rhs) 
  {
    mesh_      = _rhs.mesh_;
    hnd_       = _rhs.hnd_;
    skip_bits_ = _rhs.skip_bits_;
    return *this;
  }

#else
  friend class ConstFaceIterT<Mesh>;
#endif


  reference operator*()  const { return mesh_->deref(hnd_); }
  
  pointer   operator->() const { return &(mesh_->deref(hnd_)); }
  
  value_handle handle() const { return hnd_; }

  operator value_handle() const { return hnd_; }

  bool operator==(const ConstFaceIterT& _rhs) const 
  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }

  bool operator!=(const ConstFaceIterT& _rhs) const 
  { return !operator==(_rhs); }
  
  ConstFaceIterT& operator++() 
  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }

  ConstFaceIterT& operator--() 
  { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
  

  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;
  }


  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_;
};


//=============================================================================
} // namespace Iterators
} // namespace OpenMesh
//=============================================================================
#endif 
//=============================================================================

---