passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/container/slist.hpp

@@ -34,6 +34,7 @@
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/node_alloc_holder.hpp>
 #include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/value_functors.hpp>
 // intrusive
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/slist.hpp>
@@ -61,13 +62,13 @@ namespace container {
 template <class T, class Allocator>
 class slist;
 
-namespace container_detail {
+namespace dtl {
 
 template<class VoidPointer>
 struct slist_hook
 {
-   typedef typename container_detail::bi::make_slist_base_hook
-      <container_detail::bi::void_pointer<VoidPointer>, container_detail::bi::link_mode<container_detail::bi::normal_link> >::type type;
+   typedef typename dtl::bi::make_slist_base_hook
+      <dtl::bi::void_pointer<VoidPointer>, dtl::bi::link_mode<dtl::bi::normal_link> >::type type;
 };
 
 template <class T, class VoidPointer>
@@ -104,20 +105,20 @@ struct intrusive_slist_type
       <typename allocator_traits_type::pointer>::template
          rebind_pointer<void>::type
             void_pointer;
-   typedef typename container_detail::slist_node
+   typedef typename dtl::slist_node
          <value_type, void_pointer>             node_type;
 
-   typedef typename container_detail::bi::make_slist
+   typedef typename dtl::bi::make_slist
       <node_type
-      ,container_detail::bi::base_hook<typename slist_hook<void_pointer>::type>
-      ,container_detail::bi::constant_time_size<true>
-      , container_detail::bi::size_type
+      ,dtl::bi::base_hook<typename slist_hook<void_pointer>::type>
+      ,dtl::bi::constant_time_size<true>
+      , dtl::bi::size_type
          <typename allocator_traits_type::size_type>
       >::type                                   container_type;
    typedef container_type                       type ;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -162,26 +163,26 @@ template <class T, class Allocator = new_allocator<T> >
 template <class T, class Allocator>
 #endif
 class slist
-   : protected container_detail::node_alloc_holder
-      <Allocator, typename container_detail::intrusive_slist_type<Allocator>::type>
+   : protected dtl::node_alloc_holder
+      <Allocator, typename dtl::intrusive_slist_type<Allocator>::type>
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef typename
-      container_detail::intrusive_slist_type<Allocator>::type           Icont;
-   typedef container_detail::node_alloc_holder<Allocator, Icont>        AllocHolder;
+      dtl::intrusive_slist_type<Allocator>::type           Icont;
+   typedef dtl::node_alloc_holder<Allocator, Icont>        AllocHolder;
    typedef typename AllocHolder::NodePtr                    NodePtr;
    typedef typename AllocHolder::NodeAlloc                  NodeAlloc;
    typedef typename AllocHolder::ValAlloc                   ValAlloc;
    typedef typename AllocHolder::Node                       Node;
-   typedef container_detail::allocator_destroyer<NodeAlloc> Destroyer;
+   typedef dtl::allocator_destroyer<NodeAlloc> Destroyer;
    typedef typename AllocHolder::alloc_version              alloc_version;
    typedef boost::container::
       allocator_traits<Allocator>                           allocator_traits_type;
    typedef boost::container::equal_to_value<Allocator>      equal_to_value_type;
 
    BOOST_COPYABLE_AND_MOVABLE(slist)
-   typedef container_detail::iterator_from_iiterator<typename Icont::iterator, false>  iterator_impl;
-   typedef container_detail::iterator_from_iiterator<typename Icont::iterator, true >  const_iterator_impl;
+   typedef dtl::iterator_from_iiterator<typename Icont::iterator, false>  iterator_impl;
+   typedef dtl::iterator_from_iiterator<typename Icont::iterator, true >  const_iterator_impl;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -216,7 +217,7 @@ class slist
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   slist() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   slist() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       :  AllocHolder()
    {}
 
@@ -357,7 +358,7 @@ class slist
       if (&x != this){
          NodeAlloc &this_alloc     = this->node_alloc();
          const NodeAlloc &x_alloc  = x.node_alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
@@ -442,7 +443,7 @@ class slist
    template <class InpIt>
    void assign(InpIt first, InpIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible<InpIt, size_type>::type * = 0
+      , typename dtl::disable_if_convertible<InpIt, size_type>::type * = 0
       #endif
       )
    {
@@ -846,10 +847,10 @@ class slist
    template <class InpIt>
    iterator insert_after(const_iterator prev_p, InpIt first, InpIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<InpIt, size_type>::value
-          && (container_detail::is_input_iterator<InpIt>::value
-                || container_detail::is_same<alloc_version, version_1>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_convertible<InpIt, size_type>::value
+          && (dtl::is_input_iterator<InpIt>::value
+                || dtl::is_same<alloc_version, version_1>::value
                )
          >::type * = 0
       #endif
@@ -884,10 +885,10 @@ class slist
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
    iterator insert_after(const_iterator prev, FwdIt first, FwdIt last
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<FwdIt, size_type>::value
-            && !(container_detail::is_input_iterator<FwdIt>::value
-                || container_detail::is_same<alloc_version, version_1>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_convertible<FwdIt, size_type>::value
+            && !(dtl::is_input_iterator<FwdIt>::value
+                || dtl::is_same<alloc_version, version_1>::value
                )
          >::type * = 0
       )
@@ -1165,7 +1166,7 @@ class slist
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void unique()
-   {  this->unique(value_equal());  }
+   {  this->unique(value_equal_t());  }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
@@ -1195,7 +1196,7 @@ class slist
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    void merge(slist & x)
-   {  this->merge(x, value_less()); }
+   {  this->merge(x, value_less_t()); }
 
    //! <b>Requires</b>: The lists x and *this must be distinct.
    //!
@@ -1261,7 +1262,7 @@ class slist
    //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N
    //!   is the list's size.
    void sort()
-   {  this->sort(value_less());  }
+   {  this->sort(value_less_t());  }
 
    //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>.
    //!   The sort is stable, that is, the relative order of equivalent elements is preserved.
@@ -1470,7 +1471,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //!   list. Iterators of this list and all the references are not invalidated.
    void splice(const_iterator p, slist& x, const_iterator i) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice_after(this->previous(p), x, this->previous(i));  }
+   {  this->splice_after(this->previous(p), x, x.previous(i));  }
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. i must point to an element contained in list x.
@@ -1504,7 +1505,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //!   list. Iterators of this list and all the references are not invalidated.
    void splice(const_iterator p, slist& x, const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice_after(this->previous(p), x, this->previous(first), this->previous(last));  }
+   {  this->splice_after(this->previous(p), x, x.previous(first), x.previous(last));  }
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. first and last must point to elements contained in list x.
@@ -1625,28 +1626,9 @@ class slist
    };
 
    //Functors for member algorithm defaults
-   struct value_less
-   {
-      bool operator()(const value_type &a, const value_type &b) const
-         {  return a < b;  }
-   };
-
-   struct value_equal
-   {
-      bool operator()(const value_type &a, const value_type &b) const
-         {  return a == b;  }
-   };
+   typedef value_less<value_type>   value_less_t;
+   typedef value_equal<value_type>  value_equal_t;
 
-   struct value_equal_to_this
-   {
-      explicit value_equal_to_this(const value_type &ref)
-         : m_ref(ref){}
-
-      bool operator()(const value_type &val) const
-         {  return m_ref == val;  }
-
-      const value_type &m_ref;
-   };
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 

data/src/cxx_supportlib/vendor-modified/boost/container/small_vector.hpp

@@ -118,11 +118,11 @@ class small_vector_allocator
    typedef typename allocator_traits<Allocator>::propagate_on_container_move_assignment   propagate_on_container_move_assignment;
    typedef typename allocator_traits<Allocator>::propagate_on_container_swap              propagate_on_container_swap;
    //! An integral constant with member `value == false`
-   typedef BOOST_CONTAINER_IMPDEF(container_detail::bool_<false>)                         is_always_equal;
+   typedef BOOST_CONTAINER_IMPDEF(dtl::bool_<false>)                         is_always_equal;
    //! An integral constant with member `value == true`
-   typedef BOOST_CONTAINER_IMPDEF(container_detail::bool_<true>)                          is_partially_propagable;
+   typedef BOOST_CONTAINER_IMPDEF(dtl::bool_<true>)                          is_partially_propagable;
 
-   BOOST_CONTAINER_DOCIGN(typedef container_detail::version_type<small_vector_allocator BOOST_CONTAINER_I 1>  version;)
+   BOOST_CONTAINER_DOCIGN(typedef dtl::version_type<small_vector_allocator BOOST_CONTAINER_I 1>  version;)
 
    //!Obtains an small_vector_allocator that allocates
    //!objects of type T2
@@ -282,7 +282,8 @@ class small_vector_allocator
    pointer internal_storage() const
    {
       typedef typename Allocator::value_type                                              value_type;
-      typedef container_detail::vector_alloc_holder< small_vector_allocator<Allocator> >  vector_alloc_holder_t;
+      typedef typename allocator_traits_type::size_type                                   size_type;
+      typedef vector_alloc_holder< small_vector_allocator<Allocator>, size_type >         vector_alloc_holder_t;
       typedef vector<value_type, small_vector_allocator<Allocator> >                      vector_base;
       typedef small_vector_base<value_type, Allocator>                                    derived_type;
       //
@@ -337,7 +338,7 @@ class small_vector_base
    pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       return boost::intrusive::pointer_traits<pointer>::pointer_to
-         (*const_cast<T*>(static_cast<const T*>(static_cast<const void*>(&m_storage_start))));
+         (*const_cast<T*>(static_cast<const T*>(static_cast<const void*>(m_storage_start.data))));
    }
 
    typedef vector<T, small_vector_allocator<SecondaryAllocator> > base_type;
@@ -345,12 +346,11 @@ class small_vector_base
    const base_type &as_base() const { return static_cast<const base_type&>(*this); }
 
    public:
-   typedef typename container_detail::aligned_storage
-      <sizeof(T), container_detail::alignment_of<T>::value>::type storage_type;
+   typedef typename dtl::aligned_storage
+      <sizeof(T), dtl::alignment_of<T>::value>::type storage_type;
    typedef small_vector_allocator<SecondaryAllocator>             allocator_type;
 
    protected:
-   typedef typename base_type::initial_capacity_t initial_capacity_t;
 
    BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(initial_capacity_t, std::size_t initial_capacity)
       : base_type(initial_capacity_t(), this->internal_storage(), initial_capacity)
@@ -387,8 +387,8 @@ class small_vector_base
          this->steal_resources(x);
       }
       else{
-         this->assign( boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.end  ()))
+         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
+                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end  ()))
                      );
       }
    }
