passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/algorithm/string/detail/util.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <functional>
-#include <boost/range/iterator_range.hpp>
+#include <boost/range/iterator_range_core.hpp>
 
 namespace boost {
     namespace algorithm {

data/src/cxx_supportlib/vendor-modified/boost/algorithm/string/erase.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/algorithm/string/config.hpp>
 
-#include <boost/range/iterator_range.hpp>
+#include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/iterator.hpp>

data/src/cxx_supportlib/vendor-modified/boost/algorithm/string/find.hpp

@@ -0,0 +1,334 @@
+//  Boost string_algo library find.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// 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/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_FIND_HPP
+#define BOOST_STRING_FIND_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/as_literal.hpp>
+
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/compare.hpp>
+#include <boost/algorithm/string/constants.hpp>
+
+/*! \file
+    Defines a set of find algorithms. The algorithms are searching
+    for a substring of the input. The result is given as an \c iterator_range
+    delimiting the substring.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  Generic find -----------------------------------------------//
+
+        //! Generic find algorithm
+        /*!
+            Search the input using the given finder.
+
+            \param Input A string which will be searched.
+            \param Finder Finder object used for searching.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+        */
+        template<typename RangeT, typename FinderT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find( 
+            RangeT& Input, 
+            const FinderT& Finder)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
+        }
+
+//  find_first  -----------------------------------------------//
+
+        //! Find first algorithm
+        /*!
+            Search for the first occurrence of the substring in the input. 
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+
+              \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        find_first( 
+            Range1T& Input, 
+            const Range2T& Search)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
+        }
+
+        //! Find first algorithm ( case insensitive )
+        /*!
+            Search for the first occurrence of the substring in the input. 
+            Searching is case insensitive.
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        ifind_first( 
+            Range1T& Input, 
+            const Range2T& Search,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
+        }
+
+//  find_last  -----------------------------------------------//
+
+        //! Find last algorithm
+        /*!
+            Search for the last occurrence of the substring in the input. 
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        find_last( 
+            Range1T& Input, 
+            const Range2T& Search)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
+        }
+
+        //! Find last algorithm ( case insensitive )
+        /*!
+            Search for the last match a string in the input. 
+            Searching is case insensitive.
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+        
+            \note This function provides the strong exception-safety guarantee    
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        ifind_last( 
+            Range1T& Input, 
+            const Range2T& Search,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
+        }
+
+//  find_nth ----------------------------------------------------------------------//
+
+        //! Find n-th algorithm 
+        /*!
+            Search for the n-th (zero-indexed) occurrence of the substring in the 
+            input.         
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Nth An index (zero-indexed) of the match to be found.
+                For negative N, the matches are counted from the end of string.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        find_nth( 
+            Range1T& Input, 
+            const Range2T& Search,
+            int Nth)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
+        }
+
+        //! Find n-th algorithm ( case insensitive ).
+        /*!
+            Search for the n-th (zero-indexed) occurrence of the substring in the 
+            input. Searching is case insensitive.
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Nth An index (zero-indexed) of the match to be found. 
+                For negative N, the matches are counted from the end of string.
+            \param Loc A locale used for case insensitive comparison
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        ifind_nth( 
+            Range1T& Input, 
+            const Range2T& Search,
+            int Nth,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
+        }
+
+//  find_head ----------------------------------------------------------------------//
+
+        //! Find head algorithm
+        /*!
+            Get the head of the input. Head is a prefix of the string of the 
+            given size. If the input is shorter then required, whole input is considered 
+            to be the head.
+
+            \param Input An input string
+            \param N Length of the head
+                For N>=0, at most N characters are extracted.
+                For N<0, at most size(Input)-|N| characters are extracted.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename RangeT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find_head( 
+            RangeT& Input, 
+            int N)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
+        }
+
+//  find_tail ----------------------------------------------------------------------//
+
+        //! Find tail algorithm
+        /*!
+            Get the tail of the input. Tail is a suffix of the string of the 
+            given size. If the input is shorter then required, whole input is considered 
+            to be the tail.
+
+            \param Input An input string
+            \param N Length of the tail. 
+                For N>=0, at most N characters are extracted.
+                For N<0, at most size(Input)-|N| characters are extracted.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename RangeT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find_tail( 
+            RangeT& Input, 
+            int N)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
+        }
+
+//  find_token --------------------------------------------------------------------//
+
+        //! Find token algorithm
+        /*!
+            Look for a given token in the string. Token is a character that matches the
+            given predicate.
+            If the "token compress mode" is enabled, adjacent tokens are considered to be one match.
+            
+            \param Input A input string.
+            \param Pred A unary predicate to identify a token
+            \param eCompress Enable/Disable compressing of adjacent tokens
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+        
+            \note This function provides the strong exception-safety guarantee    
+        */
+        template<typename RangeT, typename PredicateT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find_token( 
+            RangeT& Input,
+            PredicateT Pred,
+            token_compress_mode_type eCompress=token_compress_off)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::find;
+    using algorithm::find_first;
+    using algorithm::ifind_first;
+    using algorithm::find_last;
+    using algorithm::ifind_last;
+    using algorithm::find_nth;
+    using algorithm::ifind_nth;
+    using algorithm::find_head;
+    using algorithm::find_tail;
+    using algorithm::find_token;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_FIND_HPP

data/src/cxx_supportlib/vendor-modified/boost/algorithm/string/find_format.hpp

@@ -13,7 +13,7 @@
 
 #include <deque>
 #include <boost/detail/iterator.hpp>
-#include <boost/range/iterator_range.hpp>
+#include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/const_iterator.hpp>

data/src/cxx_supportlib/vendor-modified/boost/algorithm/string/find_iterator.hpp

@@ -0,0 +1,388 @@
+//  Boost string_algo library find_iterator.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2004.
+//
+// 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/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_FIND_ITERATOR_HPP
+#define BOOST_STRING_FIND_ITERATOR_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/as_literal.hpp>
+
+#include <boost/algorithm/string/detail/find_iterator.hpp>
+
+/*! \file
+    Defines find iterator classes. Find iterator repeatedly applies a Finder
+    to the specified input string to search for matches. Dereferencing
+    the iterator yields the current match or a range between the last and the current
+    match depending on the iterator used.
+*/
+
+namespace boost {
+    namespace algorithm { 
+
+//  find_iterator -----------------------------------------------//
+
+        //! find_iterator
+        /*!    
+            Find iterator encapsulates a Finder and allows
+            for incremental searching in a string.
+            Each increment moves the iterator to the next match.
+
+            Find iterator is a readable forward traversal iterator.
+
+            Dereferencing the iterator yields an iterator_range delimiting
+            the current match.
+        */
+        template<typename IteratorT>
+        class find_iterator : 
+            public iterator_facade<
+                find_iterator<IteratorT>,
+                const iterator_range<IteratorT>,
+                forward_traversal_tag >,
+            private detail::find_iterator_base<IteratorT>
+        {
+        private:
+            // facade support
+            friend class ::boost::iterator_core_access;
+
+        private:
+        // typedefs
+
+            typedef detail::find_iterator_base<IteratorT> base_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::input_iterator_type input_iterator_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::match_type match_type;
+
+        public:
+            //! Default constructor
+            /*!
+                Construct null iterator. All null iterators are equal.
+
+                \post eof()==true
+            */
+            find_iterator() {}
+
+            //! Copy constructor
+            /*!
+                Construct a copy of the find_iterator
+            */
+            find_iterator( const find_iterator& Other ) :
+                base_type(Other),
+                m_Match(Other.m_Match),
+                m_End(Other.m_End) {}
+
+            //! Constructor
+            /*!
+                Construct new find_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT>
+            find_iterator(
+                    IteratorT Begin,
+                    IteratorT End,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(Begin,Begin),
+                m_End(End)
+            {
+                increment();
+            }
+
+            //! Constructor
+            /*!
+                Construct new find_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT, typename RangeT>
+            find_iterator(
+                    RangeT& Col,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0)
+            {
+                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
+                m_End=::boost::end(lit_col);
+
+                increment();
+            }
+
+        private:
+        // iterator operations
+
+            // dereference
+            const match_type& dereference() const
+            {
+                return m_Match;
+            }
+
+            // increment
+            void increment()
+            {
+                m_Match=this->do_find(m_Match.end(),m_End);
+            }
+
+            // comparison
+            bool equal( const find_iterator& Other ) const
+            {
+                bool bEof=eof();
+                bool bOtherEof=Other.eof();
+
+                return bEof || bOtherEof ? bEof==bOtherEof :
+                    (
+                        m_Match==Other.m_Match &&
+                        m_End==Other.m_End 
+                    );
+            }
+
+        public:
+        // operations
+
+            //! Eof check
+            /*!
+                Check the eof condition. Eof condition means that
+                there is nothing more to be searched i.e. find_iterator
+                is after the last match.
+            */
+            bool eof() const
+            {
+                return 
+                    this->is_null() || 
+                    ( 
+                        m_Match.begin() == m_End &&
+                        m_Match.end() == m_End
+                    );
+            }
+
+        private:
+        // Attributes
+            match_type m_Match;
+            input_iterator_type m_End;
+        };
+
+        //! find iterator construction helper
+        /*!
+         *    Construct a find iterator to iterate through the specified string
+         */
+        template<typename RangeT, typename FinderT>
+        inline find_iterator< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        make_find_iterator(
+            RangeT& Collection,
+            FinderT Finder)
+        {
+            return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
+                Collection, Finder);
+        }
+
+//  split iterator -----------------------------------------------//
+
+        //! split_iterator
+        /*!    
+            Split iterator encapsulates a Finder and allows
+            for incremental searching in a string.
+            Unlike the find iterator, split iterator iterates
+            through gaps between matches.
+
+            Find iterator is a readable forward traversal iterator.
+
+            Dereferencing the iterator yields an iterator_range delimiting
+            the current match.
+        */
+        template<typename IteratorT>
+        class split_iterator : 
+            public iterator_facade<
+                split_iterator<IteratorT>,
+                const iterator_range<IteratorT>,
+                forward_traversal_tag >,
+            private detail::find_iterator_base<IteratorT>
+        {
+        private:
+            // facade support
+            friend class ::boost::iterator_core_access;
+
+        private:
+        // typedefs
+
+            typedef detail::find_iterator_base<IteratorT> base_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::input_iterator_type input_iterator_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::match_type match_type;
+
+        public:
+            //! Default constructor
+            /*!
+                Construct null iterator. All null iterators are equal.
+    
+                \post eof()==true
+            */
+            split_iterator() :
+                m_Next(),
+                m_End(),
+                m_bEof(true)
+            {}
+
+            //! Copy constructor
+            /*!
+                Construct a copy of the split_iterator
+            */
+            split_iterator( const split_iterator& Other ) :
+                base_type(Other),
+                m_Match(Other.m_Match),
+                m_Next(Other.m_Next),
+                m_End(Other.m_End),
+                m_bEof(Other.m_bEof)
+            {}
+
+            //! Constructor
+            /*!
+                Construct new split_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT>
+            split_iterator(
+                    IteratorT Begin,
+                    IteratorT End,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(Begin,Begin),
+                m_Next(Begin),
+                m_End(End),
+                m_bEof(false)
+            {
+                // force the correct behavior for empty sequences and yield at least one token
+                if(Begin!=End)
+                {
+                    increment();
+                }
+            }
+            //! Constructor
+            /*!
+                Construct new split_iterator for a given finder
+                and a collection.
+            */
+            template<typename FinderT, typename RangeT>
+            split_iterator(
+                    RangeT& Col,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_bEof(false)
+            {
+                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
+                m_Next=::boost::begin(lit_col);
+                m_End=::boost::end(lit_col);
+
+                // force the correct behavior for empty sequences and yield at least one token
+                if(m_Next!=m_End)
+                {
+                    increment();
+                }
+            }
+
+
+        private:
+        // iterator operations
+
+            // dereference
+            const match_type& dereference() const
+            {
+                return m_Match;
+            }
+
+            // increment
+            void increment()
+            {
+                match_type FindMatch=this->do_find( m_Next, m_End );
+
+                if(FindMatch.begin()==m_End && FindMatch.end()==m_End)
+                {
+                    if(m_Match.end()==m_End)
+                    {
+                        // Mark iterator as eof
+                        m_bEof=true;
+                    }
+                }
+
+                m_Match=match_type( m_Next, FindMatch.begin() );
+                m_Next=FindMatch.end();
+            }
+
+            // comparison
+            bool equal( const split_iterator& Other ) const
+            {
+                bool bEof=eof();
+                bool bOtherEof=Other.eof();
+
+                return bEof || bOtherEof ? bEof==bOtherEof :
+                    (
+                        m_Match==Other.m_Match &&
+                        m_Next==Other.m_Next &&
+                        m_End==Other.m_End
+                    );
+            }
+
+        public:
+        // operations
+
+            //! Eof check
+            /*!
+                Check the eof condition. Eof condition means that
+                there is nothing more to be searched i.e. find_iterator
+                is after the last match.
+            */
+            bool eof() const
+            {
+                return this->is_null() || m_bEof;
+            }
+
+        private:
+        // Attributes
+            match_type m_Match;
+            input_iterator_type m_Next;
+            input_iterator_type m_End;
+            bool m_bEof;
+        };
+
+        //! split iterator construction helper
+        /*!
+         *    Construct a split iterator to iterate through the specified collection
+         */
+        template<typename RangeT, typename FinderT>
+        inline split_iterator< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        make_split_iterator(
+            RangeT& Collection,
+            FinderT Finder)
+        {
+            return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
+                Collection, Finder);
+        }
+
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::find_iterator;
+    using algorithm::make_find_iterator;
+    using algorithm::split_iterator;
+    using algorithm::make_split_iterator;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_FIND_ITERATOR_HPP