62 typedef std::bidirectional_iterator_tag iterator_category;
63 typedef int difference_type;
64 typedef const OH value_type;
65 typedef const OH* pointer;
66 typedef const OH& reference;
70 valid_(
true), cur_handle_(_ch), mesh_(_mesh) {}
73 valid_(
true), mesh_(_mesh) {}
76 BaseIterator() : valid_(
false), mesh_(0) {}
77 virtual ~BaseIterator() {}
78 bool operator== (
const BaseIterator& _c)
const {
79 return (this->cur_handle_ == _c.cur_handle() &&
80 this->valid_ == _c.valid() &&
81 this->mesh_ == _c.mesh());
83 bool operator!= (
const BaseIterator& _c)
const {
84 return !this->operator==(_c);
87 pointer operator->()
const {
91 reference operator*()
const {
95 bool operator< (
const BaseIterator& _c)
const {
96 return cur_handle_.idx() < _c.cur_handle_.idx();
99 BaseIterator& operator=(
const BaseIterator& _c) {
100 this->valid_ = _c.valid();
101 this->cur_handle_ = _c.cur_handle();
102 this->mesh_ = _c.mesh();
106 operator bool()
const {
110 void valid(
bool _valid) {
116 void cur_handle(
const OH& _h) {
119 reference cur_handle()
const {
136class BaseCirculator :
public BaseIterator<OH> {
139 typedef BaseIterator<OH> BaseIter;
141 BaseCirculator(
const TopologyKernel* _mesh,
const IH& _ih,
const OH& _oh,
int _max_laps = 1) :
142 BaseIter(_mesh, _oh),
144 max_laps_(_max_laps),
148 BaseCirculator(
const TopologyKernel* _mesh,
const IH& _ih,
int _max_laps = 1) :
149 BaseIter(_mesh, OH()),
151 max_laps_(_max_laps),
162 virtual ~BaseCirculator() {}
164 bool operator== (
const BaseCirculator& _c)
const {
165 return (BaseIter::operator==(_c) &&
166 this->lap() == _c.lap() &&
167 this->ref_handle() == _c.ref_handle());
169 bool operator!= (
const BaseCirculator& _c)
const {
170 return !this->operator==(_c);
173 bool operator< (
const BaseCirculator& _c)
const {
175 return BaseIter::operator<(_c);
177 return lap_ < _c.lap_;
180 BaseCirculator& operator=(
const BaseCirculator& _c) {
181 BaseIter::operator=(_c);
182 this->ref_handle_ = _c.ref_handle();
183 this->lap_ = _c.lap_;
184 this->max_laps_ = _c.max_laps_;
188 const IH& ref_handle()
const {
199 void max_laps(
int _max_laps) {
200 max_laps_ = _max_laps;
202 int max_laps()
const {
215class VertexOHalfEdgeIter :
216 public BaseCirculator<
220 typedef BaseCirculator<
229 VertexOHalfEdgeIter operator++(
int) {
230 VertexOHalfEdgeIter cpy = *
this;
234 VertexOHalfEdgeIter operator--(
int) {
235 VertexOHalfEdgeIter cpy = *
this;
239 VertexOHalfEdgeIter operator+(
int _n) {
240 VertexOHalfEdgeIter cpy = *
this;
241 for(
int i = 0; i < _n; ++i) {
246 VertexOHalfEdgeIter operator-(
int _n) {
247 VertexOHalfEdgeIter cpy = *
this;
248 for(
int i = 0; i < _n; ++i) {
253 VertexOHalfEdgeIter& operator+=(
int _n) {
254 for(
int i = 0; i < _n; ++i) {
259 VertexOHalfEdgeIter& operator-=(
int _n) {
260 for(
int i = 0; i < _n; ++i) {
266 VertexOHalfEdgeIter& operator++();
267 VertexOHalfEdgeIter& operator--();
276class HalfEdgeHalfFaceIter :
public BaseCirculator<
280 typedef BaseCirculator<
288 HalfEdgeHalfFaceIter operator++(
int) {
289 HalfEdgeHalfFaceIter cpy = *
this;
293 HalfEdgeHalfFaceIter operator--(
int) {
294 HalfEdgeHalfFaceIter cpy = *
this;
298 HalfEdgeHalfFaceIter operator+(
int _n) {
299 HalfEdgeHalfFaceIter cpy = *
this;
300 for(
int i = 0; i < _n; ++i) {
305 HalfEdgeHalfFaceIter operator-(
int _n) {
306 HalfEdgeHalfFaceIter cpy = *
this;
307 for(
int i = 0; i < _n; ++i) {
312 HalfEdgeHalfFaceIter& operator+=(
int _n) {
313 for(
int i = 0; i < _n; ++i) {
318 HalfEdgeHalfFaceIter& operator-=(
int _n) {
319 for(
int i = 0; i < _n; ++i) {
325 HalfEdgeHalfFaceIter& operator++();
326 HalfEdgeHalfFaceIter& operator--();
334class VertexCellIter :
public BaseCirculator<
338 typedef BaseCirculator<
345 VertexCellIter operator++(
int) {
346 VertexCellIter cpy = *
this;
350 VertexCellIter operator--(
int) {
351 VertexCellIter cpy = *
this;
355 VertexCellIter operator+(
int _n) {
356 VertexCellIter cpy = *
this;
357 for(
int i = 0; i < _n; ++i) {
362 VertexCellIter operator-(
int _n) {
363 VertexCellIter cpy = *
this;
364 for(
int i = 0; i < _n; ++i) {
369 VertexCellIter& operator+=(
int _n) {
370 for(
int i = 0; i < _n; ++i) {
375 VertexCellIter& operator-=(
int _n) {
376 for(
int i = 0; i < _n; ++i) {
382 VertexCellIter& operator++();
383 VertexCellIter& operator--();
386 std::vector<CellHandle> cells_;
390class HalfEdgeCellIter :
public BaseCirculator<
394 typedef BaseCirculator<
402 HalfEdgeCellIter operator++(
int) {
403 HalfEdgeCellIter cpy = *
this;
407 HalfEdgeCellIter operator--(
int) {
408 HalfEdgeCellIter cpy = *
this;
412 HalfEdgeCellIter operator+(
int _n) {
413 HalfEdgeCellIter cpy = *
this;
414 for(
int i = 0; i < _n; ++i) {
419 HalfEdgeCellIter operator-(
int _n) {
420 HalfEdgeCellIter cpy = *
this;
421 for(
int i = 0; i < _n; ++i) {
426 HalfEdgeCellIter& operator+=(
int _n) {
427 for(
int i = 0; i < _n; ++i) {
432 HalfEdgeCellIter& operator-=(
int _n) {
433 for(
int i = 0; i < _n; ++i) {
439 HalfEdgeCellIter& operator++();
440 HalfEdgeCellIter& operator--();
443 CellHandle getCellHandle(
int _cur_index)
const;
446 std::vector<CellHandle> cells_;
452class CellVertexIter :
public BaseCirculator<
456 typedef BaseCirculator<
463 CellVertexIter operator++(
int) {
464 CellVertexIter cpy = *
this;
468 CellVertexIter operator--(
int) {
469 CellVertexIter cpy = *
this;
473 CellVertexIter operator+(
int _n) {
474 CellVertexIter cpy = *
this;
475 for(
int i = 0; i < _n; ++i) {
480 CellVertexIter operator-(
int _n) {
481 CellVertexIter cpy = *
this;
482 for(
int i = 0; i < _n; ++i) {
487 CellVertexIter& operator+=(
int _n) {
488 for(
int i = 0; i < _n; ++i) {
493 CellVertexIter& operator-=(
int _n) {
494 for(
int i = 0; i < _n; ++i) {
500 CellVertexIter& operator++();
501 CellVertexIter& operator--();
504 std::vector<VertexHandle> incident_vertices_;
510class CellCellIter :
public BaseCirculator<
514 typedef BaseCirculator<
521 CellCellIter operator++(
int) {
522 CellCellIter cpy = *
this;
526 CellCellIter operator--(
int) {
527 CellCellIter cpy = *
this;
531 CellCellIter operator+(
int _n) {
532 CellCellIter cpy = *
this;
533 for(
int i = 0; i < _n; ++i) {
538 CellCellIter operator-(
int _n) {
539 CellCellIter cpy = *
this;
540 for(
int i = 0; i < _n; ++i) {
545 CellCellIter& operator+=(
int _n) {
546 for(
int i = 0; i < _n; ++i) {
551 CellCellIter& operator-=(
int _n) {
552 for(
int i = 0; i < _n; ++i) {
558 CellCellIter& operator++();
559 CellCellIter& operator--();
562 std::vector<CellHandle> adjacent_cells_;
568class HalfFaceVertexIter :
public BaseCirculator<
572 typedef BaseCirculator<
579 HalfFaceVertexIter operator++(
int) {
580 HalfFaceVertexIter cpy = *
this;
584 HalfFaceVertexIter operator--(
int) {
585 HalfFaceVertexIter cpy = *
this;
589 HalfFaceVertexIter operator+(
int _n) {
590 HalfFaceVertexIter cpy = *
this;
591 for(
int i = 0; i < _n; ++i) {
596 HalfFaceVertexIter operator-(
int _n) {
597 HalfFaceVertexIter cpy = *
this;
598 for(
int i = 0; i < _n; ++i) {
603 HalfFaceVertexIter& operator+=(
int _n) {
604 for(
int i = 0; i < _n; ++i) {
609 HalfFaceVertexIter& operator-=(
int _n) {
610 for(
int i = 0; i < _n; ++i) {
616 HalfFaceVertexIter& operator++();
617 HalfFaceVertexIter& operator--();
620 std::vector<VertexHandle> vertices_;
626class BoundaryHalfFaceHalfFaceIter :
public BaseCirculator<HalfFaceHandle,
636 BoundaryHalfFaceHalfFaceIter operator++(
int) {
637 BoundaryHalfFaceHalfFaceIter cpy = *
this;
641 BoundaryHalfFaceHalfFaceIter operator--(
int) {
642 BoundaryHalfFaceHalfFaceIter cpy = *
this;
646 BoundaryHalfFaceHalfFaceIter operator+(
int _n) {
647 BoundaryHalfFaceHalfFaceIter cpy = *
this;
648 for(
int i = 0; i < _n; ++i) {
653 BoundaryHalfFaceHalfFaceIter operator-(
int _n) {
654 BoundaryHalfFaceHalfFaceIter cpy = *
this;
655 for(
int i = 0; i < _n; ++i) {
660 BoundaryHalfFaceHalfFaceIter& operator+=(
int _n) {
661 for(
int i = 0; i < _n; ++i) {
666 BoundaryHalfFaceHalfFaceIter& operator-=(
int _n) {
667 for(
int i = 0; i < _n; ++i) {
673 const EdgeHandle& common_edge()
const {
return common_edges_[cur_index_]; }
675 BoundaryHalfFaceHalfFaceIter& operator++();
676 BoundaryHalfFaceHalfFaceIter& operator--();
679 std::vector<HalfFaceHandle> neighbor_halffaces_;
680 std::vector<EdgeHandle> common_edges_;
794class HalfEdgeIter :
public BaseIterator<HalfEdgeHandle> {
796 typedef BaseIterator<HalfEdgeHandle> BaseIter;
802 HalfEdgeIter operator++(
int) {
803 HalfEdgeIter cpy = *
this;
807 HalfEdgeIter operator--(
int) {
808 HalfEdgeIter cpy = *
this;
812 HalfEdgeIter operator+(
int _n) {
813 HalfEdgeIter cpy = *
this;
814 for(
int i = 0; i < _n; ++i) {
819 HalfEdgeIter operator-(
int _n) {
820 HalfEdgeIter cpy = *
this;
821 for(
int i = 0; i < _n; ++i) {
826 HalfEdgeIter& operator+=(
int _n) {
827 for(
int i = 0; i < _n; ++i) {
832 HalfEdgeIter& operator-=(
int _n) {
833 for(
int i = 0; i < _n; ++i) {
839 HalfEdgeIter& operator++();
840 HalfEdgeIter& operator--();
902class HalfFaceIter :
public BaseIterator<HalfFaceHandle> {
904 typedef BaseIterator<HalfFaceHandle> BaseIter;
910 HalfFaceIter operator++(
int) {
911 HalfFaceIter cpy = *
this;
915 HalfFaceIter operator--(
int) {
916 HalfFaceIter cpy = *
this;
920 HalfFaceIter operator+(
int _n) {
921 HalfFaceIter cpy = *
this;
922 for(
int i = 0; i < _n; ++i) {
927 HalfFaceIter operator-(
int _n) {
928 HalfFaceIter cpy = *
this;
929 for(
int i = 0; i < _n; ++i) {
934 HalfFaceIter& operator+=(
int _n) {
935 for(
int i = 0; i < _n; ++i) {
940 HalfFaceIter& operator-=(
int _n) {
941 for(
int i = 0; i < _n; ++i) {
947 HalfFaceIter& operator++();
948 HalfFaceIter& operator--();
1010class BoundaryFaceIter :
public BaseIterator<FaceHandle> {
1012 typedef BaseIterator<FaceHandle> BaseIter;
1018 BoundaryFaceIter operator++(
int) {
1019 BoundaryFaceIter cpy = *
this;
1023 BoundaryFaceIter operator--(
int) {
1024 BoundaryFaceIter cpy = *
this;
1028 BoundaryFaceIter operator+(
int _n) {
1029 BoundaryFaceIter cpy = *
this;
1030 for(
int i = 0; i < _n; ++i) {
1035 BoundaryFaceIter operator-(
int _n) {
1036 BoundaryFaceIter cpy = *
this;
1037 for(
int i = 0; i < _n; ++i) {
1042 BoundaryFaceIter& operator+=(
int _n) {
1043 for(
int i = 0; i < _n; ++i) {
1048 BoundaryFaceIter& operator-=(
int _n) {
1049 for(
int i = 0; i < _n; ++i) {
1055 BoundaryFaceIter& operator++();
1056 BoundaryFaceIter& operator--();