passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/intrusive/set_hook.hpp

@@ -49,7 +49,8 @@ struct make_set_base_hook
       >::type packed_options;
 
    typedef generic_hook
-   < rbtree_algorithms<rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size> >
+   < RbTreeAlgorithms
+   , rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
    , typename packed_options::tag
    , packed_options::link_mode
    , RbTreeBaseHookId
@@ -180,7 +181,8 @@ struct make_set_member_hook
       >::type packed_options;
 
    typedef generic_hook
-   < rbtree_algorithms<rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size> >
+   < RbTreeAlgorithms
+   , rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
    , member_tag
    , packed_options::link_mode
    , NoBaseHookId

data/src/cxx_supportlib/vendor-modified/boost/intrusive/sg_set.hpp

@@ -26,6 +26,11 @@
 namespace boost {
 namespace intrusive {
 
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
+class sg_multiset_impl;
+#endif
+
 //! The class template sg_set is an intrusive container, that mimics most of
 //! the interface of std::sg_set as described in the C++ standard.
 //!
@@ -81,9 +86,13 @@ class sg_set_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::sgtree::sgtree()
+   sg_set_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::sgtree::sgtree(const key_compare &,const value_traits &)
-   explicit sg_set_impl( const key_compare &cmp = key_compare()
-                    , const value_traits &v_traits = value_traits())
+   explicit sg_set_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -144,6 +153,15 @@ class sg_set_impl
    //! @copydoc ::boost::intrusive::sgtree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::sgtree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::sgtree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::sgtree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::sgtree::container_from_end_iterator(iterator)
    static sg_set_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -194,6 +212,17 @@ class sg_set_impl
    iterator insert(const_iterator hint, reference value)
    {  return tree_type::insert_unique(hint, value);  }
 
+   //! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_check
+      (const key_type &key, insert_commit_data &commit_data)
+   {  return tree_type::insert_unique_check(key, commit_data); }
+
+   //! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const_iterator,const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_check
+      (const_iterator hint, const key_type &key
+      ,insert_commit_data &commit_data)
+   {  return tree_type::insert_unique_check(hint, key, commit_data); }
+
    //! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<iterator, bool> insert_check
@@ -319,21 +348,21 @@ class sg_set_impl
 
    #endif   //   #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
+   //! @copydoc ::boost::intrusive::sgtree::equal_range(const key_type &)
    std::pair<iterator,iterator> equal_range(const key_type &key)
    {  return this->tree_type::lower_bound_range(key); }
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
+   //! @copydoc ::boost::intrusive::sgtree::equal_range(const KeyType&,KeyTypeKeyCompare)
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
    {  return this->tree_type::equal_range(key, comp); }
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
+   //! @copydoc ::boost::intrusive::sgtree::equal_range(const key_type &)const
    std::pair<const_iterator, const_iterator>
       equal_range(const key_type &key) const
    {  return this->tree_type::lower_bound_range(key); }
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
+   //! @copydoc ::boost::intrusive::sgtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<const_iterator, const_iterator>
       equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
@@ -395,6 +424,24 @@ class sg_set_impl
    //! @copydoc ::boost::intrusive::sgtree::balance_factor(float)
    void balance_factor(float new_alpha);
 
+   //! @copydoc ::boost::intrusive::rbtree::merge_unique
+   template<class ...Options2>
+   void merge(sg_set<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::rbtree::merge_unique
+   template<class ...Options2>
+   void merge(sg_multiset<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(sg_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, FloatingPoint, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
+   template<class Compare2>
+   void merge(sg_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, FloatingPoint, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -487,8 +534,11 @@ class sg_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit sg_set( const key_compare &cmp = key_compare()
-                  , const value_traits &v_traits = value_traits())
+   sg_set()
+      :  Base()
+   {}
+
+   explicit sg_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
@@ -584,9 +634,13 @@ class sg_multiset_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::sgtree::sgtree()
+   sg_multiset_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::sgtree::sgtree(const key_compare &,const value_traits &)
-   explicit sg_multiset_impl( const key_compare &cmp = key_compare()
-                         , const value_traits &v_traits = value_traits())
+   explicit sg_multiset_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -647,6 +701,15 @@ class sg_multiset_impl
    //! @copydoc ::boost::intrusive::sgtree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::sgtree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::sgtree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::sgtree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::sgtree::container_from_end_iterator(iterator)
    static sg_multiset_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -867,6 +930,24 @@ class sg_multiset_impl
    //! @copydoc ::boost::intrusive::sgtree::balance_factor(float)
    void balance_factor(float new_alpha);
 
+   //! @copydoc ::boost::intrusive::treap::merge_unique
+   template<class ...Options2>
+   void merge(sg_multiset<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::treap::merge_unique
+   template<class ...Options2>
+   void merge(sg_set<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(sg_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, FloatingPoint, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
+   template<class Compare2>
+   void merge(sg_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, FloatingPoint, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -960,8 +1041,11 @@ class sg_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   sg_multiset( const key_compare &cmp = key_compare()
-           , const value_traits &v_traits = value_traits())
+   sg_multiset()
+      :  Base()
+   {}
+
+   explicit sg_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/sgtree.hpp

@@ -156,6 +156,9 @@ struct alpha_holder
    multiply_by_alpha_t get_multiply_by_alpha_t() const
    {  return multiply_by_alpha_t(alpha_);  }
 
+   SizeType &get_max_tree_size()
+   {  return max_tree_size_;  }
+
    protected:
    float alpha_;
    float inv_minus_logalpha_;
@@ -189,6 +192,10 @@ struct alpha_holder<false, SizeType>
    multiply_by_alpha_t get_multiply_by_alpha_t() const
    {  return multiply_by_alpha_t();  }
 
+   SizeType &get_max_tree_size()
+   {  return max_tree_size_;  }
+
+   protected:
    SizeType max_tree_size_;
 };
 
@@ -281,9 +288,13 @@ class sgtree_impl
 
    typedef BOOST_INTRUSIVE_IMPDEF(typename node_algorithms::insert_commit_data) insert_commit_data;
 
+   //! @copydoc ::boost::intrusive::bstree::bstree()
+   sgtree_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
-   explicit sgtree_impl( const key_compare &cmp = key_compare()
-                       , const value_traits &v_traits = value_traits())
+   explicit sgtree_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -371,6 +382,15 @@ class sgtree_impl
    //! @copydoc ::boost::intrusive::bstree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::bstree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::bstree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::bstree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::bstree::container_from_end_iterator(iterator)
    static sgtree_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -486,7 +506,11 @@ class sgtree_impl
 
    //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
    template<class KeyType, class KeyTypeKeyCompare>
-   std::pair<iterator, bool> insert_unique_check
+   BOOST_INTRUSIVE_DOC1ST(std::pair<iterator BOOST_INTRUSIVE_I bool>
+      , typename detail::disable_if_convertible
+         <KeyType BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I 
+         std::pair<iterator BOOST_INTRUSIVE_I bool> >::type)
+      insert_unique_check
       (const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
    {
       std::pair<node_ptr, bool> ret =
@@ -507,6 +531,16 @@ class sgtree_impl
       return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
    }
 
+   //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_unique_check
+      (const key_type &key, insert_commit_data &commit_data)
+   {  return this->insert_unique_check(key, this->key_comp(), commit_data);   }
+
+   //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_unique_check
+      (const_iterator hint, const key_type &key, insert_commit_data &commit_data)
+   {  return this->insert_unique_check(hint, key, this->key_comp(), commit_data);   }
+
    //! @copydoc ::boost::intrusive::bstree::insert_unique_commit
    iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
    {
@@ -678,6 +712,66 @@ class sgtree_impl
       this->max_tree_size_ = 0;
    }
 
+   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+   //! @copydoc ::boost::intrusive::bstree::merge_unique
+   template<class T, class ...Options2> void merge_unique(sgtree<T, Options2...> &);
+   #else
+   template<class Compare2>
+   void merge_unique(sgtree_impl
+      <ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, FloatingPoint, HeaderHolder> &source)
+   #endif
+   {
+      node_ptr it   (node_algorithms::begin_node(source.header_ptr()))
+             , itend(node_algorithms::end_node  (source.header_ptr()));
+
+      while(it != itend){
+         node_ptr const p(it);
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || !node_algorithms::unique(p));
+         it = node_algorithms::next_node(it);
+
+         std::size_t max_tree1_size = this->max_tree_size_;
+         std::size_t max_tree2_size = source.get_max_tree_size();
+         if( node_algorithms::transfer_unique
+               ( this->header_ptr(), this->key_node_comp(this->key_comp()), this->size(), max_tree1_size
+               , source.header_ptr(), p, source.size(), max_tree2_size
+               , this->get_h_alpha_func(), this->get_alpha_by_max_size_func()) ){
+            this->max_tree_size_  = (size_type)max_tree1_size;
+            this->sz_traits().increment();
+            source.get_max_tree_size() = (size_type)max_tree2_size;
+            source.sz_traits().decrement();
+         }
+      }
+   }
+
+   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+   //! @copydoc ::boost::intrusive::bstree::merge_equal
+   template<class T, class ...Options2> void merge_equal(sgtree<T, Options2...> &);
+   #else
+   template<class Compare2>
+   void merge_equal(sgtree_impl
+      <ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, FloatingPoint, HeaderHolder> &source)
+   #endif
+   {
+      node_ptr it   (node_algorithms::begin_node(source.header_ptr()))
+             , itend(node_algorithms::end_node  (source.header_ptr()));
+
+      while(it != itend){
+         node_ptr const p(it);
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || !node_algorithms::unique(p));
+         it = node_algorithms::next_node(it);
+         std::size_t max_tree1_size = this->max_tree_size_;
+         std::size_t max_tree2_size = source.get_max_tree_size();
+         node_algorithms::transfer_equal
+            ( this->header_ptr(), this->key_node_comp(this->key_comp()), this->size(), max_tree1_size
+            , source.header_ptr(), p, source.size(), max_tree2_size
+            , this->get_h_alpha_func(), this->get_alpha_by_max_size_func());
+         this->max_tree_size_  = (size_type)max_tree1_size;
+         this->sz_traits().increment();
+         source.get_max_tree_size() = (size_type)max_tree2_size;
+         source.sz_traits().decrement();
+      }
+   }
+
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    //! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
    size_type count(const key_type &key) const;
@@ -934,8 +1028,11 @@ class sgtree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit sgtree( const key_compare &cmp = key_compare()
-                  , const value_traits &v_traits = value_traits())
+   sgtree()
+      :  Base()
+   {}
+
+   explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/sgtree_algorithms.hpp

@@ -138,7 +138,6 @@ class sgtree_algorithms
    template<class AlphaByMaxSize>
    static node_ptr erase(const node_ptr & header, const node_ptr & z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize)
    {
-      //typename bstree_algo::data_for_rebalance info;
       bstree_algo::erase(header, z);
       --tree_size;
       if (tree_size > 0 &&
@@ -288,12 +287,38 @@ class sgtree_algorithms
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(const node_ptr&,const node_ptr&,const insert_commit_data&)
    template<class H_Alpha>
-   static void insert_unique_commit
+   BOOST_INTRUSIVE_FORCEINLINE static void insert_unique_commit
       (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data
       ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {  return insert_commit(header, new_value, commit_data, tree_size, h_alpha, max_tree_size);  }
+
+   //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_unique
+   template<class NodePtrCompare, class H_Alpha, class AlphaByMaxSize>
+   static bool transfer_unique
+      ( const node_ptr & header1, NodePtrCompare comp, std::size_t tree1_size, std::size_t &max_tree1_size
+      , const node_ptr &header2, const node_ptr & z,   std::size_t tree2_size, std::size_t &max_tree2_size
+      ,H_Alpha h_alpha, AlphaByMaxSize alpha_by_maxsize)
    {
-      bstree_algo::insert_unique_commit(header, new_value, commit_data);
-      rebalance_after_insertion(new_value, commit_data.depth, tree_size+1, h_alpha, max_tree_size);
+      insert_commit_data commit_data;
+      bool const transferable = insert_unique_check(header1, z, comp, commit_data).second;
+      if(transferable){
+         erase(header2, z, tree2_size, max_tree2_size, alpha_by_maxsize);
+         insert_commit(header1, z, commit_data, tree1_size, h_alpha, max_tree1_size);
+      }
+      return transferable;
+   }
+
+   //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_equal
+   template<class NodePtrCompare, class H_Alpha, class AlphaByMaxSize>
+   static void transfer_equal
+      ( const node_ptr & header1, NodePtrCompare comp, std::size_t tree1_size, std::size_t &max_tree1_size
+      , const node_ptr &header2, const node_ptr & z,   std::size_t tree2_size, std::size_t &max_tree2_size
+      ,H_Alpha h_alpha, AlphaByMaxSize alpha_by_maxsize)
+   {
+      insert_commit_data commit_data;
+      insert_equal_upper_bound_check(header1, z, comp, commit_data);
+      erase(header2, z, tree2_size, max_tree2_size, alpha_by_maxsize);
+      insert_commit(header1, z, commit_data, tree1_size, h_alpha, max_tree1_size);
    }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -310,6 +335,25 @@ class sgtree_algorithms
    /// @cond
    private:
 
+   template<class KeyType, class KeyNodePtrCompare>
+   static void insert_equal_upper_bound_check
+      (const node_ptr & header,  const KeyType &key
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
+   {
+      std::size_t depth;
+      bstree_algo::insert_equal_upper_bound_check(header, key, comp, commit_data, &depth);
+      commit_data.depth = depth;
+   }
+
+   template<class H_Alpha>
+   static void insert_commit
+      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data
+      ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {
+      bstree_algo::insert_unique_commit(header, new_value, commit_data);
+      rebalance_after_insertion(new_value, commit_data.depth, tree_size+1, h_alpha, max_tree_size);
+   }
+
    template<class H_Alpha>
    static void rebalance_after_insertion
       (const node_ptr &x, std::size_t depth

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

@@ -307,7 +307,17 @@ class slist_impl
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks).
-   explicit slist_impl(const value_traits &v_traits = value_traits())
+   slist_impl()
+      :  data_(value_traits())
+   {  this->set_default_constructed_state(); }
+
+   //! <b>Effects</b>: constructs an empty list.
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: If value_traits::node_traits::node
+   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks).
+   explicit slist_impl(const value_traits &v_traits)
       :  data_(v_traits)
    {  this->set_default_constructed_state(); }
 
@@ -333,8 +343,7 @@ class slist_impl
    slist_impl(BOOST_RV_REF(slist_impl) x)
       : data_(::boost::move(x.priv_value_traits()))
    {
-      this->priv_size_traits().set_size(size_type(0));
-      node_algorithms::init_header(this->get_root_node());
+      this->set_default_constructed_state();
       //nothrow, no need to rollback to release elements on exception
       this->swap(x);
    }
@@ -707,11 +716,7 @@ class slist_impl
       else{
          this->priv_swap_lists(this->get_root_node(), other.get_root_node(), detail::bool_<linear>());
       }
-      if(constant_time_size){
-         size_type backup = this->priv_size_traits().get_size();
-         this->priv_size_traits().set_size(other.priv_size_traits().get_size());
-         other.priv_size_traits().set_size(backup);
-      }
+      this->priv_size_traits().swap(other.priv_size_traits());
    }
 
    //! <b>Effects</b>: Moves backwards all the elements, so that the first
@@ -1110,7 +1115,7 @@ class slist_impl
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Complexity</b>: Lineal to the elements (l - before_f + 1).
+   //! <b>Complexity</b>: Linear to the elements (l - before_f + 1).
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>
@@ -1255,7 +1260,7 @@ class slist_impl
          if(l) *l = this->previous(this->cend());
       }
       else{
-         const_iterator last_x(x.previous(x.end()));  //<- constant time if cache_last is active
+         const_iterator last_x(x.previous(x.end()));  //constant time if cache_last is active
          node_ptr prev_n(prev.pointed_node());
          node_ptr last_x_n(last_x.pointed_node());
          if(cache_last){
@@ -2190,7 +2195,11 @@ class slist
    typedef typename Base::size_type          size_type;
    typedef typename Base::node_ptr           node_ptr;
 
-   explicit slist(const value_traits &v_traits = value_traits())
+   slist()
+      :  Base()
+   {}
+
+   explicit slist(const value_traits &v_traits)
       :  Base(v_traits)
    {}