// 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 ::boost::algorithm::iter_find( | |
Result, | |
Input, | |
::boost::algorithm::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 ::boost::algorithm::iter_find( | |
Result, | |
Input, | |
::boost::algorithm::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 ::boost::algorithm::iter_split( | |
Result, | |
Input, | |
::boost::algorithm::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 | |