- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- File List
- File Members

# Core/Mesh/Iterators/gen/circulators_template.hh

    00001 //== CLASS DEFINITION =========================================================
    00002
    00003
    00008 template <class Mesh>
    00009 class CirculatorT
    00010 {
    00011  public:
    00012
    00013
    00014   //--- Typedefs ---
    00015
    00016   typedef typename Mesh::HalfedgeHandle   HalfedgeHandle;
    00017
    00018   typedef TargetType           value_type;
    00019   typedef TargetHandle         value_handle;
    00020
    00021 #if IsConst
    00022   typedef const Mesh&         mesh_ref;
    00023   typedef const Mesh*         mesh_ptr;
    00024   typedef const TargetType&   reference;
    00025   typedef const TargetType*   pointer;
    00026 #else
    00027   typedef Mesh&               mesh_ref;
    00028   typedef Mesh*               mesh_ptr;
    00029   typedef TargetType&         reference;
    00030   typedef TargetType*         pointer;
    00031 #endif
    00032
    00033
    00034
    00036   CirculatorT() : mesh_(0), active_(false) {}
    00037
    00038
    00040   CirculatorT(mesh_ref _mesh, SourceHandle _start) :
    00041     mesh_(&_mesh),
    00042     start_(_mesh.halfedge_handle(_start)),
    00043     heh_(start_),
    00044     active_(false)
    00045   { post_init; }
    00046
    00047
    00049   CirculatorT(mesh_ref _mesh, HalfedgeHandle _heh) :
    00050     mesh_(&_mesh),
    00051     start_(_heh),
    00052     heh_(_heh),
    00053     active_(false)
    00054   { post_init; }
    00055
    00056
    00058   CirculatorT(const CirculatorT& _rhs) :
    00059     mesh_(_rhs.mesh_),
    00060     start_(_rhs.start_),
    00061     heh_(_rhs.heh_),
    00062     active_(_rhs.active_)
    00063   { post_init; }
    00064
    00065
    00067   CirculatorT& operator=(const CirculatorT<Mesh>& _rhs)
    00068   {
    00069     mesh_   = _rhs.mesh_;
    00070     start_  = _rhs.start_;
    00071     heh_    = _rhs.heh_;
    00072     active_ = _rhs.active_;
    00073     return *this;
    00074   }
    00075
    00076
    00077 #if IsConst
    00079   CirculatorT(const NonConstCircT<Mesh>& _rhs) :
    00080     mesh_(_rhs.mesh_),
    00081     start_(_rhs.start_),
    00082     heh_(_rhs.heh_),
    00083     active_(_rhs.active_)
    00084   { post_init; }
    00085
    00086
    00088   CirculatorT& operator=(const NonConstCircT<Mesh>& _rhs)
    00089   {
    00090     mesh_   = _rhs.mesh_;
    00091     start_  = _rhs.start_;
    00092     heh_    = _rhs.heh_;
    00093     active_ = _rhs.active_;
    00094     return *this;
    00095   }
    00096 #else
    00097   friend class ConstCircT<Mesh>;
    00098 #endif
    00099
    00100
    00102   bool operator==(const CirculatorT& _rhs) const {
    00103     return ((mesh_   == _rhs.mesh_) &&
    00104             (start_  == _rhs.start_) &&
    00105             (heh_    == _rhs.heh_) &&
    00106             (active_ == _rhs.active_));
    00107   }
    00108
    00109
    00111   bool operator!=(const CirculatorT& _rhs) const {
    00112     return !operator==(_rhs);
    00113   }
    00114
    00115
    00117   CirculatorT& operator++() {
    00118     assert(mesh_);
    00119     active_ = true;
    00120     increment;
    00121     return *this;
    00122   }
    00123
    00124
    00126   CirculatorT& operator--() {
    00127     assert(mesh_);
    00128     active_ = true;
    00129     decrement;
    00130     return *this;
    00131   }
    00132
    00133
    00138   HalfedgeHandle current_halfedge_handle() const {
    00139     return heh_;
    00140   }
    00141
    00142
    00144   TargetHandle handle() const {
    00145     assert(mesh_);
    00146     return get_handle;
    00147   }
    00148
    00149
    00151   operator TargetHandle() const {
    00152     assert(mesh_);
    00153     return get_handle;
    00154   }
    00155
    00156
    00158   reference operator*() const {
    00159     assert(mesh_);
    00160     return mesh_->deref(handle());
    00161   }
    00162
    00163
    00165   pointer operator->() const {
    00166     assert(mesh_);
    00167     return &mesh_->deref(handle());
    00168   }
    00169
    00170
    00177   operator bool() const {
    00178     return heh_.is_valid() && ((start_ != heh_) || (!active_));
    00179   }
    00180
    00181
    00182 private:
    00183
    00184   mesh_ptr         mesh_;
    00185   HalfedgeHandle   start_, heh_;
    00186   bool             active_;
    00187 };
    00188
    00189
    00190