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/keywords.hh>
#include <dune/common/typetraits.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>
    {};
 
 
    // Simple TMP to deduce set of partitions from partition iterator type.
 
    template<PartitionIteratorType pitype>
    struct derive_partition_set;
 
 
    // specializations of derive_partition_set for existing PartitionIteratorTypes
 
    template<>
    struct derive_partition_set<Interior_Partition>
      : std::integral_constant<unsigned int, (1 << InteriorEntity)>
    {};
 
    template<>
    struct derive_partition_set<InteriorBorder_Partition>
      : std::integral_constant<unsigned int, (1 << InteriorEntity) | (1 << BorderEntity)>
    {};
 
    template<>
    struct derive_partition_set<Overlap_Partition>
      : std::integral_constant<unsigned int, (1 << InteriorEntity) | (1 << BorderEntity) | (1 << OverlapEntity)>
    {};
 
    template<>
    struct derive_partition_set<OverlapFront_Partition>
      : std::integral_constant<unsigned int, (1 << InteriorEntity) | (1 << BorderEntity) | (1 << OverlapEntity) | (1 << FrontEntity)>
    {};
 
    template<>
    struct derive_partition_set<Ghost_Partition>
      : std::integral_constant<unsigned int, (1 << GhostEntity)>
    {};
 
    template<>
    struct derive_partition_set<All_Partition>
      : std::integral_constant<unsigned int, (1 << InteriorEntity) | (1 << BorderEntity) | (1 << OverlapEntity) | (1 << FrontEntity) | (1 << GhostEntity)>
    {};
 
  } // anonymous namespace
 
 
 
  template<unsigned int partitions>
  struct PartitionSet
  {
    static constexpr unsigned int value = partitions;
 
 
    template<unsigned int p>
    struct PartitionSet<partitions | p>
    constexpr operator+(const PartitionSet<p>& set) const
    {
      return PartitionSet<partitions | p>();
    }
 
    template<unsigned int p>
    struct PartitionSet<partitions & ~p>
    constexpr 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;
    }
 
 
    static constexpr PartitionIteratorType partitionIterator()
    {
      return derive_partition_iterator_type<partitions>::value;
    }
 
    static constexpr bool contains(PartitionType pt)
    {
      return partitions & (1 << pt);
    }
 
    template<unsigned int contained_partitions>
    static constexpr bool contains(PartitionSet<contained_partitions>)
    {
      return (partitions & contained_partitions) == contained_partitions;
    }
 
    template<unsigned int p2>
    constexpr bool operator==(PartitionSet<p2>) const
    {
      return partitions == p2;
    }
 
    template<unsigned int p2>
    constexpr bool operator!=(PartitionSet<p2>) const
    {
      return partitions != p2;
    }
 
  };
 
 
  template<PartitionType p>
  PartitionSet<(1 << p)> partitionSet()
  {
    return PartitionSet<(1 << p)>();
  }
 
  template<PartitionIteratorType pitype>
  constexpr PartitionSet<derive_partition_set<pitype>::value> partitionSet()
  {
    return PartitionSet<derive_partition_set<pitype>::value>();
  }
 
  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;
 
 
    constexpr Interior interior;
 
    constexpr Border border;
 
    constexpr Overlap overlap;
 
    constexpr Front front;
 
    constexpr Ghost ghost;
 
    constexpr InteriorBorder interiorBorder;
 
    constexpr InteriorBorderOverlap interiorBorderOverlap;
 
    constexpr InteriorBorderOverlapFront interiorBorderOverlapFront;
 
    constexpr 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;
 
#ifndef __cpp_inline_variables
    namespace {
#endif
 
      // 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
 
      DUNE_INLINE_VARIABLE constexpr Interior interior = {};
      DUNE_INLINE_VARIABLE constexpr Border border = {};
      DUNE_INLINE_VARIABLE constexpr Overlap overlap = {};
      DUNE_INLINE_VARIABLE constexpr Front front = {};
      DUNE_INLINE_VARIABLE constexpr Ghost ghost = {};
 
#ifndef __cpp_inline_variables
    }
#endif
 
    // 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;
 
#ifndef __cpp_inline_variables
    namespace {
#endif
 
      // again, place the global objects in an anonymous namespace
 
      DUNE_INLINE_VARIABLE constexpr InteriorBorder interiorBorder = {};
      DUNE_INLINE_VARIABLE constexpr InteriorBorderOverlap interiorBorderOverlap = {};
      DUNE_INLINE_VARIABLE constexpr InteriorBorderOverlapFront interiorBorderOverlapFront = {};
      DUNE_INLINE_VARIABLE constexpr All all = {};
 
#ifndef __cpp_inline_variables
    }
#endif
 
#endif // DOXYGEN
 
  } // namespace Partitions
 
} // namespace Dune
 
#endif // DUNE_GRID_COMMON_PARTITIONSET_HH