passenger 5.0.24 → 5.0.25

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

@@ -1,7 +1,7 @@
 /////////////////////////////////////////////////////////////////////////////
 //
 // (C) Copyright Olaf Krzikalla 2004-2006.
-// (C) Copyright Ion Gaztanaga  2006-2012
+// (C) Copyright Ion Gaztanaga  2006-2013
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -14,10 +14,16 @@
 #ifndef BOOST_INTRUSIVE_SLIST_NODE_HPP
 #define BOOST_INTRUSIVE_SLIST_NODE_HPP
 
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
 #include <boost/intrusive/detail/config_begin.hpp>
-#include <iterator>
-#include <boost/intrusive/detail/assert.hpp>
-#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/intrusive/pointer_rebind.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -25,8 +31,7 @@ namespace intrusive {
 template<class VoidPointer>
 struct slist_node
 {
-   typedef typename pointer_traits
-      <VoidPointer>::template rebind_pointer<slist_node>::type   node_ptr;
+   typedef typename pointer_rebind<VoidPointer, slist_node>::type   node_ptr;
    node_ptr next_;
 };
 
@@ -36,11 +41,9 @@ struct slist_node
 template<class VoidPointer>
 struct slist_node_traits
 {
-   typedef slist_node<VoidPointer> node;
-   typedef typename pointer_traits
-      <VoidPointer>::template rebind_pointer<node>::type          node_ptr;
-   typedef typename pointer_traits
-      <VoidPointer>::template rebind_pointer<const node>::type    const_node_ptr;
+   typedef slist_node<VoidPointer>  node;
+   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)
    {  return n->next_;  }
@@ -52,112 +55,6 @@ struct slist_node_traits
    {  n->next_ = next;  }
 };
 
-// slist_iterator provides some basic functions for a
-// node oriented bidirectional iterator:
-template<class Container, bool IsConst>
-class slist_iterator
-   :  public std::iterator
-         < std::forward_iterator_tag
-         , typename Container::value_type
-         , typename Container::difference_type
-         , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type
-         , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type
-         >
-{
-   protected:
-   typedef typename Container::real_value_traits   real_value_traits;
-   typedef typename real_value_traits::node_traits node_traits;
-   typedef typename node_traits::node              node;
-   typedef typename node_traits::node_ptr          node_ptr;
-   typedef typename pointer_traits
-      <node_ptr>::template rebind_pointer <void>::type                       void_pointer;
-   static const bool store_container_ptr =
-      detail::store_cont_ptr_on_it<Container>::value;
-
-   public:
-   typedef typename Container::value_type    value_type;
-   typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer;
-   typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;
-
-   slist_iterator()
-      : members_ (node_ptr(), 0)
-   {}
-
-   explicit slist_iterator(const node_ptr & node, const Container *cont_ptr)
-      : members_ (node, cont_ptr)
-   {}
-
-   slist_iterator(slist_iterator<Container, false> const& other)
-      :  members_(other.pointed_node(), other.get_container())
-   {}
-
-   const node_ptr &pointed_node() const
-   { return members_.nodeptr_; }
-
-   slist_iterator &operator=(const node_ptr &node)
-   {  members_.nodeptr_ = node;  return static_cast<slist_iterator&>(*this);  }
-
-   public:
-   slist_iterator& operator++()
-   {
-      members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
-      return static_cast<slist_iterator&> (*this);
-   }
-
-   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)
-   {  return l.pointed_node() == r.pointed_node();   }
-
-   friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
-   {  return !(l == r);   }
-
-   reference operator*() const
-   {  return *operator->();   }
-
-   pointer operator->() const
-   { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); }
-
-   const Container *get_container() const
-   {
-      if(store_container_ptr)
-         return static_cast<const Container*>(members_.get_ptr());
-      else
-         return 0;
-   }
-
-   slist_iterator<Container, false> unconst() const
-   {  return slist_iterator<Container, false>(this->pointed_node(), this->get_container());   }
-
-   const real_value_traits *get_real_value_traits() const
-   {
-      if(store_container_ptr)
-         return &this->get_container()->get_real_value_traits();
-      else
-         return 0;
-   }
-
-   private:
-   struct members
-      :  public detail::select_constptr
-         <void_pointer, store_container_ptr>::type
-   {
-      typedef typename detail::select_constptr
-         <void_pointer, store_container_ptr>::type Base;
-
-      members(const node_ptr &n_ptr, const void *cont)
-         :  Base(cont), nodeptr_(n_ptr)
-      {}
-
-      node_ptr nodeptr_;
-   } members_;
-};
-
 } //namespace intrusive
 } //namespace boost
 

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

