dune-spgrid  2.7
direction.hh
Go to the documentation of this file.
1 #ifndef DUNE_GRID_SPGRID_DIRECTION_HH
2 #define DUNE_GRID_SPGRID_DIRECTION_HH
3 
4 #include <bitset>
5 #include <cassert>
6 
9 
10 namespace Dune
11 {
12 
13  // SPDirection
14  // -----------
15 
16  template< int dim >
18  {
19  typedef SPDirection< dim > This;
20 
21  static_assert( (dim >= 0) && (dim < 8*sizeof( unsigned long )), "Invalid dimension." );
22 
23  template< int, int >
24  friend class SPDirectionIterator;
25 
26  public:
27  static const int dimension = dim;
28 
29  explicit SPDirection ( const SPMultiIndex< dimension > &id );
30 
31  explicit SPDirection ( unsigned long bits ) : bits_( bits ) {}
32 
33  bool operator== ( const This &other ) const { return (bits_ == other.bits_); }
34  bool operator!= ( const This &other ) const { return (bits_ != other.bits_); }
35 
36  unsigned int operator[] ( int i ) const { return bits_[ i ]; }
37 
38  int mydimension () const { return bits_.count(); }
39  int codimension () const { return dimension - mydimension(); }
40 
41  unsigned long bits () const { return bits_.to_ulong(); }
42 
43  private:
44  std::bitset< dimension > bits_;
45  };
46 
47 
48 
49  // SPBasicEntityDirection
50  // ----------------------
51 
52  template< int dim, int mydim >
54  {
56 
57  static_assert( (mydim >= 0) && (mydim <= dim), "Invalid entity dimension." );
58 
59  public:
60  static const int dimension = dim;
61 
63 
64  int mydimension () const { return mydim; }
65  };
66 
67 
68 
69  // SPEntityDirection
70  // -----------------
71 
72  template< int dim, int mydim >
74  : public SPBasicEntityDirection< dim, mydim >
75  {
78 
79  public:
81 
82  typedef typename Base::Direction Direction;
83 
84  SPEntityDirection () : direction_( 0u ) {}
85  explicit SPEntityDirection ( const SPMultiIndex< dimension > &id ) : direction_( id ) {}
86 
87  operator Direction () const { return direction_; }
88 
89  private:
90  Direction direction_;
91  };
92 
93 
94  template< int dim >
95  class SPEntityDirection< dim, 0 >
96  : public SPBasicEntityDirection< dim, 0 >
97  {
100 
101  public:
102  using Base::dimension;
103 
104  typedef typename Base::Direction Direction;
105 
106  SPEntityDirection () = default;
107  explicit SPEntityDirection ( const SPMultiIndex< dimension > &id ) { assert( Direction( id ) == static_cast< Direction >( This() ) ); }
108 
109  operator Direction () const { return Direction( 0u ); }
110  };
111 
112 
113  template< int dim >
114  class SPEntityDirection< dim, dim >
115  : public SPBasicEntityDirection< dim, dim >
116  {
119 
120  public:
121  using Base::dimension;
122 
123  typedef typename Base::Direction Direction;
124 
125  SPEntityDirection () = default;
126  explicit SPEntityDirection ( const SPMultiIndex< dimension > &id ) { assert( Direction( id ) == static_cast< Direction >( This() ) ); }
127 
128  operator Direction () const { return Direction( (1u << dim) - 1u ); }
129  };
130 
131 
132  template< >
133  class SPEntityDirection< 0, 0 >
134  : public SPBasicEntityDirection< 0, 0 >
135  {
138 
139  public:
140  using Base::dimension;
141 
143 
144  SPEntityDirection () = default;
145  explicit SPEntityDirection ( const SPMultiIndex< dimension > &id ) { assert( Direction( id ) == static_cast< Direction >( This() ) ); }
146 
147  operator Direction () const { return Direction( 0u ); }
148  };
149 
150 
151 
152  // SPDirectionIterator
153  // -------------------
154 
155  template< int dim, int codim >
157  {
159 
160  public:
162 
163  SPDirectionIterator () : bits_( (1u << (dim - codim)) - 1u ) {}
164  explicit SPDirectionIterator ( const Direction &direction ) : bits_( direction.bits() ) {}
165 
166  SPDirectionIterator ( const This & ) = default;
167  SPDirectionIterator ( This && ) = default;
168 
169  This &operator= ( const This & ) = default;
170  This &operator= ( This && ) = default;
171 
172  operator bool () const { return (bits_ != ((1u << dim) - (1u << codim) + 1u)); }
173 
174  Direction operator* () const { return Direction( bits_ ); }
175 
176  const This &operator++ ();
177 
178  private:
179  unsigned long bits_;
180  };
181 
182 
183 
184  // Implementation of SPDirection
185  // -----------------------------
186 
187  template< int dim >
189 
190 
191  template< int dim >
193  {
194  for( int i = 0; i < dimension; ++i )
195  bits_[ i ] = (id[ i ] & 1);
196  }
197 
198 
199 
200  // Implementation of SPBasicEntityDirection
201  // ----------------------------------------
202 
203  template< int dim, int mydim >
205 
206 
207 
208  // Implementation of SPDirectionIterator
209  // -------------------------------------
210 
211  template< int dim, int codim >
212  inline const typename SPDirectionIterator< dim, codim >::This &
214  {
215  assert( *this );
216  do {
217  ++bits_;
218  } while( *this && (Direction( bits_ ).mydimension() != (dim - codim)) );
219  return *this;
220  }
221 
222 } // namespace Dune
223 
224 #endif // #ifndef DUNE_GRID_SPGRID_DIRECTION_HH
miscellaneous helper functions
Definition: iostream.hh:7
Definition: direction.hh:18
static const int dimension
Definition: direction.hh:27
unsigned long bits() const
Definition: direction.hh:41
int mydimension() const
Definition: direction.hh:38
bool operator==(const This &other) const
Definition: direction.hh:33
SPDirection(unsigned long bits)
Definition: direction.hh:31
int codimension() const
Definition: direction.hh:39
SPDirection(const SPMultiIndex< dimension > &id)
Definition: direction.hh:192
bool operator!=(const This &other) const
Definition: direction.hh:34
unsigned int operator[](int i) const
Definition: direction.hh:36
Definition: direction.hh:54
static const int dimension
Definition: direction.hh:60
int mydimension() const
Definition: direction.hh:64
SPDirection< dimension > Direction
Definition: direction.hh:62
Definition: direction.hh:75
SPEntityDirection()
Definition: direction.hh:84
Base::Direction Direction
Definition: direction.hh:82
SPEntityDirection(const SPMultiIndex< dimension > &id)
Definition: direction.hh:85
Definition: direction.hh:97
Base::Direction Direction
Definition: direction.hh:104
SPEntityDirection(const SPMultiIndex< dimension > &id)
Definition: direction.hh:107
Definition: direction.hh:116
Base::Direction Direction
Definition: direction.hh:123
SPEntityDirection(const SPMultiIndex< dimension > &id)
Definition: direction.hh:126
Definition: direction.hh:135
Base::Direction Direction
Definition: direction.hh:142
SPEntityDirection(const SPMultiIndex< dimension > &id)
Definition: direction.hh:145
Definition: direction.hh:157
SPDirectionIterator(const This &)=default
Direction operator*() const
Definition: direction.hh:174
SPDirectionIterator(const Direction &direction)
Definition: direction.hh:164
const This & operator++()
Definition: direction.hh:213
SPDirectionIterator()
Definition: direction.hh:163
SPDirectionIterator(This &&)=default
This & operator=(const This &)=default
SPDirection< dim > Direction
Definition: direction.hh:161