Mutex.hpp

/*
 * FreeRTOS-Cpp
 * Copyright (C) 2021 Jon Enz. All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * https://github.com/jonenz/FreeRTOS-Cpp
 */
 
#ifndef FREERTOS_MUTEX_HPP
#define FREERTOS_MUTEX_HPP
 
#include "FreeRTOS.h"
#include "semphr.h"
 
namespace FreeRTOS {
 
class MutexBase {
 public:
  friend class Mutex;
  friend class StaticMutex;
  friend class RecursiveMutexBase;
  friend class RecursiveMutex;
  friend class StaticRecursiveMutex;
 
  MutexBase(const MutexBase&) = delete;
  MutexBase& operator=(const MutexBase&) = delete;
 
  static void* operator new(size_t) = delete;
  static void* operator new[](size_t) = delete;
 
  static void* operator new(size_t, void* ptr) {
    return ptr;
  }
 
  static void* operator new[](size_t, void* ptr) {
    return ptr;
  }
 
  inline bool isValid() const {
    return (handle != NULL);
  }
 
  inline bool lock(const TickType_t ticksToWait = portMAX_DELAY) const {
    return (xSemaphoreTake(handle, ticksToWait) == pdTRUE);
  }
 
  inline bool lockFromISR(bool& higherPriorityTaskWoken) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xSemaphoreTakeFromISR(handle, &taskWoken) == pdTRUE);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool lockFromISR() const {
    return (xSemaphoreTakeFromISR(handle, NULL) == pdTRUE);
  }
 
  inline bool unlock() const {
    return (xSemaphoreGive(handle) == pdTRUE);
  }
 
 private:
  MutexBase() = default;
 
  ~MutexBase() {
    vSemaphoreDelete(this->handle);
  }
 
  MutexBase(MutexBase&&) noexcept = default;
  MutexBase& operator=(MutexBase&&) noexcept = default;
 
  SemaphoreHandle_t handle = NULL;
};
 
class RecursiveMutexBase : public MutexBase {
 public:
  friend class RecursiveMutex;
  friend class StaticRecursiveMutex;
 
  RecursiveMutexBase(const RecursiveMutexBase&) = delete;
  RecursiveMutexBase& operator=(const RecursiveMutexBase&) = delete;
 
  static void* operator new(size_t, void*);
  static void* operator new[](size_t, void*);
  static void* operator new(size_t) = delete;
  static void* operator new[](size_t) = delete;
 
  inline bool lock(const TickType_t ticksToWait = portMAX_DELAY) const {
    return (xSemaphoreTakeRecursive(handle, ticksToWait) == pdTRUE);
  }
 
  inline bool unlock() const {
    return (xSemaphoreGiveRecursive(handle) == pdTRUE);
  }
 
 private:
  RecursiveMutexBase() = default;
  ~RecursiveMutexBase() = default;
 
  RecursiveMutexBase(RecursiveMutexBase&&) noexcept = default;
  RecursiveMutexBase& operator=(RecursiveMutexBase&&) noexcept = default;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class Mutex : public MutexBase {
 public:
  Mutex() {
    this->handle = xSemaphoreCreateMutex();
  }
  ~Mutex() = default;
 
  Mutex(const Mutex&) = delete;
  Mutex& operator=(const Mutex&) = delete;
 
  Mutex(Mutex&&) noexcept = default;
  Mutex& operator=(Mutex&&) noexcept = default;
};
 
class RecursiveMutex : public RecursiveMutexBase {
 public:
  RecursiveMutex() {
    this->handle = xSemaphoreCreateRecursiveMutex();
  }
  ~RecursiveMutex() = default;
 
  RecursiveMutex(const RecursiveMutex&) = delete;
  RecursiveMutex& operator=(const RecursiveMutex&) = delete;
 
  RecursiveMutex(RecursiveMutex&&) noexcept = default;
  RecursiveMutex& operator=(RecursiveMutex&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
class StaticMutex : public MutexBase {
 public:
  StaticMutex() {
    this->handle = xSemaphoreCreateMutexStatic(&staticMutex);
  }
  ~StaticMutex() = default;
 
  StaticMutex(const StaticMutex&) = delete;
  StaticMutex& operator=(const StaticMutex&) = delete;
 
  StaticMutex(StaticMutex&&) noexcept = default;
  StaticMutex& operator=(StaticMutex&&) noexcept = default;
 
 private:
  StaticSemaphore_t staticMutex;
};
 
class StaticRecursiveMutex : public RecursiveMutexBase {
 public:
  StaticRecursiveMutex() {
    this->handle = xSemaphoreCreateRecursiveMutexStatic(&staticRecursiveMutex);
  }
  ~StaticRecursiveMutex() = default;
 
  StaticRecursiveMutex(const StaticRecursiveMutex&) = delete;
  StaticRecursiveMutex& operator=(const StaticRecursiveMutex&) = delete;
 
  StaticRecursiveMutex(StaticRecursiveMutex&&) noexcept = default;
  StaticRecursiveMutex& operator=(StaticRecursiveMutex&&) noexcept = default;
 
 private:
  StaticSemaphore_t staticRecursiveMutex;
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
#endif  // FREERTOS_MUTEX_HPP