UnorderedMap.h

#ifndef DASH__UNORDERED_MAP_H__INCLUDED
#define DASH__UNORDERED_MAP_H__INCLUDED

#include <dash/Types.h>
#include <dash/GlobRef.h>
#include <dash/Team.h>
#include <dash/Array.h>
#include <dash/memory/GlobHeapMem.h>
#include <dash/Allocator.h>

#include <dash/atomic/GlobAtomicRef.h>

#include <iterator>
#include <utility>
#include <limits>
#include <vector>
#include <functional>
#include <algorithm>
#include <cstddef>

#ifdef DOXYGEN

namespace dash {

template<
  typename Key,
  typename Mapped,
  typename Hash    = dash::HashLocal<Key>,
  typename Pred    = std::equal_to<Key>,
  typename LocalMemType = HostSpace >
class UnorderedMap
{
  typedef UnorderedMap<Key, Mapped, Hash, Pred, LocalMemType> self_type;

  using glob_mem_type = dash::GlobHeapMem<
      std::pair<const Key, Mapped>,
      LocalMemorySpace,
      dash::global_allocation_policy::epoch_synchronized,
      dash::allocator::DefaultAllocator>;

public:

  typedef Key    key_type;
  typedef Mapped mapped_type;
  typedef Hash   hasher;
  typedef Pred   key_equal;

  typedef dash::default_index_t                  index_type;
  typedef dash::default_index_t                  difference_type;
  typedef dash::default_size_t                   size_type;
  typedef std::pair<const key_type, mapped_type> value_type;

  typedef typename dash::container_traits<self_type>::local_type local_type;

  typedef GlobHeapPtr<value_type, glob_mem_type>       pointer;
  typedef GlobHeapPtr<const value_type, glob_mem_type> const_pointer;

  typedef GlobSharedRef<value_type, GlobHeapPtr<value_type, glob_mem_type>>
      reference;

  typedef GlobSharedRef<value_type const, GlobHeapPtr<value_type, glob_mem_type>>
      const_reference;

  typedef typename reference::template rebind<mapped_type>::other
    mapped_type_reference;
  typedef typename const_reference::template rebind<mapped_type>::other
    const_mapped_type_reference;

  typedef typename glob_mem_type::global_iterator
    node_iterator;
  typedef typename glob_mem_type::const_global_iterator
    const_node_iterator;
  typedef typename glob_mem_type::local_iterator
    local_node_iterator;
  typedef typename glob_mem_type::const_local_iterator
    const_local_node_iterator;
  typedef typename glob_mem_type::reverse_global_iterator
    reverse_node_iterator;
  typedef typename glob_mem_type::const_reverse_global_iterator
    const_reverse_node_iterator;
  typedef typename glob_mem_type::reverse_local_iterator
    reverse_local_node_iterator;
  typedef typename glob_mem_type::const_reverse_local_iterator
    const_reverse_local_node_iterator;

  typedef typename glob_mem_type::local_iterator
    local_node_pointer;
  typedef typename glob_mem_type::const_local_iterator
    const_local_node_pointer;

  typedef UnorderedMapGlobIter<Key, Mapped, Hash, Pred, glob_mem_type>
    iterator;
  typedef UnorderedMapGlobIter<Key, Mapped, Hash, Pred, glob_mem_type>
    const_iterator;
  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;
  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef UnorderedMapLocalIter<Key, Mapped, Hash, Pred, LocalMemType>
    local_pointer;
  typedef UnorderedMapLocalIter<Key, Mapped, Hash, Pred, LocalMemType>
    const_local_pointer;
  typedef UnorderedMapLocalIter<Key, Mapped, Hash, Pred, LocalMemType>
    local_iterator;
  typedef UnorderedMapLocalIter<Key, Mapped, Hash, Pred, LocalMemType>
    const_local_iterator;
  typedef typename std::reverse_iterator<local_iterator>
    reverse_local_iterator;
  typedef typename std::reverse_iterator<const_local_iterator>
    const_reverse_local_iterator;

  typedef typename glob_mem_type::local_reference
    local_reference;
  typedef typename glob_mem_type::const_local_reference
    const_local_reference;

  typedef dash::Array<
            size_type, int, dash::CSRPattern<1, dash::ROW_MAJOR, int> >
    local_sizes_map;

public:
  local_type local;

  // Distributed container

  constexpr Team & team() const noexcept;

  const glob_mem_type & globmem() const;

  // Dynamic distributed memory

  void barrier();

  bool allocate(
    size_type    nelem = 0,
    dash::Team & team  = dash::Team::All());

  void deallocate();

  // Global Iterators

  iterator & begin() noexcept;

  const_iterator & begin() const noexcept;

  const_iterator & cbegin() const noexcept;

  iterator & end() noexcept;

  const_iterator & end() const noexcept;

  const_iterator & cend() const noexcept;

  // Local Iterators

  local_iterator & lbegin() noexcept;

  const_local_iterator & lbegin() const noexcept;

  const_local_iterator & clbegin() const noexcept;

  local_iterator & lend() noexcept;

  const_local_iterator & lend() const noexcept;

  const_local_iterator & clend() const noexcept;

  // Capacity

  constexpr size_type max_size() const noexcept;

  size_type size() const noexcept;

  size_type capacity() const noexcept;

  bool empty() const noexcept;

  size_type lsize() const noexcept;

  size_type lcapacity() const noexcept;

  // Element Access

  mapped_type_reference operator[](const key_type & key);

  const_mapped_type_reference at(const key_type & key) const;

  mapped_type_reference at(const key_type & key);

  // Element Lookup

  size_type count(const key_type & key) const;

  iterator find(const key_type & key);

  const_iterator find(const key_type & key) const;

  // Modifiers

  std::pair<iterator, bool> insert(
    const value_type & value);

  iterator insert(
    //Iterator hint
    const_iterator hint,
    //The element to insert
    const value_type & value);

  template<class InputIterator>
  void insert(
    // Iterator at first value in the range to insert.
    InputIterator first,
    // Iterator past the last value in the range to insert.
    InputIterator last);

  iterator erase(
    const_iterator position);

  size_type erase(
    const key_type & key);

  iterator erase(
    const_iterator first,
    const_iterator last);

  // Bucket Interface

  size_type bucket(
    const key_type & key) const;

  size_type bucket_size(
    size_type bucket_index) const;

  // Observers

  key_equal key_eq() const;

  hasher hash_function() const;

}; // class UnorderedMap

} // namespace dash

#endif // ifdef DOXYGEN

#include <dash/map/UnorderedMap.h>

#endif // DASH__UNORDERED_MAP_H__INCLUDED