rangegenerators.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_RANGEGENERATORS_HH
#define DUNE_GRID_COMMON_RANGEGENERATORS_HH
 
#include <dune/common/iteratorrange.hh>
#include <dune/geometry/dimension.hh>
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/common/partitionset.hh>
 
namespace Dune
{
 
#ifdef DOXYGEN
 
  // *****************************************************************************************
  // Doxygen documentation
  // *****************************************************************************************
  //
  // In the following, the range generating functions are documented for Doxygen; the actual
  // implementations are further down in this file and hidden from Doxygen.
  // The main reason for this split are the return types of those functions, which either contain
  // long type listings to obtain the iterator type or (in the case of the forwarded functions
  // use the new-style function syntax and calculate the return type using decltype. In both cases,
  // Doxygen generates function signatures that are very confusing to the average user.
  //
  // *****************************************************************************************
 
 
 
 
 
 
  template<typename GV>
  inline IteratorRange<...> elements(const GV& gv);
 
 
 
  template<typename GV>
  inline IteratorRange<...> facets(const GV& gv);
 
 
 
  template<typename GV>
  inline IteratorRange<...> edges(const GV& gv);
 
 
 
  template<typename GV>
  inline IteratorRange<...> vertices(const GV& gv);
 
 
 
 
 
 
 
  template<typename GV, typename Entity>
  inline IteratorRange<...> intersections(const GV& gv, const Entity& e);
 
 
 
 
 
 
 
 
  template<typename Entity>
  inline IteratorRange<...> descendantElements(const Entity& e, int maxLevel);
  // Entity<int dim, class GridImp, template<int,int,class> class EntityImp>
 
 
 
 
 
 
 
  template<typename GV, int codim>
  inline IteratorRange<...> entities(const GV& gv, Codim<codim> cd);
 
 
 
  template<typename GV, int dim>
  inline IteratorRange<...> entities(const GV& gv, Dim<dim> d);
 
 
 
 
 
 
 
  template<typename GV, unsigned int partitions>
  inline IteratorRange<...> elements(const GV& gv, PartitionSet<partitions> ps);
 
 
 
  template<typename GV, unsigned int partitions>
  inline IteratorRange<...> facets(const GV& gv, PartitionSet<partitions> ps);
 
 
 
  template<typename GV, unsigned int partitions>
  inline IteratorRange<...> edges(const GV& gv, PartitionSet<partitions> ps);
 
 
 
  template<typename GV, unsigned int partitions>
  inline IteratorRange<...> vertices(const GV& gv, PartitionSet<partitions> ps);
 
 
 
 
 
 
 
  template<typename GV, int codim, unsigned int partitions>
  inline IteratorRange<...> entities(const GV& gv gv, Codim<codim> cd, PartitionSet<partitions> ps);
 
 
 
  template<typename GV, int dim, unsigned int partitions>
  inline IteratorRange<...> entities(const GV& gv, Dim<dim> d, PartitionSet<partitions> ps);
 
 
 
 
#else // DOXYGEN
 
// only make the implementations available on new compilers - there is a really nasty bug in GCC 4.4...
#if HAVE_RANGE_BASED_FOR
 
  // ******************************************************************************************
  // Implementations
  // ******************************************************************************************
 
 
  template<typename GV, int codim, unsigned int partitions>
  inline IteratorRange<
    typename GV::template Codim<codim>::template Partition<
      derive_partition_iterator_type<partitions>::value
      >::Iterator
    >
  entities(const GV& gv, Codim<codim>, PartitionSet<partitions>)
  {
    static_assert(0 <= codim && codim <= GV::dimension, "invalid codimension for given GridView");
    const PartitionIteratorType pit = derive_partition_iterator_type<partitions>::value;
    typedef IteratorRange<
      typename GV::template Codim<codim>::template Partition<pit>::Iterator
      > return_type;
    return return_type(gv.template begin<codim,pit>(),gv.template end<codim,pit>());
  }
 
