| #ifndef _BoxTraverser_hpp_ |
| #define _BoxTraverser_hpp_ |
| |
| //@HEADER |
| // ************************************************************************ |
| // |
| // MiniFE: Simple Finite Element Assembly and Solve |
| // Copyright (2006-2013) Sandia Corporation |
| // |
| // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive |
| // license for use of this work by or on behalf of the U.S. Government. |
| // |
| // This library 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 2.1 of the |
| // License, or (at your option) any later version. |
| // |
| // This library 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 Lesser General Public |
| // License along with this library; if not, write to the Free Software |
| // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 |
| // USA |
| // |
| // ************************************************************************ |
| //@HEADER |
| |
| namespace miniFE { |
| |
| /** Class for traversing a 3-dimensional 'box' of indices. |
| |
| //One way to traverse a 'box[3][2]' is to use a triply-nested for-loop: |
| for(int z=box[2][0]; z<box[2][1]; ++z) { |
| for(int y=box[1][0]; y<box[1][1]; ++y) { |
| for(int x=box[0][0]; x<box[0][1]; ++x) { |
| ... |
| } |
| } |
| } |
| |
| //Another way is to use this BoxIterator class, like so: |
| //BoxIterator iter = BoxIterator::begin(box); |
| //BoxIterator end = BoxIterator::end(box); |
| for(; iter != end; ++iter) { |
| int x = iter.x; |
| int y = iter.y; |
| int z = iter.z; |
| ... |
| } |
| */ |
| class BoxIterator { |
| public: |
| ~BoxIterator(){} |
| |
| static BoxIterator begin(const Box& box) |
| { |
| return BoxIterator(box); |
| } |
| |
| static BoxIterator end(const Box& box) |
| { |
| return BoxIterator(box, true/*at_end==true*/); |
| } |
| |
| BoxIterator& operator=(const BoxIterator& src) |
| { |
| box_[0][0] = src.box_[0][0]; box_[0][1] = src.box_[0][1]; |
| box_[1][0] = src.box_[1][0]; box_[1][1] = src.box_[1][1]; |
| box_[2][0] = src.box_[2][0]; box_[2][1] = src.box_[2][1]; |
| x = src.x; |
| y = src.y; |
| z = src.z; |
| return *this; |
| } |
| |
| BoxIterator& operator++() |
| { |
| ++x; |
| if (x >= box_[0][1]) { |
| x = box_[0][0]; |
| ++y; |
| if (y >= box_[1][1]) { |
| y = box_[1][0]; |
| ++z; |
| if (z >= box_[2][1]) { |
| z = box_[2][1]; |
| y = box_[1][1]; |
| x = box_[0][1]; |
| } |
| } |
| } |
| return *this; |
| } |
| |
| BoxIterator operator++(int) |
| { |
| BoxIterator temp = *this; |
| ++(*this); |
| return temp; |
| } |
| |
| bool operator==(const BoxIterator& rhs) const |
| { |
| return x == rhs.x && y == rhs.y && z == rhs.z; |
| } |
| |
| bool operator!=(const BoxIterator& rhs) const |
| { |
| return !(this->operator==(rhs)); |
| } |
| |
| int x; |
| int y; |
| int z; |
| |
| private: |
| BoxIterator(const Box& box, bool at_end = false) |
| : x(box[0][0]), |
| y(box[1][0]), |
| z(box[2][0]), |
| box_() |
| { |
| box_[0][0] = box[0][0]; box_[0][1] = box[0][1]; |
| box_[1][0] = box[1][0]; box_[1][1] = box[1][1]; |
| box_[2][0] = box[2][0]; box_[2][1] = box[2][1]; |
| if (at_end) { |
| x = box[0][1]; |
| y = box[1][1]; |
| z = box[2][1]; |
| } |
| } |
| |
| Box box_; |
| };//class BoxTraverser |
| |
| }//namespace miniFE |
| |
| #endif |
| |