ceph/src/boost/boost/algorithm/string/split.hpp

   1 //  Boost string_algo library split.hpp header file  ---------------------------//
   2
   3 //  Copyright Pavol Droba 2002-2006.
   4 //
   5 // Distributed under the Boost Software License, Version 1.0.
   6 //    (See accompanying file LICENSE_1_0.txt or copy at
   7 //          http://www.boost.org/LICENSE_1_0.txt)
   8
   9 //  See http://www.boost.org/ for updates, documentation, and revision history.
  10
  11 #ifndef BOOST_STRING_SPLIT_HPP
  12 #define BOOST_STRING_SPLIT_HPP
  13
  14 #include <boost/algorithm/string/config.hpp>
  15
  16 #include <boost/algorithm/string/iter_find.hpp>
  17 #include <boost/algorithm/string/finder.hpp>
  18 #include <boost/algorithm/string/compare.hpp>
  19
  20 /*! \file
  21     Defines basic split algorithms.
  22     Split algorithms can be used to divide a string
  23     into several parts according to given criteria.
  24
  25     Each part is copied and added as a new element to the
  26     output container.
  27     Thus the result container must be able to hold copies
  28     of the matches (in a compatible structure like std::string) or
  29     a reference to it (e.g. using the iterator range class).
  30     Examples of such a container are \c std::vector<std::string>
  31     or \c std::list<boost::iterator_range<std::string::iterator>>
  32 */
  33
  34 namespace boost {
  35     namespace algorithm {
  36
  37 //  find_all  ------------------------------------------------------------//
  38
  39         //! Find all algorithm
  40         /*!
  41             This algorithm finds all occurrences of the search string
  42             in the input.
  43
  44             Each part is copied and added as a new element to the
  45             output container.
  46             Thus the result container must be able to hold copies
  47             of the matches (in a compatible structure like std::string) or
  48             a reference to it (e.g. using the iterator range class).
  49             Examples of such a container are \c std::vector<std::string>
  50             or \c std::list<boost::iterator_range<std::string::iterator>>
  51
  52             \param Result A container that can hold copies of references to the substrings
  53             \param Input A container which will be searched.
  54             \param Search A substring to be searched for.
  55             \return A reference the result
  56
  57             \note Prior content of the result will be overwritten.
  58
  59             \note This function provides the strong exception-safety guarantee
  60         */
  61         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
  62         inline SequenceSequenceT& find_all(
  63             SequenceSequenceT& Result,
  64 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  65             Range1T&& Input,
  66 #else
  67             Range1T& Input,
  68 #endif
  69             const Range2T& Search)
  70         {
  71             return ::boost::algorithm::iter_find(
  72                 Result,
  73                 Input,
  74                 ::boost::algorithm::first_finder(Search) );
  75         }
  76
  77         //! Find all algorithm ( case insensitive )
  78         /*!
  79             This algorithm finds all occurrences of the search string
  80             in the input.
  81             Each part is copied and added as a new element to the
  82             output container. Thus the result container must be able to hold copies
  83             of the matches (in a compatible structure like std::string) or
  84             a reference to it (e.g. using the iterator range class).
  85             Examples of such a container are \c std::vector<std::string>
  86             or \c std::list<boost::iterator_range<std::string::iterator>>
  87
  88             Searching is case insensitive.
  89
  90             \param Result A container that can hold copies of references to the substrings
  91             \param Input A container which will be searched.
  92             \param Search A substring to be searched for.
  93             \param Loc A locale used for case insensitive comparison
  94             \return A reference the result
  95
  96             \note Prior content of the result will be overwritten.
  97
  98             \note This function provides the strong exception-safety guarantee
  99         */
 100         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
 101         inline SequenceSequenceT& ifind_all(
 102             SequenceSequenceT& Result,
 103 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 104             Range1T&& Input,
 105 #else
 106             Range1T& Input,
 107 #endif
 108             const Range2T& Search,
 109             const std::locale& Loc=std::locale() )
 110         {
 111             return ::boost::algorithm::iter_find(
 112                 Result,
 113                 Input,
 114                 ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );
 115         }
 116
 117
 118 //  tokenize  -------------------------------------------------------------//
 119
 120         //! Split algorithm
 121         /*!
 122             Tokenize expression. This function is equivalent to C strtok. Input
 123             sequence is split into tokens, separated by separators. Separators
 124             are given by means of the predicate.
 125
 126             Each part is copied and added as a new element to the
 127             output container.
 128             Thus the result container must be able to hold copies
 129             of the matches (in a compatible structure like std::string) or
 130             a reference to it (e.g. using the iterator range class).
 131             Examples of such a container are \c std::vector<std::string>
 132             or \c std::list<boost::iterator_range<std::string::iterator>>
 133
 134             \param Result A container that can hold copies of references to the substrings
 135             \param Input A container which will be searched.
 136             \param Pred A predicate to identify separators. This predicate is
 137                 supposed to return true if a given element is a separator.
 138             \param eCompress If eCompress argument is set to token_compress_on, adjacent
 139                 separators are merged together. Otherwise, every two separators
 140                 delimit a token.
 141             \return A reference the result
 142
 143             \note Prior content of the result will be overwritten.
 144
 145             \note This function provides the strong exception-safety guarantee
 146         */
 147         template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
 148         inline SequenceSequenceT& split(
 149             SequenceSequenceT& Result,
 150 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 151             RangeT&& Input,
 152 #else
 153             RangeT& Input,
 154 #endif
 155             PredicateT Pred,
 156             token_compress_mode_type eCompress=token_compress_off )
 157         {
 158             return ::boost::algorithm::iter_split(
 159                 Result,
 160                 Input,
 161                 ::boost::algorithm::token_finder( Pred, eCompress ) );
 162         }
 163
 164     } // namespace algorithm
 165
 166     // pull names to the boost namespace
 167     using algorithm::find_all;
 168     using algorithm::ifind_all;
 169     using algorithm::split;
 170
 171 } // namespace boost
 172
 173
 174 #endif  // BOOST_STRING_SPLIT_HPP
 175