passenger-jmazzi 2.2.9

data/ext/boost/algorithm/string/detail/util.hpp

@@ -0,0 +1,106 @@
+//  Boost string_algo library util.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_UTIL_DETAIL_HPP
+#define BOOST_STRING_UTIL_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <functional>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost {
+    namespace algorithm {
+        namespace detail {
+
+//  empty container  -----------------------------------------------//
+
+            //  empty_container 
+            /*
+                This class represents always empty container,
+                containing elements of type CharT.
+
+                It is supposed to be used in a const version only
+            */
+            template< typename CharT >
+            struct empty_container 
+            {
+                typedef empty_container<CharT> type;        
+                typedef CharT value_type;
+                typedef std::size_t size_type;
+                typedef std::ptrdiff_t difference_type;
+                typedef const value_type& reference;
+                typedef const value_type& const_reference;
+                typedef const value_type* iterator;
+                typedef const value_type* const_iterator;
+
+                
+                // Operations
+                const_iterator begin() const
+                {
+                    return reinterpret_cast<const_iterator>(0);
+                }
+
+                const_iterator end() const
+                {
+                    return reinterpret_cast<const_iterator>(0);
+                }
+
+                bool empty() const
+                {
+                    return false;
+                }
+
+                size_type size() const
+                {
+                    return 0;
+                }
+            };
+    
+//  bounded copy algorithm  -----------------------------------------------//
+
+            // Bounded version of the std::copy algorithm
+            template<typename InputIteratorT, typename OutputIteratorT>
+            inline OutputIteratorT bounded_copy(
+                InputIteratorT First, 
+                InputIteratorT Last, 
+                OutputIteratorT DestFirst,
+                OutputIteratorT DestLast )
+            {
+                InputIteratorT InputIt=First;
+                OutputIteratorT OutputIt=DestFirst;
+                for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
+                {
+                    *OutputIt=*InputIt;
+                }
+
+                return OutputIt;
+            }
+
+//  iterator range utilities -----------------------------------------//
+
+            // copy range functor
+            template< 
+                typename SeqT, 
+                typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator >
+            struct copy_iterator_rangeF : 
+                public std::unary_function< iterator_range<IteratorT>, SeqT >
+            {
+                SeqT operator()( const iterator_range<IteratorT>& Range ) const
+                {
+                    return copy_range<SeqT>(Range);
+                }
+            };
+
+        } // namespace detail
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_UTIL_DETAIL_HPP

data/ext/boost/algorithm/string/erase.hpp

@@ -0,0 +1,844 @@
+//  Boost string_algo library erase.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2006.
+//
+// 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_ERASE_HPP
+#define BOOST_STRING_ERASE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+
+#include <boost/algorithm/string/find_format.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/formatter.hpp>
+
+/*! \file
+    Defines various erase algorithms. Each algorithm removes
+    part(s) of the input according to a searching criteria.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  erase_range -------------------------------------------------------//
+
+        //! Erase range algorithm
+        /*!
+            Remove the given range from the input. The result is a modified copy of 
+            the input. It is returned as a sequence or copied to the output iterator.
+    
+            \param Output An output iterator to which the result will be copied
+            \param Input An input sequence
+            \param SearchRange A range in the input to be removed
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<typename OutputIteratorT, typename RangeT>
+        inline OutputIteratorT erase_range_copy(
+            OutputIteratorT Output,
+            const RangeT& Input,
+            const iterator_range<
+                BOOST_STRING_TYPENAME 
+                    range_const_iterator<RangeT>::type>& SearchRange )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                range_finder(SearchRange),
+                empty_formatter(Input) );
+        }
+
+        //! Erase range algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT>
+        inline SequenceT erase_range_copy( 
+            const SequenceT& Input,
+            const iterator_range<
+                BOOST_STRING_TYPENAME 
+                    range_const_iterator<SequenceT>::type>& SearchRange )
+        {
+            return find_format_copy( 
+                Input,
+                range_finder(SearchRange),
+                empty_formatter(Input) );
+        }
+
+        //! Erase range algorithm
+        /*!
+            Remove the given range from the input.
+            The input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param SearchRange A range in the input to be removed
+        */
+        template<typename SequenceT>
+        inline void erase_range( 
+            SequenceT& Input,
+            const iterator_range<
+                BOOST_STRING_TYPENAME 
+                    range_iterator<SequenceT>::type>& SearchRange )
+        {
+            find_format( 
+                Input, 
+                range_finder(SearchRange),
+                empty_formatter(Input) );
+        }
+
+//  erase_first  --------------------------------------------------------//
+
+        //! Erase first algorithm
+        /*!
+            Remove the first occurrence of the substring from the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for 
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+            
+            \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT erase_first_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                first_finder(Search),
+                empty_formatter(Input) );
+        }
+
+        //! Erase first algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT erase_first_copy( 
+            const SequenceT& Input,
+            const RangeT& Search )
+        {
+            return find_format_copy( 
+                Input, 
+                first_finder(Search),
+                empty_formatter(Input) );
+        }
+
+        //! Erase first algorithm
+        /*!
+            Remove the first occurrence of the substring from the input. 
+            The input sequence is modified in-place.
+
+            \param Input An input string
+            \param Search A substring to be searched for. 
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void erase_first( 
+            SequenceT& Input,
+            const RangeT& Search )
+        {
+            find_format( 
+                Input, 
+                first_finder(Search),
+                empty_formatter(Input) );
+        }
+
+//  erase_first ( case insensitive ) ------------------------------------//
+
+        //! Erase first algorithm ( case insensitive )
+        /*!
+            Remove the first occurrence of the substring from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            Searching is case insensitive.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for 
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT ierase_first_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                first_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase first algorithm ( case insensitive )
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT ierase_first_copy( 
+            const SequenceT& Input,
+            const RangeT& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_copy( 
+                Input, 
+                first_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase first algorithm ( case insensitive )
+        /*!
+            Remove the first occurrence of the substring from the input. 
+            The input sequence is modified in-place. Searching is case insensitive.
+
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void ierase_first( 
+            SequenceT& Input,
+            const RangeT& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            find_format( 
+                Input, 
+                first_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+//  erase_last  --------------------------------------------------------//
+
+        //! Erase last algorithm
+        /*!
+            Remove the last occurrence of the substring from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for.
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT erase_last_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                last_finder(Search),
+                empty_formatter(Input) );
+        }
+
+        //! Erase last algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT erase_last_copy( 
+            const SequenceT& Input,
+            const RangeT& Search )
+        {
+            return find_format_copy( 
+                Input, 
+                last_finder(Search),
+                empty_formatter(Input) );
+        }
+
+        //! Erase last algorithm
+        /*!
+            Remove the last occurrence of the substring from the input. 
+            The input sequence is modified in-place.
+
+            \param Input An input string
+            \param Search A substring to be searched for 
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void erase_last( 
+            SequenceT& Input,
+            const RangeT& Search )
+        {
+            find_format( 
+                Input, 
+                last_finder(Search),
+                empty_formatter(Input) );
+        }
+
+//  erase_last ( case insensitive ) ------------------------------------//
+
+        //! Erase last algorithm ( case insensitive )
+        /*!
+            Remove the last occurrence of the substring from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            Searching is case insensitive.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT ierase_last_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                last_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase last algorithm ( case insensitive )
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT ierase_last_copy( 
+            const SequenceT& Input,
+            const RangeT& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_copy( 
+                Input, 
+                last_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase last algorithm ( case insensitive )
+        /*!
+            Remove the last occurrence of the substring from the input. 
+            The input sequence is modified in-place. Searching is case insensitive.
+
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void ierase_last( 
+            SequenceT& Input,
+            const RangeT& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            find_format( 
+                Input, 
+                last_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+//  erase_nth --------------------------------------------------------------------//
+
+        //! Erase nth algorithm
+        /*!
+            Remove the Nth occurrence of the substring in the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Nth An index of the match to be replaced. The index is 0-based.
+                For negative N, matches are counted from the end of string.
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT erase_nth_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search,
+            int Nth )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                nth_finder(Search, Nth),
+                empty_formatter(Input) );
+        }
+
+        //! Erase nth algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT erase_nth_copy( 
+            const SequenceT& Input,
+            const RangeT& Search,
+            int Nth )
+        {
+            return find_format_copy( 
+                Input, 
+                nth_finder(Search, Nth),
+                empty_formatter(Input) );
+        }
+
+        //! Erase nth algorithm
+        /*!
+            Remove the Nth occurrence of the substring in the input.
+            The input sequence is modified in-place.
+
+            \param Input An input string
+            \param Search A substring to be searched for. 
+            \param Nth An index of the match to be replaced. The index is 0-based.
+                For negative N, matches are counted from the end of string.
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void erase_nth( 
+            SequenceT& Input,
+            const RangeT& Search,
+            int Nth )
+        {
+            find_format( 
+                Input, 
+                nth_finder(Search, Nth),
+                empty_formatter(Input) );
+        }
+
+//  erase_nth ( case insensitive ) ---------------------------------------------//
+
+        //! Erase nth algorithm ( case insensitive )
+        /*!
+            Remove the Nth occurrence of the substring in the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator. 
+            Searching is case insensitive.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for.
+            \param Nth An index of the match to be replaced. The index is 0-based.
+                For negative N, matches are counted from the end of string.
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT ierase_nth_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search,
+            int Nth,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                nth_finder(Search, Nth, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase nth algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT ierase_nth_copy( 
+            const SequenceT& Input,
+            const RangeT& Search,
+            int Nth,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_copy( 
+                Input, 
+                nth_finder(Search, Nth, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase nth algorithm
+        /*!
+            Remove the Nth occurrence of the substring in the input.
+            The input sequence is modified in-place. Searching is case insensitive.
+
+            \param Input An input string
+            \param Search A substring to be searched for. 
+            \param Nth An index of the match to be replaced. The index is 0-based.
+                For negative N, matches are counted from the end of string.
+            \param Loc A locale used for case insensitive comparison
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void ierase_nth( 
+            SequenceT& Input,
+            const RangeT& Search,
+            int Nth,
+            const std::locale& Loc=std::locale() )
+        {
+            find_format( 
+                Input, 
+                nth_finder(Search, Nth, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+
+//  erase_all  --------------------------------------------------------//
+
+        //! Erase all algorithm
+        /*!
+            Remove all the occurrences of the string from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+                        
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input sequence
+            \param Search A substring to be searched for. 
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT erase_all_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search )
+        {
+            return find_format_all_copy(
+                Output,
+                Input,
+                first_finder(Search),
+                empty_formatter(Input) );
+        }
+
+        //! Erase all algorithm
+        /*!
+            \overload
+        */  
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT erase_all_copy( 
+            const SequenceT& Input,
+            const RangeT& Search )
+        {
+            return find_format_all_copy( 
+                Input, 
+                first_finder(Search),
+                empty_formatter(Input) );
+        }
+
+        //! Erase all algorithm
+        /*!
+            Remove all the occurrences of the string from the input. 
+            The input sequence is modified in-place.
+
+            \param Input An input string
+            \param Search A substring to be searched for. 
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void erase_all( 
+            SequenceT& Input,
+            const RangeT& Search )
+        {
+            find_format_all( 
+                Input, 
+                first_finder(Search),
+                empty_formatter(Input) );
+        }
+
+//  erase_all ( case insensitive ) ------------------------------------//
+
+        //! Erase all algorithm ( case insensitive )
+        /*!
+            Remove all the occurrences of the string from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator. 
+            Searching is case insensitive.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input
+
+              \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename Range1T, 
+            typename Range2T>
+        inline OutputIteratorT ierase_all_copy(
+            OutputIteratorT Output,
+            const Range1T& Input,
+            const Range2T& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_all_copy(
+                Output,
+                Input,
+                first_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase all algorithm ( case insensitive )
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename RangeT>
+        inline SequenceT ierase_all_copy( 
+            const SequenceT& Input,
+            const RangeT& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return find_format_all_copy( 
+                Input, 
+                first_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+        //! Erase all algorithm ( case insensitive )
+        /*!
+            Remove all the occurrences of the string from the input. 
+            The input sequence is modified in-place. Searching is case insensitive.
+
+            \param Input An input string
+            \param Search A substring to be searched for. 
+            \param Loc A locale used for case insensitive comparison
+        */
+        template<typename SequenceT, typename RangeT>
+        inline void ierase_all( 
+            SequenceT& Input,
+            const RangeT& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            find_format_all( 
+                Input, 
+                first_finder(Search, is_iequal(Loc)),
+                empty_formatter(Input) );
+        }
+
+//  erase_head --------------------------------------------------------------------//
+
+        //! Erase head algorithm
+        /*!
+            Remove the head from the input. The head is a prefix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is 
+            considered to be the head. The result is a modified copy of the input. 
+            It is returned as a sequence or copied to the output iterator.
+            
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param N Length of the head.
+                For N>=0, at most N characters are extracted.
+                For N<0, size(Input)-|N| characters are extracted.
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename RangeT>
+        inline OutputIteratorT erase_head_copy(
+            OutputIteratorT Output,
+            const RangeT& Input,
+            int N )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                head_finder(N),
+                empty_formatter( Input ) );
+        }
+
+        //! Erase head algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT>
+        inline SequenceT erase_head_copy( 
+            const SequenceT& Input,
+            int N )
+        {
+            return find_format_copy( 
+                Input,
+                head_finder(N),
+                empty_formatter( Input ) );
+        }
+
+        //! Erase head algorithm
+        /*!
+            Remove the head from the input. The head is a prefix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is 
+            considered to be the head. The input sequence is modified in-place.
+
+            \param Input An input string
+            \param N Length of the head
+                For N>=0, at most N characters are extracted.
+                For N<0, size(Input)-|N| characters are extracted.
+        */
+        template<typename SequenceT>
+        inline void erase_head( 
+            SequenceT& Input,
+            int N )
+        {
+            find_format( 
+                Input, 
+                head_finder(N),
+                empty_formatter( Input ) );
+        }
+
+//  erase_tail --------------------------------------------------------------------//
+
+        //! Erase tail algorithm
+        /*!
+            Remove the tail from the input. The tail is a suffix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is 
+            considered to be the tail. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param N Length of the head.                 
+                For N>=0, at most N characters are extracted.
+                For N<0, size(Input)-|N| characters are extracted.
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+            
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<
+            typename OutputIteratorT,
+            typename RangeT>
+        inline OutputIteratorT erase_tail_copy(
+            OutputIteratorT Output,
+            const RangeT& Input,
+            int N )
+        {
+            return find_format_copy(
+                Output,
+                Input,
+                tail_finder(N),
+                empty_formatter( Input ) );
+        }
+
+        //! Erase tail algorithm
+        /*!
+            \overload
+        */
+        template<typename SequenceT>
+        inline SequenceT erase_tail_copy( 
+            const SequenceT& Input,
+            int N )
+        {
+            return find_format_copy( 
+                Input,
+                tail_finder(N),
+                empty_formatter( Input ) );
+        }
+
+        //! Erase tail algorithm
+        /*!
+            Remove the tail from the input. The tail is a suffix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is
+            considered to be the tail. The input sequence is modified in-place.
+
+            \param Input An input string
+            \param N Length of the head
+                For N>=0, at most N characters are extracted.
+                For N<0, size(Input)-|N| characters are extracted.
+        */
+        template<typename SequenceT>
+        inline void erase_tail( 
+            SequenceT& Input,
+            int N )
+        {
+            find_format( 
+                Input, 
+                tail_finder(N),
+                empty_formatter( Input ) );
+        }
+
+    } // namespace algorithm
+
+    // pull names into the boost namespace
+    using algorithm::erase_range_copy;
+    using algorithm::erase_range;
+    using algorithm::erase_first_copy;
+    using algorithm::erase_first;
+    using algorithm::ierase_first_copy;
+    using algorithm::ierase_first;
+    using algorithm::erase_last_copy;
+    using algorithm::erase_last;
+    using algorithm::ierase_last_copy;
+    using algorithm::ierase_last;
+    using algorithm::erase_nth_copy;
+    using algorithm::erase_nth;
+    using algorithm::ierase_nth_copy;
+    using algorithm::ierase_nth;
+    using algorithm::erase_all_copy;
+    using algorithm::erase_all;
+    using algorithm::ierase_all_copy;
+    using algorithm::ierase_all;
+    using algorithm::erase_head_copy;
+    using algorithm::erase_head;
+    using algorithm::erase_tail_copy;
+    using algorithm::erase_tail;
+
+} // namespace boost
+
+
+#endif  // BOOST_ERASE_HPP