Cyclic Array
(src/data_structure/cyclic.hpp)

View this file on GitHub
Last update: 2022-04-06 15:02:09+09:00
Include: #include "src/data_structure/cyclic.hpp"

Depends on

SFINAE (src/utils/sfinae.hpp)

Code

#pragma once

/**
 * @file cyclic.hpp
 * @brief Cyclic Array
 */

#include <vector>

#include "src/utils/sfinae.hpp"

namespace workspace {

/**
 * @brief Cyclic array.
 */
template <class _Tp> class cyclic : public std::vector<_Tp> {
 public:
  using container_type = std::vector<_Tp>;

  using typename container_type::difference_type;

  using container_type::vector;

  cyclic(std::initializer_list<_Tp> __x) noexcept : container_type(__x) {}

  template <class _Index> decltype(auto) operator[](_Index __i) noexcept {
    return container_type::operator[](locate(__i));
  }
  template <class _Index> decltype(auto) operator[](_Index __i) const noexcept {
    return container_type::operator[](locate(__i));
  }

  template <class _Index> decltype(auto) at(_Index __i) {
    return container_type::at(locate(__i));
  }
  template <class _Index> decltype(auto) at(_Index __i) const {
    return container_type::at(locate(__i));
  }

 private:
  template <class _Index>
  std::enable_if_t<is_integral_ext<_Index>::value,
                   typename container_type::size_type>
  locate(_Index __i) const noexcept {
    return (__i %= (_Index)container_type::size()) < 0
               ? __i + container_type::size()
               : __i;
  }
};

template <class _Tp>
cyclic(typename cyclic<_Tp>::size_type, const _Tp &) -> cyclic<_Tp>;

template <class _InputIterator>
cyclic(_InputIterator, _InputIterator)
    -> cyclic<typename std::iterator_traits<_InputIterator>::value_type>;

}  // namespace workspace

#line 2 "src/data_structure/cyclic.hpp"

/**
 * @file cyclic.hpp
 * @brief Cyclic Array
 */

#include <vector>

#line 2 "src/utils/sfinae.hpp"

/**
 * @file sfinae.hpp
 * @brief SFINAE
 */

#include <cstdint>
#include <iterator>
#include <type_traits>

#ifndef __INT128_DEFINED__

#ifdef __SIZEOF_INT128__
#define __INT128_DEFINED__ 1
#else
#define __INT128_DEFINED__ 0
#endif

#endif

namespace std {

#if __INT128_DEFINED__

template <> struct make_signed<__uint128_t> { using type = __int128_t; };
template <> struct make_signed<__int128_t> { using type = __int128_t; };

template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; };
template <> struct make_unsigned<__int128_t> { using type = __uint128_t; };

template <> struct is_signed<__uint128_t> : std::false_type {};
template <> struct is_signed<__int128_t> : std::true_type {};

template <> struct is_unsigned<__uint128_t> : std::true_type {};
template <> struct is_unsigned<__int128_t> : std::false_type {};

#endif

}  // namespace std

