Skip to content

R
riscv-gcc-1
Commit 45ba8f9f by Jonathan Wakely Committed by Jonathan Wakely
Options

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
parent 7ca2afa0
Showing with 1290 additions and 59 deletions
libstdc++-v3/ChangeLog
2011-05-28 Jonathan Wakely <jwakely.gcc@gmail.com> 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 * include/std/future (launch): Update enumerators and define
operators required for bitmask type. Remove trailing whitespace. operators required for bitmask type. Remove trailing whitespace.
* src/future.cc: Remove trailing whitespace. * src/future.cc: Remove trailing whitespace.
......
libstdc++-v3/include/Makefile.am
...@@ -119,6 +119,7 @@ bits_headers = \ ...@@ -119,6 +119,7 @@ bits_headers = \
${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream.tcc \
${bits_srcdir}/ostream_insert.h \ ${bits_srcdir}/ostream_insert.h \
${bits_srcdir}/postypes.h \ ${bits_srcdir}/postypes.h \
${bits_srcdir}/ptr_traits.h \
${bits_srcdir}/random.h \ ${bits_srcdir}/random.h \
${bits_srcdir}/random.tcc \ ${bits_srcdir}/random.tcc \
${bits_srcdir}/range_access.h \ ${bits_srcdir}/range_access.h \
......
libstdc++-v3/include/Makefile.in
...@@ -370,6 +370,7 @@ bits_headers = \ ...@@ -370,6 +370,7 @@ bits_headers = \
${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream.tcc \
${bits_srcdir}/ostream_insert.h \ ${bits_srcdir}/ostream_insert.h \
${bits_srcdir}/postypes.h \ ${bits_srcdir}/postypes.h \
${bits_srcdir}/ptr_traits.h \
${bits_srcdir}/random.h \ ${bits_srcdir}/random.h \
${bits_srcdir}/random.tcc \ ${bits_srcdir}/random.tcc \
${bits_srcdir}/range_access.h \ ${bits_srcdir}/range_access.h \
......
libstdc++-v3/include/bits/allocator.h
...@@ -48,7 +48,9 @@ ...@@ -48,7 +48,9 @@
#include <bits/c++allocator.h> #include <bits/c++allocator.h>
#ifdef __GXX_EXPERIMENTAL_CXX0X__ #ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <bits/ptr_traits.h>
#include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE #include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE
#include <limits>
#endif #endif
namespace std _GLIBCXX_VISIBILITY(default) namespace std _GLIBCXX_VISIBILITY(default)
...@@ -85,8 +87,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -85,8 +87,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @brief The @a standard allocator, as per [20.4]. * @brief The @a standard allocator, as per [20.4].
* @ingroup allocators * @ingroup allocators
* *
* Further details: * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html * for further details.
*/ */
template<typename _Tp> template<typename _Tp>
class allocator: public __glibcxx_base_allocator<_Tp> class allocator: public __glibcxx_base_allocator<_Tp>
...@@ -185,7 +187,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -185,7 +187,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// A very basic implementation for now. In general we have to wait for // A very basic implementation for now. In general we have to wait for
// the availability of the infrastructure described in N2983: we should // the availability of the infrastructure described in N2983: we should
// try when either T has a move constructor which cannot throw or T is // 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 // NB: This code doesn't properly belong here, we should find a more
// suited place common to std::vector and std::deque. // suited place common to std::vector and std::deque.
template<typename _Tp, template<typename _Tp,
...@@ -231,6 +233,404 @@ _GLIBCXX_HAS_NESTED_TYPE(allocator_type) ...@@ -231,6 +233,404 @@ _GLIBCXX_HAS_NESTED_TYPE(allocator_type)
__uses_allocator_helper<_Tp, _Alloc>::value> __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 #endif
_GLIBCXX_END_NAMESPACE_VERSION _GLIBCXX_END_NAMESPACE_VERSION
......
libstdc++-v3/include/bits/ptr_traits.h 0 → 100644
// 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
libstdc++-v3/include/ext/array_allocator.h
...@@ -72,21 +72,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -72,21 +72,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
max_size() const throw() max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); } { 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 // _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct // 402. wrong new expression in [some_] allocator::construct
void void
construct(pointer __p, const _Tp& __val) construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) value_type(__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 void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
#endif
}; };
/** /**
......
libstdc++-v3/include/ext/bitmap_allocator.h
...@@ -1053,20 +1053,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1053,20 +1053,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
max_size() const throw() max_size() const throw()
{ return size_type(-1) / sizeof(value_type); } { 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 void
construct(pointer __p, const_reference __data) construct(pointer __p, const_reference __data)
{ ::new((void *)__p) value_type(__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 void
destroy(pointer __p) destroy(pointer __p)
{ __p->~value_type(); } { __p->~value_type(); }
#endif
}; };
template<typename _Tp1, typename _Tp2> template<typename _Tp1, typename _Tp2>
......
libstdc++-v3/include/ext/extptr_allocator.h
...@@ -100,18 +100,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -100,18 +100,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
size_type max_size() const throw() size_type max_size() const throw()
{ return std::numeric_limits<size_type>::max() / sizeof(_Tp); } { 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__ #ifdef __GXX_EXPERIMENTAL_CXX0X__
template<typename... _Args> template<typename _Up, typename... _Args>
void void
construct(pointer __p, _Args&&... __args) construct(_Up* __p, _Args&&... __args)
{ ::new(__p.get()) _Tp(std::forward<_Args>(__args)...); } { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
#endif
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) void destroy(pointer __p)
{ __p->~_Tp(); } { __p->~_Tp(); }
#endif
template<typename _Up> template<typename _Up>
inline bool inline bool
......
libstdc++-v3/include/ext/malloc_allocator.h
...@@ -104,21 +104,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -104,21 +104,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
max_size() const throw() max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); } { 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 // _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct // 402. wrong new expression in [some_] allocator::construct
void void
construct(pointer __p, const _Tp& __val) construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) value_type(__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 void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
#endif
}; };
template<typename _Tp> template<typename _Tp>
......
libstdc++-v3/include/ext/mt_allocator.h
...@@ -588,21 +588,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -588,21 +588,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
max_size() const throw() max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); } { 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 // _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct // 402. wrong new expression in [some_] allocator::construct
void void
construct(pointer __p, const _Tp& __val) construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) _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 void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
#endif
}; };
#ifdef __GTHREADS #ifdef __GTHREADS
......
libstdc++-v3/include/ext/new_allocator.h
...@@ -101,21 +101,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -101,21 +101,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
max_size() const throw() max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); } { 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 // _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct // 402. wrong new expression in [some_] allocator::construct
void void
construct(pointer __p, const _Tp& __val) construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) _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 void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
#endif
}; };
template<typename _Tp> template<typename _Tp>
......
libstdc++-v3/include/ext/pool_allocator.h
...@@ -158,21 +158,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -158,21 +158,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
max_size() const throw() max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); } { 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 // _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct // 402. wrong new expression in [some_] allocator::construct
void void
construct(pointer __p, const _Tp& __val) construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) _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 void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
#endif
pointer pointer
allocate(size_type __n, const void* = 0); allocate(size_type __n, const void* = 0);
......
libstdc++-v3/include/ext/throw_allocator.h
...@@ -639,20 +639,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -639,20 +639,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return a; 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 void
construct(pointer __p, const value_type& val) construct(pointer __p, const value_type& val)
{ return _M_allocator.construct(__p, 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 void
destroy(pointer __p) destroy(pointer __p)
{ _M_allocator.destroy(__p); } { _M_allocator.destroy(__p); }
#endif
void void
deallocate(pointer __p, size_type __n) deallocate(pointer __p, size_type __n)
......
libstdc++-v3/testsuite/20_util/allocator_traits/members/allocate_hint.cc 0 → 100644
// { 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();
}
libstdc++-v3/testsuite/20_util/allocator_traits/members/construct.cc 0 → 100644
// { 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();
}
libstdc++-v3/testsuite/20_util/allocator_traits/members/destroy.cc 0 → 100644
// { 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();
}
libstdc++-v3/testsuite/20_util/allocator_traits/members/max_size.cc 0 → 100644
// { 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();
}
libstdc++-v3/testsuite/20_util/allocator_traits/members/select.cc 0 → 100644
// { 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();
}
libstdc++-v3/testsuite/20_util/allocator_traits/requirements/explicit_instantiation.cc 0 → 100644
// { 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>>;
}
libstdc++-v3/testsuite/20_util/allocator_traits/requirements/typedefs.cc 0 → 100644
// { 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>>();
}
libstdc++-v3/testsuite/20_util/pointer_traits/requirements/explicit_instantiation.cc 0 → 100644
// { 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>>;
}
libstdc++-v3/testsuite/20_util/pointer_traits/requirements/typedefs.cc 0 → 100644
// { 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>>();
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment