//  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