namespace workspace {

template <class Tp, class... Args> struct variadic_front { using type = Tp; };

template <class... Args> struct variadic_back;

template <class Tp> struct variadic_back<Tp> { using type = Tp; };

template <class Tp, class... Args> struct variadic_back<Tp, Args...> {
  using type = typename variadic_back<Args...>::type;
};

template <class type, template <class> class trait>
using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type;

/**
 * @brief Return type of subscripting ( @c [] ) access.
 */
template <class _Tp>
using subscripted_type =
    typename std::decay<decltype(std::declval<_Tp&>()[0])>::type;

template <class Container>
using element_type = typename std::decay<decltype(*std::begin(
    std::declval<Container&>()))>::type;

template <class _Tp, class = void> struct has_begin : std::false_type {};

template <class _Tp>
struct has_begin<
    _Tp, std::__void_t<decltype(std::begin(std::declval<const _Tp&>()))>>
    : std::true_type {
  using type = decltype(std::begin(std::declval<const _Tp&>()));
};

template <class _Tp, class = void> struct has_size : std::false_type {};

template <class _Tp>
struct has_size<_Tp, std::__void_t<decltype(std::size(std::declval<_Tp>()))>>
    : std::true_type {};

template <class _Tp, class = void> struct has_resize : std::false_type {};

template <class _Tp>
struct has_resize<_Tp, std::__void_t<decltype(std::declval<_Tp>().resize(
                           std::declval<size_t>()))>> : std::true_type {};

template <class _Tp, class = void> struct has_mod : std::false_type {};

template <class _Tp>
struct has_mod<_Tp, std::__void_t<decltype(_Tp::mod)>> : std::true_type {};

template <class _Tp, class = void> struct is_integral_ext : std::false_type {};
template <class _Tp>
struct is_integral_ext<
    _Tp, typename std::enable_if<std::is_integral<_Tp>::value>::type>
    : std::true_type {};

#if __INT128_DEFINED__

template <> struct is_integral_ext<__int128_t> : std::true_type {};
template <> struct is_integral_ext<__uint128_t> : std::true_type {};

#endif

#if __cplusplus >= 201402

template <class _Tp>
constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value;

#endif

template <typename _Tp, typename = void> struct multiplicable_uint {
  using type = uint_least32_t;
};
template <typename _Tp>
struct multiplicable_uint<
    _Tp,
    typename std::enable_if<(2 < sizeof(_Tp)) &&
                            (!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> {
  using type = uint_least64_t;
};

#if __INT128_DEFINED__

template <typename _Tp>
struct multiplicable_uint<_Tp,
                          typename std::enable_if<(4 < sizeof(_Tp))>::type> {
  using type = __uint128_t;
};

#endif

template <typename _Tp> struct multiplicable_int {
  using type =
      typename std::make_signed<typename multiplicable_uint<_Tp>::type>::type;
};

template <typename _Tp> struct multiplicable {
  using type = std::conditional_t<
      is_integral_ext<_Tp>::value,
      std::conditional_t<std::is_signed<_Tp>::value,
                         typename multiplicable_int<_Tp>::type,
                         typename multiplicable_uint<_Tp>::type>,
      _Tp>;
};

template <class> struct first_arg { using type = void; };

template <class _R, class _Tp, class... _Args>
struct first_arg<_R(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _R, class _Tp, class... _Args>
struct first_arg<_R (*)(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...) const> {
  using type = _Tp;
};

template <class _Tp, class = void> struct parse_compare : first_arg<_Tp> {};

template <class _Tp>
struct parse_compare<_Tp, std::__void_t<decltype(&_Tp::operator())>>
    : first_arg<decltype(&_Tp::operator())> {};

template <class _Container, class = void> struct get_dimension {
  static constexpr size_t value = 0;
};

template <class _Container>
struct get_dimension<_Container,
                     std::enable_if_t<has_begin<_Container>::value>> {
  static constexpr size_t value =
      1 + get_dimension<typename std::iterator_traits<
              typename has_begin<_Container>::type>::value_type>::value;
};

}  // namespace workspace
#line 11 "src/data_structure/cyclic.hpp"

namespace workspace {

/**
 * @brief Cyclic array.
 */
template <class _Tp> class cyclic : public std::vector<_Tp> {
 public:
  using container_type = std::vector<_Tp>;

  using typename container_type::difference_type;

  using container_type::vector;

  cyclic(std::initializer_list<_Tp> __x) noexcept : container_type(__x) {}

  template <class _Index> decltype(auto) operator[](_Index __i) noexcept {
    return container_type::operator[](locate(__i));
  }
  template <class _Index> decltype(auto) operator[](_Index __i) const noexcept {
    return container_type::operator[](locate(__i));
  }

  template <class _Index> decltype(auto) at(_Index __i) {
    return container_type::at(locate(__i));
  }
  template <class _Index> decltype(auto) at(_Index __i) const {
    return container_type::at(locate(__i));
  }

 private:
  template <class _Index>
  std::enable_if_t<is_integral_ext<_Index>::value,
                   typename container_type::size_type>
  locate(_Index __i) const noexcept {
    return (__i %= (_Index)container_type::size()) < 0
               ? __i + container_type::size()
               : __i;
  }
};

template <class _Tp>
cyclic(typename cyclic<_Tp>::size_type, const _Tp &) -> cyclic<_Tp>;

template <class _InputIterator>
cyclic(_InputIterator, _InputIterator)
    -> cyclic<typename std::iterator_traits<_InputIterator>::value_type>;

}  // namespace workspace

Cyclic Array (src/data_structure/cyclic.hpp)

Depends on

Code

Cyclic Array
(src/data_structure/cyclic.hpp)