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
10namespace Dune
11{
12
13 // SPDirection
14 // -----------
15
16 template< int dim >
18 {
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
SPDirection< dim > Direction
Definition: direction.hh:161
This & operator=(const This &)=default