universalmapper.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_UNIVERSALMAPPER_HH
#define DUNE_GRID_COMMON_UNIVERSALMAPPER_HH
 
#include <iostream>
#include <map>
#include "mapper.hh"
 
namespace Dune
{
  template <typename G, typename IDS, typename IndexType=int>
  class UniversalMapper :
    public Mapper<G,UniversalMapper<G,IDS> >
  {
    typedef typename IDS::IdType IdType;
  public:
 
    typedef IndexType Index;
 
    UniversalMapper (const G& grid, const IDS& idset)
      : g(grid), ids(idset), index_()
    {
      n=0;     // zero data elements
    }
 
    template<class EntityType>
    Index index (const EntityType& e) const
    {
      IdType id = ids.id(e);                                 // get id
      typename std::map<IdType,Index>::iterator it = index_.find(id);    // look up in map
      if (it!=index_.end()) return it->second;               // return index if found
      index_[id] = n++;                                      // put next index in map
      return n-1;                                            // and return it
    }
 
    Index subIndex (const typename G::Traits::template Codim<0>::Entity& e, int i, int cc) const
    {
      IdType id = ids.subId(e,i,cc);           // get id
      typename std::map<IdType,Index>::iterator it = index_.find(id);    // look up in map
      if (it!=index_.end()) return it->second;               // return index if found
      index_[id] = n++;                                      // put next index in map
      return n-1;                                            // and return it
    }
 
    int size () const
    {
      return n;
    }
 
    template<class EntityType>
    bool contains (const EntityType& e, Index& result) const
    {
      IdType id = ids.id(e);                                 // get id
      typename std::map<IdType,Index>::iterator it = index_.find(id);    // look up in map
      if (it!=index_.end())
      {
        result = it->second;
        return true;
      }
      else
        return false;
    }
 
    bool contains (const typename G::Traits::template Codim<0>::Entity& e, int i, int cc, Index& result) const
    {
      IdType id = ids.subId(e,i,cc);           // get id
      typename std::map<IdType,Index>::iterator it = index_.find(id);    // look up in map
      if (it!=index_.end())
      {
        result = it->second;
        return true;
      }
      else
        return false;
    }
 
    void update ()
    {     // nothing to do here
    }
 
    // clear the mapper
    void clear ()
    {
      index_.clear();
      n = 0;
    }
 
  private:
    mutable int n;     // number of data elements required
    const G& g;
    const IDS& ids;
    mutable std::map<IdType,Index> index_;
  };
 
 
 
 
  template <typename G>
  class GlobalUniversalMapper : public UniversalMapper<G,typename G::Traits::GlobalIdSet>
  {
  public:
    /* @brief The constructor
       @param grid A reference to a grid.
     */
    GlobalUniversalMapper (const G& grid)
      : UniversalMapper<G,typename G::Traits::GlobalIdSet>(grid,grid.globalIdSet())
    {}
  };
 
  template <typename G>
  class LocalUniversalMapper : public UniversalMapper<G,typename G::Traits::LocalIdSet>
  {
  public:
    LocalUniversalMapper (const G& grid)
      : UniversalMapper<G,typename G::Traits::LocalIdSet>(grid,grid.localIdSet())
    {}
  };
 
 
}
#endif