164 lines
6.6 KiB
Plaintext
164 lines
6.6 KiB
Plaintext
// 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
|
|
|