//  Boost string_algo library split.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_SPLIT_HPP

#define BOOST_STRING_SPLIT_HPP

#include <boost/algorithm/string/config.hpp>

#include <boost/algorithm/string/iter_find.hpp>

#include <boost/algorithm/string/finder.hpp>

#include <boost/algorithm/string/compare.hpp>

/*! \file

    Defines basic split algorithms. 

    Split algorithms can be used to divide a string

    into several parts according to given criteria.

    Each part is copied and added as a new element to the

    output container.

    Thus the result container must be able to hold copies

    of the matches (in a compatible structure like std::string) or

    a reference to it (e.g. using the iterator range class).

    Examples of such a container are \c std::vector<std::string>

    or \c std::list<boost::iterator_range<std::string::iterator>>

*/

namespace boost {

    namespace algorithm {

//  find_all  ------------------------------------------------------------//

        //! Find all algorithm

        /*!

            This algorithm finds all occurrences of the search string

            in the input.

            Each part is copied and added as a new element to the

            output container.

            Thus the result container must be able to hold copies

            of the matches (in a compatible structure like std::string) or

            a reference to it (e.g. using the iterator range class).

            Examples of such a container are \c std::vector<std::string>

            or \c std::list<boost::iterator_range<std::string::iterator>>

            \param Result A container that can hold copies of references to the substrings

            \param Input A container which will be searched.

            \param Search A substring to be searched for.

            \return A reference the result

            \note Prior content of the result will be overwritten.

            \note This function provides the strong exception-safety guarantee

        */

        template< typename SequenceSequenceT, typename Range1T, typename Range2T >

        inline SequenceSequenceT& find_all(

            SequenceSequenceT& Result,

            Range1T& Input,

            const Range2T& Search)

        {

            return iter_find(

                Result,

                Input,

                first_finder(Search) );        

        }

        //! Find all algorithm ( case insensitive ) 

        /*!

            This algorithm finds all occurrences of the search string

            in the input. 

            Each part is copied and added as a new element to the

            output container. Thus the result container must be able to hold copies

            of the matches (in a compatible structure like std::string) or

            a reference to it (e.g. using the iterator range class).

            Examples of such a container are \c std::vector<std::string>

            or \c std::list<boost::iterator_range<std::string::iterator>>

            Searching is case insensitive.

            \param Result A container that can hold copies of references to the substrings

            \param Input A container which will be searched.

            \param Search A substring to be searched for.

            \param Loc A locale used for case insensitive comparison

            \return A reference the result

            \note Prior content of the result will be overwritten.

            \note This function provides the strong exception-safety guarantee

        */

        template< typename SequenceSequenceT, typename Range1T, typename Range2T >

        inline SequenceSequenceT& ifind_all(

            SequenceSequenceT& Result,

            Range1T& Input,

            const Range2T& Search,

            const std::locale& Loc=std::locale() )

        {

            return iter_find(

                Result,

                Input,

                first_finder(Search, is_iequal(Loc) ) );        

        }

//  tokenize  -------------------------------------------------------------//

        //! Split algorithm

        /*! 

            Tokenize expression. This function is equivalent to C strtok. Input

            sequence is split into tokens, separated by separators. Separators 

            are given by means of the predicate.

            Each part is copied and added as a new element to the

            output container.

            Thus the result container must be able to hold copies

            of the matches (in a compatible structure like std::string) or

            a reference to it (e.g. using the iterator range class).

            Examples of such a container are \c std::vector<std::string>

            or \c std::list<boost::iterator_range<std::string::iterator>>

            \param Result A container that can hold copies of references to the substrings          

            \param Input A container which will be searched.

            \param Pred A predicate to identify separators. This predicate is 

                supposed to return true if a given element is a separator.

            \param eCompress If eCompress argument is set to token_compress_on, adjacent 

                separators are merged together. Otherwise, every two separators

                delimit a token.

            \return A reference the result

            \note Prior content of the result will be overwritten.

            \note This function provides the strong exception-safety guarantee

        */

        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >

        inline SequenceSequenceT& split(

            SequenceSequenceT& Result,

            RangeT& Input,

            PredicateT Pred,

            token_compress_mode_type eCompress=token_compress_off )

        {

            return iter_split(

                Result,

                Input,

                token_finder( Pred, eCompress ) );         

        }

    } // namespace algorithm

    // pull names to the boost namespace

    using algorithm::find_all;

    using algorithm::ifind_all;

    using algorithm::split;    

} // namespace boost

#endif  // BOOST_STRING_SPLIT_HPP