PatternProperties.h

#ifndef DASH__PATTERN_PROPERTIES_H__
#define DASH__PATTERN_PROPERTIES_H__

#include <dash/Types.h>
#include <sstream>
#include <iostream>

namespace dash {

// Pattern Layout Properties

struct pattern_layout_tag
{
  typedef enum {
    any,

    row_major,

    col_major,

    blocked,

    canonical,

    linear

  } type;
};

template<pattern_layout_tag::type ... Tags>
struct pattern_layout_properties
{
  typedef pattern_layout_tag::type tag_type;


  static const bool row_major = true;

  static const bool col_major = false;

  static const bool blocked   = false;

  static const bool canonical = true;

  static const bool linear    = false;
};

#ifndef DOXYGEN

template<pattern_layout_tag::type ... Tags>
struct pattern_layout_properties<
         pattern_layout_tag::type::blocked, Tags ...>
: public pattern_layout_properties<Tags ...>
{
  static const bool blocked;
  static const bool canonical;
};

template<pattern_layout_tag::type ... Tags>
const bool
pattern_layout_properties<
  pattern_layout_tag::type::blocked, Tags ...
>::blocked = true;

template<pattern_layout_tag::type ... Tags>
const bool
pattern_layout_properties<
  pattern_layout_tag::type::blocked, Tags ...
>::canonical = false;

template<pattern_layout_tag::type ... Tags>
struct pattern_layout_properties<
         pattern_layout_tag::type::canonical, Tags ...>
: public pattern_layout_properties<Tags ...>
{
  static const bool canonical;
  static const bool blocked;
};

template<pattern_layout_tag::type ... Tags>
const bool
pattern_layout_properties<
  pattern_layout_tag::type::canonical, Tags ...
>::blocked = false;

template<pattern_layout_tag::type ... Tags>
const bool
pattern_layout_properties<
  pattern_layout_tag::type::canonical, Tags ...
>::canonical = true;

template<pattern_layout_tag::type ... Tags>
struct pattern_layout_properties<
         pattern_layout_tag::type::linear, Tags ...>
: public pattern_layout_properties<Tags ...>
{
  static const bool linear;
};

template<pattern_layout_tag::type ... Tags>
const bool
pattern_layout_properties<
  pattern_layout_tag::type::linear, Tags ...
>::linear = true;

#endif // DOXYGEN

// Pattern Mapping Properties

struct pattern_mapping_tag
{
  typedef enum {
    any,

    balanced,

    unbalanced,

    neighbor,

    shifted,

    diagonal,

    multiple,

    cyclic

  } type;
};

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties
{
  typedef pattern_mapping_tag::type tag_type;


  static const bool balanced   = false;

  static const bool unbalanced = false;

  static const bool neighbor   = false;

  static const bool shifted    = false;

  static const bool diagonal   = false;

  static const bool multiple   = false;

  static const bool cyclic     = false;
};

#ifndef DOXYGEN

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::balanced, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool balanced;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::balanced, Tags ...
>::balanced = true;

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::unbalanced, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool unbalanced;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::unbalanced, Tags ...
>::unbalanced = true;

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::neighbor, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool neighbor;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::neighbor, Tags ...
>::neighbor = true;

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::shifted, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool shifted;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::shifted, Tags ...
>::shifted = true;

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::diagonal, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool diagonal;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::diagonal, Tags ...
>::diagonal = true;

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::multiple, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool multiple;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::multiple, Tags ...
>::multiple = true;

template<pattern_mapping_tag::type ... Tags>
struct pattern_mapping_properties<
         pattern_mapping_tag::type::cyclic, Tags ...>
: public pattern_mapping_properties<Tags ...>
{
  static const bool cyclic;
};

template<pattern_mapping_tag::type ... Tags>
const bool
pattern_mapping_properties<
  pattern_mapping_tag::type::cyclic, Tags ...
>::cyclic = true;

#endif // DOXYGEN

// Pattern partitioning properties

struct pattern_partitioning_tag
{
  typedef enum {
    any,

    rectangular,

    minimal,

    regular,

    balanced,

    unbalanced,

    ndimensional,

    dynamic
  } type;
};

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties
{
  typedef pattern_partitioning_tag::type tag_type;


  static const bool rectangular  = false;

  static const bool minimal      = false;

  static const bool regular      = false;

  static const bool balanced     = false;

  static const bool unbalanced   = false;

  static const bool ndimensional = false;

  static const bool dynamic      = false;
};

#ifndef DOXYGEN

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::rectangular, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool rectangular;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::rectangular, Tags ...
>::rectangular = true;

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::minimal, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool minimal;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::minimal, Tags ...
>::minimal = true;

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::regular, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool regular;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::regular, Tags ...
>::regular = true;

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::balanced, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool balanced;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::balanced, Tags ...
>::balanced = true;

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::unbalanced, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool unbalanced;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::unbalanced, Tags ...
>::unbalanced = true;

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::ndimensional, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool ndimensional;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::ndimensional, Tags ...
>::ndimensional = true;

template<pattern_partitioning_tag::type ... Tags>
struct pattern_partitioning_properties<
         pattern_partitioning_tag::type::dynamic, Tags ...>
: public pattern_partitioning_properties<Tags ...>
{
  static const bool dynamic;
};

template<pattern_partitioning_tag::type ... Tags>
const bool
pattern_partitioning_properties<
  pattern_partitioning_tag::type::dynamic, Tags ...
>::dynamic = true;

#endif // DOXYGEN

// Pattern Traits Default Definitions

template<typename PatternType>
struct pattern_partitioning_traits
{
  typedef typename PatternType::partitioning_properties
          type;
};

template<typename PatternType>
struct pattern_mapping_traits
{
  typedef typename PatternType::mapping_properties
          type;
};

template<typename PatternType>
struct pattern_layout_traits
{
  typedef typename PatternType::layout_properties
          type;
};

template<typename PatternType>
struct pattern_traits
{
  typedef typename PatternType::index_type
          index_type;
  typedef typename PatternType::size_type
          size_type;

