path: root/boost/container/allocator/scoped_allocator.hpp

//////////////////////////////////////////////////////////////////////////////
//
// (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