/*============================================================================= | |
Copyright (c) 2003 Martin Wille | |
http://spirit.sourceforge.net/ | |
Distributed under the Boost Software License, Version 1.0. (See accompanying | |
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
=============================================================================*/ | |
#ifndef BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP | |
#define BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP | |
/////////////////////////////////////////////////////////////////////////////// | |
#include <boost/spirit/home/classic/namespace.hpp> | |
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP) | |
#include <boost/spirit/home/classic/core/composite.hpp> | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace boost { namespace spirit { | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// scoped_lock_parser class | |
// | |
// implements locking of a mutex during execution of | |
// the parse method of an embedded parser | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename MutexT, typename ParserT> | |
struct scoped_lock_parser | |
: public unary< ParserT, parser< scoped_lock_parser<MutexT, ParserT> > > | |
{ | |
typedef scoped_lock_parser<MutexT, ParserT> self_t; | |
typedef MutexT mutex_t; | |
typedef ParserT parser_t; | |
template <typename ScannerT> | |
struct result | |
{ | |
typedef typename parser_result<parser_t, ScannerT>::type type; | |
}; | |
scoped_lock_parser(mutex_t &m, parser_t const &p) | |
: unary< ParserT, parser< scoped_lock_parser<MutexT, ParserT> > >(p) | |
, mutex(m) | |
{} | |
template <typename ScannerT> | |
typename parser_result<self_t, ScannerT>::type | |
parse(ScannerT const &scan) const | |
{ | |
typedef typename mutex_t::scoped_lock scoped_lock_t; | |
scoped_lock_t lock(mutex); | |
return this->subject().parse(scan); | |
} | |
mutex_t &mutex; | |
}; | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// scoped_lock_parser_gen | |
// | |
// generator for scoped_lock_parser objects | |
// operator[] returns scoped_lock_parser according to its argument | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename MutexT> | |
struct scoped_lock_parser_gen | |
{ | |
typedef MutexT mutex_t; | |
explicit scoped_lock_parser_gen(mutex_t &m) : mutex(m) {} | |
template<typename ParserT> | |
scoped_lock_parser | |
< | |
MutexT, | |
typename as_parser<ParserT>::type | |
> | |
operator[](ParserT const &p) const | |
{ | |
typedef ::BOOST_SPIRIT_CLASSIC_NS::as_parser<ParserT> as_parser_t; | |
typedef typename as_parser_t::type parser_t; | |
return scoped_lock_parser<mutex_t, parser_t> | |
(mutex, as_parser_t::convert(p)); | |
} | |
mutex_t &mutex; | |
}; | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// scoped_lock_d parser directive | |
// | |
// constructs a scoped_lock_parser generator from its argument | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename MutexT> | |
scoped_lock_parser_gen<MutexT> | |
scoped_lock_d(MutexT &mutex) | |
{ | |
return scoped_lock_parser_gen<MutexT>(mutex); | |
} | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
}} // namespace BOOST_SPIRIT_CLASSIC_NS | |
#endif // BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP |