ListRef.h

#ifndef DASH__LIST__LIST_REF_H__INCLUDED
#define DASH__LIST__LIST_REF_H__INCLUDED

#include <iterator>
#include <limits>

#include <dash/Types.h>
#include <dash/GlobRef.h>
#include <dash/Team.h>
#include <dash/Exception.h>
#include <dash/Cartesian.h>
#include <dash/Dimensional.h>
#include <dash/memory/GlobHeapMem.h>
#include <dash/Allocator.h>

#include <dash/iterator/GlobIter.h>

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


namespace dash {

// forward declaration
template<
  typename ElementType,
  class    LMemSpace >
class List;

// forward declaration
template<
  typename ElementType,
  class    LMemSpace >
class LocalListRef;

template<
  typename ElementType,
  class    LMemSpace >
class ListRef
{
private:
  static const dim_t NumDimensions = 1;

public:
  typedef dash::default_index_t               index_type;
  typedef ElementType                         value_type;
  typedef ListRef<ElementType, LMemSpace>     view_type;
  typedef LocalListRef<value_type, LMemSpace> local_type;

private:
  typedef ListRef<ElementType, LMemSpace>     self_t;
  typedef List<ElementType, LMemSpace>        list_type;
  typedef ViewSpec<NumDimensions, index_type> ViewSpec_t;
  typedef typename list_type::node_type       ListNode_t;
  typedef typename list_type::glob_mem_type   glob_mem_type;

public:
  typedef typename std::make_unsigned<index_type>::type            size_type;

  typedef typename list_type::iterator                              iterator;
  typedef typename list_type::const_iterator                  const_iterator;
  typedef typename list_type::reverse_iterator              reverse_iterator;
  typedef typename list_type::const_reverse_iterator  const_reverse_iterator;
  typedef typename list_type::reference                            reference;
  typedef typename list_type::const_reference                const_reference;
  typedef typename list_type::pointer                                pointer;
  typedef typename list_type::const_pointer                    const_pointer;
  typedef typename glob_mem_type::local_pointer                local_pointer;
  typedef typename glob_mem_type::const_local_pointer    const_local_pointer;

public:
  ListRef(
    list_type        * list,
    const ViewSpec_t & viewspec)
  : _list(list),
    _viewspec(viewspec)
  { }

public:
  inline void push_back(const value_type & value)
  {
    DASH_THROW(dash::exception::NotImplemented,
               "dash::ListRef.push_back is not implemented");
  }

  void pop_back()
  {
    DASH_THROW(dash::exception::NotImplemented,
               "dash::ListRef.pop_back is not implemented");
  }

  reference back()
  {
    DASH_THROW(dash::exception::NotImplemented,
               "dash::ListRef.back is not implemented");
  }

  inline void push_front(const value_type & value)
  {
    DASH_THROW(dash::exception::NotImplemented,
               "dash::ListRef.push_front is not implemented");
  }

  void pop_front()
  {
    DASH_THROW(dash::exception::NotImplemented,
               "dash::ListRef.pop_front is not implemented");
  }

  reference front()
  {
    DASH_THROW(dash::exception::NotImplemented,
               "dash::ListRef.front is not implemented");
  }

  inline Team              & team()             const noexcept;

  inline size_type           size()             const noexcept;
  inline size_type           local_size()       const noexcept;
  inline size_type           local_capacity()   const noexcept;
  inline bool                empty()            const noexcept;

  inline void                barrier()          const;

  inline const_pointer       data()             const noexcept;
  inline iterator            begin()                  noexcept;
  inline const_iterator      begin()            const noexcept;
  inline iterator            end()                    noexcept;
  inline const_iterator      end()              const noexcept;
  inline local_pointer       lbegin()           const noexcept;
  inline local_pointer       lend()             const noexcept;

private:
  list_type  * _list;
  ViewSpec_t   _viewspec;

}; // class ListRef

} // namespace dash

#endif // DASH__LIST__LIST_REF_H__INCLUDED