* include/ext/alloc_traits.h (__alloc_traits::max_size): Define.
(__alloc_traits::rebind): Define.
* include/bits/stl_vector.h: Use them.
* testsuite/util/testsuite_allocator.h (SimpleAllocator): Define.
* testsuite/23_containers/vector/allocator/minimal.cc: New.
* testsuite/23_containers/vector/requirements/dr438/assign_neg.cc:
Adjust dg-error line numbers.
* testsuite/23_containers/vector/requirements/dr438/insert_neg.cc:
Likewise.
* testsuite/23_containers/vector/requirements/dr438/
constructor_1_neg.cc: Likewise.
* testsuite/23_containers/vector/requirements/dr438/
constructor_2_neg.cc: Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@179523
138bc75d-0d04-0410-961f-
82ee72b054a4
+2011-10-04 Jonathan Wakely <jwakely.gcc@gmail.com>
+
+ * include/ext/alloc_traits.h (__alloc_traits::max_size): Define.
+ (__alloc_traits::rebind): Define.
+ * include/bits/stl_vector.h: Use them.
+ * testsuite/util/testsuite_allocator.h (SimpleAllocator): Define.
+ * testsuite/23_containers/vector/allocator/minimal.cc: New.
+ * testsuite/23_containers/vector/requirements/dr438/assign_neg.cc:
+ Adjust dg-error line numbers.
+ * testsuite/23_containers/vector/requirements/dr438/insert_neg.cc:
+ Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_1_neg.cc: Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_2_neg.cc: Likewise.
+
2011-10-03 Jonathan Wakely <jwakely.gcc@gmail.com>
* testsuite/20_util/pointer_traits/pointer_to.cc: Define equality
template<typename _Tp, typename _Alloc>
struct _Vector_base
{
- typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+ typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
pointer;
/** Returns the size() of the largest possible %vector. */
size_type
max_size() const _GLIBCXX_NOEXCEPT
- { return _M_get_Tp_allocator().max_size(); }
+ { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
/**
using _Base_type::deallocate;
using _Base_type::construct;
using _Base_type::destroy;
+ using _Base_type::max_size;
private:
template<typename _Ptr>
{ };
public:
+ // overload construct for non-standard pointer types
template<typename _Ptr, typename... _Args>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
std::forward<_Args>(__args)...);
}
+ // overload destroy for non-standard pointer types
template<typename _Ptr>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
destroy(_Alloc& __a, _Ptr __p)
|| noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
}
+ template<typename _Tp>
+ struct rebind
+ { typedef typename _Base_type::template __rebind_alloc<_Tp>::__type other; };
#else
typedef typename _Alloc::pointer pointer;
static void destroy(_Alloc& __a, pointer __p)
{ __a.destroy(__p); }
+ static size_type max_size(const _Alloc& __a)
+ { return __a.max_size(); }
+
static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; }
static void _S_on_swap(_Alloc& __a, _Alloc& __b)
// 431. Swapping containers with unequal allocators.
std::__alloc_swap<_Alloc>::_S_do_it(__a, __b);
}
+
+ template<typename _Tp>
+ struct rebind
+ { typedef typename _Alloc::template rebind<_Tp>::other other; };
#endif
};
--- /dev/null
+// Copyright (C) 2011 Free Software Foundation
+//
+// 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/>.
+
+// { dg-options "-std=gnu++0x" }
+
+#include <vector>
+#include <memory>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+struct T { int i; };
+
+using __gnu_test::SimpleAllocator;
+
+template class std::vector<T, SimpleAllocator<T>>;
+
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef SimpleAllocator<T> alloc_type;
+ typedef std::allocator_traits<alloc_type> traits_type;
+ typedef std::vector<T, alloc_type> test_type;
+ test_type v(alloc_type{});
+ VERIFY( v.max_size() == traits_type::max_size(v.get_allocator()) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1222 }
+// { dg-error "no matching" "" { target *-*-* } 1223 }
#include <vector>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1152 }
+// { dg-error "no matching" "" { target *-*-* } 1153 }
#include <vector>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1152 }
+// { dg-error "no matching" "" { target *-*-* } 1153 }
#include <vector>
#include <utility>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1263 }
+// { dg-error "no matching" "" { target *-*-* } 1264 }
#include <vector>
typedef std::integral_constant<bool, Propagate> trait_type;
public:
+ // default allocator_traits::rebind_alloc would select
+ // uneq_allocator::rebind so we must define rebind here
template<typename Up>
struct rebind { typedef propagating_allocator<Up, Propagate> other; };
{ return Propagate ? *this : propagating_allocator(); }
};
+ // Class template supporting the minimal interface that satisfies the
+ // Allocator requirements, from example in [allocator.requirements]
+ template <class Tp>
+ struct SimpleAllocator
+ {
+ typedef Tp value_type;
+
+ SimpleAllocator() { }
+
+ template <class T>
+ SimpleAllocator(const SimpleAllocator<T>& other) { }
+
+ Tp *allocate(std::size_t n)
+ { return std::allocator<Tp>().allocate(n); }
+
+ void deallocate(Tp *p, std::size_t n)
+ { std::allocator<Tp>().deallocate(p, n); }
+ };
+
+ template <class T, class U>
+ bool operator==(const SimpleAllocator<T>&, const SimpleAllocator<U>&)
+ { return true; }
+ template <class T, class U>
+ bool operator!=(const SimpleAllocator<T>&, const SimpleAllocator<U>&)
+ { return false; }
+
#endif
template<typename Tp>
OSDN Git Service
