Iterator.h

#ifndef DASH__ITERATOR_H__INCLUDED
#define DASH__ITERATOR_H__INCLUDED

#include <dash/Types.h>
#include <dash/Dimensional.h>
#include <dash/iterator/IteratorTraits.h>
#include <dash/iterator/GlobIter.h>
#include <dash/iterator/GlobViewIter.h>

#include <iterator>

namespace dash {


template <class IndexType>
constexpr typename std::enable_if<
  std::is_integral<IndexType>::value, IndexType >::type
index(IndexType idx) {
  return idx;
}

// template <class Iterator>
// constexpr auto index(Iterator it) -> decltype((++it).pos()) {
//   return it.pos();
// }

template <class Iterator>
constexpr auto index(Iterator it) -> decltype((++it).gpos()) {
  return it.gpos();
}


template <class RandomAccessIt>
typename RandomAccessIt::difference_type
distance(
  const RandomAccessIt & first,
  const RandomAccessIt & last)
{
  return last - first;
}

template<
  typename ElementType,
  class    Pattern,
  class    GlobMemType,
  class    Pointer,
  class    Reference >
typename Pattern::index_type
distance(
  const GlobIter<ElementType, Pattern, GlobMemType, Pointer, Reference> &
    first,
  const GlobIter<ElementType, Pattern, GlobMemType, Pointer, Reference> &
    last)
{
  return last - first;
}

template<
  typename ElementType,
  class    Pattern,
  class    GlobMemType,
  class    Pointer,
  class    Reference >
DASH_CONSTEXPR auto operator-(
  const GlobIter<ElementType, Pattern, GlobMemType, Pointer, Reference> &
    lhs,
  const GlobIter<ElementType, Pattern, GlobMemType, Pointer, Reference> &
    rhs) DASH_NOEXCEPT
{
  return lhs.pos() - rhs.pos();
}

template <class T>
constexpr std::ptrdiff_t distance(T * const first, T * const last) {
  return std::distance(first, last);
}

template <
  class OffsetType >
constexpr typename std::enable_if<
  std::is_integral<OffsetType>::value,
  OffsetType >::type
distance(
  OffsetType begin,
  OffsetType end) {
  return (end - begin);
}

} // namespace dash

#endif // DASH__ITERATOR_H__INCLUDED