BVB Source Codes

mars Show split.hpp Source code

Return Download mars: download split.hpp Source code - Download mars Source code - Type:.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<mars_boost::iterator_range<std::string::iterator>>
  32. */
  33.  
  34. namespace mars_boost {} namespace boost = mars_boost; namespace mars_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<mars_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.             Range1T& Input,
  65.             const Range2T& Search)
  66.         {
  67.             return ::mars_boost::algorithm::iter_find(
  68.                 Result,
  69.                 Input,
  70.                 ::mars_boost::algorithm::first_finder(Search) );        
  71.         }
  72.  
  73.         //! Find all algorithm ( case insensitive )
  74.         /*!
  75.             This algorithm finds all occurrences of the search string
  76.             in the input.
  77.             Each part is copied and added as a new element to the
  78.             output container. Thus the result container must be able to hold copies
  79.             of the matches (in a compatible structure like std::string) or
  80.             a reference to it (e.g. using the iterator range class).
  81.             Examples of such a container are \c std::vector<std::string>
  82.             or \c std::list<mars_boost::iterator_range<std::string::iterator>>
  83.  
  84.             Searching is case insensitive.
  85.  
  86.             \param Result A container that can hold copies of references to the substrings
  87.             \param Input A container which will be searched.
  88.             \param Search A substring to be searched for.
  89.             \param Loc A locale used for case insensitive comparison
  90.             \return A reference the result
  91.  
  92.             \note Prior content of the result will be overwritten.
  93.  
  94.             \note This function provides the strong exception-safety guarantee
  95.         */
  96.         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
  97.         inline SequenceSequenceT& ifind_all(
  98.             SequenceSequenceT& Result,
  99.             Range1T& Input,
  100.             const Range2T& Search,
  101.             const std::locale& Loc=std::locale() )
  102.         {
  103.             return ::mars_boost::algorithm::iter_find(
  104.                 Result,
  105.                 Input,
  106.                 ::mars_boost::algorithm::first_finder(Search, is_iequal(Loc) ) );        
  107.         }
  108.  
  109.  
  110. //  tokenize  -------------------------------------------------------------//
  111.  
  112.         //! Split algorithm
  113.         /*!
  114.             Tokenize expression. This function is equivalent to C strtok. Input
  115.             sequence is split into tokens, separated by separators. Separators
  116.             are given by means of the predicate.
  117.  
  118.             Each part is copied and added as a new element to the
  119.             output container.
  120.             Thus the result container must be able to hold copies
  121.             of the matches (in a compatible structure like std::string) or
  122.             a reference to it (e.g. using the iterator range class).
  123.             Examples of such a container are \c std::vector<std::string>
  124.             or \c std::list<mars_boost::iterator_range<std::string::iterator>>
  125.    
  126.             \param Result A container that can hold copies of references to the substrings          
  127.             \param Input A container which will be searched.
  128.             \param Pred A predicate to identify separators. This predicate is
  129.                 supposed to return true if a given element is a separator.
  130.             \param eCompress If eCompress argument is set to token_compress_on, adjacent
  131.                 separators are merged together. Otherwise, every two separators
  132.                 delimit a token.
  133.             \return A reference the result
  134.  
  135.             \note Prior content of the result will be overwritten.
  136.  
  137.             \note This function provides the strong exception-safety guarantee
  138.         */
  139.         template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
  140.         inline SequenceSequenceT& split(
  141.             SequenceSequenceT& Result,
  142.             RangeT& Input,
  143.             PredicateT Pred,
  144.             token_compress_mode_type eCompress=token_compress_off )
  145.         {
  146.             return ::mars_boost::algorithm::iter_split(
  147.                 Result,
  148.                 Input,
  149.                 ::mars_boost::algorithm::token_finder( Pred, eCompress ) );        
  150.         }
  151.  
  152.     } // namespace algorithm
  153.  
  154.     // pull names to the boost namespace
  155.     using algorithm::find_all;
  156.     using algorithm::ifind_all;
  157.     using algorithm::split;    
  158.  
  159. } // namespace mars_boost
  160.  
  161.  
  162. #endif  // BOOST_STRING_SPLIT_HPP
  163.  
  164.  
downloadsplit.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top