@@ -419,7 +419,7 @@ struct small_vector_storage_calculator
 {
    typedef small_vector_base<T, Allocator> svh_type;
    typedef vector<T, small_vector_allocator<Allocator> > svhb_type;
-   static const std::size_t s_align = container_detail::alignment_of<Storage>::value;
+   static const std::size_t s_align = dtl::alignment_of<Storage>::value;
    static const std::size_t s_size = sizeof(Storage);
    static const std::size_t svh_sizeof = sizeof(svh_type);
    static const std::size_t svhb_sizeof = sizeof(svhb_type);
@@ -481,7 +481,6 @@ class small_vector : public small_vector_base<T, Allocator>
 
    BOOST_COPYABLE_AND_MOVABLE(small_vector)
 
-   typedef typename base_type::initial_capacity_t initial_capacity_t;
    typedef allocator_traits<typename base_type::allocator_type> allocator_traits_type;
 
    public:
@@ -507,7 +506,7 @@ class small_vector : public small_vector_base<T, Allocator>
 
    public:
    BOOST_CONTAINER_FORCEINLINE small_vector()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : base_type(initial_capacity_t(), internal_capacity())
    {}
 
@@ -541,18 +540,18 @@ class small_vector : public small_vector_base<T, Allocator>
 
    template <class InIt>
    BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_c
-         < container_detail::is_convertible<InIt BOOST_MOVE_I size_type>::value
-         BOOST_MOVE_I container_detail::nat >::type * = 0)
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
+         < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
+         BOOST_MOVE_I dtl::nat >::type * = 0)
       )
       : base_type(initial_capacity_t(), internal_capacity())
    {  this->assign(first, last); }
 
    template <class InIt>
    BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last, const allocator_type& a
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_c
-         < container_detail::is_convertible<InIt BOOST_MOVE_I size_type>::value
-         BOOST_MOVE_I container_detail::nat >::type * = 0)
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
+         < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
+         BOOST_MOVE_I dtl::nat >::type * = 0)
       )
       : base_type(initial_capacity_t(), internal_capacity(), a)
    {  this->assign(first, last); }

