summaryrefslogtreecommitdiffstats
path: root/src/safe
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/safe/accessmode.h49
-rw-r--r--src/safe/defaulttypes.h23
-rw-r--r--src/safe/mutableref.h40
-rw-r--r--src/safe/safe.h359
4 files changed, 471 insertions, 0 deletions
diff --git a/src/safe/accessmode.h b/src/safe/accessmode.h
new file mode 100644
index 0000000..3dd0f4f
--- /dev/null
+++ b/src/safe/accessmode.h
@@ -0,0 +1,49 @@
+/**
+ * @file accessmode.h
+ * @author L.-C. C.
+ * @brief
+ * @version 0.1
+ * @date 2019-01-20
+ *
+ * @copyright Copyright (c) 2019
+ *
+ */
+
+#pragma once
+
+#include <mutex>
+#if __cplusplus >= 201402L
+#include <shared_mutex>
+#endif // __cplusplus >= 201402L
+
+namespace safe
+{
+ enum class AccessMode
+ {
+ ReadOnly,
+ ReadWrite
+ };
+
+ template<typename LockType>
+ struct AccessTraits
+ {
+ static constexpr bool IsReadOnly = false;
+ };
+ template<typename MutexType>
+ struct AccessTraits<std::lock_guard<MutexType>>
+ {
+ static constexpr bool IsReadOnly = false;
+ };
+ template<typename MutexType>
+ struct AccessTraits<std::unique_lock<MutexType>>
+ {
+ static constexpr bool IsReadOnly = false;
+ };
+#if __cplusplus >= 201402L
+ template<typename MutexType>
+ struct AccessTraits<std::shared_lock<MutexType>>
+ {
+ static constexpr bool IsReadOnly = true;
+ };
+#endif // __cplusplus >= 201402L
+} // namespace safe
diff --git a/src/safe/defaulttypes.h b/src/safe/defaulttypes.h
new file mode 100644
index 0000000..1cb2273
--- /dev/null
+++ b/src/safe/defaulttypes.h
@@ -0,0 +1,23 @@
+/**
+ * @file defaulttypes.h
+ * @author L.-C. C.
+ * @brief
+ * @version 0.1
+ * @date 2020-01-29
+ *
+ * @copyright Copyright (c) 2020
+ *
+ */
+
+#pragma once
+
+#include <mutex>
+
+namespace safe
+{
+ using DefaultMutex = std::mutex;
+ template<typename MutexType>
+ using DefaultReadOnlyLock = std::lock_guard<MutexType>;
+ template<typename MutexType>
+ using DefaultReadWriteLock = std::lock_guard<MutexType>;
+} // namespace safe
diff --git a/src/safe/mutableref.h b/src/safe/mutableref.h
new file mode 100644
index 0000000..fb65825
--- /dev/null
+++ b/src/safe/mutableref.h
@@ -0,0 +1,40 @@
+/**
+ * @file mutableref.h
+ * @author L.-C. C.
+ * @brief
+ * @version 0.1
+ * @date 2020-01-03
+ *
+ * @copyright Copyright (c) 2020
+ *
+ */
+
+#pragma once
+
+#include <utility>
+
+namespace safe
+{
+ namespace impl
+ {
+ /**
+ * @brief A helper class that defines a member variable of type
+ * Type. The variable is defined "mutable Type" if Type is not a
+ * reference, the variable is "Type&" if Type is a reference.
+ *
+ * @tparam Type The type of the variable to define.
+ */
+ template<typename Type>
+ struct MutableIfNotReference
+ {
+ /// Mutable Type object.
+ mutable Type get;
+ };
+ template<typename Type>
+ struct MutableIfNotReference<Type&>
+ {
+ /// Reference to a Type object.
+ Type& get;
+ };
+ } // namespace impl
+} // namespace safe
diff --git a/src/safe/safe.h b/src/safe/safe.h
new file mode 100644
index 0000000..2beab55
--- /dev/null
+++ b/src/safe/safe.h
@@ -0,0 +1,359 @@
+/**
+ * @file safe.h
+ * @author L.-C. C.
+ * @brief
+ * @version 0.1
+ * @date 2018-09-21
+ *
+ * @copyright Copyright (c) 2018
+ *
+ */
+
+#pragma once
+
+#include "accessmode.h"
+#include "defaulttypes.h"
+#include "mutableref.h"
+
+#include <type_traits>
+#include <utility>
+
+#if __cplusplus >= 201703L
+#define EXPLICIT_IF_CPP17 explicit
+#define EXPLICITLY_CONSTRUCT_RETURN_TYPE_IF_CPP17 ReturnType
+#else
+#define EXPLICIT_IF_CPP17
+#define EXPLICITLY_CONSTRUCT_RETURN_TYPE_IF_CPP17
+#endif
+
+namespace safe
+{
+ /**
+ * @brief Use this tag to default construct the mutex when constructing a
+ * Safe object.
+ */
+ struct DefaultConstructMutex {};
+ static constexpr DefaultConstructMutex default_construct_mutex;
+
+ /**
+ * @brief Wraps a value together with a mutex.
+ *
+ * @tparam ValueType The type of the value to protect.
+ * @tparam MutexType The type of the mutex.
+ */
+ template<typename ValueType, typename MutexType = DefaultMutex>
+ class Safe
+ {
+ private:
+ /// Type ValueType with reference removed, if present
+ using RemoveRefValueType = typename std::remove_reference<ValueType>::type;
+ /// Type MutexType with reference removed, if present
+ using RemoveRefMutexType = typename std::remove_reference<MutexType>::type;
+
+ /**
+ * @brief Manages a mutex and gives pointer-like access to a value
+ * object.
+ *
+ * @tparam LockType The type of the lock object that manages the
+ * mutex, example: std::lock_guard.
+ * @tparam Mode Determines the access mode of the Access
+ * object. Can be either AccessMode::ReadOnly or
+ * AccessMode::ReadWrite.
+ */
+ template<template<typename> class LockType, AccessMode Mode>
+ class Access
+ {
+ // Make sure AccessMode is ReadOnly if a read-only lock is used
+ static_assert(!(AccessTraits<LockType<RemoveRefMutexType>>::IsReadOnly && Mode==AccessMode::ReadWrite), "Cannot have ReadWrite access mode with ReadOnly lock. Check the value of AccessTraits<LockType>::IsReadOnly if it exists.");
+
+ /// ValueType with const qualifier if AccessMode is ReadOnly.
+ using ConstIfReadOnlyValueType = typename std::conditional<Mode==AccessMode::ReadOnly, const RemoveRefValueType, RemoveRefValueType>::type;
+
+ public:
+ /// Pointer-to-const ValueType
+ using ConstPointerType = const ConstIfReadOnlyValueType*;
+ /// Pointer-to-const ValueType if Mode is ReadOnly, pointer to ValueType otherwise.
+ using PointerType = ConstIfReadOnlyValueType*;
+ /// Reference-to-const ValueType
+ using ConstReferenceType = const ConstIfReadOnlyValueType&;
+ /// Reference-to-const ValueType if Mode is ReadOnly, reference to ValueType otherwise.
+ using ReferenceType = ConstIfReadOnlyValueType&;
+
+ /**
+ * @brief Construct an Access object from a possibly const
+ * reference to the value object and any additionnal argument
+ * needed to construct the Lock object.
+ *
+ * @tparam LockArgs Deduced from lockArgs.
+ * @param value Reference to the value.
+ * @param lockArgs Arguments needed to construct the lock object.
+ */
+ template<typename... OtherLockArgs>
+ EXPLICIT_IF_CPP17
+ Access(ReferenceType value, MutexType& mutex, OtherLockArgs&&... otherLockArgs):
+ lock(mutex, std::forward<OtherLockArgs>(otherLockArgs)...),
+ m_value(value)
+ {}
+
+ /**
+ * @brief Construct a read-only Access object from a const
+ * safe::Safe object and any additionnal argument needed to
+ * construct the Lock object.
+ *
+ * If needed, you can provide additionnal arguments to construct
+ * the lock object (such as std::adopt_lock). The mutex from the
+ * safe::Locakble object is already passed to the lock object's
+ * constructor though, you must not provide it.
+ *
+ * @tparam OtherLockArgs Deduced from otherLockArgs.
+ * @param safe The const Safe object to give protected access to.
+ * @param otherLockArgs Other arguments needed to construct the lock
+ * object.
+ */
+ template<typename... OtherLockArgs>
+ EXPLICIT_IF_CPP17
+ Access(const Safe& safe, OtherLockArgs&&... otherLockArgs):
+ Access(safe.m_value, safe.m_mutex.get, std::forward<OtherLockArgs>(otherLockArgs)...)
+ {}
+
+ /**
+ * @brief Construct a read-write Access object from a
+ * safe::Safe object and any additionnal argument needed to
+ * construct the Lock object.
+ *
+ * If needed, you can provide additionnal arguments to construct
+ * the lock object (such as std::adopt_lock). The mutex from the
+ * safe object is already passed to the lock object's constructor
+ * though, you must not provide it.
+ *
+ * @tparam OtherLockArgs Deduced from otherLockArgs.
+ * @param safe The Safe object to give protected access to.
+ * @param otherLockArgs Other arguments needed to construct the lock
+ * object.
+ */
+ template<typename... OtherLockArgs>
+ EXPLICIT_IF_CPP17
+ Access(Safe& safe, OtherLockArgs&&... otherLockArgs):
+ Access(safe.m_value, safe.m_mutex.get, std::forward<OtherLockArgs>(otherLockArgs)...)
+ {}
+
+ /**
+ * @brief Construct an Access object from another one.
+ * OtherLockType must implement release() like std::unique_lock
+ * does.
+ *
+ * @tparam OtherLockType Deduced from otherAccess.
+ * @tparam OtherMode Deduced from otherAccess.
+ * @tparam OtherLockArgs Deduced from otherLockArgs.
+ * @param otherAccess The Access object to construct from.
+ * @param otherLockArgs Other arguments needed to construct the lock
+ * object.
+ */
+ template<template<typename> class OtherLockType, AccessMode OtherMode, typename... OtherLockArgs>
+ EXPLICIT_IF_CPP17
+ Access(Access<OtherLockType, OtherMode>& otherAccess, OtherLockArgs&&... otherLockArgs):
+ Access(*otherAccess, *otherAccess.lock.release(), std::adopt_lock, std::forward<OtherLockArgs>(otherLockArgs)...)
+ {
+ static_assert(OtherMode == AccessMode::ReadWrite || OtherMode == Mode, "Cannot construct a ReadWrite Access object from a ReadOnly one!");
+ }
+
+ /**
+ * @brief Const accessor to the value.
+ * @return ConstPointerType Const pointer to the protected value.
+ */
+ ConstPointerType operator->() const noexcept
+ {
+ return &m_value;
+ }
+
+ /**
+ * @brief Accessor to the value.
+ * @return ValuePointerType Pointer to the protected value.
+ */
+ PointerType operator->() noexcept
+ {
+ return &m_value;
+ }
+
+ /**
+ * @brief Const accessor to the value.
+ * @return ConstValueReferenceType Const reference to the protected
+ * value.
+ */
+ ConstReferenceType operator*() const noexcept
+ {
+ return m_value;
+ }
+
+ /**
+ * @brief Accessor to the value.
+ * @return ValueReferenceType Reference to the protected.
+ */
+ ReferenceType operator*() noexcept
+ {
+ return m_value;
+ }
+
+ /// The lock that manages the mutex.
+ mutable LockType<RemoveRefMutexType> lock;
+
+ private:
+ /// The protected value.
+ ReferenceType m_value;
+ };
+
+ /// Reference-to-const ValueType.
+ using ConstValueReferenceType = const RemoveRefValueType&;
+ /// Reference to ValueType.
+ using ValueReferenceType = RemoveRefValueType&;
+ /// Reference to MutexType.
+ using MutexReferenceType = RemoveRefMutexType&;
+
+ public:
+ /// Aliases to ReadAccess and WriteAccess classes for this Safe class.
+ template<template<typename> class LockType=DefaultReadOnlyLock>
+ using ReadAccess = Access<LockType, AccessMode::ReadOnly>;
+ template<template<typename> class LockType=DefaultReadWriteLock>
+ using WriteAccess = Access<LockType, AccessMode::ReadWrite>;
+
+ /**
+ * @brief Construct a Safe object
+ */
+ Safe() = default;
+
+ /**
+ * @brief Construct a Safe object with default construction of
+ * the mutex and perfect forwarding of the other arguments to
+ * construct the value object.
+ *
+ * @tparam ValueArgs Deduced from valueArgs.
+ * @param valueArgs Perfect forwarding arguments to construct the value object.
+ * @param tag Indicates that the mutex should be default constructed.
+ */
+ template<typename... ValueArgs>
+ explicit Safe(DefaultConstructMutex, ValueArgs&&... valueArgs):
+ m_mutex(),
+ m_value(std::forward<ValueArgs>(valueArgs)...)
+ {}
+ /**
+ * @brief Construct a Safe object, forwarding the first
+ * argument to construct the mutex and the other arguments to
+ * construct the value object.
+ *
+ * @tparam MutexArg Deduced from mutexArg.
+ * @tparam ValueArgs Deduced from valueArgs.
+ * @param valueArgs Perfect forwarding arguments to construct the
+ * value object.
+ * @param mutexArg Perfect forwarding argument to construct the
+ * mutex object.
+ */
+ template<typename MutexArg, typename... ValueArgs>
+ explicit Safe(MutexArg&& mutexArg, ValueArgs&&... valueArgs):
+ m_mutex{std::forward<MutexArg>(mutexArg)},
+ m_value(std::forward<ValueArgs>(valueArgs)...)
+ {}
+
+ /// Delete all copy/move construction/assignment, as these operations
+ /// require locking the mutex under the covers.
+ /// Use copy(), assign() and other defined constructors to get the behavior
+ /// you need with an explicit syntax.
+ Safe(const Safe&) = delete;
+ Safe(Safe&&) = delete;
+ Safe& operator =(const Safe&) = delete;
+ Safe& operator =(Safe&&) = delete;
+
+ template<template<typename> class LockType=DefaultReadOnlyLock, typename... LockArgs>
+ ReadAccess<LockType> readAccess(LockArgs&&... lockArgs) const
+ {
+ // using ReturnType = ReadAccess<LockType>;
+ return EXPLICITLY_CONSTRUCT_RETURN_TYPE_IF_CPP17{*this, std::forward<LockArgs>(lockArgs)...};
+ }
+
+ template<template<typename> class LockType=DefaultReadWriteLock, typename... LockArgs>
+ WriteAccess<LockType> writeAccess(LockArgs&&... lockArgs)
+ {
+ // using ReturnType = WriteAccess<LockType>;
+ return EXPLICITLY_CONSTRUCT_RETURN_TYPE_IF_CPP17{*this, std::forward<LockArgs>(lockArgs)...};
+ }
+
+ template<template<typename> class LockType=DefaultReadOnlyLock, typename... LockArgs>
+ RemoveRefValueType copy(LockArgs&&... lockArgs) const
+ {
+ return *readAccess<LockType>(std::forward<LockArgs>(lockArgs)...);
+ }
+
+ template<template<typename> class LockType=DefaultReadWriteLock, typename... LockArgs>
+ void assign(ConstValueReferenceType value, LockArgs&&... lockArgs)
+ {
+ *writeAccess<LockType>(std::forward<LockArgs>(lockArgs)...) = value;
+ }
+ template<template<typename> class LockType=DefaultReadWriteLock, typename... LockArgs>
+ void assign(RemoveRefValueType&& value, LockArgs&&... lockArgs)
+ {
+ *writeAccess<LockType>(std::forward<LockArgs>(lockArgs)...) = std::move(value);
+ }
+
+ /**
+ * @brief Unsafe const accessor to the value. If you use this
+ * function, you exit the realm of safe!
+ *
+ * @return ConstValueReferenceType Const reference to the value
+ * object.
+ */
+ ConstValueReferenceType unsafe() const noexcept
+ {
+ return m_value;
+ }
+ /**
+ * @brief Unsafe accessor to the value. If you use this function,
+ * you exit the realm of safe!
+ *
+ * @return ValueReferenceType Reference to the value object.
+ */
+ ValueReferenceType unsafe() noexcept
+ {
+ return m_value;
+ }
+
+ /**
+ * @brief Accessor to the mutex.
+ *
+ * @return MutexReferenceType Reference to the mutex.
+ */
+ MutexReferenceType mutex() const noexcept
+ {
+ return m_mutex.get;
+ }
+
+ private:
+ /// The helper object that holds the mutable mutex, or a reference to a mutex.
+ impl::MutableIfNotReference<MutexType> m_mutex;
+ /// The value to protect.
+ ValueType m_value;
+ };
+
+ /**
+ * @brief Type alias for read-only Access.
+ *
+ * @tparam SafeType The type of Safe object to give read-only access to.
+ * @tparam LockType=DefaultReadOnlyLock The type of lock.
+ */
+ template<
+ typename SafeType,
+ template<typename> class LockType=DefaultReadOnlyLock>
+ using ReadAccess = typename SafeType::template ReadAccess<LockType>;
+
+ /**
+ * @brief Type alias for read-write Access.
+ *
+ * @tparam SafeType The type of Safe object to give read-write access to.
+ * @tparam LockType=DefaultReadWriteLock The type of lock.
+ */
+ template<
+ typename SafeType,
+ template<typename> class LockType=DefaultReadWriteLock>
+ using WriteAccess = typename SafeType::template WriteAccess<LockType>;
+} // namespace safe
+
+#undef EXPLICIT_IF_CPP17
+#undef EXPLICITLY_CONSTRUCT_RETURN_TYPE_IF_CPP17