implemented assignment of HierarchicIterators.

Assignment for Level- or LeafIterators not working.

[[Imported from SVN: r4467]]

grid/alu3dgrid/entity.hh

@@ -404,6 +404,9 @@ namespace Dune {
     int level () const ;
 
   protected:
+    // clones object
+    void clone (const ALU3dGridEntityPointerType & org);
+
     //! has to be called when iterator is finished
     void done ();
 

grid/alu3dgrid/entity_imp.cc

@@ -734,6 +734,27 @@ namespace Dune {
     return *this;
   }
 
+  template<int codim, class GridImp >
+  inline void
+  ALU3dGridEntityPointerBase<codim,GridImp> ::
+  clone (const ALU3dGridEntityPointerType & org)
+  {
+    assert( &grid_ == &org.grid_ );
+    // set item
+    item_ = org.item_;
+
+    // if entity exists, just remove item pointer
+    if(entity_)
+    {
+      if(item_)
+        this->entityImp().setElement( *item_ );
+      else
+        this->entityImp().removeElement();
+    }
+
+    return ;
+  }
+
   template<int codim, class GridImp >
   inline ALU3dGridEntityPointerBase<codim,GridImp> ::
   ~ALU3dGridEntityPointerBase()

grid/alu3dgrid/iterator.hh

@@ -1041,15 +1041,15 @@ namespace Dune {
     //! dereference Entity, faster then the entity pointersmethod
     Entity & dereference () const;
 
-  private:
     //! the assignment operator
     ThisType & operator = (const ALU3dGridHierarchicIterator<GridImp> &org);
 
+  private:
     // go to next valid element
     ALU3DSPACE HElementType * goNextElement (ALU3DSPACE HElementType * oldEl);
 
     //! element from where we started
-    const ALU3DSPACE HElementType & elem_;
+    const ALU3DSPACE HElementType * elem_;
 
     //! maximal level to go down
     int maxlevel_;

grid/alu3dgrid/iterator_imp.cc

@@ -763,13 +763,13 @@ namespace Dune {
   ALU3dGridHierarchicIterator(const GridImp & grid ,
                               const ALU3DSPACE HElementType & elem, int maxlevel ,bool end)
     : ALU3dGridEntityPointer<0,GridImp> ( grid, maxlevel )
-      , elem_(elem)
+      , elem_(&elem)
       , maxlevel_(maxlevel)
   {
     if (!end)
     {
       ALU3DSPACE HElementType * item =
-        const_cast<ALU3DSPACE HElementType *> (elem_.down());
+        const_cast<ALU3DSPACE HElementType *> (elem.down());
       if(item)
       {
         // we have children and they lie in the disired level range
@@ -797,6 +797,20 @@ namespace Dune {
       , maxlevel_(org.maxlevel_)
   {}
 
+  template <class GridImp>
+  inline ALU3dGridHierarchicIterator<GridImp> &
+  ALU3dGridHierarchicIterator<GridImp> ::
+  operator = (const ALU3dGridHierarchicIterator<GridImp> & org)
+  {
+    elem_     = org.elem_;
+    maxlevel_ = org.maxlevel_;
+
+    // this method will free entity
+    this->clone(org);
+
+    return *this;
+  }
+
   template <class GridImp>
   inline ALU3DSPACE HElementType * ALU3dGridHierarchicIterator<GridImp>::
   goNextElement(ALU3DSPACE HElementType * oldelem )
@@ -820,12 +834,12 @@ namespace Dune {
     }
 
     nextelem = oldelem->up();
-    if(nextelem == &elem_) return 0;
+    if(nextelem == elem_) return 0;
 
     while( !nextelem->next() )
     {
       nextelem = nextelem->up();
-      if(nextelem == &elem_) return 0;
+      if(nextelem == elem_) return 0;
     }
 
     if(nextelem) nextelem = nextelem->next();