data/src/cxx_supportlib/vendor-modified/boost/container/stable_vector.hpp

@@ -44,7 +44,7 @@
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/iterators.hpp>
 #include <boost/container/detail/placement_new.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // intrusive
 #include <boost/intrusive/pointer_traits.hpp>
@@ -245,7 +245,7 @@ class stable_vector_iterator
    typedef std::random_access_iterator_tag                                          iterator_category;
    typedef typename non_const_ptr_traits::element_type                              value_type;
    typedef typename non_const_ptr_traits::difference_type                           difference_type;
-   typedef typename ::boost::container::container_detail::if_c
+   typedef typename ::boost::container::dtl::if_c
       < IsConst
       , typename non_const_ptr_traits::template
          rebind_pointer<const value_type>::type
@@ -464,14 +464,14 @@ class stable_vector
    typedef typename node_ptr_traits::reference        node_reference;
    typedef typename const_node_ptr_traits::reference  const_node_reference;
 
-   typedef ::boost::container::container_detail::integral_constant
-      <unsigned, boost::container::container_detail::
+   typedef ::boost::container::dtl::integral_constant
+      <unsigned, boost::container::dtl::
       version<Allocator>::value>                              alloc_version;
    typedef typename allocator_traits_type::
       template portable_rebind_alloc
          <node_type>::type                            node_allocator_type;
 
