BVB Source Codes

mars Show finder.hpp Source code

Return Download mars: download finder.hpp Source code - Download mars Source code - Type:.hpp
  1. //  Boost string_algo library finder.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_FINDER_HPP
  12. #define BOOST_STRING_FINDER_HPP
  13.  
  14. #include <boost/algorithm/string/config.hpp>
  15.  
  16. #include <boost/range/iterator_range_core.hpp>
  17. #include <boost/range/begin.hpp>
  18. #include <boost/range/end.hpp>
  19. #include <boost/range/iterator.hpp>
  20. #include <boost/range/const_iterator.hpp>
  21.  
  22. #include <boost/algorithm/string/constants.hpp>
  23. #include <boost/algorithm/string/detail/finder.hpp>
  24. #include <boost/algorithm/string/compare.hpp>
  25.  
  26. /*! \file
  27.     Defines Finder generators. Finder object is a functor which is able to
  28.     find a substring matching a specific criteria in the input.
  29.     Finders are used as a pluggable components for replace, find
  30.     and split facilities. This header contains generator functions
  31.     for finders provided in this library.
  32. */
  33.  
  34. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  35.     namespace algorithm {
  36.  
  37. //  Finder generators ------------------------------------------//
  38.        
  39.         //! "First" finder
  40.         /*!
  41.             Construct the \c first_finder. The finder searches for the first
  42.             occurrence of the string in a given input.
  43.             The result is given as an \c iterator_range delimiting the match.
  44.  
  45.             \param Search A substring to be searched for.
  46.             \param Comp An element comparison predicate
  47.             \return An instance of the \c first_finder object
  48.         */
  49.         template<typename RangeT>
  50.         inline detail::first_finderF<
  51.             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
  52.             is_equal>
  53.         first_finder( const RangeT& Search )
  54.         {
  55.             return
  56.                 detail::first_finderF<
  57.                     BOOST_STRING_TYPENAME
  58.                         range_const_iterator<RangeT>::type,
  59.                         is_equal>( ::mars_boost::as_literal(Search), is_equal() ) ;
  60.         }
  61.  
  62.         //! "First" finder
  63.         /*!
  64.             \overload
  65.         */
  66.         template<typename RangeT,typename PredicateT>
  67.         inline detail::first_finderF<
  68.             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
  69.             PredicateT>
  70.         first_finder(
  71.             const RangeT& Search, PredicateT Comp )
  72.         {
  73.             return
  74.                 detail::first_finderF<
  75.                     BOOST_STRING_TYPENAME
  76.                         range_const_iterator<RangeT>::type,
  77.                     PredicateT>( ::mars_boost::as_literal(Search), Comp );
  78.         }
  79.  
  80.         //! "Last" finder
  81.         /*!
  82.             Construct the \c last_finder. The finder searches for the last
  83.             occurrence of the string in a given input.
  84.             The result is given as an \c iterator_range delimiting the match.
  85.  
  86.             \param Search A substring to be searched for.
  87.             \param Comp An element comparison predicate
  88.             \return An instance of the \c last_finder object
  89.         */
  90.         template<typename RangeT>
  91.         inline detail::last_finderF<
  92.             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
  93.             is_equal>
  94.         last_finder( const RangeT& Search )
  95.         {
  96.             return
  97.                 detail::last_finderF<
  98.                     BOOST_STRING_TYPENAME
  99.                         range_const_iterator<RangeT>::type,
  100.                     is_equal>( ::mars_boost::as_literal(Search), is_equal() );
  101.         }
  102.         //! "Last" finder
  103.         /*!
  104.             \overload
  105.         */
  106.         template<typename RangeT, typename PredicateT>
  107.         inline detail::last_finderF<
  108.             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
  109.             PredicateT>
  110.         last_finder( const RangeT& Search, PredicateT Comp )
  111.         {
  112.             return
  113.                 detail::last_finderF<
  114.                     BOOST_STRING_TYPENAME
  115.                         range_const_iterator<RangeT>::type,
  116.                     PredicateT>( ::mars_boost::as_literal(Search), Comp ) ;
  117.         }
  118.  
  119.         //! "Nth" finder
  120.         /*!
  121.             Construct the \c nth_finder. The finder searches for the n-th (zero-indexed)
  122.             occurrence of the string in a given input.
  123.             The result is given as an \c iterator_range delimiting the match.
  124.  
  125.             \param Search A substring to be searched for.
  126.             \param Nth An index of the match to be find
  127.             \param Comp An element comparison predicate
  128.             \return An instance of the \c nth_finder object
  129.         */
  130.         template<typename RangeT>
  131.         inline detail::nth_finderF<
  132.             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
  133.             is_equal>
  134.         nth_finder(
  135.             const RangeT& Search,
  136.             int Nth)
  137.         {
  138.             return
  139.                 detail::nth_finderF<
  140.                     BOOST_STRING_TYPENAME
  141.                         range_const_iterator<RangeT>::type,
  142.                     is_equal>( ::mars_boost::as_literal(Search), Nth, is_equal() ) ;
  143.         }
  144.         //! "Nth" finder
  145.         /*!
  146.             \overload
  147.         */
  148.         template<typename RangeT, typename PredicateT>
  149.         inline detail::nth_finderF<
  150.             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
  151.             PredicateT>
  152.         nth_finder(
  153.             const RangeT& Search,
  154.             int Nth,
  155.             PredicateT Comp )
  156.         {
  157.             return
  158.                 detail::nth_finderF<
  159.                     BOOST_STRING_TYPENAME
  160.                         range_const_iterator<RangeT>::type,
  161.                     PredicateT>( ::mars_boost::as_literal(Search), Nth, Comp );
  162.         }
  163.  
  164.         //! "Head" finder
  165.         /*!
  166.             Construct the \c head_finder. The finder returns a head of a given
  167.             input. The head is a prefix of a string up to n elements in
  168.             size. If an input has less then n elements, whole input is
  169.             considered a head.
  170.             The result is given as an \c iterator_range delimiting the match.
  171.  
  172.             \param N The size of the head
  173.             \return An instance of the \c head_finder object
  174.         */
  175.         inline detail::head_finderF
  176.         head_finder( int N )
  177.         {
  178.             return detail::head_finderF(N);
  179.         }
  180.        
  181.         //! "Tail" finder
  182.         /*!
  183.             Construct the \c tail_finder. The finder returns a tail of a given
  184.             input. The tail is a suffix of a string up to n elements in
  185.             size. If an input has less then n elements, whole input is
  186.             considered a head.
  187.             The result is given as an \c iterator_range delimiting the match.
  188.  
  189.             \param N The size of the head
  190.             \return An instance of the \c tail_finder object
  191.         */
  192.         inline detail::tail_finderF
  193.         tail_finder( int N )
  194.         {
  195.             return detail::tail_finderF(N);
  196.         }
  197.  
  198.         //! "Token" finder
  199.         /*!
  200.             Construct the \c token_finder. The finder searches for a token
  201.             specified by a predicate. It is similar to std::find_if
  202.             algorithm, with an exception that it return a range of
  203.             instead of a single iterator.
  204.  
  205.             If "compress token mode" is enabled, adjacent matching tokens are
  206.             concatenated into one match. Thus the finder can be used to
  207.             search for continuous segments of characters satisfying the
  208.             given predicate.
  209.  
  210.             The result is given as an \c iterator_range delimiting the match.
  211.  
  212.             \param Pred An element selection predicate
  213.             \param eCompress Compress flag
  214.             \return An instance of the \c token_finder object
  215.         */
  216.         template< typename PredicateT >
  217.         inline detail::token_finderF<PredicateT>
  218.         token_finder(
  219.             PredicateT Pred,
  220.             token_compress_mode_type eCompress=token_compress_off )
  221.         {
  222.             return detail::token_finderF<PredicateT>( Pred, eCompress );
  223.         }
  224.  
  225.         //! "Range" finder
  226.         /*!
  227.             Construct the \c range_finder. The finder does not perform
  228.             any operation. It simply returns the given range for
  229.             any input.
  230.  
  231.             \param Begin Beginning of the range
  232.             \param End End of the range
  233.             \param Range The range.
  234.             \return An instance of the \c range_finger object
  235.         */
  236.         template< typename ForwardIteratorT >
  237.         inline detail::range_finderF<ForwardIteratorT>
  238.         range_finder(
  239.             ForwardIteratorT Begin,
  240.             ForwardIteratorT End )
  241.         {
  242.             return detail::range_finderF<ForwardIteratorT>( Begin, End );
  243.         }
  244.  
  245.         //! "Range" finder
  246.         /*!      
  247.             \overload
  248.         */
  249.         template< typename ForwardIteratorT >
  250.         inline detail::range_finderF<ForwardIteratorT>
  251.         range_finder( iterator_range<ForwardIteratorT> Range )
  252.         {
  253.             return detail::range_finderF<ForwardIteratorT>( Range );
  254.         }
  255.  
  256.     } // namespace algorithm
  257.  
  258.     // pull the names to the boost namespace
  259.     using algorithm::first_finder;
  260.     using algorithm::last_finder;
  261.     using algorithm::nth_finder;
  262.     using algorithm::head_finder;
  263.     using algorithm::tail_finder;
  264.     using algorithm::token_finder;
  265.     using algorithm::range_finder;
  266.  
  267. } // namespace mars_boost
  268.  
  269.  
  270. #endif  // BOOST_STRING_FINDER_HPP
  271.  
downloadfinder.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