include/boost/corosio/detail/conditionally_enabled_mutex.hpp

100.0% Lines (34/34) 100.0% List of functions (11/11) 78.6% Branches (11/14)

[ ] prev/next file n p prev/next uncovered line

conditionally_enabled_mutex.hpp

f(x) Functions (11)

Function Calls Lines Branches Blocks

Line	Branch	Hits	Source Code
1			//
2			// Copyright (c) 2026 Michael Vandeberg
3			//
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			// Official repository: https://github.com/cppalliance/corosio
8			//
9
10			#ifndef BOOST_COROSIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
11			#define BOOST_COROSIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
12
13			#include <mutex>
14
15			namespace boost::corosio::detail {
16
17			/* Mutex wrapper that becomes a no-op when disabled.
18
19			When enabled (the default), lock/unlock delegate to an
20			underlying std::mutex. When disabled, all operations are
21			no-ops. The enabled flag is fixed after construction.
22
23			scoped_lock wraps std::unique_lock<std::mutex> internally
24			so that condvar wait paths (which require the real lock
25			type) compile and work in multi-threaded mode.
26			*/
27			class conditionally_enabled_mutex
28			{
29			std::mutex mutex_;
30			bool enabled_;
31
32			public:
33		53804x	explicit conditionally_enabled_mutex(bool enabled = true) noexcept
34		26902x	: enabled_(enabled)
35		26902x	{
36		53804x	}
37
38			conditionally_enabled_mutex(conditionally_enabled_mutex const&) = delete;
39			conditionally_enabled_mutex&
40			operator=(conditionally_enabled_mutex const&) = delete;
41
42			bool enabled() const noexcept
43			{
44			return enabled_;
45			}
46
47		17568x	void set_enabled(bool v) noexcept
48			{
49		17568x	enabled_ = v;
50		17568x	}
51
52			// Lockable interface — allows std::lock_guard<conditionally_enabled_mutex>
53		157420x	void lock()
54			{
55	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 157420 times.	157420x	if (enabled_)
56		157420x	mutex_.lock();
57		157420x	}
58		157420x	void unlock()
59			{
60	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 157420 times.	157420x	if (enabled_)
61		157420x	mutex_.unlock();
62		157420x	}
63			bool try_lock()
64			{
65			return !enabled_ \|\| mutex_.try_lock();
66			}
67
68			class scoped_lock
69			{
70			std::unique_lock<std::mutex> lock_;
71			bool enabled_;
72
73			public:
74		5306826x	explicit scoped_lock(conditionally_enabled_mutex& m)
75		2653413x	: lock_(m.mutex_, std::defer_lock)
76		2653413x	, enabled_(m.enabled_)
77		2653413x	{
78	2/2 ✓ Branch 0 taken 20 times. ✓ Branch 1 taken 2653393 times.	2653413x	if (enabled_)
79	1/2 ✓ Branch 0 taken 2653393 times. ✗ Branch 1 not taken.	2653393x	lock_.lock();
80		5306826x	}
81
82			scoped_lock(scoped_lock const&) = delete;
83			scoped_lock& operator=(scoped_lock const&) = delete;
84
85		2285061x	void lock()
86			{
87	2/2 ✓ Branch 0 taken 6 times. ✓ Branch 1 taken 2285055 times.	2285061x	if (enabled_)
88		2285055x	lock_.lock();
89		2285061x	}
90
91		2303065x	void unlock()
92			{
93	2/2 ✓ Branch 0 taken 8 times. ✓ Branch 1 taken 2303057 times.	2303065x	if (enabled_)
94		2303057x	lock_.unlock();
95		2303065x	}
96
97		2290848x	bool owns_lock() const noexcept
98			{
99	2/2 ✓ Branch 0 taken 8 times. ✓ Branch 1 taken 2290840 times.	2290848x	return enabled_ && lock_.owns_lock();
100			}
101
102			// Access the underlying unique_lock for condvar wait().
103			// Only called when locking is enabled.
104		16x	std::unique_lock<std::mutex>& underlying() noexcept
105			{
106		16x	return lock_;
107			}
108			};
109			};
110
111			} // namespace boost::corosio::detail
112
113			#endif // BOOST_COROSIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
114