-   typedef ::boost::container::container_detail::
+   typedef ::boost::container::dtl::
       allocator_version_traits<node_allocator_type>                    allocator_version_traits_t;
    typedef typename allocator_version_traits_t::multiallocation_chain  multiallocation_chain;
 
@@ -540,7 +540,7 @@ class stable_vector
    //! <b>Throws</b>: If allocator_type's default constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   stable_vector() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   stable_vector() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : internal_data(), index()
    {
       STABLE_VECTOR_CHECK_INVARIANT;
@@ -765,14 +765,14 @@ class stable_vector
       if (&x != this){
          node_allocator_type &this_alloc     = this->priv_node_alloc();
          const node_allocator_type &x_alloc  = x.priv_node_alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
             this->shrink_to_fit();
          }
-         container_detail::assign_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
-         container_detail::assign_alloc(this->index.get_stored_allocator(), x.index.get_stored_allocator(), flag);
+         dtl::assign_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
+         dtl::assign_alloc(this->index.get_stored_allocator(), x.index.get_stored_allocator(), flag);
          this->assign(x.begin(), x.end());
       }
       return *this;
@@ -799,7 +799,7 @@ class stable_vector
       node_allocator_type &x_alloc    = x.priv_node_alloc();
       const bool propagate_alloc = allocator_traits_type::
             propagate_on_container_move_assignment::value;