@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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_INTRUSIVE_DETAIL_STD_FWD_HPP
+#define BOOST_INTRUSIVE_DETAIL_STD_FWD_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//                        Standard predeclarations
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/move/detail/std_ns_begin.hpp>
+BOOST_MOVE_STD_NS_BEG
+
+template<class T>
+struct less;
+
+template<class T>
+struct equal_to;
+
+struct input_iterator_tag;
+struct forward_iterator_tag;
+struct bidirectional_iterator_tag;
+struct random_access_iterator_tag;
+
+BOOST_MOVE_STD_NS_END
+#include <boost/move/detail/std_ns_end.hpp>
+
+#endif //#ifndef BOOST_INTRUSIVE_DETAIL_STD_FWD_HPP

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

@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2014-2014
+//
+// 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
+#define BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/pointer_element.hpp>
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template <class T>
+inline T* to_raw_pointer(T* p)
+{  return p; }
+
+template <class Pointer>
+inline typename boost::intrusive::pointer_element<Pointer>::type*
+to_raw_pointer(const Pointer &p)
+{  return boost::intrusive::detail::to_raw_pointer(p.operator->());  }
+
+} //namespace detail
+} //namespace intrusive
+} //namespace boost
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP

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

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2007-2012
+// (C) Copyright Ion Gaztanaga 2007-2013
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -13,9 +13,17 @@
 #ifndef BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP
 #define BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP
 
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
 #include <boost/intrusive/detail/config_begin.hpp>
-#include <iterator>
 #include <boost/intrusive/detail/mpl.hpp>
+#include <boost/intrusive/detail/iterator.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -51,14 +59,14 @@ struct operator_arrow_proxy<T&>
 
 template <class Iterator, class UnaryFunction>
 class transform_iterator
-   : public std::iterator
-      < typename Iterator::iterator_category
-      , typename detail::remove_reference<typename UnaryFunction::result_type>::type
-      , typename Iterator::difference_type
-      , operator_arrow_proxy<typename UnaryFunction::result_type>
-      , typename UnaryFunction::result_type>
 {
    public:
+   typedef typename Iterator::iterator_category                                           iterator_category;
+   typedef typename detail::remove_reference<typename UnaryFunction::result_type>::type   value_type;
+   typedef typename Iterator::difference_type                                             difference_type;
+   typedef operator_arrow_proxy<typename UnaryFunction::result_type>                      pointer;
+   typedef typename UnaryFunction::result_type                                            reference;
+   
    explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
       :  members_(it, f)
    {}
@@ -87,16 +95,6 @@ class transform_iterator
    friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i == i2); }
 
