+2011-06-10 Paolo Carlini <paolo.carlini@oracle.com>
+
+ * include/ext/throw_allocator.h: Use noexcept.
+ * include/ext/pool_allocator.h: Likewise.
+ * include/ext/bitmap_allocator.h: Likewise.
+ * include/ext/new_allocator.h: Likewise.
+ * include/ext/malloc_allocator.h: Likewise.
+ * include/ext/array_allocator.h: Likewise.
+ * include/ext/mt_allocator.h: Likewise.
+ * include/ext/extptr_allocator.h: Likewise.
+ * testsuite/util/testsuite_allocator.h: Likewise; do not include
+ <cassert> directly, include <testsuite_hooks.h> instead.
+
2011-06-10 Benjamin Kosnik <bkoz@redhat.com>
* include/ext/pb_ds/*: Doxygen markup redo.
// array allocator -*- C++ -*-
-// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
typedef _Tp value_type;
pointer
- address(reference __x) const { return std::__addressof(__x); }
+ address(reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
const_pointer
- address(const_reference __x) const { return std::__addressof(__x); }
+ address(const_reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
void
deallocate(pointer, size_type)
}
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_t(-1) / sizeof(_Tp); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
struct rebind
{ typedef array_allocator<_Tp1, _Array1> other; };
- array_allocator(array_type* __array = 0) throw()
+ array_allocator(array_type* __array = 0) _GLIBCXX_USE_NOEXCEPT
: _M_array(__array), _M_used(size_type()) { }
- array_allocator(const array_allocator& __o) throw()
+ array_allocator(const array_allocator& __o) _GLIBCXX_USE_NOEXCEPT
: _M_array(__o._M_array), _M_used(__o._M_used) { }
template<typename _Tp1, typename _Array1>
- array_allocator(const array_allocator<_Tp1, _Array1>&) throw()
+ array_allocator(const array_allocator<_Tp1, _Array1>&)
+ _GLIBCXX_USE_NOEXCEPT
: _M_array(0), _M_used(size_type()) { }
- ~array_allocator() throw() { }
+ ~array_allocator() _GLIBCXX_USE_NOEXCEPT { }
pointer
allocate(size_type __n, const void* = 0)
}
public:
- bitmap_allocator() throw()
+ bitmap_allocator() _GLIBCXX_USE_NOEXCEPT
{ }
- bitmap_allocator(const bitmap_allocator&)
+ bitmap_allocator(const bitmap_allocator&) _GLIBCXX_USE_NOEXCEPT
{ }
template<typename _Tp1>
- bitmap_allocator(const bitmap_allocator<_Tp1>&) throw()
+ bitmap_allocator(const bitmap_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT
{ }
- ~bitmap_allocator() throw()
+ ~bitmap_allocator() _GLIBCXX_USE_NOEXCEPT
{ }
pointer
}
pointer
- address(reference __r) const
+ address(reference __r) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__r); }
const_pointer
- address(const_reference __r) const
+ address(const_reference __r) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__r); }
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_type(-1) / sizeof(value_type); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
struct rebind
{ typedef _ExtPtr_allocator<_Up> other; };
- _ExtPtr_allocator() throw()
+ _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT
: _M_real_alloc() { }
- _ExtPtr_allocator(const _ExtPtr_allocator &__rarg) throw()
+ _ExtPtr_allocator(const _ExtPtr_allocator& __rarg) _GLIBCXX_USE_NOEXCEPT
: _M_real_alloc(__rarg._M_real_alloc) { }
template<typename _Up>
- _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg) throw()
+ _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg)
+ _GLIBCXX_USE_NOEXCEPT
: _M_real_alloc(__rarg._M_getUnderlyingImp()) { }
- ~_ExtPtr_allocator() throw()
+ ~_ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT
{ }
- pointer address(reference __x) const
+ pointer address(reference __x) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__x); }
- const_pointer address(const_reference __x) const
+ const_pointer address(const_reference __x) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__x); }
pointer allocate(size_type __n, void* __hint = 0)
void deallocate(pointer __p, size_type __n)
{ _M_real_alloc.deallocate(__p.get(), __n); }
- size_type max_size() const throw()
+ size_type max_size() const _GLIBCXX_USE_NOEXCEPT
{ return __numeric_traits<size_type>::__max / sizeof(_Tp); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// Allocator that wraps "C" malloc -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+// 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
struct rebind
{ typedef malloc_allocator<_Tp1> other; };
- malloc_allocator() throw() { }
+ malloc_allocator() _GLIBCXX_USE_NOEXCEPT { }
- malloc_allocator(const malloc_allocator&) throw() { }
+ malloc_allocator(const malloc_allocator&) _GLIBCXX_USE_NOEXCEPT { }
template<typename _Tp1>
- malloc_allocator(const malloc_allocator<_Tp1>&) throw() { }
+ malloc_allocator(const malloc_allocator<_Tp1>&)
+ _GLIBCXX_USE_NOEXCEPT { }
- ~malloc_allocator() throw() { }
+ ~malloc_allocator() _GLIBCXX_USE_NOEXCEPT { }
pointer
- address(reference __x) const { return std::__addressof(__x); }
+ address(reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
const_pointer
- address(const_reference __x) const { return std::__addressof(__x); }
+ address(const_reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
// NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
{ std::free(static_cast<void*>(__p)); }
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_t(-1) / sizeof(_Tp); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// MT-optimized allocator -*- C++ -*-
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
typedef _Tp value_type;
pointer
- address(reference __x) const
+ address(reference __x) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__x); }
const_pointer
- address(const_reference __x) const
+ address(const_reference __x) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__x); }
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_t(-1) / sizeof(_Tp); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
typedef __mt_alloc<_Tp1, pol_type> other;
};
- __mt_alloc() throw() { }
+ __mt_alloc() _GLIBCXX_USE_NOEXCEPT { }
- __mt_alloc(const __mt_alloc&) throw() { }
+ __mt_alloc(const __mt_alloc&) _GLIBCXX_USE_NOEXCEPT { }
template<typename _Tp1, typename _Poolp1>
- __mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) throw() { }
+ __mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) _GLIBCXX_USE_NOEXCEPT { }
- ~__mt_alloc() throw() { }
+ ~__mt_alloc() _GLIBCXX_USE_NOEXCEPT { }
pointer
allocate(size_type __n, const void* = 0);
struct rebind
{ typedef new_allocator<_Tp1> other; };
- new_allocator() throw() { }
+ new_allocator() _GLIBCXX_USE_NOEXCEPT { }
- new_allocator(const new_allocator&) throw() { }
+ new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { }
template<typename _Tp1>
- new_allocator(const new_allocator<_Tp1>&) throw() { }
+ new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
- ~new_allocator() throw() { }
+ ~new_allocator() _GLIBCXX_USE_NOEXCEPT { }
pointer
- address(reference __x) const { return std::__addressof(__x); }
+ address(reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
const_pointer
- address(const_reference __x) const { return std::__addressof(__x); }
+ address(const_reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
// NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
{ ::operator delete(__p); }
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_t(-1) / sizeof(_Tp); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// Allocators -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+// 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
struct rebind
{ typedef __pool_alloc<_Tp1> other; };
- __pool_alloc() throw() { }
+ __pool_alloc() _GLIBCXX_USE_NOEXCEPT { }
- __pool_alloc(const __pool_alloc&) throw() { }
+ __pool_alloc(const __pool_alloc&) _GLIBCXX_USE_NOEXCEPT { }
template<typename _Tp1>
- __pool_alloc(const __pool_alloc<_Tp1>&) throw() { }
+ __pool_alloc(const __pool_alloc<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
- ~__pool_alloc() throw() { }
+ ~__pool_alloc() _GLIBCXX_USE_NOEXCEPT { }
pointer
- address(reference __x) const { return std::__addressof(__x); }
+ address(reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
const_pointer
- address(const_reference __x) const { return std::__addressof(__x); }
+ address(const_reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_t(-1) / sizeof(_Tp); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// -*- C++ -*-
-// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
public:
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_allocator.max_size(); }
pointer
- address(reference __x) const { return std::__addressof(__x); }
+ address(reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
const_pointer
- address(const_reference __x) const { return std::__addressof(__x); }
+ address(const_reference __x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(__x); }
pointer
allocate(size_type __n, std::allocator<void>::const_pointer hint = 0)
struct rebind
{ typedef throw_allocator_limit<_Tp1> other; };
- throw_allocator_limit() throw() { }
+ throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { }
- throw_allocator_limit(const throw_allocator_limit&) throw() { }
+ throw_allocator_limit(const throw_allocator_limit&)
+ _GLIBCXX_USE_NOEXCEPT { }
template<typename _Tp1>
- throw_allocator_limit(const throw_allocator_limit<_Tp1>&) throw() { }
+ throw_allocator_limit(const throw_allocator_limit<_Tp1>&)
+ _GLIBCXX_USE_NOEXCEPT { }
- ~throw_allocator_limit() throw() { }
+ ~throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { }
};
/// Allocator throwing via random condition.
struct rebind
{ typedef throw_allocator_random<_Tp1> other; };
- throw_allocator_random() throw() { }
+ throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { }
- throw_allocator_random(const throw_allocator_random&) throw() { }
+ throw_allocator_random(const throw_allocator_random&)
+ _GLIBCXX_USE_NOEXCEPT { }
template<typename _Tp1>
- throw_allocator_random(const throw_allocator_random<_Tp1>&) throw() { }
+ throw_allocator_random(const throw_allocator_random<_Tp1>&)
+ _GLIBCXX_USE_NOEXCEPT { }
- ~throw_allocator_random() throw() { }
+ ~throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { }
};
_GLIBCXX_END_NAMESPACE_VERSION
// -*- C++ -*-
// Testing allocator for the C++ library testsuite.
//
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#define _GLIBCXX_TESTSUITE_ALLOCATOR_H
#include <tr1/unordered_map>
-#include <cassert>
-
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <bits/move.h>
-#endif
+#include <testsuite_hooks.h>
namespace __gnu_test
{
template<class U> struct rebind { typedef tracker_allocator<U> other; };
pointer
- address(reference value) const
- { return &value; }
-
+ address(reference value) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(value); }
+
const_pointer
- address(const_reference value) const
- { return &value; }
-
- tracker_allocator() throw()
+ address(const_reference value) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(value); }
+
+ tracker_allocator() _GLIBCXX_USE_NOEXCEPT
{ }
- tracker_allocator(const tracker_allocator&) throw()
+ tracker_allocator(const tracker_allocator&) _GLIBCXX_USE_NOEXCEPT
{ }
template<class U>
- tracker_allocator(const tracker_allocator<U>&) throw()
+ tracker_allocator(const tracker_allocator<U>&) _GLIBCXX_USE_NOEXCEPT
{ }
- ~tracker_allocator() throw()
+ ~tracker_allocator() _GLIBCXX_USE_NOEXCEPT
{ }
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_type(-1) / sizeof(T); }
pointer
struct rebind
{ typedef uneq_allocator<Tp1> other; };
- uneq_allocator() throw()
+ uneq_allocator() _GLIBCXX_USE_NOEXCEPT
: personality(0) { }
- uneq_allocator(int person) throw()
+ uneq_allocator(int person) _GLIBCXX_USE_NOEXCEPT
: personality(person) { }
template<typename Tp1>
- uneq_allocator(const uneq_allocator<Tp1>& b) throw()
+ uneq_allocator(const uneq_allocator<Tp1>& b) _GLIBCXX_USE_NOEXCEPT
: personality(b.get_personality()) { }
+ ~uneq_allocator() _GLIBCXX_USE_NOEXCEPT
+ { }
+
int get_personality() const { return personality; }
pointer
- address(reference x) const { return &x; }
+ address(reference x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(x); }
const_pointer
- address(const_reference x) const { return &x; }
-
+ address(const_reference x) const _GLIBCXX_NOEXCEPT
+ { return std::__addressof(x); }
+
pointer
allocate(size_type n, const void* = 0)
{
}
return p;
}
-
+
void
deallocate(pointer p, size_type)
{
- assert( p );
-
+ bool test __attribute__((unused)) = true;
+
+ VERIFY( p );
+
map_type::iterator it = get_map().find(reinterpret_cast<void*>(p));
- assert( it != get_map().end() );
+ VERIFY( it != get_map().end() );
// Enforce requirements in Table 32 about deallocation vs
// allocator equality.
- assert( it->second == personality );
-
+ VERIFY( it->second == personality );
+
get_map().erase(it);
::operator delete(p);
}
-
+
size_type
- max_size() const throw()
+ max_size() const _GLIBCXX_USE_NOEXCEPT
{ return size_type(-1) / sizeof(Tp); }
-
+
#ifdef __GXX_EXPERIMENTAL_CXX0X__
template<typename U, typename... Args>
void
projects / gcc.git / commitdiff