Pattern.h

#ifndef DASH__PATTERN_H__INCLUDED
#define DASH__PATTERN_H__INCLUDED

#ifdef DOXYGEN

namespace dash {

template<
  dim_t      NumDimensions,
  MemArrange Arrangement   = ROW_MAJOR,
  typename   IndexType     = dash::default_index_t
>
class PatternConcept
{
  typedef typename std::make_unsigned<IndexType>::type      SizeType;
  typedef ViewSpec<NumDimensions, IndexType>            ViewSpecType;

public:

  static constexpr char const * PatternName = "TheConcretePatternTypeName";

public:

  typedef IndexType        index_type;
  typedef SizeType          size_type;
  typedef ViewSpecType  viewspec_type;

  typedef struct {
    team_unit_t unit;
    index_type  index;
  } local_index_type;

  typedef struct {
    team_unit_t unit;
    std::array<index_type, NumDimensions> coords;
  } local_coords_type;

public:

  PatternConcept(self_t & other);

  bool operator==(
    const self_t & other) const;

  bool operator!=(
    const self_t & other) const;

  PatternConcept & operator=(const PatternConcept & other);

  index_type lbegin() const;

  index_type lend() const;


  team_unit_t unit_at(
    const std::array<index_type, NumDimensions> & coords,
    const ViewSpec_t & viewspec) const;

  team_unit_t unit_at(
    const std::array<index_type, NumDimensions> & coords) const;

  team_unit_t unit_at(
    index_type global_pos,
    const ViewSpec_t & viewspec) const;

  team_unit_t unit_at(
    index_type global_pos) const;


  index_type extent(dim_t dim) const;

  index_type local_extent(dim_t dim) const;

  std::array<size_type, NumDimensions> local_extents() const;

  std::array<size_type, NumDimensions> local_extents(
    team_unit_t unit) const;


  index_type local_at(
    const std::array<index_type, NumDimensions> & local_coords,
    const ViewSpec_t & viewspec) const;

  index_type local_at(
    const std::array<index_type, NumDimensions> & local_coords) const;

  local_coords_t local(
    const std::array<index_type, NumDimensions> & global_coords) const;

  local_index_t local(
    index_type g_index) const;

  std::array<index_type, NumDimensions> local_coords(
    const std::array<index_type, NumDimensions> & global_coords) const;

  local_index_t local_index(
    const std::array<index_type, NumDimensions> & global_coords) const;


  std::array<index_type, NumDimensions> global(
    team_unit_t unit,
    const std::array<index_type, NumDimensions> & local_coords) const;

  std::array<index_type, NumDimensions> global(
    const std::array<index_type, NumDimensions> & local_coords) const;

  index_type global(
    index_type local_index) const;

  index_type global_index(
    team_unit_t unit,
    const std::array<index_type, NumDimensions> & local_coords) const;

  index_type global_at(
    const std::array<index_type, NumDimensions> & view_coords,
    const ViewSpec_t                           & viewspec) const;

  index_type global_at(
    const std::array<index_type, NumDimensions> & global_coords) const;


  index_type at(
    const std::array<index_type, NumDimensions> & global_coords) const;

  index_type at(
    const std::array<index_type, NumDimensions> & global_coords,
    const ViewSpec_t & viewspec) const;

  template<typename ... Values>
  index_type at(index_type value, Values ... values) const;


  bool is_local(
    index_type index,
    team_unit_t unit) const;

  bool is_local(
    index_type index) const;


  const BlockSpec_t & blockspec() const;

  index_type block_at(
    const std::array<index_type, NumDimensions> & g_coords) const;

  ViewSpec_t block(
    index_type global_block_index) const;

  ViewSpec_t local_block(
    index_type local_block_index) const;

  ViewSpec_t local_block_local(
    index_type local_block_index) const;

  size_type blocksize(
    dim_t dimension) const;

  size_type max_blocksize() const;

  inline size_type local_capacity() const;

  inline size_type local_size(
    team_unit_t unit = UNDEFINED_TEAM_UNIT_ID) const;

  inline index_type capacity() const;

  inline index_type size() const;

  inline dash::Team & team() const;

  const DistributionSpec_t & distspec() const;

  SizeSpec_t sizespec() const;

  const std::array<size_type, NumDimensions> & extents() const;

  const TeamSpec_t & teamspec() const;

  std::array<index_type, NumDimensions> coords(
    index_type index) const;

  std::array<index_type, NumDimensions> coords(
    index_type         index,
    const ViewSpec_t & viewspec) const;

  constexpr static MemArrange memory_order();

  constexpr static dim_t ndim();

  size_type underfilled_blocksize(
    dim_t dimension) const;

};

} // namespace dash

#endif // DOXYGEN

// Static regular pattern types:
#include <dash/pattern/BlockPattern.h>
#include <dash/pattern/TilePattern.h>
#include <dash/pattern/ShiftTilePattern.h>
#include <dash/pattern/SeqTilePattern.h>

// Static irregular pattern types:
#include <dash/pattern/CSRPattern.h>
#include <dash/pattern/LoadBalancePattern.h>

#include <dash/Types.h>
#include <dash/Distribution.h>

namespace dash {

template<
  dim_t      NumDimensions,
  MemArrange Arrangement   = ROW_MAJOR,
  typename   IndexType     = dash::default_index_t
>
using Pattern = dash::BlockPattern<NumDimensions, Arrangement, IndexType>;

} // namespace dash

#include <dash/pattern/PatternIterator.h>
#include <dash/pattern/PatternProperties.h>
#include <dash/pattern/MakePattern.h>

#endif // DASH__PATTERN_H__INCLUDED