-/*
-   friend bool operator> (const transform_iterator& i, const transform_iterator& i2)
-   { return i2 < i; }
-
-   friend bool operator<= (const transform_iterator& i, const transform_iterator& i2)
-   { return !(i > i2); }
-
-   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)
    { return i2.distance_to(i); }
 
@@ -158,10 +156,10 @@ class transform_iterator
    { return members_(*members_.m_it); }
 
    void advance(typename Iterator::difference_type n)
-   {  std::advance(members_.m_it, n); }
+   {  boost::intrusive::iterator_advance(members_.m_it, n); }
 
    typename Iterator::difference_type distance_to(const transform_iterator &other)const
-   {  return std::distance(other.members_.m_it, members_.m_it); }
+   {  return boost::intrusive::iterator_distance(other.members_.m_it, members_.m_it); }
 };
 
 } //namespace detail

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

@@ -0,0 +1,171 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2007-2013
+//
+// 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_TREE_ITERATOR_HPP
+#define BOOST_INTRUSIVE_TREE_ITERATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/std_fwd.hpp>
+#include <boost/intrusive/detail/iiterator.hpp>
+#include <boost/intrusive/detail/bstree_algorithms_base.hpp>
+
+namespace boost {
+namespace intrusive {
+
+/////////////////////////////////////////////////////////////////////////////
+//                                                                         //
+//                   Implementation of the tree iterator                   //
+//                                                                         //
+/////////////////////////////////////////////////////////////////////////////
+
+// tree_iterator provides some basic functions for a
+// node oriented bidirectional iterator:
+template<class ValueTraits, bool IsConst>
+class tree_iterator
+{
+   private:
+   typedef iiterator< ValueTraits, IsConst
+                    , std::bidirectional_iterator_tag>   types_t;
+   typedef typename types_t::value_traits                value_traits;
+   typedef typename types_t::node_traits                 node_traits;
+   typedef typename types_t::node                        node;
+   typedef typename types_t::node_ptr                    node_ptr;
+   typedef typename types_t::const_value_traits_ptr      const_value_traits_ptr;
+   typedef bstree_algorithms_base<node_traits>           node_algorithms;
+
+   static const bool stateful_value_traits = types_t::stateful_value_traits;
+
+   void unspecified_bool_type_func() const {}
+   typedef void (tree_iterator::*unspecified_bool_type)() const;
+
+   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;
+
+   tree_iterator()
+   {}
+
+   explicit tree_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
+      : members_(nodeptr, traits_ptr)
+   {}
+
+   tree_iterator(tree_iterator<value_traits, false> const& other)
+      :  members_(other.pointed_node(), other.get_value_traits())
+   {}
+
+   const node_ptr &pointed_node() const
+   { return members_.nodeptr_; }
+
+   tree_iterator &operator=(const node_ptr &nodeptr)
+   {  members_.nodeptr_ = nodeptr;  return static_cast<tree_iterator&>(*this);  }
+
+   public:
+   tree_iterator& operator++()
+   {
+      members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
+      return static_cast<tree_iterator&> (*this);
+   }
+
+   tree_iterator operator++(int)
+   {
+      tree_iterator result (*this);
+      members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
+      return result;
+   }
+
+   tree_iterator& operator--()
+   {
+      members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
+      return static_cast<tree_iterator&> (*this);
+   }
+
+   tree_iterator operator--(int)
+   {
+      tree_iterator result (*this);
+      members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
+      return result;
+   }
+
+   tree_iterator&  go_left()
+   {
+      members_.nodeptr_ = node_traits::get_left(members_.nodeptr_);
+      return static_cast<tree_iterator&> (*this);
+   }
+
+   tree_iterator&  go_right()
+   {
+      members_.nodeptr_ = node_traits::get_right(members_.nodeptr_);
+      return static_cast<tree_iterator&> (*this);
+   }
+
+   tree_iterator&  go_parent()
+   {
+      members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_);
+      return static_cast<tree_iterator&> (*this);
+   }
+
+   operator unspecified_bool_type() const
+   {  return members_.nodeptr_ ? &tree_iterator::unspecified_bool_type_func : 0;   }
+
+   bool operator! () const
+   {  return !members_.nodeptr_;   }
+
+   friend bool operator== (const tree_iterator& l, const tree_iterator& r)
+   { return l.pointed_node() == r.pointed_node(); }
+
+   friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
+   {  return !(l == r);   }
+
+   reference operator*() const
+   {  return *operator->();   }
+
+   pointer operator->() const
+   { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
+
+   const_value_traits_ptr get_value_traits() const
+   {  return members_.get_ptr();  }
+
+   tree_iterator end_iterator_from_it() const
+   {
+      return tree_iterator(node_algorithms::get_header(this->pointed_node()), this->get_value_traits());
+   }
+
+   tree_iterator<value_traits, false> unconst() const
+   {  return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits());   }
+
+   private:
+   pointer operator_arrow(detail::false_) const
+   { return ValueTraits::to_value_ptr(members_.nodeptr_); }
+
+   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_;
+};
+
+} //namespace intrusive
+} //namespace boost
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_TREE_ITERATOR_HPP