← Back to branch summary

~ubuntu-branches/ubuntu/utopic/dune-grid/utopic-proposed

« back to all changes in this revision

Viewing changes to dune/grid/alugrid/2d/entityseed.hh

  • Committer: Package Import Robot
  • Author(s): Ansgar Burchardt
  • Date: 2014-02-14 10:49:16 UTC
  • mfrom: (1.3.1) (5.1.4 experimental)
  • Revision ID: package-import@ubuntu.com-20140214104916-2clchnny3eu7ks4w
Tags: 2.3.0-2
Install /usr/share/dune-grid.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dune/grid/alugrid/2d/entityseed.hh
 
1
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 
2
// vi: set et ts=4 sw=2 sts=2:
1
3
#ifndef ALU2DGRID_ENTITYKEY_HH
2
4
#define ALU2DGRID_ENTITYKEY_HH
3
5
 
4
 
namespace Dune 
5
 
{
6
 
 
7
 
template<int cd, class GridImp>
8
 
class ALU2dGridEntitySeed ;
9
 
 
10
 
//**********************************************************************
11
 
//
12
 
// --ALU2dGridEntitySeed
13
 
// --EntitySeed
14
 
//**********************************************************************
15
 
template< int codim, class GridImp >
16
 
class ALU2dGridEntitySeedBase
17
 
{
18
 
protected:  
19
 
  typedef ALU2dGridEntitySeedBase< codim, GridImp > ThisType;
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;
30
 
  typedef ImplementationType  HElementType;
31
 
  typedef ImplementationType  KeyType;
32
 
 
33
 
public:
34
 
  static const int defaultValue = -1 ;
35
 
 
36
 
  enum { codimension = codim };
37
 
 
38
 
  //! type of Entity 
39
 
  typedef typename GridImp::template Codim<codimension>::Entity   Entity;
40
 
  //! underlying EntityImplementation 
41
 
  typedef MakeableInterfaceObject<Entity> EntityObject;
42
 
  typedef typename EntityObject :: ImplementationType EntityImp;
43
 
  
44
 
  //! typedef of my type 
45
 
  typedef ThisType ALU2dGridEntitySeedType;
46
 
 
47
 
  //! make type of entity pointer implementation available in derived classes
48
 
  typedef ALU2dGridEntitySeed<codimension,GridImp> EntitySeedImp;
49
 
  
50
 
  //! Destructor  
51
 
  ~ALU2dGridEntitySeedBase() 
 
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 >
 
18
  class ALU2dGridEntitySeedBase
52
19
  {
53
 
#ifndef NDEBUG 
54
 
    // clear pointer 
55
 
    clear();
 
20
  protected:
 
21
    typedef ALU2dGridEntitySeedBase< codim, GridImp > ThisType;
 
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;
 
32
    typedef ImplementationType HElementType;
 
33
    typedef ImplementationType KeyType;
 
34
 
 
35
  public:
 
36
    static const int defaultValue = -1 ;
 
37
 
 
38
    enum { codimension = codim };
 
39
 
 
40
    //! type of Entity
 
41
    typedef typename GridImp::template Codim<codimension>::Entity Entity;
 
42
    //! underlying EntityImplementation
 
43
    typedef MakeableInterfaceObject<Entity> EntityObject;
 
44
    typedef typename EntityObject :: ImplementationType EntityImp;
 
45
 
 
46
    //! typedef of my type
 
47
    typedef ThisType ALU2dGridEntitySeedType;
 
48
 
 
49
    //! make type of entity pointer implementation available in derived classes
 
50
    typedef ALU2dGridEntitySeed<codimension,GridImp> EntitySeedImp;
 
51
 
 
52
    //! Destructor
 
53
    ~ALU2dGridEntitySeedBase()
 
54
    {
 
55
#ifndef NDEBUG
 
56
      // clear pointer
 
57
      clear();
56
58
#endif
57
 
  }
58
 
 
59
 
  //! Constructor for EntitySeed that points to an element 
60
 
  ALU2dGridEntitySeedBase();
61
 
 
62
 
  //! Constructor for EntitySeed that points to an element 
63
 
  ALU2dGridEntitySeedBase(const HElementType& item);
64
 
 
65
 
  /////////////////////////////////////////////////////////////
66
 
  //
67
 
  //  interface methods 
68
 
  //
69
 
  /////////////////////////////////////////////////////////////
70
 
  //! copy constructor 
71
 
  ALU2dGridEntitySeedBase(const ALU2dGridEntitySeedType & org);
72
 
  
73
 
  //! equality operator 
74
 
  bool operator == (const ALU2dGridEntitySeedType& i) const
75
 
  {
76
 
    return equals( i );
77
 
  }
78
 
 
79
 
  //! inequality operator 
80
 
  bool operator != (const ALU2dGridEntitySeedType& i) const
81
 
  {
82
 
    return ! equals( i );
83
 
  }
84
 
 
85
 
  //! assignment operator
86
 
  ThisType & operator = (const ThisType & org);
87
 
 
88
 
  //////////////////////////////////////////////////////
89
 
  //
90
 
  //  non-interface methods 
91
 
  //
92
 
  //////////////////////////////////////////////////////
93
 
  //! equality
94
 
  bool equals (const ALU2dGridEntitySeedType& i) const;
95
 
 
96
 
  //! invalidate seed 
97
 
  void clear() 
98
 
  { 
99
 
    item_ = 0;
100
 
  }
101
 
 
102
 
  //! get item from key 
103
 
  HElementType* item() const { return item_; }
104
 
 
105
 
  KeyType* toKey(const HElementType* item)
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
 
 
146
 
  //! type of Entity 
147
 
  typedef typename GridImp::template Codim<cd>::Entity Entity;
148
 
  
149
 
  //! typedef of my type 
150
 
  typedef ALU2dGridEntitySeed<cd,GridImp> ALU2dGridEntitySeedType;
151
 
  
152
 
  //! Constructor for EntitySeed that points to an element 
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
 
 
160
 
  //! Constructor for EntitySeed that points to an element 
161
 
  ALU2dGridEntitySeed(const HElementType & item,
162
 
                      const int level, 
163
 
                      const int duneFace = defaultValue
164
 
                     );
165
 
 
166
 
  //! Constructor for EntitySeed that points to an element 
167
 
  ALU2dGridEntitySeed() 
168
 
    : BaseType(), level_(defaultValue), face_(defaultValue) {}
169
 
 
170
 
  //! Constructor for EntitySeed that points to given entity 
171
 
  ALU2dGridEntitySeed(const ALU2dGridEntityType& entity) 
172
 
    : ALU2dGridEntitySeedBase<cd,GridImp> (entity.getItem()),
173
 
   level_(entity.level()), face_(defaultValue)
174
 
  {}
175
 
 
176
 
  //! copy constructor 
177
 
  ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org);
178
 
  
179
 
  //! assignment operator
180
 
  ThisType & operator = (const ThisType & org);
181
 
 
182
 
  //! clear the key data structure 
183
 
  void clear();
184
 
 
185
 
  //! set element and level 
186
 
  void set(const HElementType & item, const int level, const int duneFace )
187
 
  {
188
 
    BaseType :: set( item );
189
 
    level_ = level ;
190
 
    face_  = duneFace ; 
191
 
  }
192
 
 
193
 
  //! return level 
194
 
  int level () const { return level_ ; }
195
 
  //! return face 
196
 
  int face  () const { return face_ ; }
197
 
 
198
 
  using BaseType :: set ;
199
 
 
200
 
  bool operator == (const ALU2dGridEntitySeedType& i) const
201
 
  {
202
 
    return equals( i );
203
 
  }
204
 
 
205
 
  bool operator != (const ALU2dGridEntitySeedType& i) const
206
 
  {
207
 
    return ! equals( i );
208
 
  }
209
 
 
210
 
  //! equality, calls BaseType equals 
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
 
 
224
 
//! ALUGridEntitySeed points to an entity
225
 
//! this class is the specialisation for codim 0, 
226
 
//! it has exactly the same functionality as the ALU2dGridEntitySeedBase
227
 
template<class GridImp>
228
 
class ALU2dGridEntitySeed<0,GridImp> : 
229
 
public ALU2dGridEntitySeedBase<0,GridImp> 
230
 
{
231
 
protected:  
232
 
  typedef ALU2dGridEntitySeedBase<0,GridImp> BaseType;
233
 
 
234
 
  enum { cd = 0 };
235
 
  typedef ALU2dGridEntitySeed <cd,GridImp> ThisType;
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;
245
 
  typedef ImplementationType  HElementType;
246
 
 
247
 
  typedef ALU2dGridEntity< 0,dim,GridImp> ALU2dGridEntityType ;
248
 
 
249
 
public:
250
 
  using BaseType :: defaultValue ;
251
 
 
252
 
  //! type of Entity 
253
 
  typedef typename GridImp::template Codim<cd>::Entity Entity;
254
 
  
255
 
  //! typedef of my type 
256
 
  typedef ThisType ALU2dGridEntitySeedType;
257
 
  
258
 
  //! Constructor for EntitySeed that points to an element 
259
 
  ALU2dGridEntitySeed() : BaseType() {} 
260
 
 
261
 
  //! Constructor for EntitySeed that points to an interior element 
262
 
  ALU2dGridEntitySeed(const HElementType& item)
263
 
    : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
264
 
 
265
 
  //! Constructor for EntitySeed that points to an interior element 
266
 
  ALU2dGridEntitySeed(const HElementType& item, int , int )
267
 
    : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
268
 
 
269
 
  //! copy constructor 
 
59
    }
 
60
 
 
61
    //! Constructor for EntitySeed that points to an element
 
62
    ALU2dGridEntitySeedBase();
 
63
 
 
64
    //! Constructor for EntitySeed that points to an element
 
65
    ALU2dGridEntitySeedBase(const HElementType& item);
 
66
 
 
67
    /////////////////////////////////////////////////////////////
 
68
    //
 
69
    //  interface methods
 
70
    //
 
71
    /////////////////////////////////////////////////////////////
 
72
    //! copy constructor
 
73
    ALU2dGridEntitySeedBase(const ALU2dGridEntitySeedType & org);
 
74
 
 
75
    //! equality operator
 
76
    bool operator == (const ALU2dGridEntitySeedType& i) const
 
77
    {
 
78
      return equals( i );
 
79
    }
 
80
 
 
81
    //! inequality operator
 
82
    bool operator != (const ALU2dGridEntitySeedType& i) const
 
83
    {
 
84
      return ! equals( i );
 
85
    }
 
86
 
 
87
    //! assignment operator
 
88
    ThisType & operator = (const ThisType & org);
 
89
 
 
90
    //! check for valid seed
 
91
    bool isValid () const
 
92
    {
 
93
      return item_ != 0;
 
94
    }
 
95
 
 
96
    //////////////////////////////////////////////////////
 
97
    //
 
98
    //  non-interface methods
 
99
    //
 
100
    //////////////////////////////////////////////////////
 
101
    //! equality
 
102
    bool equals (const ALU2dGridEntitySeedType& i) const;
 
103
 
 
104
    //! invalidate seed
 
105
    void clear()
 
106
    {
 
107
      item_ = 0;
 
108
    }
 
109
 
 
110
    //! get item from key
 
111
    HElementType* item() const { return item_; }
 
112
 
 
113
    KeyType* toKey(const HElementType* item)
 
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
 
 
154
    //! type of Entity
 
155
    typedef typename GridImp::template Codim<cd>::Entity Entity;
 
156
 
 
157
    //! typedef of my type
 
158
    typedef ALU2dGridEntitySeed<cd,GridImp> ALU2dGridEntitySeedType;
 
159
 
 
160
    //! Constructor for EntitySeed that points to an element
 
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
 
 
168
    //! Constructor for EntitySeed that points to an element
 
169
    ALU2dGridEntitySeed(const HElementType & item,
 
170
                        const int level,
 
171
                        const int duneFace = defaultValue
 
172
                        );
 
173
 
 
174
    //! Constructor for EntitySeed that points to an element
 
175
    ALU2dGridEntitySeed()
 
176
      : BaseType(), level_(defaultValue), face_(defaultValue) {}
 
177
 
 
178
    //! Constructor for EntitySeed that points to given entity
 
179
    ALU2dGridEntitySeed(const ALU2dGridEntityType& entity)
 
180
      : ALU2dGridEntitySeedBase<cd,GridImp> (entity.getItem()),
 
181
        level_(entity.level()), face_(defaultValue)
 
182
    {}
 
183
 
 
184
    //! copy constructor
 
185
    ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org);
 
186
 
 
187
    //! assignment operator
 
188
    ThisType & operator = (const ThisType & org);
 
189
 
 
190
    //! clear the key data structure
 
191
    void clear();
 
192
 
 
193
    //! set element and level
 
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
 
 
201
    //! return level
 
202
    int level () const { return level_ ; }
 
203
    //! return face
 
204
    int face  () const { return face_ ; }
 
205
 
 
206
    using BaseType :: set ;
 
207
 
 
208
    bool operator == (const ALU2dGridEntitySeedType& i) const
 
209
    {
 
210
      return equals( i );
 
211
    }
 
212
 
 
213
    bool operator != (const ALU2dGridEntitySeedType& i) const
 
214
    {
 
215
      return ! equals( i );
 
216
    }
 
217
 
 
218
    //! equality, calls BaseType equals
 
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
 
 
232
  //! ALUGridEntitySeed points to an entity
 
233
  //! this class is the specialisation for codim 0,
 
234
  //! it has exactly the same functionality as the ALU2dGridEntitySeedBase
 
235
  template<class GridImp>
 
236
  class ALU2dGridEntitySeed<0,GridImp> :
 
237
    public ALU2dGridEntitySeedBase<0,GridImp>
 
238
  {
 
239
  protected:
 
240
    typedef ALU2dGridEntitySeedBase<0,GridImp> BaseType;
 
241
 
 
242
    enum { cd = 0 };
 
243
    typedef ALU2dGridEntitySeed <cd,GridImp> ThisType;
 
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;
 
253
    typedef ImplementationType HElementType;
 
254
 
 
255
    typedef ALU2dGridEntity< 0,dim,GridImp> ALU2dGridEntityType ;
 
256
 
 
257
  public:
 
258
    using BaseType :: defaultValue ;
 
259
 
 
260
    //! type of Entity
 
261
    typedef typename GridImp::template Codim<cd>::Entity Entity;
 
262
 
 
263
    //! typedef of my type
 
264
    typedef ThisType ALU2dGridEntitySeedType;
 
265
 
 
266
    //! Constructor for EntitySeed that points to an element
 
267
    ALU2dGridEntitySeed() : BaseType() {}
 
268
 
 
269
    //! Constructor for EntitySeed that points to an interior element
 
270
    ALU2dGridEntitySeed(const HElementType& item)
 
271
      : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
 
272
 
 
273
    //! Constructor for EntitySeed that points to an interior element
 
274
    ALU2dGridEntitySeed(const HElementType& item, int , int )
 
275
      : ALU2dGridEntitySeedBase<cd,GridImp> (item) {}
 
276
 
 
277
    //! copy constructor
 
278
    ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org)
 
279
      : ALU2dGridEntitySeedBase<cd,GridImp> (org)
 
280
    {}
 
281
  };
 
