passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/reverse_iterator.hpp

@@ -43,12 +43,16 @@ class reverse_iterator
 
    reverse_iterator()
       : m_current()  //Value initialization to achieve "null iterators" (N3644)
-      {}
+   {}
 
    explicit reverse_iterator(It r)
       : m_current(r)
    {}
 
+   reverse_iterator(const reverse_iterator& r)
+      : m_current(r.base())
+   {}
+
    template<class OtherIt>
    reverse_iterator( const reverse_iterator<OtherIt>& r
                    , typename boost::intrusive::detail::enable_if_convertible<OtherIt, It>::type* =0
@@ -56,6 +60,9 @@ class reverse_iterator
       : m_current(r.base())
    {}
 
+   reverse_iterator & operator=( const reverse_iterator& r)
+   {  m_current = r.base();   return *this;  }
+
    template<class OtherIt>
    typename boost::intrusive::detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
          operator=( const reverse_iterator<OtherIt>& r)
@@ -65,20 +72,34 @@ class reverse_iterator
    {  return m_current;  }
 
    reference operator*() const
-   {  It temp(m_current);   --temp; return *temp; }
+   {
+      It temp(m_current);
+      --temp;
+      reference r = *temp;
+      return r;
+   }
 
    pointer operator->() const
-   {  It temp(m_current);   --temp; return iterator_arrow_result(temp); }
+   {
+      It temp(m_current);
+      --temp;
+      return iterator_arrow_result(temp);
+   }
 
    reference operator[](difference_type off) const
-   {  return this->m_current[-off - 1];  }
+   {
+      return this->m_current[-off - 1];
+   }
 
    reverse_iterator& operator++()
-   {  --m_current;   return *this;   }
+   {
+      --m_current;
+      return *this;
+   }
 
    reverse_iterator operator++(int)
    {
-      reverse_iterator temp = *this;
+      reverse_iterator temp((*this));
       --m_current;
       return temp;
    }
@@ -91,7 +112,7 @@ class reverse_iterator
 
    reverse_iterator operator--(int)
    {
-      reverse_iterator temp(*this);
+      reverse_iterator temp((*this));
       ++m_current;
       return temp;
    }
@@ -117,17 +138,17 @@ class reverse_iterator
    reverse_iterator& operator+=(difference_type off)
    {  m_current -= off; return *this;  }
 
+   reverse_iterator& operator-=(difference_type off)
+   {  m_current += off; return *this;  }
+
    friend reverse_iterator operator+(reverse_iterator l, difference_type off)
-   {  l.m_current -= off;  return l;  }
+   {  return (l += off);  }
 
    friend reverse_iterator operator+(difference_type off, reverse_iterator r)
    {  return (r += off);   }
 
-   reverse_iterator& operator-=(difference_type off)
-   {  m_current += off; return *this;  }
-
    friend reverse_iterator operator-(reverse_iterator l, difference_type off)
-   {  l.m_current += off;  return l;  }
+   {  return (l-= off);  }
 
    friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
    {  return r.m_current - l.m_current;  }

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/size_holder.hpp

@@ -21,6 +21,8 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
+
 namespace boost {
 namespace intrusive {
 namespace detail {
@@ -31,24 +33,27 @@ struct size_holder
    static const bool constant_time_size = ConstantSize;
    typedef SizeType  size_type;
 
-   SizeType get_size() const
+   BOOST_INTRUSIVE_FORCEINLINE SizeType get_size() const
    {  return size_;  }
 
-   void set_size(SizeType size)
+   BOOST_INTRUSIVE_FORCEINLINE void set_size(SizeType size)
    {  size_ = size; }
 
-   void decrement()
+   BOOST_INTRUSIVE_FORCEINLINE void decrement()
    {  --size_; }
 
-   void increment()
+   BOOST_INTRUSIVE_FORCEINLINE void increment()
    {  ++size_; }
 
-   void increase(SizeType n)
+   BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType n)
    {  size_ += n; }
 
-   void decrease(SizeType n)
+   BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType n)
    {  size_ -= n; }
 
+   BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder &other)
+   {  SizeType tmp(size_); size_ = other.size_; other.size_ = tmp; }
+
    SizeType size_;
 };
 
@@ -58,23 +63,25 @@ struct size_holder<false, SizeType, Tag>
    static const bool constant_time_size = false;
    typedef SizeType  size_type;
 
-   size_type get_size() const
+   BOOST_INTRUSIVE_FORCEINLINE size_type get_size() const
    {  return 0;  }
 
