dune-grid  2.4.1
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>
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>
132  class ALU2dGridEntitySeed :
133  public ALU2dGridEntitySeedBase<cd,GridImp>
134  {
135  typedef ALU2dGridEntitySeedBase<cd,GridImp> BaseType;
136 
137  typedef ALU2dGridEntitySeed <cd,GridImp> ThisType;
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  {
196  BaseType :: set( item );
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
std::ostream & operator<<(std::ostream &out, const ALU2dGridEntitySeed< cd, GridImp > &key)
print alugrid entity key to std::stream
Definition: alugrid/2d/entityseed.hh:286
ALU2dGridEntitySeed(const ALU2dGridEntityType &entity)
Constructor for EntitySeed that points to given entity.
Definition: alugrid/2d/entityseed.hh:179
KeyType * toKey(const HElementType *item)
Definition: alugrid/2d/entityseed.hh:113
ALU2dGridEntitySeed< codimension, GridImp > EntitySeedImp
make type of entity pointer implementation available in derived classes
Definition: alugrid/2d/entityseed.hh:50
bool operator==(const ALU2dGridEntitySeedType &i) const
Definition: alugrid/2d/entityseed.hh:208
GridImp::template Codim< cd >::Entity Entity
type of Entity
Definition: alugrid/2d/entityseed.hh:155
ThisType & operator=(const ThisType &org)
assignment operator
Definition: alugrid/2d/entityseed.hh:363
ImplementationType HElementType
Definition: alugrid/2d/entityseed.hh:32
void set(const HElementType &item, const int level, const int duneFace)
set element and level
Definition: alugrid/2d/entityseed.hh:194
void set(const HElementType &item, const int level=-1, const int face=-1)
Definition: alugrid/2d/entityseed.hh:118
ALU2dGridEntitySeed< cd, GridImp > ALU2dGridEntitySeedType
typedef of my type
Definition: alugrid/2d/entityseed.hh:158
ALU2dGridEntitySeed(const HElementType &item, int, int)
Constructor for EntitySeed that points to an interior element.
Definition: alugrid/2d/entityseed.hh:274
Definition: alugrid/2d/entity.hh:20
void clear()
invalidate seed
Definition: alugrid/2d/entityseed.hh:105
int face() const
Definition: alugrid/2d/entityseed.hh:124
ALU2dGridEntitySeed< cd, GridImp > ThisType
Definition: alugrid/2d/entityseed.hh:243
Definition: alugrid/2d/entityseed.hh:18
ImplTraits::template Codim< cd >::InterfaceType ImplementationType
Definition: alugrid/2d/entityseed.hh:252
KeyType * item_
Definition: alugrid/2d/entityseed.hh:128
ALU2dGridEntitySeed(const HElementType &item)
Constructor for EntitySeed that points to an interior element.
Definition: alugrid/2d/entityseed.hh:270
HElementType * item() const
get item from key
Definition: alugrid/2d/entityseed.hh:111
GridImp::template Codim< cd >::Entity Entity
type of Entity
Definition: alugrid/2d/entityseed.hh:261
ImplTraits::template Codim< codim >::InterfaceType ImplementationType
Definition: alugrid/2d/entityseed.hh:31
Definition: alugrid/2d/entityseed.hh:38
ALU2dGridEntitySeed(const ALU2dGridEntitySeedType &org)
copy constructor
Definition: alugrid/2d/entityseed.hh:278
ALU2dGridEntitySeed()
Constructor for EntitySeed that points to an element.
Definition: alugrid/2d/entityseed.hh:175
bool isValid() const
check for valid seed
Definition: alugrid/2d/entityseed.hh:91
GridImp::template Codim< codimension >::Entity Entity
type of Entity
Definition: alugrid/2d/entityseed.hh:41
MakeableInterfaceObject< Entity > EntityObject
underlying EntityImplementation
Definition: alugrid/2d/entityseed.hh:43
bool operator!=(const ALU2dGridEntitySeedType &i) const
Definition: alugrid/2d/entityseed.hh:213
Entity::Implementation ImplementationType
Definition: common/grid.hh:1468
void clear()
clear the key data structure
Definition: alugrid/2d/entityseed.hh:376
bool equals(const ALU2dGridEntitySeedType &key) const
equality, calls BaseType equals
Definition: alugrid/2d/entityseed.hh:219
EntityObject::ImplementationType EntityImp
Definition: alugrid/2d/entityseed.hh:44
Definition: alugrid/2d/entityseed.hh:23
ImplementationType HElementType
Definition: alugrid/2d/entityseed.hh:253
int face() const
return face
Definition: alugrid/2d/entityseed.hh:204
ImplementationType KeyType
Definition: alugrid/2d/entityseed.hh:33
int level() const
Definition: alugrid/2d/entityseed.hh:123
int face_
Definition: alugrid/2d/entityseed.hh:229
static const int defaultValue
Definition: alugrid/2d/entityseed.hh:36
ThisType & operator=(const ThisType &org)
assignment operator
Definition: alugrid/2d/entityseed.hh:320
ALU2dGridEntitySeedBase< 0, GridImp > BaseType
Definition: alugrid/2d/entityseed.hh:240
bool operator==(const ALU2dGridEntitySeedType &i) const
equality operator
Definition: alugrid/2d/entityseed.hh:76
bool equals(const ALU2dGridEntitySeedType &i) const
equality
Definition: alugrid/2d/entityseed.hh:328
ALU2dGridEntitySeedBase< codim, GridImp > ThisType
Definition: alugrid/2d/entityseed.hh:21
ALU2dGridEntitySeedBase()
Constructor for EntitySeed that points to an element.
Definition: alugrid/2d/entityseed.hh:301
Definition: alu2dinclude.hh:97
Definition: alugrid/2d/entityseed.hh:22
Definition: alugrid/2d/entityseed.hh:10
InterfaceType
Parameter to be used for the communication functions.
Definition: gridenums.hh:84
Definition: alugrid/2d/entity.hh:210
int level_
Definition: alugrid/2d/entityseed.hh:227
int level() const
return level
Definition: alugrid/2d/entityseed.hh:202
~ALU2dGridEntitySeedBase()
Destructor.
Definition: alugrid/2d/entityseed.hh:53
[ provides Dune::Grid ]
Definition: alugrid/2d/entity.hh:38
bool operator!=(const ALU2dGridEntitySeedType &i) const
inequality operator
Definition: alugrid/2d/entityseed.hh:82
ThisType ALU2dGridEntitySeedType
typedef of my type
Definition: alugrid/2d/entityseed.hh:47