array.hpp

Go to the documentation of this file.

// Copyright 2021 Lawrence Livermore National Security, LLC and other Metall
// Project Developers. See the top-level COPYRIGHT file for details.
//
// SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
#ifndef METALL_JSON_ARRAY_HPP
#define METALL_JSON_ARRAY_HPP
 
#include <iostream>
#include <memory>
#include <algorithm>
 
#include <metall/container/vector.hpp>
#include <metall/container/scoped_allocator.hpp>
#include <metall/json/json_fwd.hpp>
 
namespace metall::json {
 
namespace {
namespace mc = metall::container;
}
 
namespace jsndtl {
 
template <typename allocator_type, typename other_array_type>
inline bool general_array_equal(const array<allocator_type> &array,
                                const other_array_type &other_array) noexcept {
  if (array.size() != other_array.size()) return false;
  return std::equal(array.begin(), array.end(), other_array.begin());
}
 
}  // namespace jsndtl
 
#ifdef DOXYGEN_SKIP
template <typename Alloc = std::allocator<std::byte>>
#else
template <typename Alloc>
#endif
class array {
 public:
  using value_type = value<Alloc>;
 
 private:
  template <typename alloc, typename T>
  using other_scoped_allocator = mc::scoped_allocator_adaptor<
      typename std::allocator_traits<alloc>::template rebind_alloc<T>>;
  using aray_allocator_type = other_scoped_allocator<Alloc, value_type>;
  using array_type = mc::vector<value_type, aray_allocator_type>;
 
 public:
  using allocator_type = Alloc;
  using iterator = typename array_type::iterator;
  using const_iterator = typename array_type::const_iterator;
  using reference = value_type &;
  using const_reference = const value_type &;
 
  array() = default;
 
  explicit array(const allocator_type &alloc) : m_array(alloc) {}
 
  array(const array &) = default;
 
  array(const array &other, const allocator_type &alloc)
      : m_array(other.m_array, alloc) {}
 
  array(array &&) noexcept = default;
 
  array(array &&other, const allocator_type &alloc) noexcept
      : m_array(std::move(other.m_array), alloc) {}
 
  array &operator=(const array &) = default;
 
  array &operator=(array &&) noexcept = default;
 
  void swap(array &other) noexcept {
    using std::swap;
    swap(m_array, other.m_array);
  }
 
  std::size_t size() const noexcept { return m_array.size(); }
 
  std::size_t capacity() const noexcept { return m_array.capacity(); }
 
  void resize(const std::size_t size) {
    m_array.resize(size, value_type{m_array.get_allocator()});
  }
 
  void clear() { m_array.clear(); }
 
  reference operator[](const std::size_t index) { return m_array[index]; }
 
  const_reference operator[](const std::size_t index) const {
    return m_array[index];
  }
 
  iterator begin() { return m_array.begin(); }
 
  const_iterator begin() const { return m_array.begin(); }
 
  iterator end() { return m_array.end(); }
 
  const_iterator end() const { return m_array.end(); }
 
  iterator erase(iterator position) { return m_array.erase(position); }
 
  iterator erase(const_iterator position) { return m_array.erase(position); }
 
  void push_back(const value_type &value) { m_array.push_back(value); }
 
  void push_back(value_type &&value) { m_array.push_back(std::move(value)); }
 
  friend bool operator==(const array &lhs, const array &rhs) noexcept {
    return jsndtl::general_array_equal(lhs, rhs);
  }
 
  friend bool operator!=(const array &lhs, const array &rhs) noexcept {
    return !(lhs == rhs);
  }
 
  allocator_type get_allocator() const noexcept {
    return m_array.get_allocator();
  }
 
 private:
  array_type m_array{allocator_type{}};
};
 
template <typename allocator_type>
inline void swap(array<allocator_type> &lhd,
                 array<allocator_type> &rhd) noexcept {
  lhd.swap(rhd);
}
 
}  // namespace metall::json
 
#endif  // METALL_JSON_ARRAY_HPP