Commit 45ba8f9f by Jonathan Wakely Committed by Jonathan Wakely

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
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.
......
......@@ -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 \
......
......@@ -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 \
......
// 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
......@@ -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
};
/**
......
......@@ -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>
......
......@@ -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
......
......@@ -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>
......
......@@ -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
......
......@@ -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>
......
......@@ -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);
......
......@@ -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)
......
// { 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();
}
// { 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();
}
// { 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();
}
// { 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();
}
// { 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();
}
// { 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>>;
}
// { 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>>();
}
// { 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>>;
}
// { 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