-      container_detail::bool_<propagate_alloc> flag;
+      dtl::bool_<propagate_alloc> flag;
       const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
       //Resources can be transferred if both allocators are
       //going to be equal after this function (either propagated or already equal)
@@ -808,7 +808,7 @@ class stable_vector
          //Destroy objects but retain memory in case x reuses it in the future
          this->clear();
          //Move allocator if needed
-         container_detail::move_alloc(this_alloc, x_alloc, flag);
+         dtl::move_alloc(this_alloc, x_alloc, flag);
          //Take resources
          this->index.swap(x.index);
          this->priv_swap_members(x);
@@ -852,7 +852,7 @@ class stable_vector
    //! <b>Complexity</b>: Linear to n.
    template<typename InputIterator>
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-   typename container_detail::disable_if_convertible<InputIterator, size_type>::type
+   typename dtl::disable_if_convertible<InputIterator, size_type>::type
    #else
    void
    #endif
@@ -1537,10 +1537,10 @@ class stable_vector
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
          //Put this as argument instead of the return type as old GCC's like 3.4
          //detect this and the next disable_if_or as overloads
-         ,  typename container_detail::disable_if_or
+         ,  typename dtl::disable_if_or
                < void
-               , container_detail::is_convertible<InputIterator, size_type>
-               , container_detail::is_not_input_iterator<InputIterator>
+               , dtl::is_convertible<InputIterator, size_type>
+               , dtl::is_not_input_iterator<InputIterator>
                >::type* = 0
          #endif
          )
@@ -1556,10 +1556,10 @@ class stable_vector
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
-   typename container_detail::disable_if_or
+   typename dtl::disable_if_or
       < iterator
-      , container_detail::is_convertible<FwdIt, size_type>
-      , container_detail::is_input_iterator<FwdIt>
+      , dtl::is_convertible<FwdIt, size_type>
+      , dtl::is_input_iterator<FwdIt>
       >::type
       insert(const_iterator p, FwdIt first, FwdIt last)
    {
@@ -1672,8 +1672,8 @@ class stable_vector
                    allocator_traits_type::is_always_equal::value ||
                    this->get_stored_allocator() == x.get_stored_allocator());
       STABLE_VECTOR_CHECK_INVARIANT;
-      container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
-      container_detail::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
       //vector's allocator is swapped here
       this->index.swap(x.index);
       this->priv_swap_members(x);
@@ -1956,7 +1956,7 @@ class stable_vector
    void priv_destroy_node(const node_type &n)
    {
       allocator_traits<node_allocator_type>::
-         destroy(this->priv_node_alloc(), container_detail::addressof(n.value));
+         destroy(this->priv_node_alloc(), dtl::addressof(n.value));
       static_cast<const node_base_type*>(&n)->~node_base_type();
    }
 
@@ -1972,10 +1972,10 @@ class stable_vector
       //This can throw
       boost::container::construct_in_place
          ( this->priv_node_alloc()
-         , container_detail::addressof(p->value)
+         , dtl::addressof(p->value)
          , it);
       //This does not throw
-      ::new(static_cast<node_base_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t())
+      ::new(static_cast<node_base_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t())
          node_base_type(index_traits_type::ptr_to_node_base_ptr(*up_index));
    }
 
@@ -1985,10 +1985,10 @@ class stable_vector
       //This can throw
       boost::container::allocator_traits<node_allocator_type>::construct
          ( this->priv_node_alloc()
-         , container_detail::addressof(p->value)
+         , dtl::addressof(p->value)
          , ::boost::forward<ValueConvertible>(value_convertible));
       //This does not throw
-      ::new(static_cast<node_base_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) node_base_type;
+      ::new(static_cast<node_base_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) node_base_type;
    }
 
    void priv_swap_members(stable_vector &x)