GlobListIter.h

#ifndef DASH__LIST__GLOB_LIST_ITER_H__INCLUDED
#define DASH__LIST__GLOB_LIST_ITER_H__INCLUDED

#include <dash/GlobPtr.h>
#include <dash/GlobRef.h>

#include <dash/list/internal/ListTypes.h>

#include <iterator>


namespace dash {

template<
  typename ElementType,
  class    GlobMemType,
  class    PointerType   = GlobPtr<ElementType, GlobMemType>,
  class    ReferenceType = GlobRef<ElementType> >
class GlobListIter
: public std::iterator<
           std::bidirectional_iterator_tag,
           ElementType,
           dash::default_index_t,
           PointerType,
           ReferenceType >
{
private:
  typedef GlobListIter<
            ElementType,
            GlobMemType,
            PointerType,
            ReferenceType>
    self_t;

public:
  typedef ElementType                             value_type;
  typedef       ReferenceType                      reference;
  typedef const ReferenceType                const_reference;
  typedef       PointerType                          pointer;
  typedef const PointerType                    const_pointer;

  typedef typename GlobMemType::local_pointer  local_pointer;

  typedef internal::ListNode<value_type>           node_type;

public:
  typedef std::integral_constant<bool, false>       has_view;

public:
  GlobListIter() = default;

  GlobListIter(
    GlobMemType  * gmem,
    node_type    & node)
  : _globmem(gmem),
    _node(&node),
    _myid(dash::Team::GlobalUnitID())
  {
    DASH_LOG_TRACE("GlobListIter(gmem,node,pat)");
  }

  GlobListIter(
    const self_t & other) = default;

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

  operator pointer() const
  {
    pointer ptr;
    // TODO
    return ptr;
  }

  reference operator*()
  {
    return reference(this);
  }

  const_reference operator*() const
  {
  }

  inline self_t global() const
  {
    return *this;
  }

  inline constexpr bool is_relative() const noexcept
  {
    return false;
  }

  inline const GlobMemType & globmem() const
  {
    return *_globmem;
  }

  inline GlobMemType & globmem()
  {
    return *_globmem;
  }

  inline self_t & operator++()
  {
    increment();
    return *this;
  }

  inline self_t operator++(int)
  {
    self_t result = *this;
    increment();
    return result;
  }

  inline self_t & operator--()
  {
    decrement();
    return *this;
  }

  inline self_t operator--(int)
  {
    self_t result = *this;
    decrement();
    return result;
  }

  inline bool operator==(const self_t & other) const
  {
    return _node == other._node;
  }

  inline bool operator!=(const self_t & other) const
  {
    return _node != other._node;
  }

private:

  void increment()
  {
  }

  void decrement()
  {
  }

private:
  GlobMemType          * _globmem{};
  node_type            * _node     = nullptr;
  team_unit_t            _myid;

}; // class GlobListIter

} // namespace dash

#endif // DASH__LIST__GLOB_LIST_ITER_H__INCLUDED