class recursive_timed_mutex added

include/boost/fiber/all.hpp

@@ -15,6 +15,7 @@
 #include <boost/fiber/operations.hpp>
 #include <boost/fiber/protected_fixedsize_stack.hpp>
 #include <boost/fiber/recursive_mutex.hpp>
+#include <boost/fiber/recursive_timed_mutex.hpp>
 #include <boost/fiber/timed_mutex.hpp>
 #include <boost/fiber/scheduler.hpp>
 #include <boost/fiber/segmented_stack.hpp>

include/boost/fiber/recursive_timed_mutex.hpp

@@ -0,0 +1,82 @@
+
+//          Copyright Oliver Kowalke 2013.
+// 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)
+//
+//  based on boost::interprocess::sync::interprocess_spinlock
+
+#ifndef BOOST_FIBERS_RECURSIVE_TIMED_MUTEX_H
+#define BOOST_FIBERS_RECURSIVE_TIMED_MUTEX_H
+
+#include <atomic>
+#include <chrono>
+#include <cstddef>
+
+#include <boost/config.hpp>
+
+#include <boost/fiber/context.hpp>
+#include <boost/fiber/detail/config.hpp>
+#include <boost/fiber/detail/convert.hpp>
+#include <boost/fiber/detail/spinlock.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost {
+namespace fibers {
+
+class BOOST_FIBERS_DECL recursive_timed_mutex {
+private:
+    enum class mutex_status {
+        locked = 0,
+        unlocked
+    };
+
+    typedef context::wait_queue_t   wait_queue_t;
+
+    std::atomic< mutex_status > state_;
+    std::atomic< context * >    owner_;
+    std::size_t                 count_;
+    wait_queue_t                wait_queue_;
+    detail::spinlock            wait_queue_splk_;
+
+    bool lock_if_unlocked_();
+
+    bool try_lock_until_( std::chrono::steady_clock::time_point const& timeout_time);
+
+public:
+    recursive_timed_mutex();
+
+    ~recursive_timed_mutex();
+
+    recursive_timed_mutex( recursive_timed_mutex const&) = delete;
+    recursive_timed_mutex & operator=( recursive_timed_mutex const&) = delete;
+
+    void lock();
+
+    bool try_lock();
+
+    template< typename Clock, typename Duration >
+    bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time_) {
+        std::chrono::steady_clock::time_point timeout_time(
+                detail::convert( timeout_time_) );
+        return try_lock_until_( timeout_time);
+    }
+
+    template< typename Rep, typename Period >
+    bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration) {
+        return try_lock_until_( std::chrono::steady_clock::now() + timeout_duration);
+    }
+
+    void unlock();
+};
+
+}}
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_FIBERS_RECURSIVE_TIMED_MUTEX_H