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		68846x	explicit conditionally_enabled_mutex(bool enabled = true) noexcept
34		34423x	: enabled_(enabled)
35		34423x	{
36		68846x	}
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		22619x	void set_enabled(bool v) noexcept
48			{
49		22619x	enabled_ = v;
50		22619x	}
51
52			// Lockable interface — allows std::lock_guard<conditionally_enabled_mutex>
53		225723x	void lock()
54			{
55	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 225723 times.	225723x	if (enabled_)
56		225723x	mutex_.lock();
57		225723x	}
58		225723x	void unlock()
59			{
60	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 225723 times.	225723x	if (enabled_)
61		225723x	mutex_.unlock();
62		225723x	}
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		1095026x	explicit scoped_lock(conditionally_enabled_mutex& m)
75		547513x	: lock_(m.mutex_, std::defer_lock)
76		547513x	, enabled_(m.enabled_)
77		547513x	{
78	2/2 ✓ Branch 0 taken 18 times. ✓ Branch 1 taken 547495 times.	547513x	if (enabled_)
79	1/2 ✓ Branch 0 taken 547495 times. ✗ Branch 1 not taken.	547495x	lock_.lock();
80		1095026x	}
81
82			scoped_lock(scoped_lock const&) = delete;
83			scoped_lock& operator=(scoped_lock const&) = delete;
84
85		768564x	void lock()
86			{
87	2/2 ✓ Branch 0 taken 5 times. ✓ Branch 1 taken 768559 times.	768564x	if (enabled_)
88		768559x	lock_.lock();
89		768564x	}
90
91		794331x	void unlock()
92			{
93	2/2 ✓ Branch 0 taken 8 times. ✓ Branch 1 taken 794323 times.	794331x	if (enabled_)
94		794323x	lock_.unlock();
95		794331x	}
96
97		775521x	bool owns_lock() const noexcept
98			{
99	2/2 ✓ Branch 0 taken 8 times. ✓ Branch 1 taken 775513 times.	775521x	return enabled_ && lock_.owns_lock();
100			}
101
102			// Access the underlying unique_lock for condvar wait().
103			// Only called when locking is enabled.
104		21x	std::unique_lock<std::mutex>& underlying() noexcept
105			{
106		21x	return lock_;
107			}
108			};
109			};
110
111			} // namespace boost::corosio::detail
112
113			#endif // BOOST_COROSIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
114