dune-grid  2.3beta2
alugrid/2d/entityseed.hh
Go to the documentation of this file.
1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 // vi: set et ts=4 sw=2 sts=2:
3 #ifndef ALU2DGRID_ENTITYKEY_HH
4 #define ALU2DGRID_ENTITYKEY_HH
5 
6 namespace Dune
7 {
8 
9  template<int cd, class GridImp>
10  class ALU2dGridEntitySeed ;
11 
12  //**********************************************************************
13  //
14  // --ALU2dGridEntitySeed
15  // --EntitySeed
16  //**********************************************************************
17  template< int codim, class GridImp >
19  {
20  protected:
22  enum { dim = GridImp::dimension };
23  enum { dimworld = GridImp::dimensionworld };
24 
25 
26  friend class ALU2dGridEntity<codim,dim,GridImp>;
27  friend class ALU2dGridEntity< 0,dim,GridImp>;
28  friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
29 
30  typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
31  typedef typename ImplTraits::template Codim<codim>::InterfaceType ImplementationType;
34 
35  public:
36  static const int defaultValue = -1 ;
37 
38  enum { codimension = codim };
39 
41  typedef typename GridImp::template Codim<codimension>::Entity Entity;
45 
48 
51 
54  {
55 #ifndef NDEBUG
56  // clear pointer
57  clear();
58 #endif
59  }
60 
63 
66 
68  //
69  // interface methods
70  //
74 
77  {
78  return equals( i );
79  }
80 
83  {
84  return ! equals( i );
85  }
86 
88  ThisType & operator = (const ThisType & org);
89 
91  bool isValid () const
92  {
93  return item_ != 0;
94  }
95 
97  //
98  // non-interface methods
99  //
102  bool equals (const ALU2dGridEntitySeedType& i) const;
103 
105  void clear()
106  {
107  item_ = 0;
108  }
109 
111  HElementType* item() const { return item_; }
112 
114  {
115  return static_cast< KeyType* > (const_cast< ImplementationType* > (static_cast<const ImplementationType* > (item)));
116  }
117 
118  void set(const HElementType& item, const int level = -1 , const int face = -1 )
119  {
120  item_ = toKey( &item );
121  }
122 
123  int level () const { return ( item_ ) ? item_->level() : defaultValue; }
124  int face () const { return defaultValue; }
125 
126  protected:
127  // pointer to item
128  mutable KeyType* item_;
129  };
130 
131  template<int cd, class GridImp>
133  public ALU2dGridEntitySeedBase<cd,GridImp>
134  {
136 
138  enum { dim = GridImp::dimension };
139  enum { dimworld = GridImp::dimensionworld };
140 
141  friend class ALU2dGridEntity<cd,dim,GridImp>;
142  friend class ALU2dGridEntity< 0,dim,GridImp>;
143  friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
144 
145  typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
146  typedef typename ImplTraits::template Codim<cd>::InterfaceType ImplementationType;
147  typedef ImplementationType HElementType;
148 
149  typedef ALU2dGridEntity<cd,dim,GridImp> ALU2dGridEntityType;
150 
151  public:
152  using BaseType :: defaultValue ;
153 
155  typedef typename GridImp::template Codim<cd>::Entity Entity;
156 
159 
161  ALU2dGridEntitySeed(const ImplementationType & item)
162  {
163  // this constructor should only be called by codim=0 entity keys
164  assert( false );
165  abort();
166  }
167 
169  ALU2dGridEntitySeed(const HElementType & item,
170  const int level,
171  const int duneFace = defaultValue
172  );
173 
177 
180  : ALU2dGridEntitySeedBase<cd,GridImp> (entity.getItem()),
181  level_(entity.level()), face_(defaultValue)
182  {}
183 
186 
188  ThisType & operator = (const ThisType & org);
189 
191  void clear();
192 
194  void set(const HElementType & item, const int level, const int duneFace )
195  {
197  level_ = level ;
198  face_ = duneFace ;
199  }
200 
202  int level () const { return level_ ; }
204  int face () const { return face_ ; }
205 
206  using BaseType :: set ;
207 
209  {
210  return equals( i );
211  }
212 
214  {
215  return ! equals( i );
216  }
217 
219  bool equals (const ALU2dGridEntitySeedType& key) const
220  {
221  // only compare the item pointer, this is the real key
222  return BaseType :: equals( key ) && (level() == key.level());
223  }
224 
225  protected:
226  // level of entity
227  int level_;
228  // face number, for codim 1 only
229  int face_;
230  };
231 
235  template<class GridImp>
236  class ALU2dGridEntitySeed<0,GridImp> :
237  public ALU2dGridEntitySeedBase<0,GridImp>
238  {
239  protected:
241 
242  enum { cd = 0 };
244  enum { dim = GridImp::dimension };
245  enum { dimworld = GridImp::dimensionworld };
246 
247  friend class ALU2dGridEntity<cd,dim,GridImp>;
248  friend class ALU2dGridEntity< 0,dim,GridImp>;
249  friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
250 
251  typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
252  typedef typename ImplTraits::template Codim<cd>::InterfaceType ImplementationType;
254 
255  typedef ALU2dGridEntity< 0,dim,GridImp> ALU2dGridEntityType ;
256 
257  public:
258  using BaseType :: defaultValue ;
259 
261  typedef typename GridImp::template Codim<cd>::Entity Entity;
262 
265 
268 
271  : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
272 
275  : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
276 
279  : ALU2dGridEntitySeedBase<cd,GridImp> (org)
280  {}
281  };
282 
283 
285  template <int cd, class GridImp>
286  inline std :: ostream &operator<< ( std :: ostream &out,
288  {
289  out << key.item() << " " << key.level() << " " << key.face();
290  return out;
291  }
292 
293 
294  //*******************************************************************
295  //
296  // Implementation
297  //
298  //*******************************************************************
299  template<int codim, class GridImp >
302  : item_( 0 )
303  {}
304 
305  template<int codim, class GridImp >
308  : item_( toKey(&item) )
309  {}
310 
311  template<int codim, class GridImp >
314  : item_(org.item_)
315  {}
316 
317  template<int codim, class GridImp >
321  {
322  item_ = org.item_;
323  return *this;
324  }
325 
326  template<int codim, class GridImp >
329  {
330  // check equality of underlying items
331  return (item_ == i.item_);
332  }
333 
335  //
336  // specialisation for higher codims
337  //
339 
340  template<int codim, class GridImp >
342  ALU2dGridEntitySeed(const HElementType &item,
343  const int level,
344  const int duneFace )
345  : ALU2dGridEntitySeedBase<codim,GridImp> (item)
346  , level_(level)
347  , face_(duneFace)
348  {
349  assert( (codim == 1) ? (face_ >= 0) : 1 );
350  }
351 
352  template<int codim, class GridImp >
355  : ALU2dGridEntitySeedBase<codim,GridImp>(org)
356  , level_(org.level_)
357  , face_(org.face_)
358  {}
359 
360  template<int codim, class GridImp >
364  {
365  // docu and cleanup
366  BaseType :: operator = ( org );
367 
368  // clone other stuff
369  level_ = org.level_;
370  face_ = org.face_;
371  return *this;
372  }
373 
374  template<int codim, class GridImp >
375  inline void
377  {
378  BaseType :: clear();
379  level_ = defaultValue ;
380  face_ = defaultValue ;
381  }
382 
383 } // end namespace Dune
384 #endif