282
 
 
283
 
 
284
  //! print alugrid entity key to std::stream
 
285
  template <int cd, class GridImp>
 
286
  inline std :: ostream &operator<< ( std :: ostream &out,
 
287
                                      const ALU2dGridEntitySeed<cd,GridImp>& key)
 
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 >
 
300
  inline ALU2dGridEntitySeedBase<codim,GridImp> ::
 
301
  ALU2dGridEntitySeedBase()
 
302
    : item_( 0 )
 
303
  {}
 
304
 
 
305
  template<int codim, class GridImp >
 
306
  inline ALU2dGridEntitySeedBase<codim,GridImp> ::
 
307
  ALU2dGridEntitySeedBase(const HElementType &item)
 
308
    : item_( toKey(&item) )
 
309
  {}
 
310
 
 
311
  template<int codim, class GridImp >
 
312
  inline ALU2dGridEntitySeedBase<codim,GridImp> ::
 
313
  ALU2dGridEntitySeedBase(const ALU2dGridEntitySeedType & org)
 
314
    : item_(org.item_)
 
315
  {}
 
316
 
 
317
  template<int codim, class GridImp >
 
318
  inline ALU2dGridEntitySeedBase<codim,GridImp> &
 
319
  ALU2dGridEntitySeedBase<codim,GridImp> ::
 
