Prune unneeded stubs

Author: jeongsoolee09

cpp/common/test/includes/standard-library/memory.h

@@ -129,368 +129,42 @@ class bad_alloc : public exception {
   virtual const char *what() const noexcept;
 };
 
-  template <typename T1>
-  struct allocator {
-    using value_type = T1;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-    using propagate_on_container_move_assignment = std::true_type;
-    using is_always_equal = std::true_type;
+template <typename T1> struct allocator {
+  using value_type = T1;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
 
-    using pointer = T1*; // deprecated since C++17
-    using const_pointer = const T1*; // deprecated since C++17
-    using reference = T1&; // deprecated since C++17
-    using const_reference = const T1&; // deprecated since C++17
+  constexpr allocator() noexcept = default;
+  constexpr allocator(const allocator &) noexcept = default;
 
-    // deprecated since C++17
-    template <typename T2>
-    struct rebind {
-      using other = allocator<T2>;
-    };
+  template <typename T2> constexpr allocator(const allocator<T2> &) noexcept;
 
-    constexpr allocator() noexcept = default;
-    constexpr allocator(const allocator&) noexcept = default;
+  ~allocator() = default;
 
-    template <typename T2>
-    constexpr allocator(const allocator<T2>&) noexcept;
-
-    ~allocator() = default;
-
-    allocator& operator=(const allocator&) = default;
-
-    T1* allocate(std::size_t);
-    void deallocate(T1*, std::size_t);
-
-    T1* address(T1&) const noexcept; // deprecated since C++17
-    const T1* address(const T1&) const noexcept; // deprecated since C++17
-    std::size_t max_size() const noexcept; // deprecated since C++17
-
-    // deprecated since C++17
-    template <typename T2, typename... T3>
-    void construct(T2*, T3&&...);
-
-    // deprecated since C++17
-    template <typename T2>
-    void destroy(T2*);
-  };
-
-  // deprecated since C++17
-  template <>
-  struct allocator<void> {
-    using value_type = void;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-    using propagate_on_container_move_assignment = std::true_type;
-    using is_always_equal = std::true_type;
-
-    // deprecated since C++17
-    template <typename T1>
-    struct rebind {
-      using other = allocator<T1>;
-    };
-  };
-
-  template <typename T1, typename T2>
-  constexpr bool operator==(const allocator<T1>&, const allocator<T2>&) noexcept;
-
-  template <typename T1, typename T2>
-  constexpr bool operator!=(const allocator<T1>&, const allocator<T2>&) noexcept;
-
-  namespace detail {
-
-    template <typename T1, typename = void>
-    struct has_pointer : std::false_type {};
-
-    template <typename T1>
-    struct has_pointer<T1, std::void_t<typename T1::pointer>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_const_pointer : std::false_type {};
-
-    template <typename T1>
-    struct has_const_pointer<T1, std::void_t<typename T1::const_pointer>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_void_pointer : std::false_type {};
-
-    template <typename T1>
-    struct has_void_pointer<T1, std::void_t<typename T1::void_pointer>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_const_void_pointer : std::false_type {};
-
-    template <typename T1>
-    struct has_const_void_pointer<T1, std::void_t<typename T1::const_void_pointer>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_difference_type : std::false_type {};
-
-    template <typename T1>
-    struct has_difference_type<T1, std::void_t<typename T1::difference_type>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_size_type : std::false_type {};
-
-    template <typename T1>
-    struct has_size_type<T1, std::void_t<typename T1::size_type>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_propagate_on_container_copy_assignment : std::false_type {};
-
-    template <typename T1>
-    struct has_propagate_on_container_copy_assignment<T1,
-                                                      std::void_t<typename T1::propagate_on_container_copy_assignment>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_propagate_on_container_move_assignment : std::false_type {};
-
-    template <typename T1>
-    struct has_propagate_on_container_move_assignment<T1,
-                                                      std::void_t<typename T1::propagate_on_container_move_assignment>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_propagate_on_container_swap : std::false_type {};
-
-    template <typename T1>
-    struct has_propagate_on_container_swap<T1,
-                                           std::void_t<typename T1::propagate_on_container_swap>> : std::true_type {};
-
-    template <typename T1, typename = void>
-    struct has_is_always_equal : std::false_type {};
-
-    template <typename T1>
-    struct has_is_always_equal<T1, std::void_t<typename T1::is_always_equal>> : std::true_type {};
-
-    template <typename T1, typename T2, typename = void>
-    struct has_rebind_alloc : std::false_type {};
-
-    template <typename T1, typename T2>
-    struct has_rebind_alloc<T1, T2,
-                            std::void_t<typename T1::template rebind<T2>::other>> : std::true_type {};
-
-    template <typename T1, typename T2, bool = has_rebind_alloc<T1, T2>::value>
-    struct rebind_alloc_helper;
-
-    template <typename T1, typename T2>
-    struct rebind_alloc_helper<T1, T2, true> {
-      using type = typename T1::template rebind<T2>::other;
-    };
-
-    template <template <typename, typename...> class T1, typename T2, typename T3, typename... T4>
-    struct rebind_alloc_helper<T1<T2, T4...>, T3, false> {
-      using type = T1<T3, T4...>;
-    };
-
-  }
-
-  template <typename T1>
-  struct allocator_traits {
-    using allocator_type = T1;
-    using value_type = typename T1::value_type;
-
-    using pointer = typename std::conditional<
-      detail::has_pointer<T1>::value,
-      typename T1::pointer,
-      value_type*
-      >::type;
-
-    using const_pointer = typename std::conditional<
-      detail::has_const_pointer<T1>::value,
-      typename T1::const_pointer,
-      typename std::pointer_traits<pointer>::template rebind<const value_type>
-      >::type;
-
-    using void_pointer = typename std::conditional<
-      detail::has_void_pointer<T1>::value,
-      typename T1::void_pointer,
-      typename std::pointer_traits<pointer>::template rebind<void>
-      >::type;
-
-    using const_void_pointer = typename std::conditional<
-      detail::has_const_void_pointer<T1>::value,
-      typename T1::const_void_pointer,
-      typename std::pointer_traits<pointer>::template rebind<const void>
-      >::type;
-
-    using difference_type = typename std::conditional<
-      detail::has_difference_type<T1>::value,
-      typename T1::difference_type,
-      typename std::pointer_traits<pointer>::difference_type
-      >::type;
-
-    using size_type = typename std::conditional<
-      detail::has_size_type<T1>::value,
-      typename T1::size_type,
-      typename std::make_unsigned<difference_type>::type
-      >::type;
-
-    using propagate_on_container_copy_assignment = typename std::conditional<
-      detail::has_propagate_on_container_copy_assignment<T1>::value,
-      typename T1::propagate_on_container_copy_assignment,
-      std::false_type
-      >::type;
-
-    using propagate_on_container_move_assignment = typename std::conditional<
-      detail::has_propagate_on_container_move_assignment<T1>::value,
-      typename T1::propagate_on_container_move_assignment,
-      std::false_type
-      >::type;
-
-    using propagate_on_container_swap = typename std::conditional<
-      detail::has_propagate_on_container_swap<T1>::value,
-      typename T1::propagate_on_container_swap,
-      std::false_type
-      >::type;
-
-    using is_always_equal = typename std::conditional<
-      detail::has_is_always_equal<T1>::value,
-      typename T1::is_always_equal,
-      typename std::is_empty<T1>::type
-      >::type;
-
-    template <typename T2>
-    using rebind_alloc = typename detail::rebind_alloc_helper<T1, T2>::type;
-
-    template <typename T2>
-    using rebind_traits = allocator_traits<rebind_alloc<T2>>;
-
-    static pointer allocate(T1&, size_type);
-    static pointer allocate(T1&, size_type, const_void_pointer);
-    static void deallocate(T1&, pointer, size_type);
-
-    template <typename T2, typename... T3>
-    static void construct(T1&, T2*, T3&&...);
-
-    template <typename T2>
-    static void destroy(T1&, T2*);
-
-    static size_type max_size(const T1&) noexcept;
-    static T1 select_on_container_copy_construction(const T1&);
-  };
-
-  template <typename T1, typename... T2>
-  class scoped_allocator_adaptor : public T1 {
-  public:
-    using outer_allocator_type = T1;
-    using inner_allocator_type = typename std::conditional<
-      sizeof...(T2) == 0,
-      scoped_allocator_adaptor<T1>,
-      scoped_allocator_adaptor<T2...>
-      >::type;
-
-    using value_type = typename allocator_traits<T1>::value_type;
-    using size_type = typename allocator_traits<T1>::size_type;
-    using difference_type = typename allocator_traits<T1>::difference_type;
-    using pointer = typename allocator_traits<T1>::pointer;
-    using const_pointer = typename allocator_traits<T1>::const_pointer;
-    using void_pointer = typename allocator_traits<T1>::void_pointer;
-    using const_void_pointer = typename allocator_traits<T1>::const_void_pointer;
-
-    using propagate_on_container_copy_assignment = typename std::conditional<
-      allocator_traits<T1>::propagate_on_container_copy_assignment::value ||
-      (allocator_traits<T2>::propagate_on_container_copy_assignment::value || ...),
-      std::true_type,
-      std::false_type
-      >::type;
-
-    using propagate_on_container_move_assignment = typename std::conditional<
-      allocator_traits<T1>::propagate_on_container_move_assignment::value ||
-      (allocator_traits<T2>::propagate_on_container_move_assignment::value || ...),
-      std::true_type,
-      std::false_type
-      >::type;
-
-    using propagate_on_container_swap = typename std::conditional<
-      allocator_traits<T1>::propagate_on_container_swap::value ||
-      (allocator_traits<T2>::propagate_on_container_swap::value || ...),
-      std::true_type,
-      std::false_type
-      >::type;
-
-    using is_always_equal = typename std::conditional<
-      allocator_traits<T1>::is_always_equal::value &&
-      (allocator_traits<T2>::is_always_equal::value && ...),
-      std::true_type,
-      std::false_type
-      >::type;
-
-    template <typename T3>
-    struct rebind {
-      using other = scoped_allocator_adaptor<
-        typename allocator_traits<T1>::template rebind_alloc<T3>,
-        T2...
-        >;
-    };
-
-    scoped_allocator_adaptor();
-
-    template <typename T3>
-    scoped_allocator_adaptor(T3&&, const T2&...) noexcept;
-
-    scoped_allocator_adaptor(const scoped_allocator_adaptor&) noexcept;
-    scoped_allocator_adaptor(scoped_allocator_adaptor&&) noexcept;
-
-    template <typename T3, typename... T4>
-    scoped_allocator_adaptor(const scoped_allocator_adaptor<T3, T4...>&) noexcept;
-
-    template <typename T3, typename... T4>
-    scoped_allocator_adaptor(scoped_allocator_adaptor<T3, T4...>&&) noexcept;
-
-    scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
-    scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
-
-    ~scoped_allocator_adaptor() = default;
-
-    inner_allocator_type& inner_allocator() noexcept;
-    const inner_allocator_type& inner_allocator() const noexcept;
-
-    outer_allocator_type& outer_allocator() noexcept;
-    const outer_allocator_type& outer_allocator() const noexcept;
-
-    pointer allocate(size_type);
-    pointer allocate(size_type, const_void_pointer);
-    void deallocate(pointer, size_type);
-
-    size_type max_size() const;
-
-    template <typename T3, typename... T4>
-    void construct(T3*, T4&&...);
-
-    template <typename T3, typename T4, typename... T5, typename... T6>
-    void construct(std::pair<T3, T4>*,
-                   std::piecewise_construct_t,
-                   std::tuple<T5...>,
-                   std::tuple<T6...>);
-
-    template <typename T3, typename T4>
-    void construct(std::pair<T3, T4>*);
-
-    template <typename T3, typename T4, typename T5, typename T6>
-    void construct(std::pair<T3, T4>*, T5&&, T6&&);
-
-    template <typename T3, typename T4, typename T5, typename T6>
-    void construct(std::pair<T3, T4>*, const std::pair<T5, T6>&);
-
-    template <typename T3, typename T4, typename T5, typename T6>
-    void construct(std::pair<T3, T4>*, std::pair<T5, T6>&&);
-
-    template <typename T3>
-    void destroy(T3*);
-
-    scoped_allocator_adaptor select_on_container_copy_construction() const;
-
-  private:
-    inner_allocator_type inner_;
-  };
-
-  template <typename T1, typename... T2, typename T3, typename... T4>
-  bool operator==(const scoped_allocator_adaptor<T1, T2...>&,
-                  const scoped_allocator_adaptor<T3, T4...>&) noexcept;
+  T1 *allocate(std::size_t);
+  void deallocate(T1 *, std::size_t);
+};
 
-  template <typename T1, typename... T2, typename T3, typename... T4>
-  bool operator!=(const scoped_allocator_adaptor<T1, T2...>&,
-                  const scoped_allocator_adaptor<T3, T4...>&) noexcept;
+template <> struct allocator<void> {
+  using value_type = void;
+};
 
+template <typename T1> struct allocator_traits {
+  using allocator_type = T1;
+  using value_type = typename T1::value_type;
+  using pointer = value_type *;
+  using const_pointer = const value_type *;
+  using void_pointer = void *;
+  using const_void_pointer = const void *;
+  using size_type = typename T1::size_type;
+  using difference_type = typename T1::difference_type;
+
+  template <typename T2> using rebind_alloc = allocator<T2>;
+
+  static pointer allocate(T1 &, size_type);
+  static pointer allocate(T1 &, size_type, const_void_pointer);
+  static void deallocate(T1 &, pointer, size_type);
+};
 } // namespace std
 
 #endif // _GHLIBCPP_MEMORY