-   void set_size(size_type)
+   BOOST_INTRUSIVE_FORCEINLINE void set_size(size_type)
    {}
 
-   void decrement()
+   BOOST_INTRUSIVE_FORCEINLINE void decrement()
    {}
 
-   void increment()
+   BOOST_INTRUSIVE_FORCEINLINE void increment()
    {}
 
-   void increase(SizeType)
+   BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType)
    {}
 
-   void decrease(SizeType)
+   BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType)
    {}
+
+   BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder){}
 };
 
 }  //namespace detail{

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/slist_iterator.hpp

@@ -23,6 +23,7 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/std_fwd.hpp>
 #include <boost/intrusive/detail/iiterator.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
@@ -50,67 +51,67 @@ class slist_iterator
    typedef typename types_t::const_value_traits_ptr         const_value_traits_ptr;
 
    public:
-   typedef typename types_t::iterator_traits::difference_type    difference_type;
-   typedef typename types_t::iterator_traits::value_type         value_type;
-   typedef typename types_t::iterator_traits::pointer            pointer;
-   typedef typename types_t::iterator_traits::reference          reference;
-   typedef typename types_t::iterator_traits::iterator_category  iterator_category;
+   typedef typename types_t::iterator_type::difference_type    difference_type;
+   typedef typename types_t::iterator_type::value_type         value_type;
+   typedef typename types_t::iterator_type::pointer            pointer;
+   typedef typename types_t::iterator_type::reference          reference;
+   typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   slist_iterator()
+   BOOST_INTRUSIVE_FORCEINLINE slist_iterator()
    {}
 
-   explicit slist_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
+   BOOST_INTRUSIVE_FORCEINLINE explicit slist_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   slist_iterator(slist_iterator<ValueTraits, false> const& other)
+   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(slist_iterator<ValueTraits, false> const& other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   const node_ptr &pointed_node() const
+   BOOST_INTRUSIVE_FORCEINLINE const node_ptr &pointed_node() const
    { return members_.nodeptr_; }
 
-   slist_iterator &operator=(const node_ptr &node)
+   BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(const node_ptr &node)
    {  members_.nodeptr_ = node;  return static_cast<slist_iterator&>(*this);  }
 
-   const_value_traits_ptr get_value_traits() const
+   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }
 
    public:
-   slist_iterator& operator++()
+   BOOST_INTRUSIVE_FORCEINLINE slist_iterator& operator++()
    {
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return static_cast<slist_iterator&> (*this);
    }
 
-   slist_iterator operator++(int)
+   BOOST_INTRUSIVE_FORCEINLINE slist_iterator operator++(int)
    {
       slist_iterator result (*this);
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return result;
    }
 
-   friend bool operator== (const slist_iterator& l, const slist_iterator& r)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const slist_iterator& l, const slist_iterator& r)
    {  return l.pointed_node() == r.pointed_node();   }
 
-   friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
    {  return !(l == r);   }
 
-   reference operator*() const
+   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
    {  return *operator->();   }
 
