comparison DEPENDENCIES/generic/include/boost/spirit/home/classic/utility/scoped_lock.hpp @ 16:2665513ce2d3

Add boost headers

+/*=============================================================================
+    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