320
  operator = (const ALU2dGridEntitySeedType & org)
 
321
  {
 
322
    item_  = org.item_;
 
323
    return *this;
 
324
  }
 
325
 
 
326
  template<int codim, class GridImp >
 
327
  inline bool ALU2dGridEntitySeedBase<codim,GridImp>::
 
328
  equals (const ALU2dGridEntitySeedBase<codim,GridImp>& i) const
 
329
  {
 
330
    // check equality of underlying items
 
331
    return (item_ == i.item_);
 
332
  }
 
333
 
 
334
  ///////////////////////////////////////////////////////////////////
 
335
  //
 
336
  //  specialisation for higher codims
 
337
  //
 
338
  ///////////////////////////////////////////////////////////////////
 
339
 
 
340
  template<int codim, class GridImp >
 
341
  inline ALU2dGridEntitySeed<codim,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 >
 
353
  inline ALU2dGridEntitySeed<codim,GridImp> ::
270
354
  ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org)
271
 
    : ALU2dGridEntitySeedBase<cd,GridImp> (org) 
272
 
  {
273
 
  }
274
 
};
275
 
 
276
 
 
277
 
//! print alugrid entity key to std::stream 
278
 
template <int cd, class GridImp> 
279
 
inline std :: ostream &operator<< ( std :: ostream &out, 
280
 
                                    const ALU2dGridEntitySeed<cd,GridImp>& key)
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 >
293
 
inline ALU2dGridEntitySeedBase<codim,GridImp> :: 
294
 
ALU2dGridEntitySeedBase()
295
 
  : item_( 0 )
296
 
{
297
 
}
298
 
 
299
 
template<int codim, class GridImp >
300
 
inline ALU2dGridEntitySeedBase<codim,GridImp> :: 
301
 
ALU2dGridEntitySeedBase(const HElementType &item)
302
 
  : item_( toKey(&item) )
303
 
{
304
 
}
305
 
 
306
 
template<int codim, class GridImp >
307
 
inline ALU2dGridEntitySeedBase<codim,GridImp> :: 
308
 
ALU2dGridEntitySeedBase(const ALU2dGridEntitySeedType & org)
309
 
  : item_(org.item_)
310
 
{
311
 
}
312
 
 
313
 
template<int codim, class GridImp >
314
 
inline ALU2dGridEntitySeedBase<codim,GridImp> & 
315
 
ALU2dGridEntitySeedBase<codim,GridImp> :: 
316
 
operator = (const ALU2dGridEntitySeedType & org)
317
 
{
318
 
  item_  = org.item_;
319
 
  return *this;
320
 
}
321
 
 
322
 
template<int codim, class GridImp >
323
 
inline bool ALU2dGridEntitySeedBase<codim,GridImp>::
324
 
