dune-grid  2.2.0
alugrid/2d/entityseed.hh
Go to the documentation of this file.
00001 #ifndef ALU2DGRID_ENTITYKEY_HH
00002 #define ALU2DGRID_ENTITYKEY_HH
00003 
00004 namespace Dune 
00005 {
00006 
00007 template<int cd, class GridImp>
00008 class ALU2dGridEntitySeed ;
00009 
00010 //**********************************************************************
00011 //
00012 // --ALU2dGridEntitySeed
00013 // --EntitySeed
00014 //**********************************************************************
00015 template< int codim, class GridImp >
00016 class ALU2dGridEntitySeedBase
00017 {
00018 protected:  
00019   typedef ALU2dGridEntitySeedBase< codim, GridImp > ThisType;
00020   enum { dim       = GridImp::dimension };
00021   enum { dimworld  = GridImp::dimensionworld };
00022 
00023    
00024   friend class ALU2dGridEntity<codim,dim,GridImp>;
00025   friend class ALU2dGridEntity< 0,dim,GridImp>;
00026   friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
00027 
00028   typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
00029   typedef typename ImplTraits::template Codim<codim>::InterfaceType   ImplementationType;
00030   typedef ImplementationType  HElementType;
00031   typedef ImplementationType  KeyType;
00032 
00033 public:
00034   static const int defaultValue = -1 ;
00035 
00036   enum { codimension = codim };
00037 
00039   typedef typename GridImp::template Codim<codimension>::Entity   Entity;
00041   typedef MakeableInterfaceObject<Entity> EntityObject;
00042   typedef typename EntityObject :: ImplementationType EntityImp;
00043   
00045   typedef ThisType ALU2dGridEntitySeedType;
00046 
00048   typedef ALU2dGridEntitySeed<codimension,GridImp> EntitySeedImp;
00049   
00051   ~ALU2dGridEntitySeedBase() 
00052   {
00053 #ifndef NDEBUG 
00054     // clear pointer 
00055     clear();
00056 #endif
00057   }
00058 
00060   ALU2dGridEntitySeedBase();
00061 
00063   ALU2dGridEntitySeedBase(const HElementType& item);
00064 
00066   //
00067   //  interface methods 
00068   //
00071   ALU2dGridEntitySeedBase(const ALU2dGridEntitySeedType & org);
00072   
00074   bool operator == (const ALU2dGridEntitySeedType& i) const
00075   {
00076     return equals( i );
00077   }
00078 
00080   bool operator != (const ALU2dGridEntitySeedType& i) const
00081   {
00082     return ! equals( i );
00083   }
00084 
00086   ThisType & operator = (const ThisType & org);
00087 
00089   //
00090   //  non-interface methods 
00091   //
00094   bool equals (const ALU2dGridEntitySeedType& i) const;
00095 
00097   void clear() 
00098   { 
00099     item_ = 0;
00100   }
00101 
00103   HElementType* item() const { return item_; }
00104 
00105   KeyType* toKey(const HElementType* item)
00106   {
00107     return static_cast< KeyType* > (const_cast< ImplementationType* > (static_cast<const ImplementationType* > (item)));
00108   }
00109 
00110   void set(const HElementType& item, const int level = -1 , const int face = -1 )
00111   {
00112     item_ = toKey( &item );
00113   }
00114 
00115   int level () const { return ( item_ ) ? item_->level() : defaultValue; }
00116   int face  () const { return defaultValue; }
00117 
00118 protected:
00119   // pointer to item 
00120   mutable KeyType* item_;
00121 };
00122 
00123 template<int cd, class GridImp>
00124 class ALU2dGridEntitySeed : 
00125 public ALU2dGridEntitySeedBase<cd,GridImp>
00126 {
00127   typedef ALU2dGridEntitySeedBase<cd,GridImp> BaseType;
00128 
00129   typedef ALU2dGridEntitySeed <cd,GridImp> ThisType;
00130   enum { dim       = GridImp::dimension };
00131   enum { dimworld  = GridImp::dimensionworld };
00132     
00133   friend class ALU2dGridEntity<cd,dim,GridImp>;
00134   friend class ALU2dGridEntity< 0,dim,GridImp>;
00135   friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
00136 
00137   typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
00138   typedef typename ImplTraits::template Codim<cd>::InterfaceType  ImplementationType;
00139   typedef ImplementationType  HElementType;
00140 
00141   typedef ALU2dGridEntity<cd,dim,GridImp> ALU2dGridEntityType;
00142 
00143 public:
00144   using BaseType :: defaultValue ;
00145 
00147   typedef typename GridImp::template Codim<cd>::Entity Entity;
00148   
00150   typedef ALU2dGridEntitySeed<cd,GridImp> ALU2dGridEntitySeedType;
00151   
00153   ALU2dGridEntitySeed(const ImplementationType & item) 
00154   {
00155     // this constructor should only be called by codim=0 entity keys
00156     assert( false );
00157     abort();
00158   }
00159 
00161   ALU2dGridEntitySeed(const HElementType & item,
00162                       const int level, 
00163                       const int duneFace = defaultValue
00164                      );
00165 
00167   ALU2dGridEntitySeed() 
00168     : BaseType(), level_(defaultValue), face_(defaultValue) {}
00169 
00171   ALU2dGridEntitySeed(const ALU2dGridEntityType& entity) 
00172     : ALU2dGridEntitySeedBase<cd,GridImp> (entity.getItem()),
00173    level_(entity.level()), face_(defaultValue)
00174   {}
00175 
00177   ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org);
00178   
00180   ThisType & operator = (const ThisType & org);
00181 
00183   void clear();
00184 
00186   void set(const HElementType & item, const int level, const int duneFace )
00187   {
00188     BaseType :: set( item );
00189     level_ = level ;
00190     face_  = duneFace ; 
00191   }
00192 
00194   int level () const { return level_ ; }
00196   int face  () const { return face_ ; }
00197 
00198   using BaseType :: set ;
00199 
00200   bool operator == (const ALU2dGridEntitySeedType& i) const
00201   {
00202     return equals( i );
00203   }
00204 
00205   bool operator != (const ALU2dGridEntitySeedType& i) const
00206   {
00207     return ! equals( i );
00208   }
00209 
00211   bool equals (const ALU2dGridEntitySeedType& key) const
00212   {
00213     // only compare the item pointer, this is the real key 
00214     return BaseType :: equals( key ) && (level() == key.level()); 
00215   }
00216 
00217 protected:
00218   // level of entity 
00219   int level_; 
00220   // face number, for codim 1 only 
00221   int face_;
00222 };
00223 
00227 template<class GridImp>
00228 class ALU2dGridEntitySeed<0,GridImp> : 
00229 public ALU2dGridEntitySeedBase<0,GridImp> 
00230 {
00231 protected:  
00232   typedef ALU2dGridEntitySeedBase<0,GridImp> BaseType;
00233 
00234   enum { cd = 0 };
00235   typedef ALU2dGridEntitySeed <cd,GridImp> ThisType;
00236   enum { dim       = GridImp::dimension };
00237   enum { dimworld  = GridImp::dimensionworld };
00238     
00239   friend class ALU2dGridEntity<cd,dim,GridImp>;
00240   friend class ALU2dGridEntity< 0,dim,GridImp>;
00241   friend class ALU2dGrid <GridImp :: dimension, GridImp::dimensionworld, GridImp::elementType >;
00242 
00243   typedef ALU2dImplTraits< GridImp::dimensionworld, GridImp::elementType > ImplTraits;
00244   typedef typename ImplTraits::template Codim<cd>::InterfaceType   ImplementationType;
00245   typedef ImplementationType  HElementType;
00246 
00247   typedef ALU2dGridEntity< 0,dim,GridImp> ALU2dGridEntityType ;
00248 
00249 public:
00250   using BaseType :: defaultValue ;
00251 
00253   typedef typename GridImp::template Codim<cd>::Entity Entity;
00254   
00256   typedef ThisType ALU2dGridEntitySeedType;
00257   
00259   ALU2dGridEntitySeed() : BaseType() {} 
00260 
00262   ALU2dGridEntitySeed(const HElementType& item)
00263     : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
00264 
00266   ALU2dGridEntitySeed(const HElementType& item, int , int )
00267     : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
00268 
00270   ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org)
00271     : ALU2dGridEntitySeedBase<cd,GridImp> (org) 
00272   {
00273   }
00274 };
00275 
00276 
00278 template <int cd, class GridImp> 
00279 inline std :: ostream &operator<< ( std :: ostream &out, 
00280                                     const ALU2dGridEntitySeed<cd,GridImp>& key)
00281 {
00282   out << key.item() << " " << key.level() << " " << key.face();
00283   return out;
00284 }
00285 
00286 
00287 //*******************************************************************
00288 //
00289 //  Implementation 
00290 //
00291 //*******************************************************************
00292 template<int codim, class GridImp >
00293 inline ALU2dGridEntitySeedBase<codim,GridImp> :: 
00294 ALU2dGridEntitySeedBase()
00295   : item_( 0 )
00296 {
00297 }
00298 
00299 template<int codim, class GridImp >
00300 inline ALU2dGridEntitySeedBase<codim,GridImp> :: 
00301 ALU2dGridEntitySeedBase(const HElementType &item)
00302   : item_( toKey(&item) )
00303 {
00304 }
00305 
00306 template<int codim, class GridImp >
00307 inline ALU2dGridEntitySeedBase<codim,GridImp> :: 
00308 ALU2dGridEntitySeedBase(const ALU2dGridEntitySeedType & org)
00309   : item_(org.item_)
00310 {
00311 }
00312 
00313 template<int codim, class GridImp >
00314 inline ALU2dGridEntitySeedBase<codim,GridImp> & 
00315 ALU2dGridEntitySeedBase<codim,GridImp> :: 
00316 operator = (const ALU2dGridEntitySeedType & org)
00317 {
00318   item_  = org.item_;
00319   return *this;
00320 }
00321 
00322 template<int codim, class GridImp >
00323 inline bool ALU2dGridEntitySeedBase<codim,GridImp>::
00324 equals (const ALU2dGridEntitySeedBase<codim,GridImp>& i) const 
00325 {
00326   // check equality of underlying items  
00327   return (item_ == i.item_);
00328 }
00329 
00331 //
00332 //  specialisation for higher codims 
00333 //  
00335 
00336 template<int codim, class GridImp >
00337 inline ALU2dGridEntitySeed<codim,GridImp> :: 
00338 ALU2dGridEntitySeed(const HElementType &item,
00339                    const int level,
00340                    const int duneFace ) 
00341   : ALU2dGridEntitySeedBase<codim,GridImp> (item) 
00342   , level_(level)
00343   , face_(duneFace)
00344 {
00345   assert( (codim == 1) ? (face_ >= 0) : 1 );
00346 }
00347 
00348 template<int codim, class GridImp >
00349 inline ALU2dGridEntitySeed<codim,GridImp> :: 
00350 ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org)
00351   : ALU2dGridEntitySeedBase<codim,GridImp>(org) 
00352   , level_(org.level_)
00353   , face_(org.face_)
00354 {
00355 }
00356 
00357 template<int codim, class GridImp >
00358 inline ALU2dGridEntitySeed<codim,GridImp> &
00359 ALU2dGridEntitySeed<codim,GridImp>:: 
00360 operator = (const ALU2dGridEntitySeedType & org)
00361 {
00362   // docu and cleanup 
00363   BaseType :: operator = ( org );
00364 
00365   // clone other stuff 
00366   level_ = org.level_;
00367   face_  = org.face_;
00368   return *this;
00369 }
00370 
00371 template<int codim, class GridImp >
00372 inline void 
00373 ALU2dGridEntitySeed<codim,GridImp>::clear ()
00374 {
00375   BaseType :: clear();
00376   level_ = defaultValue ;
00377   face_  = defaultValue ;
00378 }
00379 
00380 } // end namespace Dune 
00381 #endif