ArrayForwarder.h

Go to the documentation of this file.

/*
 * ArrayForwarder.h
 *
 *  Created on: Feb 8, 2019
 *      Author: Nicola Mori
 */
 
#ifndef HERD_ARRAYFORWARDER_H_
#define HERD_ARRAYFORWARDER_H_
 
// C/C++ headers
#include <array>
#include <type_traits>
 
namespace Herd {
 
// Define constexpr macro for C++17 for non-gnu implementations of the standard library
#ifndef _GLIBCXX17_CONSTEXPR
#if __cplusplus >= 201703L
#define _GLIBCXX17_CONSTEXPR constexpr
#else
#define _GLIBCXX17_CONSTEXPR
#endif
#endif
 
template <typename _Tp, std::size_t _Nm> struct ArrayForwarder;
 
// Array comparisons.
template <typename _Tp, std::size_t _Nm>
inline bool operator==(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two) {
  return std::equal(__one._content.begin(), __one._content.end(), __two._content.begin());
}
 
template <typename _Tp, std::size_t _Nm>
inline bool operator!=(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two) {
  return !(__one == __two);
}
 
template <typename _Tp, std::size_t _Nm>
inline bool operator<(const ArrayForwarder<_Tp, _Nm> &__a, const ArrayForwarder<_Tp, _Nm> &__b) {
  return std::lexicographical_compare(__a._content.begin(), __a._content.end(), __b._content.begin(),
                                      __b._content.end());
}
 
template <typename _Tp, std::size_t _Nm>
inline bool operator>(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two) {
  return __two < __one;
}
 
template <typename _Tp, std::size_t _Nm>
inline bool operator<=(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two) {
  return !(__one > __two);
}
 
template <typename _Tp, std::size_t _Nm>
inline bool operator>=(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two) {
  return !(__one < __two);
}
 
template <typename _Tp, std::size_t _Nm> struct ArrayForwarder {
 
  typedef _Tp value_type;
  typedef value_type *pointer;
  typedef const value_type *const_pointer;
  typedef value_type &reference;
  typedef const value_type &const_reference;
  typedef value_type *iterator;
  typedef const value_type *const_iterator;
  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;
  typedef std::reverse_iterator<iterator> reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
  constexpr ArrayForwarder() = default;
 
  constexpr ArrayForwarder(std::array<_Tp, _Nm> arr) { _content = std::move(arr); }
 
  // No explicit construct/copy/destroy for aggregate type.
 
  // DR 776.
  void fill(const value_type &__u) { _content.fill(__u); };
 
#if __cplusplus >= 201703L
  void swap(ArrayForwarder &__other) noexcept(std::__is_nothrow_swappable<_Tp>::value) {
    _content.swap(__other._content);
  }
#else
  void swap(ArrayForwarder &__other) noexcept(noexcept(std::swap(std::declval<_Tp &>(), std::declval<_Tp &>()))) {
    std::swap_ranges(_content.begin(), _content.end(), __other._content.begin());
  }
#endif
 
  // Iterators.
  _GLIBCXX17_CONSTEXPR iterator begin() noexcept { return _content.begin(); }
 
  _GLIBCXX17_CONSTEXPR const_iterator begin() const noexcept { return _content.begin(); }
 
  _GLIBCXX17_CONSTEXPR iterator end() noexcept { return _content.end(); }
 
  _GLIBCXX17_CONSTEXPR const_iterator end() const noexcept { return _content.end(); }
 
  _GLIBCXX17_CONSTEXPR reverse_iterator rbegin() noexcept { return _content.rbegin(); }
 
  _GLIBCXX17_CONSTEXPR const_reverse_iterator rbegin() const noexcept { return _content.rbegin(); }
 
  _GLIBCXX17_CONSTEXPR reverse_iterator rend() noexcept { return _content.rend(); }
 
  _GLIBCXX17_CONSTEXPR const_reverse_iterator rend() const noexcept { return _content.rend(); }
 
  _GLIBCXX17_CONSTEXPR const_iterator cbegin() const noexcept { return _content.cbegin(); }
 
  _GLIBCXX17_CONSTEXPR const_iterator cend() const noexcept { return _content.cend(); }
 
  _GLIBCXX17_CONSTEXPR const_reverse_iterator crbegin() const noexcept { return _content.crbegin(); }
 
  _GLIBCXX17_CONSTEXPR const_reverse_iterator crend() const noexcept { return _content.crend(); }
 
  // Capacity.
  [[nodiscard]] constexpr size_type size() const noexcept { return _content.size(); }
 
  [[nodiscard]] constexpr size_type max_size() const noexcept { return _content.size(); }
 
  [[nodiscard]] constexpr bool empty() const noexcept { return _content.empty(); }
 
  // Element access.
  _GLIBCXX17_CONSTEXPR reference operator[](size_type __n) noexcept { return _content.operator[](__n); }
 
  constexpr const_reference operator[](size_type __n) const noexcept { return _content.operator[](__n); }
 
  _GLIBCXX17_CONSTEXPR reference at(size_type __n) { return _content.at(__n); }
 
  constexpr const_reference at(size_type __n) const { return _content.at(__n); }
 
  _GLIBCXX17_CONSTEXPR reference front() noexcept { return _content.front(); }
 
  constexpr const_reference front() const noexcept { return _content.front(); }
 
  _GLIBCXX17_CONSTEXPR reference back() noexcept { return _content.back(); }
 
  constexpr const_reference back() const noexcept { return _content.back(); }
 
  _GLIBCXX17_CONSTEXPR pointer data() noexcept { return _content.data(); }
 
  _GLIBCXX17_CONSTEXPR const_pointer data() const noexcept { return _content.data(); }
 
private:
  std::array<_Tp, _Nm> _content{};
  friend bool operator==<>(const ArrayForwarder<_Tp, _Nm> &, const ArrayForwarder<_Tp, _Nm> &);
  friend bool operator!=<>(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two);
  // clang-format off
  friend bool operator< <>(const ArrayForwarder<_Tp, _Nm> &__a, const ArrayForwarder<_Tp, _Nm> &__b);
  // clang-format on
  friend bool operator><>(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two);
  friend bool operator<=<>(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two);
  friend bool operator>=<>(const ArrayForwarder<_Tp, _Nm> &__one, const ArrayForwarder<_Tp, _Nm> &__two);
};
 
// Specialized algorithms.
template <typename _Tp, std::size_t _Nm>
inline
#if __cplusplus > 201402L // c++1z
    // Constrained free swap overload, see p0185r1
    typename std::enable_if<std::__is_swappable<_Tp>::value>::type
#else
    void
#endif
    swap(ArrayForwarder<_Tp, _Nm> &__one, ArrayForwarder<_Tp, _Nm> &__two) noexcept(noexcept(__one.swap(__two))) {
  __one.swap(__two);
}
 
#if __cplusplus > 201402L // c++1z
template <typename _Tp, std::size_t _Nm>
typename std::enable_if<!std::__is_swappable<_Tp>::value>::type swap(ArrayForwarder<_Tp, _Nm> &,
                                                                     ArrayForwarder<_Tp, _Nm> &) = delete;
#endif
 
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp &get(ArrayForwarder<_Tp, _Nm> &__arr) noexcept {
  return std::get<_Int, _Tp, _Nm>(__arr._content);
}
 
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp &&get(ArrayForwarder<_Tp, _Nm> &&__arr) noexcept {
  return std::get<_Int, _Tp, _Nm>(std::move(__arr._content));
}
 
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr const _Tp &get(const ArrayForwarder<_Tp, _Nm> &__arr) noexcept {
  return std::get<_Int, _Tp, _Nm>(__arr._content);
}
 
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr const _Tp &&get(const ArrayForwarder<_Tp, _Nm> &&__arr) noexcept {
  return std::get<_Int, _Tp, _Nm>(std::move(__arr._content));
}
 
} // namespace Herd
#endif /* HERD_ARRAYFORWARDER_H_ */