-   pointer operator->() const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   slist_iterator<ValueTraits, false> unconst() const
+   BOOST_INTRUSIVE_FORCEINLINE slist_iterator<ValueTraits, false> unconst() const
    {  return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
 
-   pointer operator_arrow(detail::false_) const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   pointer operator_arrow(detail::true_) const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/slist_node.hpp

@@ -23,6 +23,7 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
 
 namespace boost {
@@ -45,13 +46,13 @@ struct slist_node_traits
    typedef typename node::node_ptr  node_ptr;
    typedef typename pointer_rebind<VoidPointer, const node>::type    const_node_ptr;
 
-   static node_ptr get_next(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const const_node_ptr & n)
    {  return n->next_;  }
 
-   static node_ptr get_next(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const node_ptr & n)
    {  return n->next_;  }
 
-   static void set_next(const node_ptr & n, const node_ptr & next)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_next(const node_ptr & n, const node_ptr & next)
    {  n->next_ = next;  }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/to_raw_pointer.hpp

@@ -22,6 +22,7 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/pointer_element.hpp>
 
 namespace boost {
@@ -29,11 +30,11 @@ namespace intrusive {
 namespace detail {
 
 template <class T>
-inline T* to_raw_pointer(T* p)
+BOOST_INTRUSIVE_FORCEINLINE T* to_raw_pointer(T* p)
 {  return p; }
 
 template <class Pointer>
-inline typename boost::intrusive::pointer_element<Pointer>::type*
+BOOST_INTRUSIVE_FORCEINLINE typename boost::intrusive::pointer_element<Pointer>::type*
 to_raw_pointer(const Pointer &p)
 {  return boost::intrusive::detail::to_raw_pointer(p.operator->());  }
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/transform_iterator.hpp

@@ -22,6 +22,7 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/detail/iterator.hpp>
 
@@ -32,11 +33,11 @@ namespace detail {
 template <class PseudoReference>
 struct operator_arrow_proxy
 {
-   operator_arrow_proxy(const PseudoReference &px)
+   BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(const PseudoReference &px)
       :  m_value(px)
    {}
 
-   PseudoReference* operator->() const { return &m_value; }
+   BOOST_INTRUSIVE_FORCEINLINE PseudoReference* operator->() const { return &m_value; }
    // This function is needed for MWCW and BCC, which won't call operator->
    // again automatically per 13.3.1.2 para 8
 //   operator T*() const { return &m_value; }
@@ -46,11 +47,11 @@ struct operator_arrow_proxy
 template <class T>
 struct operator_arrow_proxy<T&>
 {
-   operator_arrow_proxy(T &px)
+   BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(T &px)
       :  m_value(px)
    {}
 
-   T* operator->() const { return &m_value; }
+   BOOST_INTRUSIVE_FORCEINLINE T* operator->() const { return &m_value; }
    // This function is needed for MWCW and BCC, which won't call operator->
    // again automatically per 13.3.1.2 para 8
 //   operator T*() const { return &m_value; }
@@ -75,53 +76,53 @@ class transform_iterator
       :  members_()
    {}
 
-   Iterator get_it() const
+   BOOST_INTRUSIVE_FORCEINLINE Iterator get_it() const
    {  return members_.m_it;   }
 
    //Constructors
-   transform_iterator& operator++()
+   BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator++()
    { increment();   return *this;   }
 
-   transform_iterator operator++(int)
+   BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator++(int)
    {
       transform_iterator result (*this);
       increment();
       return result;
    }
 
-   friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
    { return i.equal(i2); }
 
-   friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i == i2); }
 
-   friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
+   BOOST_INTRUSIVE_FORCEINLINE friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
    transform_iterator& operator+=(typename Iterator::difference_type off)
    {  this->advance(off); return *this;   }
 
-   transform_iterator operator+(typename Iterator::difference_type off) const
+   BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator+(typename Iterator::difference_type off) const
    {
       transform_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
+   BOOST_INTRUSIVE_FORCEINLINE friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
    {  return right + off; }
 
-   transform_iterator& operator-=(typename Iterator::difference_type off)
+   BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator-=(typename Iterator::difference_type off)
    {  this->advance(-off); return *this;   }
 
-   transform_iterator operator-(typename Iterator::difference_type off) const
+   BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator-(typename Iterator::difference_type off) const
    {  return *this + (-off);  }
 
-   typename UnaryFunction::result_type operator*() const
+   BOOST_INTRUSIVE_FORCEINLINE typename UnaryFunction::result_type operator*() const
    { return dereference(); }
 
-   operator_arrow_proxy<typename UnaryFunction::result_type>
+   BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy<typename UnaryFunction::result_type>
       operator->() const
    { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
 
@@ -129,27 +130,27 @@ class transform_iterator
    struct members
       :  UnaryFunction
    {
-      members(const Iterator &it, const UnaryFunction &f)
+      BOOST_INTRUSIVE_FORCEINLINE members(const Iterator &it, const UnaryFunction &f)
          :  UnaryFunction(f), m_it(it)
       {}
 
-      members()
+      BOOST_INTRUSIVE_FORCEINLINE members()
       {}
 
       Iterator m_it;
    } members_;
 
 
-   void increment()
+   BOOST_INTRUSIVE_FORCEINLINE void increment()
    { ++members_.m_it; }
 
-   void decrement()
+   BOOST_INTRUSIVE_FORCEINLINE void decrement()
    { --members_.m_it; }
 
-   bool equal(const transform_iterator &other) const
+   BOOST_INTRUSIVE_FORCEINLINE bool equal(const transform_iterator &other) const
    {  return members_.m_it == other.members_.m_it;   }
 
-   bool less(const transform_iterator &other) const
+   BOOST_INTRUSIVE_FORCEINLINE bool less(const transform_iterator &other) const
    {  return other.members_.m_it < members_.m_it;   }
 
    typename UnaryFunction::result_type dereference() const