equals (const ALU2dGridEntitySeedBase<codim,GridImp>& i) const 
325
 
{
326
 
  // check equality of underlying items  
327
 
  return (item_ == i.item_);
328
 
}
329
 
 
330
 
///////////////////////////////////////////////////////////////////
331
 
//
332
 
//  specialisation for higher codims 
333
 
//  
334
 
///////////////////////////////////////////////////////////////////
335
 
 
336
 
template<int codim, class GridImp >
337
 
inline ALU2dGridEntitySeed<codim,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 >
349
 
inline ALU2dGridEntitySeed<codim,GridImp> :: 
350
 
ALU2dGridEntitySeed(const ALU2dGridEntitySeedType & org)
351
 
  : ALU2dGridEntitySeedBase<codim,GridImp>(org) 
352
 
  , level_(org.level_)
353
 
  , face_(org.face_)
354
 
{
355
 
}
356
 
 
357
 
template<int codim, class GridImp >
358
 
inline ALU2dGridEntitySeed<codim,GridImp> &
359
 
ALU2dGridEntitySeed<codim,GridImp>:: 
360
 
operator = (const ALU2dGridEntitySeedType & org)
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 
373
 
ALU2dGridEntitySeed<codim,GridImp>::clear ()
374
 
{
375
 
  BaseType :: clear();
376
 
  level_ = defaultValue ;
377
 
  face_  = defaultValue ;
378
 
}
379
 
 
380
 
} // end namespace Dune 
 
355
    : ALU2dGridEntitySeedBase<codim,GridImp>(org)
 
356
      , level_(org.level_)
 
357
      , face_(org.face_)
 
358
  {}
 
359
 
 
360
  template<int codim, class GridImp >
 
361
  inline ALU2dGridEntitySeed<codim,GridImp> &
 
362
  ALU2dGridEntitySeed<codim,GridImp>::
 
363
  operator = (const ALU2dGridEntitySeedType & org)
 
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
 
376
  ALU2dGridEntitySeed<codim,GridImp>::clear ()
 
377
  {
 
378
    BaseType :: clear();
 
379
    level_ = defaultValue ;
 
380
    face_  = defaultValue ;
 
381
  }
 
382
 
 
383
} // end namespace Dune
381
384
#endif