/src/contrib/boost/spirit/home/classic/utility/flush_multi_pass.hpp

http://pythonocc.googlecode.com/ · C++ Header · 77 lines · 35 code · 14 blank · 28 comment · 0 complexity · f43e2f3d8f4fca04640f64d0dd9f7a91 MD5 · raw file 

    

  1. /*=============================================================================
    2. 

  2.     Copyright (c) 2001-2003 Daniel Nuffer
    3. 

  3.     http://spirit.sourceforge.net/
    4. 

    5. 

  5.   Distributed under the Boost Software License, Version 1.0. (See accompanying
    6. 

  6.   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    7. 

  7. =============================================================================*/
    8. 

  8. #ifndef BOOST_SPIRIT_FLUSH_MULTI_PASS_HPP
    9. 

  9. #define BOOST_SPIRIT_FLUSH_MULTI_PASS_HPP
    10. 

  10. 

  11. ///////////////////////////////////////////////////////////////////////////////
    12. 

  12. #include <boost/spirit/home/classic/namespace.hpp>
    13. 

  13. #include <boost/spirit/home/classic/core.hpp>
    14. 

  14. #include <boost/spirit/home/classic/iterator/multi_pass.hpp>
    15. 

  15. 

  16. ///////////////////////////////////////////////////////////////////////////////
    17. 

  17. namespace boost { namespace spirit {
    18. 

  18. 

  19. BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
    20. 

  20. 

  21.     namespace impl {
    22. 

  22. 

  23.         template <typename T>
    24. 

  24.         void flush_iterator(T &) {}
    25. 

  25. 

  26.         template <typename T1, typename T2, typename T3, typename T4>
    27. 

  27.         void flush_iterator(BOOST_SPIRIT_CLASSIC_NS::multi_pass<
    28. 

  28.             T1, T2, T3, T4, BOOST_SPIRIT_CLASSIC_NS::multi_pass_policies::std_deque> &i)
    29. 

  29.         {
    30. 

  30.             i.clear_queue();
    31. 

  31.         }
    32. 

  32. 

  33.     }   // namespace impl
    34. 

  34. 

  35.     ///////////////////////////////////////////////////////////////////////////
    36. 

  36.     //
    37. 

  37.     //  flush_multi_pass_parser
    38. 

  38.     //
    39. 

  39.     //      The flush_multi_pass_parser flushes an underlying
    40. 

  40.     //      multi_pass_iterator during the normal parsing process. This may
    41. 

  41.     //      be used at certain points during the parsing process, when it is
    42. 

  42.     //      clear, that no backtracking is needed anymore and the input
    43. 

  43.     //      gathered so far may be discarded.
    44. 

  44.     //
    45. 

  45.     ///////////////////////////////////////////////////////////////////////////
    46. 

  46.     class flush_multi_pass_parser
    47. 

  47.     :   public parser<flush_multi_pass_parser>
    48. 

  48.     {
    49. 

  49.     public:
    50. 

  50.         typedef flush_multi_pass_parser this_t;
    51. 

  51. 

  52.         template <typename ScannerT>
    53. 

  53.         typename parser_result<this_t, ScannerT>::type
    54. 

  54.         parse(ScannerT const& scan) const
    55. 

  55.         {
    56. 

  56.             impl::flush_iterator(scan.first);
    57. 

  57.             return scan.empty_match();
    58. 

  58.         }
    59. 

  59.     };
    60. 

  60. 

  61.     ///////////////////////////////////////////////////////////////////////////
    62. 

  62.     //
    63. 

  63.     //  predefined flush_multi_pass_p object
    64. 

  64.     //
    65. 

  65.     //      This object should may used to flush a multi_pass_iterator along
    66. 

  66.     //      the way during the normal parsing process.
    67. 

  67.     //
    68. 

  68.     ///////////////////////////////////////////////////////////////////////////
    69. 

  69. 

  70.     flush_multi_pass_parser const
    71. 

  71.         flush_multi_pass_p = flush_multi_pass_parser();
    72. 

  72. 

  73. BOOST_SPIRIT_CLASSIC_NAMESPACE_END
    74. 

  74. 

  75. }} // namespace BOOST_SPIRIT_CLASSIC_NS
    76. 

  76. 

  77. #endif // BOOST_SPIRIT_FLUSH_MULTI_PASS_HPP
    78.