dune-grid  2.2.1
alugrid/2d/entityseed.hh
Go to the documentation of this file.
1 #ifndef ALU2DGRID_ENTITYKEY_HH
2 #define ALU2DGRID_ENTITYKEY_HH
3 
4 namespace Dune
5 {
6 
7 template<int cd, class GridImp>
9 
10 //**********************************************************************
11 //
12 // --ALU2dGridEntitySeed
13 // --EntitySeed
14 //**********************************************************************
15 template< int codim, class GridImp >
17 {
18 protected:
20  enum { dim = GridImp::dimension };
21  enum { dimworld = GridImp::dimensionworld };
22 
23 
24  friend class ALU2dGridEntity<codim,dim,GridImp>;
25  friend class ALU2dGridEntity< 0,dim,GridImp>;
26  friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
27 
28  typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
29  typedef typename ImplTraits::template Codim<codim>::InterfaceType ImplementationType;
32 
33 public:
34  static const int defaultValue = -1 ;
35 
36  enum { codimension = codim };
37 
39  typedef typename GridImp::template Codim<codimension>::Entity Entity;
43 
46 
49 
52  {
53 #ifndef NDEBUG
54  // clear pointer
55  clear();
56 #endif
57  }
58 
61 
64 
66  //
67  // interface methods
68  //
72 
75  {
76  return equals( i );
77  }
78 
81  {
82  return ! equals( i );
83  }
84 
86  ThisType & operator = (const ThisType & org);
87 
89  //
90  // non-interface methods
91  //
94  bool equals (const ALU2dGridEntitySeedType& i) const;
95 
97  void clear()
98  {
99  item_ = 0;
100  }
101 
103  HElementType* item() const { return item_; }
104 
106  {
107  return static_cast< KeyType* > (const_cast< ImplementationType* > (static_cast<const ImplementationType* > (item)));
108  }
109 
110  void set(const HElementType& item, const int level = -1 , const int face = -1 )
111  {
112  item_ = toKey( &item );
113  }
114 
115  int level () const { return ( item_ ) ? item_->level() : defaultValue; }
116  int face () const { return defaultValue; }
117 
118 protected:
119  // pointer to item
120  mutable KeyType* item_;
121 };
122 
123 template<int cd, class GridImp>
124 class ALU2dGridEntitySeed :
125 public ALU2dGridEntitySeedBase<cd,GridImp>
126 {
127  typedef ALU2dGridEntitySeedBase<cd,GridImp> BaseType;
128 
129  typedef ALU2dGridEntitySeed <cd,GridImp> ThisType;
130  enum { dim = GridImp::dimension };
131  enum { dimworld = GridImp::dimensionworld };
132 
133  friend class ALU2dGridEntity<cd,dim,GridImp>;
134  friend class ALU2dGridEntity< 0,dim,GridImp>;
135  friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
136 
137  typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
138  typedef typename ImplTraits::template Codim<cd>::InterfaceType ImplementationType;
139  typedef ImplementationType HElementType;
140 
141  typedef ALU2dGridEntity<cd,dim,GridImp> ALU2dGridEntityType;
142 
143 public:
144  using BaseType :: defaultValue ;
145 
147  typedef typename GridImp::template Codim<cd>::Entity Entity;
148 
151 
153  ALU2dGridEntitySeed(const ImplementationType & item)
154  {
155  // this constructor should only be called by codim=0 entity keys
156  assert( false );
157  abort();
158  }
159 
161  ALU2dGridEntitySeed(const HElementType & item,
162  const int level,
163  const int duneFace = defaultValue
164  );
165 
169 
172  : ALU2dGridEntitySeedBase<cd,GridImp> (entity.getItem()),
173  level_(entity.level()), face_(defaultValue)
174  {}
175 
178 
180  ThisType & operator = (const ThisType & org);
181 
183  void clear();
184 
186  void set(const HElementType & item, const int level, const int duneFace )
187  {
189  level_ = level ;
190  face_ = duneFace ;
191  }
192 
194  int level () const { return level_ ; }
196  int face () const { return face_ ; }
197 
198  using BaseType :: set ;
199 
201  {
202  return equals( i );
203  }
204 
206  {
207  return ! equals( i );
208  }
209 
211  bool equals (const ALU2dGridEntitySeedType& key) const
212  {
213  // only compare the item pointer, this is the real key
214  return BaseType :: equals( key ) && (level() == key.level());
215  }
216 
217 protected:
218  // level of entity
219  int level_;
220  // face number, for codim 1 only
221  int face_;
222 };
223 
227 template<class GridImp>
228 class ALU2dGridEntitySeed<0,GridImp> :
229 public ALU2dGridEntitySeedBase<0,GridImp>
230 {
231 protected:
233 
234  enum { cd = 0 };
236  enum { dim = GridImp::dimension };
237  enum { dimworld = GridImp::dimensionworld };
238 
239  friend class ALU2dGridEntity<cd,dim,GridImp>;
240  friend class ALU2dGridEntity< 0,dim,GridImp>;
241  friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
242 
243  typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
244  typedef typename ImplTraits::template Codim<cd>::InterfaceType ImplementationType;
246 
247  typedef ALU2dGridEntity< 0,dim,GridImp> ALU2dGridEntityType ;
248 
249 public:
250  using BaseType :: defaultValue ;
251 
253  typedef typename GridImp::template Codim<cd>::Entity Entity;
254 
257 
260 
263  : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
264 
267  : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
268 
271  : ALU2dGridEntitySeedBase<cd,GridImp> (org)
272  {
273  }
274 };
275 
276 
278 template <int cd, class GridImp>
279 inline std :: ostream &operator<< ( std :: ostream &out,
281 {
282  out << key.item() << " " << key.level() << " " << key.face();
283  return out;
284 }
285 
286 
287 //*******************************************************************
288 //
289 // Implementation
290 //
291 //*******************************************************************
292 template<int codim, class GridImp >
295  : item_( 0 )
296 {
297 }
298 
299 template<int codim, class GridImp >
302  : item_( toKey(&item) )
303 {
304 }
305 
306 template<int codim, class GridImp >
309  : item_(org.item_)
310 {
311 }
312 
313 template<int codim, class GridImp >
317 {
318  item_ = org.item_;
319  return *this;
320 }
321 
322 template<int codim, class GridImp >
325 {
326  // check equality of underlying items
327  return (item_ == i.item_);
328 }
329 
331 //
332 // specialisation for higher codims
333 //
335 
336 template<int codim, class GridImp >
338 ALU2dGridEntitySeed(const HElementType &item,
339  const int level,
340  const int duneFace )
341  : ALU2dGridEntitySeedBase<codim,GridImp> (item)
342  , level_(level)
343  , face_(duneFace)
344 {
345  assert( (codim == 1) ? (face_ >= 0) : 1 );
346 }
347 
348 template<int codim, class GridImp >
351  : ALU2dGridEntitySeedBase<codim,GridImp>(org)
352  , level_(org.level_)
353  , face_(org.face_)
354 {
355 }
356 
357 template<int codim, class GridImp >
361 {
362  // docu and cleanup
363  BaseType :: operator = ( org );
364 
365  // clone other stuff
366  level_ = org.level_;
367  face_ = org.face_;
368  return *this;
369 }
370 
371 template<int codim, class GridImp >
372 inline void
374 {
375  BaseType :: clear();
376  level_ = defaultValue ;
377  face_ = defaultValue ;
378 }
379 
380 } // end namespace Dune
381 #endif