Queue.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_QUEUE_HPP
#define FREERTOS_QUEUE_HPP
 
#include <optional>
 
#include "FreeRTOS.h"
#include "queue.h"
 
namespace FreeRTOS {
 
template <class T>
class QueueBase {
 public:
  template <class>
  friend class Queue;
 
  template <class, UBaseType_t>
  friend class StaticQueue;
 
  QueueBase(const QueueBase&) = delete;
  QueueBase& operator=(const QueueBase&) = 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 sendToBack(const T& item,
                         const TickType_t ticksToWait = portMAX_DELAY) const {
    return (xQueueSendToBack(handle, &item, ticksToWait) == pdTRUE);
  }
 
  inline bool sendToBackFromISR(bool& higherPriorityTaskWoken,
                                const T& item) const {
    BaseType_t taskWoken = pdFALSE;
    bool result =
        (xQueueSendToBackFromISR(handle, &item, &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool sendToBackFromISR(const T& item) const {
    return (xQueueSendToBackFromISR(handle, &item, NULL) == pdPASS);
  }
 
  inline bool sendToFront(const T& item,
                          const TickType_t ticksToWait = portMAX_DELAY) const {
    return (xQueueSendToFront(handle, &item, ticksToWait) == pdTRUE);
  }
 
  inline bool sendToFrontFromISR(bool& higherPriorityTaskWoken,
                                 const T& item) const {
    BaseType_t taskWoken = pdFALSE;
    bool result =
        (xQueueSendToFrontFromISR(handle, &item, &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool sendToFrontFromISR(const T& item) const {
    return (xQueueSendToFrontFromISR(handle, &item, NULL) == pdPASS);
  }
 
  inline std::optional<T> receive(
      const TickType_t ticksToWait = portMAX_DELAY) const {
    T buffer;
    return (xQueueReceive(handle, &buffer, ticksToWait) == pdTRUE)
               ? std::optional<T>(buffer)
               : std::nullopt;
  }
 
  inline std::optional<T> receiveFromISR(bool& higherPriorityTaskWoken) const {
    T buffer;
    BaseType_t taskWoken = pdFALSE;
    bool result = (xQueueReceiveFromISR(handle, &buffer, &taskWoken) == pdTRUE);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result ? std::optional<T>(buffer) : std::nullopt;
  }
 
  inline std::optional<T> receiveFromISR() const {
    T buffer;
    return (xQueueReceiveFromISR(handle, &buffer, NULL) == pdTRUE)
               ? std::optional<T>(buffer)
               : std::nullopt;
  }
 
  inline UBaseType_t messagesWaiting() const {
    return uxQueueMessagesWaiting(handle);
  }
 
  inline UBaseType_t messagesWaitingFromISR() const {
    return uxQueueMessagesWaitingFromISR(handle);
  }
 
  inline UBaseType_t spacesAvailable() const {
    return uxQueueSpacesAvailable(handle);
  }
 
  inline void reset() const {
    xQueueReset(handle);
  }
 
  inline void overwrite(const T& item) const {
    xQueueOverwrite(handle, &item);
  }
 
  inline void overwriteFromISR(bool& higherPriorityTaskWoken,
                               const T& item) const {
    BaseType_t taskWoken = pdFALSE;
    xQueueOverwriteFromISR(handle, &item, &taskWoken);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
  }
 
  inline void overwriteFromISR(const T& item) const {
    xQueueOverwriteFromISR(handle, &item, NULL);
  }
 
  inline std::optional<T> peek(
      const TickType_t ticksToWait = portMAX_DELAY) const {
    T buffer;
    return (xQueuePeek(handle, &buffer, ticksToWait) == pdTRUE)
               ? std::optional<T>(buffer)
               : std::nullopt;
  }
 
  inline std::optional<T> peekFromISR() const {
    T buffer;
    return (xQueuePeekFromISR(handle, &buffer) == pdTRUE)
               ? std::optional<T>(buffer)
               : std::nullopt;
  }
 
  inline void addToRegistry(const char* name) const {
    vQueueAddToRegistry(handle, name);
  }
 
  inline void unregister() const {
    vQueueUnregisterQueue(handle);
  }
 
  inline const char* getName() const {
    return pcQueueGetName(handle);
  }
 
  inline bool isFullFromISR() const {
    return (xQueueIsQueueFullFromISR(handle) == pdTRUE);
  }
 
  inline bool isEmptyFromISR() const {
    return (xQueueIsQueueEmptyFromISR(handle) == pdTRUE);
  }
 
 private:
  QueueBase() = default;
 
  ~QueueBase() {
    vQueueDelete(this->handle);
  }
 
  QueueBase(QueueBase&&) noexcept = default;
  QueueBase& operator=(QueueBase&&) noexcept = default;
 
  QueueHandle_t handle = NULL;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
template <class T>
class Queue : public QueueBase<T> {
 public:
  explicit Queue(const UBaseType_t length) {
    this->handle = xQueueCreate(length, sizeof(T));
  }
  ~Queue() = default;
 
  Queue(const Queue&) = delete;
  Queue& operator=(const Queue&) = delete;
 
  Queue(Queue&&) noexcept = default;
  Queue& operator=(Queue&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
template <class T, UBaseType_t N>
class StaticQueue : public QueueBase<T> {
 public:
  StaticQueue() {
    this->handle = xQueueCreateStatic(N, sizeof(T), storage, &staticQueue);
  }
  ~StaticQueue() = default;
 
  StaticQueue(const StaticQueue&) = delete;
  StaticQueue& operator=(const StaticQueue&) = delete;
 
  StaticQueue(StaticQueue&&) noexcept = default;
  StaticQueue& operator=(StaticQueue&&) noexcept = default;
 
 private:
  StaticQueue_t staticQueue;
  uint8_t storage[N * sizeof(T)];
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
#endif  // FREERTOS_QUEUE_HPP