diff options
author | Jonathan Wakely <jwakely.gcc@gmail.com> | 2011-05-28 13:27:43 +0000 |
---|---|---|
committer | Jonathan Wakely <redi@gcc.gnu.org> | 2011-05-28 14:27:43 +0100 |
commit | 45ba8f9f8f6806d4598b41fff8826ecb63a67092 (patch) | |
tree | 3395bb512611d5a4c57824500bd0bd037124d510 /libstdc++-v3 | |
parent | 7ca2afa0c3a41bb26c80fdeffc2cef044c5feec1 (diff) | |
download | gcc-45ba8f9f8f6806d4598b41fff8826ecb63a67092.zip gcc-45ba8f9f8f6806d4598b41fff8826ecb63a67092.tar.gz gcc-45ba8f9f8f6806d4598b41fff8826ecb63a67092.tar.bz2 |
Makefile.am: Add new ptr_traits.h header.
2011-05-28 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/Makefile.am: Add new ptr_traits.h header.
* include/Makefile.in: Regenerate.
* include/bits/ptr_traits.h (pointer_traits): New.
* include/bits/allocator.h (allocator_traits): Add.
* include/ext/array_allocator.h (construct, destroy): Update C++0x
versions.
* include/ext/bitmap_allocator.h (construct, destroy): Likewise.
* include/ext/extptr_allocator.h (construct, destroy): Likewise.
* include/ext/malloc_allocator.h (construct, destroy): Likewise.
* include/ext/mt_allocator.h (construct, destroy): Likewise.
* include/ext/new_allocator.h (construct, destroy): Likewise.
* include/ext/pool_allocator.h (construct, destroy): Likewise.
* include/ext/throw_allocator.h (construct, destroy): Likewise.
* testsuite/20_util/allocator_traits/requirements/typedefs.cc: New.
* testsuite/20_util/allocator_traits/requirements/
explicit_instantiation.cc: New.
* testsuite/20_util/allocator_traits/members/max_size.cc: New.
* testsuite/20_util/allocator_traits/members/select.cc: New.
* testsuite/20_util/allocator_traits/members/construct.cc: New.
* testsuite/20_util/allocator_traits/members/allocate_hint.cc: New.
* testsuite/20_util/allocator_traits/members/destroy.cc: New.
* testsuite/20_util/pointer_traits/requirements/typedefs.cc: New.
* testsuite/20_util/pointer_traits/requirements/
explicit_instantiation.cc: New.
From-SVN: r174380
Diffstat (limited to 'libstdc++-v3')
22 files changed, 1290 insertions, 59 deletions
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 71b9ade..85b55b5 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,32 @@ 2011-05-28 Jonathan Wakely <jwakely.gcc@gmail.com> + * include/Makefile.am: Add new ptr_traits.h header. + * include/Makefile.in: Regenerate. + * include/bits/ptr_traits.h (pointer_traits): New. + * include/bits/allocator.h (allocator_traits): Add. + * include/ext/array_allocator.h (construct, destroy): Update C++0x + versions. + * include/ext/bitmap_allocator.h (construct, destroy): Likewise. + * include/ext/extptr_allocator.h (construct, destroy): Likewise. + * include/ext/malloc_allocator.h (construct, destroy): Likewise. + * include/ext/mt_allocator.h (construct, destroy): Likewise. + * include/ext/new_allocator.h (construct, destroy): Likewise. + * include/ext/pool_allocator.h (construct, destroy): Likewise. + * include/ext/throw_allocator.h (construct, destroy): Likewise. + * testsuite/20_util/allocator_traits/requirements/typedefs.cc: New. + * testsuite/20_util/allocator_traits/requirements/ + explicit_instantiation.cc: New. + * testsuite/20_util/allocator_traits/members/max_size.cc: New. + * testsuite/20_util/allocator_traits/members/select.cc: New. + * testsuite/20_util/allocator_traits/members/construct.cc: New. + * testsuite/20_util/allocator_traits/members/allocate_hint.cc: New. + * testsuite/20_util/allocator_traits/members/destroy.cc: New. + * testsuite/20_util/pointer_traits/requirements/typedefs.cc: New. + * testsuite/20_util/pointer_traits/requirements/ + explicit_instantiation.cc: New. + +2011-05-28 Jonathan Wakely <jwakely.gcc@gmail.com> + * include/std/future (launch): Update enumerators and define operators required for bitmask type. Remove trailing whitespace. * src/future.cc: Remove trailing whitespace. diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 73b8589..d836783 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -119,6 +119,7 @@ bits_headers = \ ${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream_insert.h \ ${bits_srcdir}/postypes.h \ + ${bits_srcdir}/ptr_traits.h \ ${bits_srcdir}/random.h \ ${bits_srcdir}/random.tcc \ ${bits_srcdir}/range_access.h \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index aa90813..fedba33 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -370,6 +370,7 @@ bits_headers = \ ${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream_insert.h \ ${bits_srcdir}/postypes.h \ + ${bits_srcdir}/ptr_traits.h \ ${bits_srcdir}/random.h \ ${bits_srcdir}/random.tcc \ ${bits_srcdir}/range_access.h \ diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h index 9d01a60..37c6a59 100644 --- a/libstdc++-v3/include/bits/allocator.h +++ b/libstdc++-v3/include/bits/allocator.h @@ -48,7 +48,9 @@ #include <bits/c++allocator.h> #ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <bits/ptr_traits.h> #include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE +#include <limits> #endif namespace std _GLIBCXX_VISIBILITY(default) @@ -85,8 +87,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * @brief The @a standard allocator, as per [20.4]. * @ingroup allocators * - * Further details: - * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html + * for further details. */ template<typename _Tp> class allocator: public __glibcxx_base_allocator<_Tp> @@ -185,7 +187,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // A very basic implementation for now. In general we have to wait for // the availability of the infrastructure described in N2983: we should // try when either T has a move constructor which cannot throw or T is - // CopyContructible. + // CopyConstructible. // NB: This code doesn't properly belong here, we should find a more // suited place common to std::vector and std::deque. template<typename _Tp, @@ -231,6 +233,404 @@ _GLIBCXX_HAS_NESTED_TYPE(allocator_type) __uses_allocator_helper<_Tp, _Alloc>::value> { }; + template<typename _Alloc, typename _Tp> + class __alloctr_rebind_helper + { + template<typename _Alloc2, typename _Tp2> + static constexpr bool + _S_chk(typename _Alloc2::template rebind<_Tp2>::other*) + { return true; } + + template<typename, typename> + static constexpr bool + _S_chk(...) + { return false; } + + public: + static const bool __value = _S_chk<_Alloc, _Tp>(nullptr); + }; + + template<typename _Alloc, typename _Tp, + bool = __alloctr_rebind_helper<_Alloc, _Tp>::__value> + struct __alloctr_rebind; + + template<typename _Alloc, typename _Tp> + struct __alloctr_rebind<_Alloc, _Tp, true> + { + typedef typename _Alloc::template rebind<_Tp>::other __type; + }; + + template<template<typename, typename...> class _Alloc, typename _Tp, + typename _Up, typename... _Args> + struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false> + { + typedef _Alloc<_Tp, _Args...> __type; + }; + + /** + * @brief Uniform interface to all allocator types. + * @ingroup allocators + */ + template<typename _Alloc> + struct allocator_traits + { + /// The allocator type + typedef _Alloc allocator_type; + /// The allocated type + typedef typename _Alloc::value_type value_type; + +#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE, _ALT) \ + private: \ + template<typename _Tp> \ + static typename _Tp::_NTYPE _S_##_NTYPE##_helper(_Tp*); \ + static _ALT _S_##_NTYPE##_helper(...); \ + typedef decltype(_S_##_NTYPE##_helper((_Alloc*)0)) __##_NTYPE; \ + public: + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(pointer, value_type*) + + /** + * @brief The allocator's pointer type. + * + * @c Alloc::pointer if that type exists, otherwise @c value_type* + */ + typedef __pointer pointer; + +// TODO: Use pointer_traits::rebind alias template. + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(const_pointer, + typename pointer_traits<pointer>::template __rebind<const value_type>::__type) + + /** + * @brief The allocator's const pointer type. + * + * @c Alloc::const_pointer if that type exists, otherwise + * <tt> pointer_traits<pointer>::rebind<const value_type> </tt> + */ + typedef __const_pointer const_pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(void_pointer, + typename pointer_traits<pointer>::template __rebind<void>::__type) + + /** + * @brief The allocator's void pointer type. + * + * @c Alloc::void_pointer if that type exists, otherwise + * <tt> pointer_traits<pointer>::rebind<void> </tt> + */ + typedef __void_pointer void_pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(const_void_pointer, + typename pointer_traits<pointer>::template __rebind<const void>::__type) + + /** + * @brief The allocator's const void pointer type. + * + * @c Alloc::const_void_pointer if that type exists, otherwise + * <tt> pointer_traits<pointer>::rebind<const void> </tt> + */ + typedef __const_void_pointer const_void_pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(difference_type, + typename pointer_traits<pointer>::difference_type) + + /** + * @brief The allocator's difference type + * + * @c Alloc::difference_type if that type exists, otherwise + * <tt> pointer_traits<pointer>::difference_type </tt> + */ + typedef __difference_type difference_type; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(size_type, + typename make_unsigned<difference_type>::type) + + /** + * @brief The allocator's size type + * + * @c Alloc::size_type if that type exists, otherwise + * <tt> make_unsigned<difference_type>::type </tt> + */ + typedef __size_type size_type; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_copy_assignment, + false_type) + + /** + * @brief How the allocator is propagated on copy assignment + * + * @c Alloc::propagate_on_container_copy_assignment if that type exists, + * otherwise @c false_type + */ + typedef __propagate_on_container_copy_assignment + propagate_on_container_copy_assignment; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_move_assignment, + false_type) + + /** + * @brief How the allocator is propagated on move assignment + * + * @c Alloc::propagate_on_container_move_assignment if that type exists, + * otherwise @c false_type + */ + typedef __propagate_on_container_move_assignment + propagate_on_container_move_assignment; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_swap, + false_type) + + /** + * @brief How the allocator is propagated on swap + * + * @c Alloc::propagate_on_container_swap if that type exists, + * otherwise @c false_type + */ + typedef __propagate_on_container_swap propagate_on_container_swap; + +#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE + + /* TODO: use template alias + template<typename _Tp> + using rebind_alloc = __alloctr_rebind<_Alloc, _Tp>::__type; + template<typename _Tp> + using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; + */ + template<typename _Tp> + struct __rebind_alloc + { + typedef typename __alloctr_rebind<_Alloc, _Tp>::__type __type; + }; + + template<typename _Tp> + struct __rebind_traits + { + typedef allocator_traits<typename __rebind_alloc<_Tp>::__type> __type; + }; + + private: + template<typename _Alloc2> + struct __allocate_helper + { + template<typename _Alloc3, + typename = decltype(std::declval<_Alloc3*>()->allocate( + std::declval<size_type>(), + std::declval<const_void_pointer>()))> + static true_type __test(int); + + template<typename> + static false_type __test(...); + + typedef decltype(__test<_Alloc>(0)) type; + static const bool value = type::value; + }; + + template<typename _Alloc2> + static typename + enable_if<__allocate_helper<_Alloc2>::value, pointer>::type + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint) + { return __a.allocate(__n, __hint); } + + template<typename _Alloc2> + static typename + enable_if<!__allocate_helper<_Alloc2>::value, pointer>::type + _S_allocate(_Alloc2& __a, size_type __n, ...) + { return __a.allocate(__n); } + + template<typename _Tp, typename... _Args> + struct __construct_helper + { + template<typename _Alloc2, + typename = decltype(std::declval<_Alloc2*>()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template<typename> + static false_type __test(...); + + typedef decltype(__test<_Alloc>(0)) type; + static const bool value = type::value; + }; + + template<typename _Tp, typename... _Args> + static typename + enable_if<__construct_helper<_Tp, _Args...>::value, void>::type + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template<typename _Tp, typename... _Args> + static typename + enable_if<!__construct_helper<_Tp, _Args...>::value, void>::type + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); } + + template<typename _Tp> + struct __destroy_helper + { + template<typename _Alloc2, + typename = decltype(std::declval<_Alloc2*>()->destroy( + std::declval<_Tp*>()))> + static true_type __test(int); + + template<typename> + static false_type __test(...); + + typedef decltype(__test<_Alloc>(0)) type; + static const bool value = type::value; + }; + + template<typename _Tp> + static typename enable_if<__destroy_helper<_Tp>::value, void>::type + _S_destroy(_Alloc& __a, _Tp* __p) + { __a.destroy(__p); } + + template<typename _Tp> + static typename enable_if<!__destroy_helper<_Tp>::value, void>::type + _S_destroy(_Alloc&, _Tp* __p) + { __p->~_Tp(); } + + template<typename _Alloc2> + struct __maxsize_helper + { + template<typename _Alloc3, + typename = decltype(std::declval<_Alloc3*>()->max_size())> + static true_type __test(int); + + template<typename> + static false_type __test(...); + + typedef decltype(__test<_Alloc2>(0)) type; + static const bool value = type::value; + }; + + template<typename _Alloc2> + static typename + enable_if<__maxsize_helper<_Alloc2>::value, size_type>::type + _S_max_size(_Alloc2& __a) + { return __a.max_size(); } + + template<typename _Alloc2> + static typename + enable_if<!__maxsize_helper<_Alloc2>::value, size_type>::type + _S_max_size(_Alloc2&) + { return numeric_limits<size_type>::max(); } + + template<typename _Alloc2> + struct __select_helper + { + template<typename _Alloc3, typename + = decltype(std::declval<_Alloc3*>() + ->select_on_container_copy_construction())> + static true_type __test(int); + + template<typename> + static false_type __test(...); + + typedef decltype(__test<_Alloc2>(0)) type; + static const bool value = type::value; + }; + template<typename _Alloc2> + static typename + enable_if<__select_helper<_Alloc2>::value, _Alloc2>::type + _S_select(_Alloc2& __a) + { return __a.select_on_container_copy_construction(); } + + template<typename _Alloc2> + static typename + enable_if<!__select_helper<_Alloc2>::value, _Alloc2>::type + _S_select(_Alloc2& __a) + { return __a; } + + public: + + /** + * @brief Allocate memory. + * @param a An allocator. + * @param n The number of objects to allocate space for. + * + * Calls @c a.allocate(n) + */ + static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } + + /** + * @brief Allocate memory. + * @param a An allocator. + * @param n The number of objects to allocate space for. + * @param hint Aid to locality. + * @return Memory of suitable size and alignment for @a n objects + * of type @c value_type + * + * Returns <tt> a.allocate(n, hint) </tt> if that expression is + * well-formed, otherwise returns @c a.allocate(n) + */ + static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint); } + + /** + * @brief Deallocate memory. + * @param a An allocator. + * @param p Pointer to the memory to deallocate. + * @param n The number of objects space was allocated for. + * + * Calls <tt> a.deallocate(p, n) </tt> + */ + static void deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } + + /** + * @brief Construct an object of type @a Tp + * @param a An allocator. + * @param p Pointer to memory of suitable size and alignment for Tp + * @param args Constructor arguments. + * + * Calls <tt> a.construct(p, std::forward<Args>(args)...) </tt> + * if that expression is well-formed, otherwise uses placement-new + * to construct an object of type @a Tp at location @a p from the + * arguments @a args... + */ + template<typename _Tp, typename... _Args> + static void construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } + + /** + * @brief Destroy an object of type @a Tp + * @param a An allocator. + * @param p Pointer to the object to destroy + * + * Calls @c a.destroy(p) if that expression is well-formed, + * otherwise calls @c p->~Tp() + */ + template <class _Tp> + static void destroy(_Alloc& __a, _Tp* __p) + { _S_destroy(__a, __p); } + + /** + * @brief The maximum supported allocation size + * @param a An allocator. + * @return @c a.max_size() or @c %numeric_limits<size_type>::max() + * + * Returns @c a.max_size() if that expression is well-formed, + * otherwise returns @c %numeric_limits<size_type>::max() + */ + static size_type max_size(const _Alloc& __a) + { return _S_max_size(__a); } + + /** + * @brief Obtain an allocator to use when copying a container. + * @param rhs An allocator. + * @return @c rhs.select_on_container_copy_construction() or @a rhs + * + * Returns @c rhs.select_on_container_copy_construction() if that + * expression is well-formed, otherwise returns @a rhs + */ + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs); } + }; + #endif _GLIBCXX_END_NAMESPACE_VERSION diff --git a/libstdc++-v3/include/bits/ptr_traits.h b/libstdc++-v3/include/bits/ptr_traits.h new file mode 100644 index 0000000..342db12 --- /dev/null +++ b/libstdc++-v3/include/bits/ptr_traits.h @@ -0,0 +1,222 @@ +// Pointer Traits -*- C++ -*- + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file bits/ptr_traits.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _PTR_TRAITS_H +#define _PTR_TRAITS_H 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + +#include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +_GLIBCXX_HAS_NESTED_TYPE(element_type) +_GLIBCXX_HAS_NESTED_TYPE(difference_type) + + template<typename _Tp, bool = __has_element_type<_Tp>::value> + struct __ptrtr_elt_type; + + template<typename _Tp> + struct __ptrtr_elt_type<_Tp, true> + { + typedef typename _Tp::element_type __type; + }; + + template<template<typename, typename...> class _SomePtr, typename _Tp, + typename... _Args> + struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false> + { + typedef _Tp __type; + }; + + template<typename _Tp, bool = __has_difference_type<_Tp>::value> + struct __ptrtr_diff_type + { + typedef typename _Tp::difference_type __type; + }; + + template<typename _Tp> + struct __ptrtr_diff_type<_Tp, false> + { + typedef ptrdiff_t __type; + }; + + template<typename _Ptr, typename _Up> + class __ptrtr_rebind_helper + { + template<typename _Ptr2, typename _Up2> + static constexpr bool + _S_chk(typename _Ptr2::template rebind<_Up2>*) + { return true; } + + template<typename, typename> + static constexpr bool + _S_chk(...) + { return false; } + + public: + static const bool __value = _S_chk<_Ptr, _Up>(nullptr); + }; + + // hack to use _Tp::__rebind<_Up>::__type instead if that exists + template<typename _Ptr, typename _Up> + class __ptrtr_rebind_helper2 + { + template<typename _Ptr2, typename _Up2> + static constexpr bool + _S_chk(typename _Ptr2::template __rebind<_Up2>::__type*) + { return true; } + + template<typename, typename> + static constexpr bool + _S_chk(...) + { return false; } + + public: + static const bool __value = _S_chk<_Ptr, _Up>(nullptr); + }; + + /* TODO: remove second bool when alias templates are supported */ + template<typename _Tp, typename _Up, + bool = __ptrtr_rebind_helper<_Tp, _Up>::value, + bool = __ptrtr_rebind_helper2<_Tp, _Up>::value> + struct __ptrtr_rebind; + + template<typename _Tp, typename _Up, bool _B2> + struct __ptrtr_rebind<_Tp, _Up, true, _B2> + { + typedef typename _Tp::template rebind<_Up> __type; + }; + + /* TODO: remove this when alias templates are supported */ + template<typename _Tp, typename _Up> + struct __ptrtr_rebind<_Tp, _Up, false, true> + { + typedef typename _Tp::template __rebind<_Up>::__type __type; + }; + + template<template<typename, typename...> class _SomePtr, typename _Up, + typename _Tp, typename... _Args> + struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false, false> + { + typedef _SomePtr<_Up, _Args...> __type; + }; + + template<typename _Tp, typename = typename remove_cv<_Tp>::type> + struct __ptrtr_not_void + { + typedef _Tp __type; + }; + + template<typename _Tp> + struct __ptrtr_not_void<_Tp, void> + { + struct __type { }; + }; + + template<typename _Ptr> + class __ptrtr_pointer_to + { + typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type; + typedef typename __ptrtr_not_void<__orig_type>::__type __element_type; + + public: + static _Ptr pointer_to(__element_type& __e) + { return _Ptr::pointer_to(__e); } + }; + + /** + * @brief Uniform interface to all pointer-like types + * @ingroup pointer_abstractions + */ + template<typename _Ptr> + struct pointer_traits : __ptrtr_pointer_to<_Ptr> + { + /// The pointer type + typedef _Ptr pointer; + /// The type pointed to + typedef typename __ptrtr_elt_type<_Ptr>::__type element_type; + /// Type used to represent the difference between two pointers + typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type; + + private: + /* TODO: replace __rebind<U> with alias template rebind<U> */ + /* + template<typename _Up> + using rebind<_Up> = typename __ptrtr_rebind<_Ptr, _Up>::__type; + */ + template<typename _Up> + struct __rebind + { typedef typename __ptrtr_rebind<_Ptr, _Up>::__type __type; }; + + // allocator_traits needs to use __rebind + template<typename> struct allocator_traits; + template<typename, typename> class __ptrtr_rebind_helper2; + }; + + /** + * @brief Partial specialization for built-in pointers. + * @ingroup pointer_abstractions + */ + template<typename _Tp> + struct pointer_traits<_Tp*> + { + /// The pointer type + typedef _Tp* pointer; + /// The type pointed to + typedef _Tp element_type; + /// Type used to represent the difference between two pointers + typedef ptrdiff_t difference_type; + + /* TODO: replace __rebind<U> with alias template rebind<U> */ + /* + template<typename _Up> + using rebind<_Up> = U*; + */ + template<typename U> + struct __rebind { typedef U* __type; }; + + /** + * @brief Obtain a pointer to an object + * @param r A reference to an object of type @c element_type + * @return @c addressof(r) + */ + static pointer + pointer_to(typename __ptrtr_not_void<element_type>::__type& __r) + { return std::addressof(__r); } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif + +#endif diff --git a/libstdc++-v3/include/ext/array_allocator.h b/libstdc++-v3/include/ext/array_allocator.h index 9c61d74..cee53f5 100644 --- a/libstdc++-v3/include/ext/array_allocator.h +++ b/libstdc++-v3/include/ext/array_allocator.h @@ -72,21 +72,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION max_size() const throw() { return size_t(-1) / sizeof(_Tp); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) { __p->~_Up(); } +#else // _GLIBCXX_RESOLVE_LIB_DEFECTS // 402. wrong new expression in [some_] allocator::construct void construct(pointer __p, const _Tp& __val) { ::new((void *)__p) value_type(__val); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { ::new((void *)__p) _Tp(std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { __p->~_Tp(); } +#endif }; /** diff --git a/libstdc++-v3/include/ext/bitmap_allocator.h b/libstdc++-v3/include/ext/bitmap_allocator.h index 4993c2c..b03dc6a 100644 --- a/libstdc++-v3/include/ext/bitmap_allocator.h +++ b/libstdc++-v3/include/ext/bitmap_allocator.h @@ -1053,20 +1053,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION max_size() const throw() { return size_type(-1) / sizeof(value_type); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) + { __p->~_Up(); } +#else void construct(pointer __p, const_reference __data) { ::new((void *)__p) value_type(__data); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { ::new((void *)__p) _Tp(std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { __p->~value_type(); } +#endif }; template<typename _Tp1, typename _Tp2> diff --git a/libstdc++-v3/include/ext/extptr_allocator.h b/libstdc++-v3/include/ext/extptr_allocator.h index dfb76ac..c93a728 100644 --- a/libstdc++-v3/include/ext/extptr_allocator.h +++ b/libstdc++-v3/include/ext/extptr_allocator.h @@ -100,18 +100,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION size_type max_size() const throw() { return std::numeric_limits<size_type>::max() / sizeof(_Tp); } - void construct(pointer __p, const _Tp& __val) - { ::new(__p.get()) _Tp(__val); } - #ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> + template<typename _Up, typename... _Args> void - construct(pointer __p, _Args&&... __args) - { ::new(__p.get()) _Tp(std::forward<_Args>(__args)...); } -#endif + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) + { __p->~_Up(); } +#else + void construct(pointer __p, const _Tp& __val) + { ::new(__p.get()) _Tp(__val); } void destroy(pointer __p) { __p->~_Tp(); } +#endif template<typename _Up> inline bool diff --git a/libstdc++-v3/include/ext/malloc_allocator.h b/libstdc++-v3/include/ext/malloc_allocator.h index 3aa994d..e1794f7 100644 --- a/libstdc++-v3/include/ext/malloc_allocator.h +++ b/libstdc++-v3/include/ext/malloc_allocator.h @@ -104,21 +104,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION max_size() const throw() { return size_t(-1) / sizeof(_Tp); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) { __p->~_Up(); } +#else // _GLIBCXX_RESOLVE_LIB_DEFECTS // 402. wrong new expression in [some_] allocator::construct void construct(pointer __p, const _Tp& __val) { ::new((void *)__p) value_type(__val); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { ::new((void *)__p) _Tp(std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { __p->~_Tp(); } +#endif }; template<typename _Tp> diff --git a/libstdc++-v3/include/ext/mt_allocator.h b/libstdc++-v3/include/ext/mt_allocator.h index 91eac24..9281494 100644 --- a/libstdc++-v3/include/ext/mt_allocator.h +++ b/libstdc++-v3/include/ext/mt_allocator.h @@ -588,21 +588,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION max_size() const throw() { return size_t(-1) / sizeof(_Tp); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) { __p->~_Up(); } +#else // _GLIBCXX_RESOLVE_LIB_DEFECTS // 402. wrong new expression in [some_] allocator::construct void construct(pointer __p, const _Tp& __val) { ::new((void *)__p) _Tp(__val); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { ::new((void *)__p) _Tp(std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { __p->~_Tp(); } +#endif }; #ifdef __GTHREADS diff --git a/libstdc++-v3/include/ext/new_allocator.h b/libstdc++-v3/include/ext/new_allocator.h index 35d5cdc..4dd2ca2 100644 --- a/libstdc++-v3/include/ext/new_allocator.h +++ b/libstdc++-v3/include/ext/new_allocator.h @@ -101,21 +101,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION max_size() const throw() { return size_t(-1) / sizeof(_Tp); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) { __p->~_Up(); } +#else // _GLIBCXX_RESOLVE_LIB_DEFECTS // 402. wrong new expression in [some_] allocator::construct void construct(pointer __p, const _Tp& __val) { ::new((void *)__p) _Tp(__val); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { ::new((void *)__p) _Tp(std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { __p->~_Tp(); } +#endif }; template<typename _Tp> diff --git a/libstdc++-v3/include/ext/pool_allocator.h b/libstdc++-v3/include/ext/pool_allocator.h index 66ddced..9a47b19 100644 --- a/libstdc++-v3/include/ext/pool_allocator.h +++ b/libstdc++-v3/include/ext/pool_allocator.h @@ -158,21 +158,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION max_size() const throw() { return size_t(-1) / sizeof(_Tp); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) { __p->~_Up(); } +#else // _GLIBCXX_RESOLVE_LIB_DEFECTS // 402. wrong new expression in [some_] allocator::construct void construct(pointer __p, const _Tp& __val) { ::new((void *)__p) _Tp(__val); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { ::new((void *)__p) _Tp(std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { __p->~_Tp(); } +#endif pointer allocate(size_type __n, const void* = 0); diff --git a/libstdc++-v3/include/ext/throw_allocator.h b/libstdc++-v3/include/ext/throw_allocator.h index 778b8de..aa01b25 100644 --- a/libstdc++-v3/include/ext/throw_allocator.h +++ b/libstdc++-v3/include/ext/throw_allocator.h @@ -639,20 +639,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return a; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Up, typename... _Args> + void + construct(_Up* __p, _Args&&... __args) + { return _M_allocator.construct(__p, std::forward<_Args>(__args)...); } + + template<typename _Up> + void + destroy(_Up* __p) + { _M_allocator.destroy(__p); } +#else void construct(pointer __p, const value_type& val) { return _M_allocator.construct(__p, val); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - template<typename... _Args> - void - construct(pointer __p, _Args&&... __args) - { return _M_allocator.construct(__p, std::forward<_Args>(__args)...); } -#endif - void destroy(pointer __p) { _M_allocator.destroy(__p); } +#endif void deallocate(pointer __p, size_type __n) diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/members/allocate_hint.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/members/allocate_hint.cc new file mode 100644 index 0000000..6a26adc --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/members/allocate_hint.cc @@ -0,0 +1,90 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <cstddef> +#include <testsuite_hooks.h> + +struct X { }; + +template<typename T> +struct hintable_allocator +{ + typedef T value_type; + struct const_void_pointer { }; + typedef unsigned size_type; + + hintable_allocator() : called(false) { } + + bool called; + + // this is the overload that should get called: + T* allocate(size_type n, const_void_pointer) { called = true; return 0; } + + // none of these should get called: + T* allocate(size_type n); + T* allocate(size_type n, void*); + T* allocate(size_type n, const void*); + T* allocate(size_type n, const_void_pointer) const; +}; + +void test01() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<hintable_allocator<X>> traits_type; + traits_type::allocator_type a; + traits_type::const_void_pointer v; + X* p = traits_type::allocate(a, 1, v); + VERIFY( a.called ); +} + +template<typename T> +struct unhintable_allocator +{ + typedef T value_type; + typedef unsigned size_type; + + unhintable_allocator() : called(false) { } + + bool called; + + // this is the overload that should get called: + T* allocate(size_type n) { called = true; return 0; } + + // this should not get called: + T* allocate(size_type n, void*); +}; + +void test02() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<unhintable_allocator<X>> traits_type; + traits_type::allocator_type a; + traits_type::const_void_pointer v; + X* p = traits_type::allocate(a, 1, v); + VERIFY( a.called ); +} + +int main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/members/construct.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/members/construct.cc new file mode 100644 index 0000000..a133fb0 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/members/construct.cc @@ -0,0 +1,79 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <cstddef> +#include <testsuite_hooks.h> + +struct X +{ + static int counter; + X() { } + X(const X&) { ++counter; } + explicit X(int) { ++counter; } + X(int, int) { ++counter; } + X(int, int, int) { ++counter; } +}; + +int X::counter = 0; + +template<typename T> +struct fake_allocator +{ + typedef T value_type; + + fake_allocator() : counter() {} + + int counter; + + T* allocate(std::size_t n) { return (T*)new char[n*sizeof(T)]; } + void deallocate(T* p, std::size_t) { delete[] (char*)p; } + + // don't actually construct anything when these are called + void construct(T* p) { ++counter; } + void construct(T* p, int, int) { ++counter; } +}; + +void test01() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<fake_allocator<X>> traits_type; + traits_type::allocator_type a; + X* p = traits_type::allocate(a, 1); + traits_type::construct(a, p); + VERIFY( a.counter == 1 ); + traits_type::construct(a, p, 1); + VERIFY( a.counter == 1 ); + VERIFY( X::counter == 1 ); + traits_type::destroy(a, p); + traits_type::construct(a, p, 1, 1); + VERIFY( a.counter == 2 ); + VERIFY( X::counter == 1 ); + traits_type::construct(a, p, 1, 1, 1); + VERIFY( a.counter == 2 ); + VERIFY( X::counter == 2 ); + traits_type::destroy(a, p); + traits_type::deallocate(a, p, 1); +} + +int main() +{ + test01(); +} diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/members/destroy.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/members/destroy.cc new file mode 100644 index 0000000..a74efb2 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/members/destroy.cc @@ -0,0 +1,84 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <new> +#include <testsuite_hooks.h> + +struct X +{ + static int counter; + ~X() { ++counter; } +}; + +int X::counter = 0; + +template<typename T> +struct allocator_with_destroy +{ + typedef T value_type; + + allocator_with_destroy() : called() { } + + void destroy(T* p) { called = true; } + + int called; +}; + +template<typename T> +struct allocator_without_destroy +{ + typedef T value_type; + + allocator_without_destroy() : called() { } + + int called; +}; + +void test01() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<allocator_with_destroy<X>> traits_type; + traits_type::allocator_type a; + X* p = 0; + traits_type::destroy(a, p); + VERIFY( a.called ); + VERIFY( X::counter == 0 ); +} + +void test02() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<allocator_without_destroy<X>> traits_type; + traits_type::allocator_type a; + char buf[sizeof(X)]; + X* p = ::new (static_cast<void*>(buf)) X(); + traits_type::destroy(a, p); + VERIFY( !a.called ); + VERIFY( X::counter == 1 ); +} + +int main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/members/max_size.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/members/max_size.cc new file mode 100644 index 0000000..61403ce --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/members/max_size.cc @@ -0,0 +1,67 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <limits> +#include <type_traits> +#include <testsuite_hooks.h> + +struct X { }; + +template<typename T> +struct maxsize_allocator +{ + typedef T value_type; + typedef unsigned size_type; + + size_type max_size() const { return 100; } +}; + +template<typename T> +struct unsized_allocator +{ + typedef T value_type; +}; + + +void test01() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<maxsize_allocator<X>> traits_type; + traits_type::allocator_type a; + auto size = a.max_size(); + VERIFY( traits_type::max_size(a) == size ); +} + +void test02() +{ + bool test __attribute__((unused)) = true; + + typedef std::allocator_traits<unsized_allocator<X>> traits_type; + traits_type::allocator_type a; + auto size = std::numeric_limits<traits_type::size_type>::max(); + VERIFY( traits_type::max_size(a) == size ); +} + +int main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/members/select.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/members/select.cc new file mode 100644 index 0000000..eac924b --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/members/select.cc @@ -0,0 +1,68 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <testsuite_hooks.h> + +struct X { }; + +template<typename T> +struct alloc1 +{ + typedef T value_type; + + int id; +}; + +template<typename T> +struct alloc2 +{ + typedef T value_type; + + int id; + + alloc2 select_on_container_copy_construction() const + { return alloc2{id+1}; } +}; + + +void test01() +{ + typedef std::allocator_traits<alloc1<X>> traits_type; + traits_type::allocator_type a{1}; + const traits_type::allocator_type& a2 + = traits_type::select_on_container_copy_construction(a); + VERIFY( a2.id == a.id ); +} + +void test02() +{ + typedef std::allocator_traits<alloc1<X>> traits_type; + traits_type::allocator_type a{1}; + const traits_type::allocator_type& a2 + = traits_type::select_on_container_copy_construction(a); + VERIFY( a2.id != a.id ); +} + +int main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/requirements/explicit_instantiation.cc new file mode 100644 index 0000000..13d3135 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/requirements/explicit_instantiation.cc @@ -0,0 +1,29 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// NB: This file is for testing memory with NO OTHER INCLUDES. + +#include <memory> + +namespace std +{ + typedef short test_type; + template struct allocator_traits<std::allocator<test_type>>; +} diff --git a/libstdc++-v3/testsuite/20_util/allocator_traits/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/allocator_traits/requirements/typedefs.cc new file mode 100644 index 0000000..346824f --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator_traits/requirements/typedefs.cc @@ -0,0 +1,52 @@ +// { dg-options "-std=gnu++0x" } +// +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// +// NB: This file is for testing memory with NO OTHER INCLUDES. + +#include <memory> + +// { dg-do compile } + +template<typename T> +void test01() +{ + // Check for required typedefs + typedef std::allocator_traits<T> test_type; + typedef typename test_type::pointer pointer; + typedef typename test_type::const_pointer const_pointer; + typedef typename test_type::void_pointer void_pointer; + typedef typename test_type::const_void_pointer const_void_pointer; + typedef typename test_type::difference_type difference_type; + typedef typename test_type::size_type size_type; + typedef typename test_type::propagate_on_container_copy_assignment + propagate_on_container_copy_assignment; + typedef typename test_type::propagate_on_container_move_assignment + propagate_on_container_move_assignment; + typedef typename test_type::propagate_on_container_swap + propagate_on_container_swap; +} + +struct S { }; + +int main() +{ + test01<std::allocator<int>>(); + test01<std::allocator<S>>(); +} diff --git a/libstdc++-v3/testsuite/20_util/pointer_traits/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/pointer_traits/requirements/explicit_instantiation.cc new file mode 100644 index 0000000..38043d4 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/pointer_traits/requirements/explicit_instantiation.cc @@ -0,0 +1,31 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// NB: This file is for testing memory with NO OTHER INCLUDES. + +#include <memory> + +namespace std +{ + typedef short test_type; + template struct pointer_traits<test_type*>; + template struct pointer_traits<shared_ptr<test_type>>; + template struct pointer_traits<unique_ptr<test_type>>; +} diff --git a/libstdc++-v3/testsuite/20_util/pointer_traits/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/pointer_traits/requirements/typedefs.cc new file mode 100644 index 0000000..c682557 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/pointer_traits/requirements/typedefs.cc @@ -0,0 +1,45 @@ +// { dg-options "-std=gnu++0x" } +// +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// +// NB: This file is for testing memory with NO OTHER INCLUDES. + +#include <memory> + +// { dg-do compile } + +template<typename Ptr> +void test01() +{ + // Check for required typedefs + typedef std::pointer_traits<Ptr> test_type; + typedef typename test_type::pointer pointer; + typedef typename test_type::element_type element_type; + typedef typename test_type::difference_type difference_type; +} + +int main() +{ + test01<int*>(); + test01<void*>(); + test01<std::shared_ptr<int>>(); + test01<std::shared_ptr<void>>(); + test01<std::unique_ptr<int>>(); + test01<std::unique_ptr<void>>(); +} |