Package: GrAL Base       

---

Gral/Iterators/cell-on-cell-iterator.h

#ifndef GRAL_GB_BASE_CELL_ON_CELL_ITERATOR_H
#define GRAL_GB_BASE_CELL_ON_CELL_ITERATOR_H


/* ------------------------------------------------------------

    Copyright (C) 2001 - 2009 Guntram Berti

    This file is part of the Grid Algorithms Library (GrAL),
    available at http://gral.berti-cmm.de

    GrAL is distributed under the MIT license,
    see the file LICENSE or http://gral.berti-cmm.de/license

--------------------------------------------------------------- */


#include "Gral/Base/common-grid-basics.h"
#include "Gral/Base/facet-on-cell-function.h"
#include "Utility/ref-ptr.h"

#include <map>

namespace GrAL {

template<class G, 
         class NBTABLE = facet_on_cell_function<G,
                                                typename grid_types<G>::cell_handle>, 
         class GT      = grid_types<G> >
class cell_on_cell_iterator {
  typedef cell_on_cell_iterator<G,NBTABLE,GT> self;
public:
  typedef G                        grid_type;
  typedef typename GT::Cell        Cell;
  typedef typename GT::Facet       Facet;
  typedef typename GT::cell_handle cell_handle;
  typedef typename GT::FacetOnCellIterator FacetOnCellIterator;
  typedef Cell     value_type;
  typedef Cell     anchor_type;
  typedef typename get_incidence_iterator_category<typename category<value_type> ::type,
                                                   typename category<anchor_type>::type>::type
                   category;
private:
  ref_ptr<NBTABLE   const> nbs;
  Cell                 c;
  FacetOnCellIterator fc;

  //  make it possible to pass nbs not via constructor.
  //  We want to use cell_on_cell_iterator<> like
  //  XGT::Cell c; XGT::CellOnCellIterator(c);
  //  where XGT is GT + cell_on_cell_iterator.
  //  Otherwise, we would have to wrap G+NBTABLE and each type in GT.
  typedef std::map<grid_type const*, ref_ptr<NBTABLE const> > context_table;
  static  context_table  * ctxt;
public:
  cell_on_cell_iterator() : nbs(0) {}
  cell_on_cell_iterator(Cell const& c_)
    : c(c_), fc(c)
  {
    init_table();
    advance_till_valid();
  }
  cell_on_cell_iterator(Cell const& c_, NBTABLE const& nbs_) 
    : nbs(&nbs_), c(c_),  fc(c) 
  { advance_till_valid();}

  explicit cell_on_cell_iterator(FacetOnCellIterator const& fc_) : c(fc_.TheAnchor()), fc(fc_) 
  {
    init_table();
    // not necessary valid_neigbhor().
  }
  void init_table() {
    REQUIRE(ctxt->find(& (c.TheGrid())) != ctxt->end(), 
            "No neighbor table registered for grid " << & (c.TheGrid()),1);
    nbs = (*ctxt)[& (c.TheGrid())];
  }

  self& operator++() { ++fc; advance_till_valid(); return (*this);}
  Cell  operator* () const { cv(); return Cell(TheGrid(), handle());}
  cell_handle      handle()  const { return const_cast<NBTABLE &>(*nbs)[fc];}
  bool             IsDone()  const { return fc.IsDone();}

  grid_type    const& TheGrid()   const { return c.TheGrid();}
  Cell         const& TheCell()   const { return c;}
  Cell         const& TheAnchor() const { return c;}
  Facet               TheFacet()  const { return *fc;}
  FacetOnCellIterator TheFacetOnCellIterator() const { return fc;}

  static void init();

  static void init        (grid_type const& g_);
  static void remove      (grid_type const& g_);

  static void map_nb_table(grid_type const& g_, NBTABLE const& nbs_); 

  bool valid_neighbor() const { return  valid(handle());}
  bool inner_facet()    const { return  valid(handle());}
  bool boundary_facet() const { return !valid(handle());}

  void next_facet()           { ++fc;}
  void next_neighbor()        { next_facet(); advance_till_valid();}

  static self begin(Cell c) { return self(c);}
  static self end  (Cell c) { return self(GrAL::end<FacetOnCellIterator>(c));}

  bool operator==(self rhs) const { return c == rhs.c && fc == rhs.fc;}
  bool operator!=(self rhs) const { return !(*this == rhs);}

private:
  void cv() const { REQUIRE(valid_neighbor(), "",1);}
  bool valid(cell_handle ch) const { return TheGrid().valid_cell(ch);}

  void advance_till_valid() 
  { 
    while(! fc.IsDone() && ! valid(handle()))
      ++fc;
  } 
};


  template<class G, class NBTABLE, class GT>
  inline
  cell_on_cell_iterator<G,NBTABLE, GT> gral_begin(typename GT::Cell const& c, cell_on_cell_iterator<G,NBTABLE, GT>)
  { return cell_on_cell_iterator<G,NBTABLE, GT>::begin(c);}
 
  template<class G, class NBTABLE, class GT>
  inline
  cell_on_cell_iterator<G,NBTABLE, GT> gral_end  (typename GT::Cell const& c, cell_on_cell_iterator<G,NBTABLE, GT>)
  { return cell_on_cell_iterator<G,NBTABLE, GT>::end(c);}



} // namespace GrAL 

#ifdef NMWR_INCLUDE_TEMPLATE_DEFS
#include "Gral/Iterators/cell-on-cell-iterator.C"
#endif

#endif

---

©  Guntram Berti 1997-2009. See the GrAL Homepage for up-to-date information.

---