partitionset.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_PARTITIONSET_HH
#define DUNE_GRID_COMMON_PARTITIONSET_HH
 
#include <dune/common/typetraits.hh>
#include <dune/common/std/constexpr.hh>
#include <dune/grid/common/gridenums.hh>
 
namespace Dune {
 
  namespace {
 
    // Simple TMP to deduce partition iterator type from set of partitions.
    template<unsigned int partitions>
    struct derive_partition_iterator_type
    {
      // We did not match any specialization, bail out...
      static_assert(AlwaysFalse<std::integral_constant<unsigned int,partitions> >::value,
                    "There is no partition iterator for this combination of entity partitions");
    };
 
 
    // specializations of derive_partition_iterator_type for existing PartitionIteratorTypes
 
    template<>
    struct derive_partition_iterator_type<
      (1 << InteriorEntity)
        >
        : public std::integral_constant<PartitionIteratorType,Interior_Partition>
    {};
 
    template<>
    struct derive_partition_iterator_type<
      (1 << InteriorEntity) |
      (1 << BorderEntity)
      >
      : public std::integral_constant<PartitionIteratorType,InteriorBorder_Partition>
    {};
 
    template<>
    struct derive_partition_iterator_type<
      (1 << InteriorEntity) |
      (1 << BorderEntity) |
      (1 << OverlapEntity)
      >
      : public std::integral_constant<PartitionIteratorType,Overlap_Partition>
    {};
 
    template<>
    struct derive_partition_iterator_type<
      (1 << InteriorEntity) |
      (1 << BorderEntity) |
      (1 << OverlapEntity) |
      (1 << FrontEntity)
      >
      : public std::integral_constant<PartitionIteratorType,OverlapFront_Partition>
    {};
 
    template<>
    struct derive_partition_iterator_type<
      (1 << InteriorEntity) |
      (1 << BorderEntity) |
      (1 << OverlapEntity) |
      (1 << FrontEntity) |
      (1 << GhostEntity)
      >
      : public std::integral_constant<PartitionIteratorType,All_Partition>
    {};
 
    template<>
    struct derive_partition_iterator_type<
      (1 << GhostEntity)
        >
        : public std::integral_constant<PartitionIteratorType,Ghost_Partition>
    {};
 
  } // anonymous namespace
 
 
 
  template<unsigned int partitions>
  struct PartitionSet
  {
    static const unsigned int value = partitions;
 
 
    template<unsigned int p>
    struct PartitionSet<partitions | p>
    operator+(const PartitionSet<p>& set) const
    {
      return PartitionSet<partitions | p>();
    }
 
    template<unsigned int p>
    struct PartitionSet<partitions & ~p>
    operator-(const PartitionSet<p>& set) const
    {
      return PartitionSet<partitions & ~p>();
    }
 
    friend std::ostream& operator<<(std::ostream& os, const PartitionSet&)
    {
      unsigned int set = partitions;
      os << "partition set {";
      bool first = true;
      for (unsigned int p = 0; set; set &= ~(1 << p++))
        {
          if (!(set & (1 << p)))
            continue;
          if (!first)
            os << ",";
          first = false;
          os << static_cast<PartitionType>(p);
        }
      os << "}";
      return os;
    }
 
#if HAVE_CONSTEXPR || DOXYGEN
 
 
    static constexpr PartitionIteratorType partitionIterator()
    {
      return derive_partition_iterator_type<partitions>::value;
    }
 
#endif // HAVE_CONSTEXPR
 
    static DUNE_CONSTEXPR bool contains(PartitionType pt)
    {
      return partitions & (1 << pt);
    }
 
    template<unsigned int contained_partitions>
    static DUNE_CONSTEXPR bool contains(PartitionSet<contained_partitions>)
    {
      return (partitions & contained_partitions) == contained_partitions;
    }
 
    template<unsigned int p2>
    DUNE_CONSTEXPR bool operator==(PartitionSet<p2>) const
    {
      return partitions == p2;
    }
 
    template<unsigned int p2>
    DUNE_CONSTEXPR bool operator!=(PartitionSet<p2>) const
    {
      return partitions != p2;
    }
 
  };
 
 
  template<PartitionType p>
  PartitionSet<(1 << p)> partitionSet()
  {
    return PartitionSet<(1 << p)>();
  }
 
  namespace Partitions {
 
 
#ifdef DOXYGEN
 
    typedef PartitionSet<...> Interior;
 
    typedef PartitionSet<...> Border;
 
    typedef PartitionSet<...> Overlap;
 
    typedef PartitionSet<...> Front;
 
    typedef PartitionSet<...> Ghost;
 
    typedef PartitionSet<...> InteriorBorder;
 
    typedef PartitionSet<...> InteriorBorderOverlap;
 
    typedef PartitionSet<...> InteriorBorderOverlapFront;
 
    typedef PartitionSet<...> All;
 
 
    Interior interior;
 
    Border border;
 
    Overlap overlap;
 
    Front front;
 
    Ghost ghost;
 
    InteriorBorder interiorBorder;
 
    InteriorBorderOverlap interiorBorderOverlap;
 
    InteriorBorderOverlapFront interiorBorderOverlapFront;
 
     All all;
 
#else // DOXYGEN
 
    // First declare the types and objects for individual partitions
 
    typedef decltype(partitionSet<InteriorEntity>()) Interior;
    typedef decltype(partitionSet<BorderEntity>()) Border;
    typedef decltype(partitionSet<OverlapEntity>()) Overlap;
    typedef decltype(partitionSet<FrontEntity>()) Front;
    typedef decltype(partitionSet<GhostEntity>()) Ghost;
 
    namespace {
 
      // place global objects in anonymous namespace to ensure that visibility is
      // restricted to the current translation unit, making it easier for the compiler
      // to eliminate the actual objects and to avoid linking problems
 
      const Interior interior = {};
      const Border border = {};
      const Overlap overlap = {};
      const Front front = {};
      const Ghost ghost = {};
 
    }
 
    // Now we can declare the partition sets that are a result of combining partitions
 
    typedef decltype(interior + border) InteriorBorder;
    typedef decltype(interior + border + overlap) InteriorBorderOverlap;
    typedef decltype(interior + border + overlap + front) InteriorBorderOverlapFront;
    typedef decltype(interior + border + overlap + front + ghost) All;
 
    namespace {
 
      // again, place the global objects in an anonymous namespace
 
      const InteriorBorder interiorBorder = {};
      const InteriorBorderOverlap interiorBorderOverlap = {};
      const InteriorBorderOverlapFront interiorBorderOverlapFront = {};
      const All all = {};
 
    }
 
#endif // DOXYGEN
 
  } // namespace Partitions
 
} // namespace Dune
 
#endif // DUNE_GRID_COMMON_PARTITIONSET_HH