Semaphore.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_SEMAPHORE_HPP
#define FREERTOS_SEMAPHORE_HPP
 
#include "FreeRTOS.h"
#include "semphr.h"
 
namespace FreeRTOS {
 
class SemaphoreBase {
 public:
  friend class BinarySemaphore;
  friend class StaticBinarySemaphore;
  friend class CountingSemaphore;
  friend class StaticCountingSemaphore;
 
  SemaphoreBase(const SemaphoreBase&) = delete;
  SemaphoreBase& operator=(const SemaphoreBase&) = 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 UBaseType_t getCount() const {
    return uxSemaphoreGetCount(handle);
  }
 
  inline bool take(const TickType_t ticksToWait = portMAX_DELAY) const {
    return (xSemaphoreTake(handle, ticksToWait) == pdTRUE);
  }
 
  inline bool takeFromISR(bool& higherPriorityTaskWoken) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xSemaphoreTakeFromISR(handle, &taskWoken) == pdTRUE);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool takeFromISR() const {
    return (xSemaphoreTakeFromISR(handle, NULL) == pdTRUE);
  }
 
  inline bool give() const {
    return (xSemaphoreGive(handle) == pdTRUE);
  }
 
  inline bool giveFromISR(bool& higherPriorityTaskWoken) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xSemaphoreGiveFromISR(handle, &taskWoken) == pdTRUE);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool giveFromISR() const {
    return (xSemaphoreGiveFromISR(handle, NULL) == pdTRUE);
  }
 
 private:
  SemaphoreBase() = default;
 
  ~SemaphoreBase() {
    vSemaphoreDelete(this->handle);
  }
 
  SemaphoreBase(SemaphoreBase&&) noexcept = default;
  SemaphoreBase& operator=(SemaphoreBase&&) noexcept = default;
 
  SemaphoreHandle_t handle = NULL;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class BinarySemaphore : public SemaphoreBase {
 public:
  BinarySemaphore() {
    this->handle = xSemaphoreCreateBinary();
  }
  ~BinarySemaphore() = default;
 
  BinarySemaphore(const BinarySemaphore&) = delete;
  BinarySemaphore& operator=(const BinarySemaphore&) = delete;
 
  BinarySemaphore(BinarySemaphore&&) noexcept = default;
  BinarySemaphore& operator=(BinarySemaphore&&) noexcept = default;
};
 
class CountingSemaphore : public SemaphoreBase {
 public:
  explicit CountingSemaphore(const UBaseType_t maxCount,
                             const UBaseType_t initialCount = 0) {
    this->handle = xSemaphoreCreateCounting(maxCount, initialCount);
  }
  ~CountingSemaphore() = default;
 
  CountingSemaphore(const CountingSemaphore&) = delete;
  CountingSemaphore& operator=(const CountingSemaphore&) = delete;
 
  CountingSemaphore(CountingSemaphore&&) noexcept = default;
  CountingSemaphore& operator=(CountingSemaphore&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
class StaticBinarySemaphore : public SemaphoreBase {
 public:
  StaticBinarySemaphore() {
    this->handle = xSemaphoreCreateBinaryStatic(&staticBinarySemaphore);
  }
  ~StaticBinarySemaphore() = default;
 
  StaticBinarySemaphore(const StaticBinarySemaphore&) = delete;
  StaticBinarySemaphore& operator=(const StaticBinarySemaphore&) = delete;
 
  StaticBinarySemaphore(StaticBinarySemaphore&&) noexcept = default;
  StaticBinarySemaphore& operator=(StaticBinarySemaphore&&) noexcept = default;
 
 private:
  StaticSemaphore_t staticBinarySemaphore;
};
 
class StaticCountingSemaphore : public SemaphoreBase {
 public:
  explicit StaticCountingSemaphore(const UBaseType_t maxCount,
                                   const UBaseType_t initialCount = 0) {
    this->handle = xSemaphoreCreateCountingStatic(maxCount, initialCount,
                                                  &staticCountingSemaphore);
  }
  ~StaticCountingSemaphore() = default;
 
  StaticCountingSemaphore(const StaticCountingSemaphore&) = delete;
  StaticCountingSemaphore& operator=(const StaticCountingSemaphore&) = delete;
 
  StaticCountingSemaphore(StaticCountingSemaphore&&) noexcept = default;
  StaticCountingSemaphore& operator=(StaticCountingSemaphore&&) noexcept =
      default;
 
 private:
  StaticSemaphore_t staticCountingSemaphore;
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
#endif  // FREERTOS_SEMAPHORE_HPP