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

http://pythonocc.googlecode.com/ · C++ Header · 112 lines · 63 code · 17 blank · 32 comment · 0 complexity · c7dc377ac1998a2d9bd3a1db543742c4 MD5 · raw file

  1. /*=============================================================================
  2. Copyright (c) 2003 Martin Wille
  3. http://spirit.sourceforge.net/
  4. Distributed under the Boost Software License, Version 1.0. (See accompanying
  5. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6. =============================================================================*/
  7. #ifndef BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP
  8. #define BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP
  9. ///////////////////////////////////////////////////////////////////////////////
  10. #include <boost/spirit/home/classic/namespace.hpp>
  11. #if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
  12. #include <boost/spirit/home/classic/core/composite.hpp>
  13. #endif
  14. ///////////////////////////////////////////////////////////////////////////////
  15. namespace boost { namespace spirit {
  16. BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
  17. ///////////////////////////////////////////////////////////////////////////
  18. //
  19. // scoped_lock_parser class
  20. //
  21. // implements locking of a mutex during execution of
  22. // the parse method of an embedded parser
  23. //
  24. ///////////////////////////////////////////////////////////////////////////
  25. template <typename MutexT, typename ParserT>
  26. struct scoped_lock_parser
  27. : public unary< ParserT, parser< scoped_lock_parser<MutexT, ParserT> > >
  28. {
  29. typedef scoped_lock_parser<MutexT, ParserT> self_t;
  30. typedef MutexT mutex_t;
  31. typedef ParserT parser_t;
  32. template <typename ScannerT>
  33. struct result
  34. {
  35. typedef typename parser_result<parser_t, ScannerT>::type type;
  36. };
  37. scoped_lock_parser(mutex_t &m, parser_t const &p)
  38. : unary< ParserT, parser< scoped_lock_parser<MutexT, ParserT> > >(p)
  39. , mutex(m)
  40. {}
  41. template <typename ScannerT>
  42. typename parser_result<self_t, ScannerT>::type
  43. parse(ScannerT const &scan) const
  44. {
  45. typedef typename mutex_t::scoped_lock scoped_lock_t;
  46. scoped_lock_t lock(mutex);
  47. return this->subject().parse(scan);
  48. }
  49. mutex_t &mutex;
  50. };
  51. ///////////////////////////////////////////////////////////////////////////
  52. //
  53. // scoped_lock_parser_gen
  54. //
  55. // generator for scoped_lock_parser objects
  56. // operator[] returns scoped_lock_parser according to its argument
  57. //
  58. ///////////////////////////////////////////////////////////////////////////
  59. template <typename MutexT>
  60. struct scoped_lock_parser_gen
  61. {
  62. typedef MutexT mutex_t;
  63. explicit scoped_lock_parser_gen(mutex_t &m) : mutex(m) {}
  64. template<typename ParserT>
  65. scoped_lock_parser
  66. <
  67. MutexT,
  68. typename as_parser<ParserT>::type
  69. >
  70. operator[](ParserT const &p) const
  71. {
  72. typedef ::BOOST_SPIRIT_CLASSIC_NS::as_parser<ParserT> as_parser_t;
  73. typedef typename as_parser_t::type parser_t;
  74. return scoped_lock_parser<mutex_t, parser_t>
  75. (mutex, as_parser_t::convert(p));
  76. }
  77. mutex_t &mutex;
  78. };
  79. ///////////////////////////////////////////////////////////////////////////
  80. //
  81. // scoped_lock_d parser directive
  82. //
  83. // constructs a scoped_lock_parser generator from its argument
  84. //
  85. ///////////////////////////////////////////////////////////////////////////
  86. template <typename MutexT>
  87. scoped_lock_parser_gen<MutexT>
  88. scoped_lock_d(MutexT &mutex)
  89. {
  90. return scoped_lock_parser_gen<MutexT>(mutex);
  91. }
  92. BOOST_SPIRIT_CLASSIC_NAMESPACE_END
  93. }} // namespace BOOST_SPIRIT_CLASSIC_NS
  94. #endif // BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP