BVB Source Codes

mars Show classification.hpp Source code

Return Download mars: download classification.hpp Source code - Download mars Source code - Type:.hpp
  1. //  Boost string_algo library classification.hpp header file  ---------------------------//
  2.  
  3. //  Copyright Pavol Droba 2002-2003.
  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_CLASSIFICATION_HPP
  12. #define BOOST_STRING_CLASSIFICATION_HPP
  13.  
  14. #include <algorithm>
  15. #include <locale>
  16. #include <boost/range/value_type.hpp>
  17. #include <boost/range/as_literal.hpp>
  18. #include <boost/algorithm/string/detail/classification.hpp>
  19. #include <boost/algorithm/string/predicate_facade.hpp>
  20.  
  21.  
  22. /*! \file
  23.     Classification predicates are included in the library to give
  24.     some more convenience when using algorithms like \c trim() and \c all().
  25.     They wrap functionality of STL classification functions ( e.g. \c std::isspace() )
  26.     into generic functors.
  27. */
  28.  
  29. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  30.     namespace algorithm {
  31.  
  32. //  classification functor generator -------------------------------------//
  33.  
  34.         //! is_classified predicate
  35.         /*!
  36.             Construct the \c is_classified predicate. This predicate holds if the input is
  37.             of specified \c std::ctype category.
  38.  
  39.             \param Type A \c std::ctype category
  40.             \param Loc A locale used for classification
  41.             \return An instance of the \c is_classified predicate
  42.         */
  43.         inline detail::is_classifiedF
  44.         is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
  45.         {
  46.             return detail::is_classifiedF(Type, Loc);
  47.         }
  48.  
  49.         //! is_space predicate
  50.         /*!
  51.             Construct the \c is_classified predicate for the \c ctype_base::space category.  
  52.  
  53.             \param Loc A locale used for classification
  54.             \return An instance of the \c is_classified predicate
  55.         */
  56.         inline detail::is_classifiedF
  57.         is_space(const std::locale& Loc=std::locale())
  58.         {
  59.             return detail::is_classifiedF(std::ctype_base::space, Loc);
  60.         }
  61.  
  62.         //! is_alnum predicate
  63.         /*!
  64.             Construct the \c is_classified predicate for the \c ctype_base::alnum category.  
  65.  
  66.             \param Loc A locale used for classification
  67.             \return An instance of the \c is_classified predicate
  68.         */
  69.         inline detail::is_classifiedF
  70.         is_alnum(const std::locale& Loc=std::locale())
  71.         {
  72.             return detail::is_classifiedF(std::ctype_base::alnum, Loc);
  73.         }
  74.  
  75.         //! is_alpha predicate
  76.         /*!
  77.             Construct the \c is_classified predicate for the \c ctype_base::alpha category.  
  78.  
  79.             \param Loc A locale used for classification
  80.             \return An instance of the \c is_classified predicate
  81.         */
  82.         inline detail::is_classifiedF
  83.         is_alpha(const std::locale& Loc=std::locale())
  84.         {
  85.             return detail::is_classifiedF(std::ctype_base::alpha, Loc);
  86.         }
  87.  
  88.         //! is_cntrl predicate
  89.         /*!
  90.             Construct the \c is_classified predicate for the \c ctype_base::cntrl category.  
  91.  
  92.             \param Loc A locale used for classification
  93.             \return An instance of the \c is_classified predicate
  94.         */
  95.         inline detail::is_classifiedF
  96.         is_cntrl(const std::locale& Loc=std::locale())
  97.         {
  98.             return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
  99.         }
  100.  
  101.         //! is_digit predicate
  102.         /*!
  103.             Construct the \c is_classified predicate for the \c ctype_base::digit category.  
  104.  
  105.             \param Loc A locale used for classification
  106.             \return An instance of the \c is_classified predicate
  107.         */
  108.         inline detail::is_classifiedF
  109.         is_digit(const std::locale& Loc=std::locale())
  110.         {
  111.             return detail::is_classifiedF(std::ctype_base::digit, Loc);
  112.         }
  113.  
  114.         //! is_graph predicate
  115.         /*!
  116.             Construct the \c is_classified predicate for the \c ctype_base::graph category.  
  117.  
  118.             \param Loc A locale used for classification
  119.             \return An instance of the \c is_classified predicate
  120.         */
  121.         inline detail::is_classifiedF
  122.         is_graph(const std::locale& Loc=std::locale())
  123.         {
  124.             return detail::is_classifiedF(std::ctype_base::graph, Loc);
  125.         }
  126.  
  127.         //! is_lower predicate
  128.         /*!
  129.             Construct the \c is_classified predicate for the \c ctype_base::lower category.  
  130.  
  131.             \param Loc A locale used for classification
  132.             \return An instance of \c is_classified predicate
  133.         */
  134.         inline detail::is_classifiedF
  135.         is_lower(const std::locale& Loc=std::locale())
  136.         {
  137.             return detail::is_classifiedF(std::ctype_base::lower, Loc);
  138.         }
  139.  
  140.         //! is_print predicate
  141.         /*!
  142.             Construct the \c is_classified predicate for the \c ctype_base::print category.  
  143.  
  144.             \param Loc A locale used for classification
  145.             \return An instance of the \c is_classified predicate
  146.         */
  147.         inline detail::is_classifiedF
  148.         is_print(const std::locale& Loc=std::locale())
  149.         {
  150.             return detail::is_classifiedF(std::ctype_base::print, Loc);
  151.         }
  152.  
  153.         //! is_punct predicate
  154.         /*!
  155.             Construct the \c is_classified predicate for the \c ctype_base::punct category.  
  156.  
  157.             \param Loc A locale used for classification
  158.             \return An instance of the \c is_classified predicate
  159.         */
  160.         inline detail::is_classifiedF
  161.         is_punct(const std::locale& Loc=std::locale())
  162.         {
  163.             return detail::is_classifiedF(std::ctype_base::punct, Loc);
  164.         }
  165.  
  166.         //! is_upper predicate
  167.         /*!
  168.             Construct the \c is_classified predicate for the \c ctype_base::upper category.  
  169.  
  170.             \param Loc A locale used for classification
  171.             \return An instance of the \c is_classified predicate
  172.         */
  173.         inline detail::is_classifiedF
  174.         is_upper(const std::locale& Loc=std::locale())
  175.         {
  176.             return detail::is_classifiedF(std::ctype_base::upper, Loc);
  177.         }
  178.  
  179.         //! is_xdigit predicate
  180.         /*!
  181.             Construct the \c is_classified predicate for the \c ctype_base::xdigit category.  
  182.  
  183.             \param Loc A locale used for classification
  184.             \return An instance of the \c is_classified predicate
  185.         */
  186.         inline detail::is_classifiedF
  187.         is_xdigit(const std::locale& Loc=std::locale())
  188.         {
  189.             return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
  190.         }
  191.  
  192.         //! is_any_of predicate
  193.         /*!
  194.             Construct the \c is_any_of predicate. The predicate holds if the input
  195.             is included in the specified set of characters.
  196.  
  197.             \param Set A set of characters to be recognized
  198.             \return An instance of the \c is_any_of predicate
  199.         */
  200.         template<typename RangeT>
  201.         inline detail::is_any_ofF<
  202.             BOOST_STRING_TYPENAME range_value<RangeT>::type>
  203.         is_any_of( const RangeT& Set )
  204.         {
  205.             iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(mars_boost::as_literal(Set));
  206.             return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set);
  207.         }
  208.  
  209.         //! is_from_range predicate
  210.         /*!
  211.             Construct the \c is_from_range predicate. The predicate holds if the input
  212.             is included in the specified range. (i.e. From <= Ch <= To )
  213.  
  214.             \param From The start of the range
  215.             \param To The end of the range
  216.             \return An instance of the \c is_from_range predicate
  217.         */
  218.         template<typename CharT>
  219.         inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
  220.         {
  221.             return detail::is_from_rangeF<CharT>(From,To);
  222.         }
  223.        
  224.         // predicate combinators ---------------------------------------------------//
  225.  
  226.         //! predicate 'and' composition predicate
  227.         /*!
  228.             Construct the \c class_and predicate. This predicate can be used
  229.             to logically combine two classification predicates. \c class_and holds,
  230.             if both predicates return true.
  231.  
  232.             \param Pred1 The first predicate
  233.             \param Pred2 The second predicate
  234.             \return An instance of the \c class_and predicate    
  235.         */
  236.         template<typename Pred1T, typename Pred2T>
  237.         inline detail::pred_andF<Pred1T, Pred2T>
  238.         operator&&(
  239.             const predicate_facade<Pred1T>& Pred1,
  240.             const predicate_facade<Pred2T>& Pred2 )
  241.         {    
  242.             // Doing the static_cast with the pointer instead of the reference
  243.             // is a workaround for some compilers which have problems with
  244.             // static_cast's of template references, i.e. CW8. /grafik/
  245.             return detail::pred_andF<Pred1T,Pred2T>(
  246.                 *static_cast<const Pred1T*>(&Pred1),
  247.                 *static_cast<const Pred2T*>(&Pred2) );
  248.         }
  249.  
  250.         //! predicate 'or' composition predicate
  251.         /*!
  252.             Construct the \c class_or predicate. This predicate can be used
  253.             to logically combine two classification predicates. \c class_or holds,
  254.             if one of the predicates return true.
  255.  
  256.             \param Pred1 The first predicate
  257.             \param Pred2 The second predicate
  258.             \return An instance of the \c class_or predicate    
  259.         */
  260.         template<typename Pred1T, typename Pred2T>
  261.         inline detail::pred_orF<Pred1T, Pred2T>
  262.         operator||(
  263.             const predicate_facade<Pred1T>& Pred1,
  264.             const predicate_facade<Pred2T>& Pred2 )
  265.         {    
  266.             // Doing the static_cast with the pointer instead of the reference
  267.             // is a workaround for some compilers which have problems with
  268.             // static_cast's of template references, i.e. CW8. /grafik/
  269.             return detail::pred_orF<Pred1T,Pred2T>(
  270.                 *static_cast<const Pred1T*>(&Pred1),
  271.                 *static_cast<const Pred2T*>(&Pred2));
  272.         }
  273.  
  274.         //! predicate negation operator
  275.         /*!
  276.             Construct the \c class_not predicate. This predicate represents a negation.
  277.             \c class_or holds if of the predicates return false.
  278.  
  279.             \param Pred The predicate to be negated
  280.             \return An instance of the \c class_not predicate    
  281.         */
  282.         template<typename PredT>
  283.         inline detail::pred_notF<PredT>
  284.         operator!( const predicate_facade<PredT>& Pred )
  285.         {
  286.             // Doing the static_cast with the pointer instead of the reference
  287.             // is a workaround for some compilers which have problems with
  288.             // static_cast's of template references, i.e. CW8. /grafik/
  289.             return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred));
  290.         }
  291.  
  292.     } // namespace algorithm
  293.  
  294.     // pull names to the boost namespace
  295.     using algorithm::is_classified;
  296.     using algorithm::is_space;
  297.     using algorithm::is_alnum;
  298.     using algorithm::is_alpha;
  299.     using algorithm::is_cntrl;
  300.     using algorithm::is_digit;
  301.     using algorithm::is_graph;
  302.     using algorithm::is_lower;
  303.     using algorithm::is_upper;
  304.     using algorithm::is_print;
  305.     using algorithm::is_punct;
  306.     using algorithm::is_xdigit;
  307.     using algorithm::is_any_of;
  308.     using algorithm::is_from_range;
  309.  
  310. } // namespace mars_boost
  311.  
  312. #endif  // BOOST_STRING_PREDICATE_HPP
  313.  
downloadclassification.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