  typedef typename dash::pattern_partitioning_traits<PatternType>::type
          partitioning;
  typedef typename dash::pattern_mapping_traits<PatternType>::type
          mapping;
  typedef typename dash::pattern_layout_traits<PatternType>::type
          layout;

  typedef typename std::decay<
                     decltype(std::declval<PatternType>().blockspec())
                   >::type
          blockspec_type;
  typedef typename std::decay<
                     decltype(std::declval<PatternType>().local_blockspec())
                   >::type
          local_blockspec_type;
};

// Verifying Pattern Properties

template<
  typename PartitioningConstraints,
  typename MappingConstraints,
  typename LayoutConstraints,
  typename PatternType
>
bool check_pattern_constraints(
  const PatternType & pattern)
{
  // Pattern property traits of category Partitioning
  typedef typename dash::pattern_traits< PatternType >::partitioning
          partitioning_traits;
  // Pattern property traits of category Mapping
  typedef typename dash::pattern_traits< PatternType >::mapping
          mapping_traits;
  // Pattern property traits of category Layout
  typedef typename dash::pattern_traits< PatternType >::layout
          layout_traits;
  // Check compile-time invariants:

  // Partitioning properties:
  //
  static_assert(!PartitioningConstraints::rectangular ||
                partitioning_traits::rectangular,
                "Pattern does not implement rectangular partitioning");
  static_assert(!PartitioningConstraints::minimal ||
                partitioning_traits::minimal,
                "Pattern does not implement minimal partitioning");
  static_assert(!PartitioningConstraints::regular ||
                partitioning_traits::regular,
                "Pattern does not implement regular partitioning");
  static_assert(!PartitioningConstraints::balanced ||
                partitioning_traits::balanced,
                "Pattern does not implement balanced partitioning");
  static_assert(!PartitioningConstraints::unbalanced ||
                partitioning_traits::unbalanced,
                "Pattern does not implement unbalanced partitioning");
  // Mapping properties:
  //
  static_assert(!MappingConstraints::balanced ||
                mapping_traits::balanced,
                "Pattern does not implement balanced mapping");
  static_assert(!MappingConstraints::unbalanced ||
                mapping_traits::unbalanced,
                "Pattern does not implement unbalanced mapping");
  static_assert(!MappingConstraints::neighbor ||
                mapping_traits::neighbor,
                "Pattern does not implement neighbor mapping");
  static_assert(!MappingConstraints::shifted ||
                mapping_traits::shifted,
                "Pattern does not implement shifted mapping");
  static_assert(!MappingConstraints::diagonal ||
                mapping_traits::diagonal,
                "Pattern does not implement diagonal mapping");
  static_assert(!MappingConstraints::cyclic ||
                mapping_traits::cyclic,
                "Pattern does not implement cyclic mapping");
  // Layout properties:
  //
  static_assert(!LayoutConstraints::blocked ||
                layout_traits::blocked,
                "Pattern does not implement blocked layout");
  static_assert(!LayoutConstraints::canonical ||
                layout_traits::canonical,
                "Pattern does not implement canonical layout");
  static_assert(!LayoutConstraints::linear ||
                layout_traits::linear,
                "Pattern does not implement linear layout");
  return true;
}

template<
  typename PartitioningConstraints,
  typename MappingConstraints,
  typename LayoutConstraints,
  typename PatternType
>
struct pattern_constraints
{
  // Pattern property traits of category Partitioning
  typedef typename dash::pattern_traits< PatternType >::partitioning
          partitioning_traits;
  // Pattern property traits of category Mapping
  typedef typename dash::pattern_traits< PatternType >::mapping
          mapping_traits;
  // Pattern property traits of category Layout
  typedef typename dash::pattern_traits< PatternType >::layout
          layout_traits;

  typedef std::integral_constant<
            bool,
            //
            // Partitioning properties:
            //
            ( !PartitioningConstraints::rectangular ||
              partitioning_traits::rectangular )
            &&
            ( !PartitioningConstraints::minimal ||
              partitioning_traits::minimal )
            &&
            ( !PartitioningConstraints::regular ||
              partitioning_traits::regular )
            &&
            ( !PartitioningConstraints::balanced ||
              partitioning_traits::balanced )
            &&
            ( !PartitioningConstraints::unbalanced ||
              partitioning_traits::unbalanced )
            &&
            //
            // Mapping properties:
            //
            ( !MappingConstraints::balanced ||
              mapping_traits::balanced )
            &&
            ( !MappingConstraints::unbalanced ||
              mapping_traits::unbalanced )
            &&
            ( !MappingConstraints::neighbor ||
              mapping_traits::neighbor )
            &&
            ( !MappingConstraints::shifted ||
              mapping_traits::shifted )
            &&
            ( !MappingConstraints::diagonal ||
              mapping_traits::diagonal )
            &&
            ( !MappingConstraints::cyclic ||
              mapping_traits::cyclic )
            &&
            //
            // Layout properties:
            //
            ( !LayoutConstraints::blocked ||
              layout_traits::blocked )
            &&
            ( !LayoutConstraints::canonical ||
              layout_traits::canonical )
            &&
            ( !LayoutConstraints::linear ||
              layout_traits::linear )
          > satisfied;
};

// Default Pattern Traits Definitions

typedef dash::pattern_partitioning_properties<
            pattern_partitioning_tag::rectangular,
            pattern_partitioning_tag::unbalanced >
        pattern_partitioning_default_properties;

typedef dash::pattern_mapping_properties<
            pattern_mapping_tag::unbalanced >
        pattern_mapping_default_properties;

typedef dash::pattern_layout_properties<
            pattern_layout_tag::row_major,
            pattern_layout_tag::canonical,
            pattern_layout_tag::linear >
        pattern_layout_default_properties;


#ifndef DOXYGEN

template<pattern_layout_tag::type ... Tags>
std::ostream & operator<<(
    std::ostream & os,
    const pattern_layout_properties<Tags ...> traits)
{
  std::ostringstream ss;
  ss << "dash::pattern_layout_properties< ";
  if (traits.row_major) {
    ss << "row_major ";
  }
  if (traits.col_major) {
    ss << "col_major ";
  }
  if (traits.blocked) {
    ss << "blocked ";
  }
  if (traits.canonical) {
    ss << "canonical ";
  }
  if (traits.linear) {
    ss << "linear ";
  }
  ss << ">";
  return operator<<(os, ss.str());
}

template<pattern_mapping_tag::type ... Tags>
std::ostream & operator<<(
    std::ostream & os,
    const pattern_mapping_properties<Tags ...> traits)
{
  std::ostringstream ss;
  ss << "dash::pattern_mapping_properties< ";
  if (traits.balanced) {
    ss << "balanced ";
  }
  if (traits.unbalanced) {
    ss << "unbalanced ";
  }
  if (traits.neighbor) {
    ss << "neighbor ";
  }
  if (traits.shifted) {
    ss << "shifted ";
  }
  if (traits.diagonal) {
    ss << "diagonal ";
  }
  if (traits.cyclic) {
    ss << "cyclic ";
  }
  ss << ">";
  return operator<<(os, ss.str());
}

template<pattern_partitioning_tag::type ... Tags>
std::ostream & operator<<(
    std::ostream & os,
    const pattern_partitioning_properties<Tags ...> traits)
{
  std::ostringstream ss;
  ss << "dash::pattern_partitioning_properties< ";
  if (traits.rectangular) {
    ss << "rectangular ";
  }
  if (traits.minimal) {
    ss << "minimal ";
  }
  if (traits.regular) {
    ss << "regular ";
  }
  if (traits.balanced) {
    ss << "balanced ";
  }
  if (traits.unbalanced) {
    ss << "unbalanced ";
  }
  ss << ">";
  return operator<<(os, ss.str());
}

#endif

} // namespace dash

#endif // DASH__PATTERN_PROPERTIES_H__