First checkin for OpenMesh 2.0

git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@2 fdac6126-5c0c-442c-9429-916003d36597

Core/Mesh/gen/iterators_template.hh

@@ -0,0 +1,162 @@
+//== CLASS DEFINITION =========================================================
+
+	      
+/** \class IteratorT IteratorsT.hh <OpenMesh/Mesh/Iterators/IteratorsT.hh>
+    Linear iterator.
+*/
+
+template <class Mesh>
+class IteratorT
+{
+public:
+  
+
+  //--- Typedefs ---
+
+  typedef TargetType           value_type;
+  typedef TargetHandle         value_handle;
+
+#if IsConst
+  typedef const value_type&    reference;
+  typedef const value_type*    pointer;
+  typedef const Mesh*          mesh_ptr;
+  typedef const Mesh&          mesh_ref;
+#else
+  typedef value_type&          reference;
+  typedef value_type*          pointer;
+  typedef Mesh*                mesh_ptr;
+  typedef Mesh&                mesh_ref;
+#endif
+
+
+
+
+  /// Default constructor.
+  IteratorT() 
+    : mesh_(0), skip_bits_(0) 
+  {}
+
+
+  /// Construct with mesh and a target handle. 
+  IteratorT(mesh_ref _mesh, value_handle _hnd, bool _skip=false) 
+    : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0) 
+  {
+    if (_skip) enable_skipping();
+  }
+
+
+  /// Copy constructor
+  IteratorT(const IteratorT& _rhs) 
+    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
+  {}
+  
+
+  /// Assignment operator
+  IteratorT& operator=(const IteratorT<Mesh>& _rhs) 
+  {
+    mesh_      = _rhs.mesh_;
+    hnd_       = _rhs.hnd_;
+    skip_bits_ = _rhs.skip_bits_;
+    return *this;
+  }
+
+
+#if IsConst
+
+  /// Construct from a non-const iterator
+  IteratorT(const NonConstIterT<Mesh>& _rhs) 
+    : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_) 
+  {}
+  
+
+  /// Assignment from non-const iterator
+  IteratorT& operator=(const NonConstIterT<Mesh>& _rhs) 
+  {
+    mesh_      = _rhs.mesh_;
+    hnd_       = _rhs.hnd_;
+    skip_bits_ = _rhs.skip_bits_;
+    return *this;
+  }
+
+#else
+  friend class ConstIterT<Mesh>;
+#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 IteratorT& _rhs) const 
+  { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
+
+  /// Not equal?
+  bool operator!=(const IteratorT& _rhs) const 
+  { return !operator==(_rhs); }
+  
+  /// Standard pre-increment operator
+  IteratorT& operator++() 
+  { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
+
+  /// Standard pre-decrement operator
+  IteratorT& 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_element_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_elements()) && 
+	   (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_;
+};
+
+