include/lockable.hpp - main - Ant010ff/ffpp

include/lockable.hpp
102 строки3 KB
Ant010ff
Version 2.11.3.
08 авг 2026, 16:44
08 авг 2026, 16:44fd187d3
/*
This header is part of a Functional Flow Processing Primitives (FFPP) library, version 2.11.3.

Official repository: https://gitlab.com/ant010ff/ffpp

Licensed under the MIT License <http://opensource.org/licenses/MIT>.
SPDX-License-Identifier: MIT
Copyright (c) 2021 - 2026 Anton Nasonov <ant010fff @ gmail . com>.
*/

#ifndef FFPP_LOCKABLE_HPP
#define FFPP_LOCKABLE_HPP

namespace FFPP::Concepts {

	template<typename Type>
	concept Mutex = 
		requires(Type* pMtx) {
			{ pMtx->lock() };
			{ pMtx->try_lock() } -> std::same_as<bool>;
			{ pMtx->unlock() };
		}
	;

	template<typename Type>
	concept SharedMutex = 
		Mutex<Type>
		&& requires(Type* pMtx) {
			{ pMtx->lock_shared() };
			{ pMtx->try_lock_shared() } -> std::same_as<bool>;
			{ pMtx->unlock_shared() };
		}
	;

	template<typename Type>
	concept Lock = Specialization<Type, std::unique_lock> || Specialization<Type, std::shared_lock>;

	template<typename Type>
	concept Lockable = 
		requires {
			typename Type::MutexT;
			typename Type::UniqueLockT;
			typename Type::SharedLockT;
		}
		&& requires(Type* pLockable) {
			{ pLockable->template GetSharedLock<true, true>() } -> std::same_as<typename Type::SharedLockT>;
			{ pLockable->template GetUniqueLock<true, true>() } -> std::same_as<typename Type::UniqueLockT>;
		}
	;

}//FFPP::Concepts

namespace FFPP {

	template<Concepts::Lock TLock, bool t_bLocked = true, bool t_bSpin = false>
	FFPP_ATTR_INLINE
	inline TLock AcquireLock(Concepts::Mutex auto& mtx) { 
		if constexpr(t_bLocked) {
			if constexpr(t_bSpin) {
				TLock lck(mtx, std::defer_lock);
				auto onBackoff = FFPP::JitteredBackoff(); 
				while(!lck.try_lock()) {
					onBackoff();
				}
				return lck;
			}
			else return TLock(mtx); 
		}
		else return TLock(mtx, std::defer_lock);
	}//AcquireLock

}//FFPP

namespace FFPP {

	template<Concepts::Mutex TMutex = FFPP::TicketMutex<>, bool t_bDefaultSpin = false>
	class Lockable {
	public:
		using MutexT = TMutex;
		using UniqueLockT = std::unique_lock<MutexT>;
		using SharedLockT = std::conditional_t<Concepts::SharedMutex<MutexT>, std::shared_lock<MutexT>, std::unique_lock<MutexT>>;

		template<typename... TArgs>
		Lockable(TArgs&&... args)
		: mtx_(args...)
		{ }

		template<bool t_bLocked = true, bool t_bSpin = t_bDefaultSpin>
		FFPP_ATTR_INLINE
		UniqueLockT GetUniqueLock() const { return FFPP::AcquireLock<UniqueLockT, t_bLocked, t_bSpin>(mtx_); }

		template<bool t_bLocked = true, bool t_bSpin = t_bDefaultSpin>
		FFPP_ATTR_INLINE
		SharedLockT GetSharedLock() const { return FFPP::AcquireLock<SharedLockT, t_bLocked, t_bSpin>(mtx_); }
	
	private:
		MutexT mutable mtx_;
	};//Lockable

}//FFPP

#endif//FFPP_LOCKABLE_HPP