  template<typename GV, int codim>
  inline IteratorRange<
    typename GV::template Codim<codim>::Iterator
    >
  entities(const GV& gv, Codim<codim>)
  {
    static_assert(0 <= codim && codim <= GV::dimension, "invalid codimension for given GridView");
    typedef IteratorRange<
      typename GV::template Codim<codim>::Iterator
      > return_type;
    return return_type(gv.template begin<codim>(),gv.template end<codim>());
  }
 
  template<typename Entity>
  inline IteratorRange<typename Entity::HierarchicIterator> descendantElements(const Entity& e, int maxLevel)
  {
    typedef IteratorRange<typename Entity::HierarchicIterator> return_type;
    return return_type(e.hbegin(maxLevel),e.hend(maxLevel));
  }
 
  template<typename GV, typename Entity>
  inline IteratorRange<typename GV::IntersectionIterator> intersections(const GV& gv, const Entity& e)
  {
    return IteratorRange<typename GV::IntersectionIterator>(gv.ibegin(e),gv.iend(e));
  }
 
 
  template<typename GV, int dim, unsigned int partitions>
  inline auto entities(const GV& gv, Dim<dim>, PartitionSet<partitions>)
    -> decltype(entities(gv,Codim<GV::dimension - dim>(),PartitionSet<partitions>()))
  {
    static_assert(0 <= dim && dim <= GV::dimension, "invalid dimension for given GridView");
    return entities(gv,Codim<GV::dimension - dim>(),PartitionSet<partitions>());
  }
 
  template<typename GV, int dim>
  inline auto entities(const GV& gv, Dim<dim>)
    -> decltype(entities(gv,Codim<GV::dimension - dim>()))
  {
    static_assert(0 <= dim && dim <= GV::dimension, "invalid dimension for given GridView");
    return entities(gv,Codim<GV::dimension - dim>());
  }
 
  template<typename GV, unsigned int partitions>
  inline auto elements(const GV& gv, PartitionSet<partitions>)
    -> decltype(entities(gv,Codim<0>(),PartitionSet<partitions>()))
  {
    return entities(gv,Codim<0>(),PartitionSet<partitions>());
  }
 
  template<typename GV>
  inline auto elements(const GV& gv)
    -> decltype(entities(gv,Codim<0>()))
  {
    return entities(gv,Codim<0>());
  }
 
  template<typename GV, unsigned int partitions>
  inline auto facets(const GV& gv, PartitionSet<partitions>)
    -> decltype(entities(gv,Codim<1>(),PartitionSet<partitions>()))
  {
    return entities(gv,Codim<1>(),PartitionSet<partitions>());
  }
 
  template<typename GV>
  inline auto facets(const GV& gv)
    -> decltype(entities(gv,Codim<1>()))
  {
    return entities(gv,Codim<1>());
  }
 
  template<typename GV, unsigned int partitions>
  inline auto edges(const GV& gv, PartitionSet<partitions>)
    -> decltype(entities(gv,Dim<1>(),PartitionSet<partitions>()))
  {
    return entities(gv,Dim<1>(),PartitionSet<partitions>());
  }
 
  template<typename GV>
  inline auto edges(const GV& gv)
    -> decltype(entities(gv,Dim<1>()))
  {
    return entities(gv,Dim<1>());
  }
 
  template<typename GV, unsigned int partitions>
  inline auto vertices(const GV& gv, PartitionSet<partitions>)
    -> decltype(entities(gv,Dim<0>(),PartitionSet<partitions>()))
  {
    return entities(gv,Dim<0>(),PartitionSet<partitions>());
  }
 
  template<typename GV>
  inline auto vertices(const GV& gv)
    -> decltype(entities(gv,Dim<0>()))
  {
    return entities(gv,Dim<0>());
  }
 
#endif // HAVE_RANGE_BASED_FOR
 
#endif // DOXYGEN
 
} // namespace Dune
 
#endif // DUNE_GRID_COMMON_RANGEGENERATORS_HH