mutex_utils.h

Go to the documentation of this file.

// === mutex_utils.h ===================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_BASE_MUTEX_UTILS_H
#define SEN_CORE_BASE_MUTEX_UTILS_H
 
// sen
#include "sen/core/base/compiler_macros.h"
 
// std
#include <functional>
#include <mutex>
 
namespace sen
{

template <typename T, typename MutexType = std::mutex>
struct Guarded
{
  using UnderlyingValueTypeOfT = std::remove_reference_t<T>;
 
  template <typename... TArgs>
  explicit Guarded(TArgs... args): value_(std::forward<TArgs>(args)...)
  {
  }

  UnderlyingValueTypeOfT getValue() const
  {
    std::lock_guard lock(mutex_);
    return value_;
  }
 
public:  // Operators
  // NOLINTNEXTLINE(hicpp-explicit-conversions): intended to be used as a wrapper
  operator UnderlyingValueTypeOfT() const { return getValue(); }
 
  template <typename U, std::enable_if_t<std::is_convertible_v<U, T>, bool> = true>
  Guarded& operator=(U&& newValue)
  {
    std::lock_guard lock(mutex_);
    value_ = std::forward<U>(newValue);
    return *this;
  }
 
  template <typename U>
  T operator+(U&& rhs) const
  {
    std::lock_guard lock(mutex_);
    return value_ + rhs;
  }
 
  template <typename U>
  Guarded& operator+=(U&& rhs)
  {
    std::lock_guard lock(mutex_);
    value_ += rhs;
    return *this;
  }
 
public:  // Access token handling
  struct TemporaryAccessToken
  {
    TemporaryAccessToken(T* valuePtr, MutexType& m): valuePtr_(valuePtr), lock_(m) {}
 
    std::conditional_t<std::is_pointer_v<T>, T&, T*> operator->()
    {
      if constexpr (std::is_pointer_v<T>)
      {
        return *valuePtr_;
      }
      else
      {
        return valuePtr_;
      }
    }
 
  private:
    T* valuePtr_;
    std::lock_guard<MutexType> lock_;
  };
 
  TemporaryAccessToken operator->() { return createAccessToken(); }
 
  [[nodiscard]] TemporaryAccessToken createAccessToken() { return TemporaryAccessToken(&value_, mutex_); }
 
public:
  template <typename CallableType>
  auto invoke(CallableType callable)
  {
    std::lock_guard lock(mutex_);
    return std::invoke(callable, value_);
  }
 
public:  // Enable comparisions between wrapped and unwrapped types
  template <
    typename LHSType,
    typename RHSType,
    std::enable_if_t<std::disjunction_v<std::is_same<LHSType, Guarded>, std::is_same<RHSType, Guarded>>, bool> = true>
  friend inline bool operator==(const LHSType& lhs, const RHSType& rhs) noexcept
  {
    if constexpr (std::is_same_v<LHSType, Guarded> && std::is_same_v<RHSType, Guarded>)
    {
      return lhs.getValue() == rhs.getValue();
    }
    else if constexpr (std::is_same_v<LHSType, Guarded>)
    {
      return lhs.getValue() == rhs;
    }
    else
    {
      return lhs == rhs.getValue();
    }
 
    SEN_UNREACHABLE();
    return false;
  }
 
  template <
    typename LHSType,
    typename RHSType,
    std::enable_if_t<std::disjunction_v<std::is_same<LHSType, Guarded>, std::is_same<RHSType, Guarded>>, bool> = true>
  friend inline bool operator!=(const LHSType& lhs, const RHSType& rhs) noexcept
  {
    return !(lhs == rhs);
  }
 
private:
  T value_;
  mutable MutexType mutex_;
};
 
}  // namespace sen
 
#endif  // SEN_CORE_BASE_MUTEX_UTILS_H