summaryrefslogtreecommitdiff
path: root/boost/container/allocator/scoped_allocator.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/container/allocator/scoped_allocator.hpp')
-rw-r--r--boost/container/allocator/scoped_allocator.hpp651
1 files changed, 0 insertions, 651 deletions
diff --git a/boost/container/allocator/scoped_allocator.hpp b/boost/container/allocator/scoped_allocator.hpp
deleted file mode 100644
index 03e12d1d1c..0000000000
--- a/boost/container/allocator/scoped_allocator.hpp
+++ /dev/null
@@ -1,651 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Pablo Halpern 2009. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2011-2011. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/container for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_CONTAINER_ALLOCATOR_SCOPED_ALLOCATOR_HPP
-#define BOOST_CONTAINER_ALLOCATOR_SCOPED_ALLOCATOR_HPP
-
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/container/detail/config_begin.hpp>
-#include <boost/container/detail/workaround.hpp>
-#include <boost/container/allocator/allocator_traits.hpp>
-#include <boost/type_traits.hpp>
-#include <utility>
-
-namespace boost { namespace container {
-
-template <typename OuterAlloc, typename... InnerAllocs>
-class scoped_allocator_adaptor;
-
-template <typename OuterAlloc, typename... InnerAllocs>
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...> make_scoped();
-
-template <typename OuterAlloc, typename... InnerAllocs>
-class scoped_allocator_adaptor_base : public OuterAlloc
-{
- typedef allocator_traits<OuterAlloc> OuterTraits;
-
-public:
- // Workaround for inability of gcc-4.4.1 to expand InnerAllocs...
-// typedef scoped_allocator_adaptor<InnerAllocs...> inner_allocator_type;
- typedef decltype(make_scoped<InnerAllocs...>()) inner_allocator_type;
-
- scoped_allocator_adaptor_base();
-
- template <typename OuterA2>
- scoped_allocator_adaptor_base(OuterA2&& outerAlloc, const InnerAllocs&... innerAllocs);
-
- template <typename OuterA2>
- scoped_allocator_adaptor_base(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other);
- template <typename OuterA2>
- scoped_allocator_adaptor_base(scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other);
-
- inner_allocator_type& inner_allocator()
- { return _M_inner_allocs; }
- inner_allocator_type const& inner_allocator() const
- { return _M_inner_allocs; }
-
- // Allocator propagation functions.
- scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>
- select_on_container_copy_construction() const;
-
- typedef std::integral_constant<
- bool,
- OuterTraits::propagate_on_container_copy_assignment::value ||
- inner_allocator_type::propagate_on_container_copy_assignment::value
- > propagate_on_container_copy_assignment;
- typedef std::integral_constant<
- bool,
- OuterTraits::propagate_on_container_move_assignment::value ||
- inner_allocator_type::propagate_on_container_move_assignment::value
- > propagate_on_container_move_assignment;
- typedef std::integral_constant<
- bool,
- OuterTraits::propagate_on_container_swap::value ||
- inner_allocator_type::propagate_on_container_swap::value
- > propagate_on_container_swap;
-
-private:
- inner_allocator_type _M_inner_allocs;
-};
-
-// Specialization with only one parameter.
-template <typename OuterAlloc>
-class scoped_allocator_adaptor_base<OuterAlloc> : public OuterAlloc
-{
- typedef allocator_traits<OuterAlloc> OuterTraits;
-public:
- typedef scoped_allocator_adaptor<OuterAlloc> inner_allocator_type;
-
- scoped_allocator_adaptor_base();
-
- template <typename OuterA2>
- scoped_allocator_adaptor_base(OuterA2&& outerAlloc);
-
- template <typename OuterA2>
- scoped_allocator_adaptor_base(const scoped_allocator_adaptor<OuterA2>& other);
- template <typename OuterA2>
- scoped_allocator_adaptor_base(scoped_allocator_adaptor<OuterA2>&& other);
-
- inner_allocator_type& inner_allocator()
- { return static_cast<inner_allocator_type&>(*this); }
-
- inner_allocator_type const& inner_allocator() const
- { return static_cast<const inner_allocator_type&>(*this); }
-
- // Allocator propagation functions.
- scoped_allocator_adaptor<OuterAlloc>
- select_on_container_copy_construction() const;
-
- typedef typename OuterTraits::propagate_on_container_copy_assignment propagate_on_container_copy_assignment;
- typedef typename OuterTraits::propagate_on_container_move_assignment propagate_on_container_move_assignment;
- typedef typename OuterTraits::propagate_on_container_swap propagate_on_container_swap;
-};
-
-template <typename OuterAlloc, typename... InnerAllocs>
-class scoped_allocator_adaptor
- : public scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...>
-{
- typedef scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...> _Base;
- typedef allocator_traits<OuterAlloc> _Traits;
-
-public:
- typedef OuterAlloc outer_allocator_type;
- typedef typename _Base::inner_allocator_type inner_allocator_type;
-
- typedef typename allocator_traits<OuterAlloc>::size_type size_type;
- typedef typename allocator_traits<OuterAlloc>::difference_type difference_type;
- typedef typename allocator_traits<OuterAlloc>::pointer pointer;
- typedef typename allocator_traits<OuterAlloc>::const_pointer const_pointer;
- typedef typename allocator_traits<OuterAlloc>::void_pointer void_pointer;
- typedef typename allocator_traits<OuterAlloc>::const_void_pointer const_void_pointer;
- typedef typename allocator_traits<OuterAlloc>::value_type value_type;
-
- template <typename Tp>
- struct rebind {
- typedef typename allocator_traits<OuterAlloc>::template rebind_traits<Tp> rebound_traits;
- typedef typename rebound_traits::allocator_type rebound_outer; // exposition only
- typedef scoped_allocator_adaptor<rebound_outer, InnerAllocs...> other;
- };
-
- scoped_allocator_adaptor();
- scoped_allocator_adaptor(const scoped_allocator_adaptor& other);
-
- template <typename OuterA2>
- scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other);
- template <typename OuterA2>
- scoped_allocator_adaptor(scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other);
-
- template <typename OuterA2>
- scoped_allocator_adaptor(OuterA2&& outerAlloc, const InnerAllocs&... innerAllocs);
-
- ~scoped_allocator_adaptor();
-
- inner_allocator_type & inner_allocator()
- { return _Base::inner_allocator(); }
- inner_allocator_type const& inner_allocator() const
- { return _Base::inner_allocator(); }
- outer_allocator_type & outer_allocator()
- { return *this; }
- outer_allocator_type const& outer_allocator() const
- { return *this; }
-
- pointer allocate(size_type n);
- pointer allocate(size_type n, const_void_pointer hint);
- void deallocate(pointer p, size_type n);
- size_type max_size() const;
-
- template <typename T, typename... Args>
- void construct(T* p, Args&&... args);
-
- // Specializations to pass inner_allocator to pair::first and pair::second
- template <class T1, class T2>
- void construct(std::pair<T1,T2>* p);
- template <class T1, class T2, class U, class V>
- void construct(std::pair<T1,T2>* p, U&& x, V&& y);
- template <class T1, class T2, class U, class V>
- void construct(std::pair<T1,T2>* p, const std::pair<U, V>& pr);
- template <class T1, class T2, class U, class V>
- void construct(std::pair<T1,T2>* p, std::pair<U, V>&& pr);
-
- template <typename T>
- void destroy(T* p);
-};
-
-template <typename OuterA1, typename OuterA2, typename... InnerAllocs>
-inline
-bool operator==(const scoped_allocator_adaptor<OuterA1,InnerAllocs...>& a,
- const scoped_allocator_adaptor<OuterA2,InnerAllocs...>& b);
-
-template <typename OuterA1, typename OuterA2, typename... InnerAllocs>
-inline
-bool operator!=(const scoped_allocator_adaptor<OuterA1,InnerAllocs...>& a,
- const scoped_allocator_adaptor<OuterA2,InnerAllocs...>& b);
-
-///////////////////////////////////////////////////////////////////////////////
-// Implementation of scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...>
-///////////////////////////////////////////////////////////////////////////////
-
-template <typename OuterAlloc, typename... InnerAllocs>
-inline
-scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor_base()
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename OuterA2>
- scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor_base(OuterA2&& outerAlloc,
- const InnerAllocs&... innerAllocs)
- : OuterAlloc(std::forward<OuterA2>(outerAlloc))
- , _M_inner_allocs(innerAllocs...)
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename OuterA2>
- scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor_base(
- const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other)
- : OuterAlloc(other.outer_allocator())
- , _M_inner_allocs(other.inner_allocator())
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename OuterA2>
- scoped_allocator_adaptor_base<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor_base(
- scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other)
- : OuterAlloc(std::move(other.outer_allocator()))
- , _M_inner_allocs(std::move(other.inner_allocator()))
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-inline
-scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>
-scoped_allocator_adaptor_base<OuterAlloc,InnerAllocs...>::
- select_on_container_copy_construction() const
-{
- return scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>(
- allocator_traits<OuterAlloc>::select_on_container_copy_construction(
- this->outer_allocator()),
- allocator_traits<inner_allocator_type>::select_on_container_copy_construction(
- this->inner_allocator()));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Implementation of scoped_allocator_adaptor_base<OuterAlloc> specialization
-///////////////////////////////////////////////////////////////////////////////
-
-template <typename OuterAlloc>
-inline
-scoped_allocator_adaptor_base<OuterAlloc>::
- scoped_allocator_adaptor_base()
-{
-}
-
-template <typename OuterAlloc>
- template <typename OuterA2>
- scoped_allocator_adaptor_base<OuterAlloc>::
- scoped_allocator_adaptor_base(OuterA2&& outerAlloc)
- : OuterAlloc(std::forward<OuterA2>(outerAlloc))
-{
-}
-
-template <typename OuterAlloc>
- template <typename OuterA2>
- scoped_allocator_adaptor_base<OuterAlloc>::
- scoped_allocator_adaptor_base(
- const scoped_allocator_adaptor<OuterA2>& other)
- : OuterAlloc(other.outer_allocator())
-{
-}
-
-template <typename OuterAlloc>
- template <typename OuterA2>
- scoped_allocator_adaptor_base<OuterAlloc>::
- scoped_allocator_adaptor_base(
- scoped_allocator_adaptor<OuterA2>&& other)
- : OuterAlloc(std::move(other.outer_allocator()))
-{
-}
-
-// template <typename OuterAlloc>
-// inline
-// scoped_allocator_adaptor<OuterAlloc>&
-// scoped_allocator_adaptor_base<OuterAlloc>::inner_allocator()
-// {
-// return *this;
-// }
-
-// template <typename OuterAlloc>
-// inline
-// scoped_allocator_adaptor<OuterAlloc> const&
-// scoped_allocator_adaptor_base<OuterAlloc>::inner_allocator() cosnt
-// {
-// return *this;
-// }
-
-template <typename OuterAlloc>
-inline
-scoped_allocator_adaptor<OuterAlloc>
-scoped_allocator_adaptor_base<OuterAlloc>::
-select_on_container_copy_construction() const
-{
- return
- allocator_traits<OuterAlloc>::select_on_container_copy_construction(
- this->outer_allocator());
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Implementation of scoped_allocator_adaptor details
-///////////////////////////////////////////////////////////////////////////////
-
-namespace __details {
-
- // Overload resolution for __has_ctor resolves to this function
- // when _Tp is constructible with _Args. Returns true_type().
-
- static void* __void_p; // Declared but not defined
-
- template <typename _Tp, typename... _Args>
- inline
- auto __has_ctor(int, _Args&&... __args) ->
- decltype((new (__void_p) _Tp(__args...), std::true_type()))
- { return std::true_type(); }
-
- // Overload resolution for __has_ctor resolves to this function
- // when _Tp is not constructible with _Args. Returns false_type().
- template <typename _Tp, typename... _Args>
- auto __has_ctor(_LowPriorityConversion<int>, _Args&&...) ->
- std::false_type
- { return std::false_type(); }
-
- template <typename _Alloc>
- struct __is_scoped_allocator_imp {
- template <typename T>
- static char test(int, typename T::outer_allocator_type*);
- template <typename T>
- static int test(_LowPriorityConversion<int>, void*);
- static const bool value = (1 == sizeof(test<_Alloc>(0, 0)));
- };
-
- template <typename _Alloc>
- struct __is_scoped_allocator
- : std::integral_constant<bool, __is_scoped_allocator_imp<_Alloc>::value>
- {
- };
-
-#if 0
- // Called when outer_allocator_type is not a scoped allocator
- // (recursion stop).
- template <typename _Alloc>
- inline
- auto __outermost_alloc(_LowPriorityConversion<int>, _Alloc& __a) ->
- _Alloc&
- {
- return __a;
- }
-
- // Called when outer_allocator_type is a scoped allocator to
- // return the outermost allocator type.
- template <typename _Alloc>
- inline auto __outermost_alloc(int, _Alloc& __a) ->
- decltype(__outermost_alloc(0,__a.outer_allocator()))
- {
- return __a.outer_allocator();
- }
-#endif
-
- template <typename _Ignore, typename _OuterAlloc,
- typename _InnerAlloc, typename _Tp, typename... _Args>
- inline void __dispatch_scoped_construct(std::false_type __uses_alloc,
- _Ignore __use_alloc_prefix,
- _OuterAlloc& __outer_alloc,
- _InnerAlloc& __inner_alloc,
- _Tp* __p, _Args&&... __args)
- {
- // _Tp doesn't use allocators. Construct without an
- // allocator argument.
- allocator_traits<_OuterAlloc>::construct(__outer_alloc, __p,
- std::forward<_Args>(__args)...);
- }
-
- template <typename _OuterAlloc,
- typename _InnerAlloc, typename _Tp, typename... _Args>
- inline void __dispatch_scoped_construct(std::true_type __uses_alloc,
- std::true_type __use_alloc_prefix,
- _OuterAlloc& __outer_alloc,
- _InnerAlloc& __inner_alloc,
- _Tp* __p, _Args&&... __args)
- {
- // _Tp doesn't use allocators. Construct without an
- // allocator argument.
- allocator_traits<_OuterAlloc>::construct(__outer_alloc, __p,
- allocator_arg, __inner_alloc,
- std::forward<_Args>(__args)...);
- }
-
- template <typename _OuterAlloc,
- typename _InnerAlloc, typename _Tp, typename... _Args>
- inline void __dispatch_scoped_construct(std::true_type __uses_alloc,
- std::false_type __use_alloc_prefix,
- _OuterAlloc& __outer_alloc,
- _InnerAlloc& __inner_alloc,
- _Tp* __p, _Args&&... __args)
- {
- // If _Tp uses an allocator compatible with _InnerAlloc,
- // but the specific constructor does not have a variant that
- // takes an allocator argument, then program is malformed.
-// static_assert(has_constructor<_Tp, _Args...>::value,
-// "Cannot pass inner allocator to this constructor");
-
- allocator_traits<_OuterAlloc>::construct(
- __outer_alloc, __p, std::forward<_Args>(__args)...,
- __inner_alloc);
- }
-
- template <typename _OuterAlloc, typename _InnerAlloc,
- typename _Tp, typename... _Args>
- inline void __do_scoped_construct(std::false_type __scoped_outer,
- _OuterAlloc& __outer_alloc,
- _InnerAlloc& __inner_alloc,
- _Tp* __p, _Args&&... __args)
- {
- // Dispatch construction to the correct __dispatch_scoped_construct()
- // function based on whether _Tp uses an allocator of type
- // _InnerAlloc and, if so, whether there exists the following
- // constructor:
- // _Tp(allocator_arg_t, _InnerAlloc, Args...).
- auto __uses_alloc = uses_allocator<_Tp, _InnerAlloc>();
- auto __use_alloc_prefix = __has_ctor<_Tp>(0, allocator_arg,
- __inner_alloc,
- std::forward<_Args>(__args)...);
- __dispatch_scoped_construct(__uses_alloc, __use_alloc_prefix,
- __outer_alloc,
- __inner_alloc,
- __p, std::forward<_Args>(__args)...);
- }
-
- template <typename _OuterAlloc, typename _InnerAlloc,
- typename _Tp, typename... _Args>
- void __do_scoped_construct(std::true_type __scoped_outer,
- _OuterAlloc& __outer_alloc,
- _InnerAlloc& __inner_alloc,
- _Tp* __p, _Args&&... __args)
- {
- // Use outermost allocator if __outer_alloc is scoped
- typedef typename _OuterAlloc::outer_allocator_type outerouter;
- __do_scoped_construct(__is_scoped_allocator<outerouter>(),
- __outer_alloc.outer_allocator(),
- __inner_alloc,
- __p, std::forward<_Args>(__args)...);
- }
-
-} // end namespace __details
-
-///////////////////////////////////////////////////////////////////////////////
-// Implementation of scoped_allocator_adaptor
-///////////////////////////////////////////////////////////////////////////////
-
-template <typename OuterAlloc, typename... InnerAllocs>
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor()
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor(const scoped_allocator_adaptor& other)
- : _Base(other)
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename OuterA2>
- scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2,
- InnerAllocs...>& other)
- : _Base(other)
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename OuterA2>
- scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor(scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other)
- : _Base(std::move(other))
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename OuterA2>
- scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- scoped_allocator_adaptor(OuterA2&& outerAlloc, const InnerAllocs&... innerAllocs)
- : _Base(std::forward<OuterA2>(outerAlloc), innerAllocs...)
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- ~scoped_allocator_adaptor()
-{
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-inline typename allocator_traits<OuterAlloc>::pointer
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- allocate(size_type n)
-{
- return allocator_traits<OuterAlloc>::allocate(outer_allocator(), n);
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-inline typename allocator_traits<OuterAlloc>::pointer
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- allocate(size_type n, const_void_pointer hint)
-{
- return allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint);
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-inline void scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- deallocate(pointer p, size_type n)
-{
- allocator_traits<OuterAlloc>::deallocate(outer_allocator(), p, n);
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
-inline typename allocator_traits<OuterAlloc>::size_type
-scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::max_size() const
-{
- return allocator_traits<OuterAlloc>::max_size(outer_allocator());
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename T>
- inline void scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>::
- destroy(T* p)
-{
- allocator_traits<OuterAlloc>::destroy(outer_allocator(), p);
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <typename T, typename... Args>
- inline
- void scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>::construct(T* p,
- Args&&... args)
-{
- __do_scoped_construct(__details::__is_scoped_allocator<OuterAlloc>(),
- this->outer_allocator(), this->inner_allocator(),
- p, std::forward<Args>(args)...);
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <class T1, class T2>
- void scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>::construct(
- std::pair<T1,T2>* p)
-{
- construct(addressof(p->first));
- try {
- construct(addressof(p->second));
- }
- catch (...) {
- destroy(addressof(p->first));
- throw;
- }
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <class T1, class T2, class U, class V>
- void scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>::construct(
- std::pair<T1,T2>* p, U&& x, V&& y)
-{
- construct(addressof(p->first), std::forward<U>(x));
- try {
- construct(addressof(p->second), std::forward<V>(y));
- }
- catch (...) {
- destroy(addressof(p->first));
- throw;
- }
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <class T1, class T2, class U, class V>
- void scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>::construct(
- std::pair<T1,T2>* p, const std::pair<U, V>& pr)
-{
- construct(addressof(p->first), pr.first);
- try {
- construct(addressof(p->second), pr.second);
- }
- catch (...) {
- destroy(addressof(p->first));
- throw;
- }
-}
-
-template <typename OuterAlloc, typename... InnerAllocs>
- template <class T1, class T2, class U, class V>
- void scoped_allocator_adaptor<OuterAlloc,InnerAllocs...>::construct(
- std::pair<T1,T2>* p, std::pair<U, V>&& pr)
-{
- construct(addressof(p->first), std::move(pr.first));
- try {
- construct(addressof(p->second), std::move(pr.second));
- }
- catch (...) {
- destroy(addressof(p->first));
- throw;
- }
-}
-
-template <typename OuterA1, typename OuterA2, typename... InnerAllocs>
-inline
-bool operator==(const scoped_allocator_adaptor<OuterA1,InnerAllocs...>& a,
- const scoped_allocator_adaptor<OuterA2,InnerAllocs...>& b)
-{
- return a.outer_allocator() == b.outer_allocator()
- && a.inner_allocator() == b.inner_allocator();
-}
-
-template <typename OuterA1, typename OuterA2>
-inline
-bool operator==(const scoped_allocator_adaptor<OuterA1>& a,
- const scoped_allocator_adaptor<OuterA2>& b)
-{
- return a.outer_allocator() == b.outer_allocator();
-}
-
-template <typename OuterA1, typename OuterA2, typename... InnerAllocs>
-inline
-bool operator!=(const scoped_allocator_adaptor<OuterA1,InnerAllocs...>& a,
- const scoped_allocator_adaptor<OuterA2,InnerAllocs...>& b)
-{
- return ! (a == b);
-}
-
-}} // namespace boost { namespace container {
-
-#include <boost/container/detail/config_end.hpp>
-
-#endif // BOOST_CONTAINER_ALLOCATOR_SCOPED_ALLOCATOR_HPP