MessageBuffer.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_MESSAGEBUFFER_HPP
#define FREERTOS_MESSAGEBUFFER_HPP
 
#include "FreeRTOS.h"
#include "message_buffer.h"
 
namespace FreeRTOS {
 
class MessageBufferBase {
 public:
  friend class MessageBuffer;
  template <size_t>
  friend class StaticMessageBuffer;
 
  MessageBufferBase(const MessageBufferBase&) = delete;
  MessageBufferBase& operator=(const MessageBufferBase&) = 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 size_t send(const void* data, const size_t length,
                     const TickType_t ticksToWait = portMAX_DELAY) const {
    return xMessageBufferSend(handle, data, length, ticksToWait);
  }
 
  inline size_t sendFromISR(bool& higherPriorityTaskWoken, const void* data,
                            const size_t length) const {
    BaseType_t taskWoken = pdFALSE;
    const size_t result =
        xMessageBufferSendFromISR(handle, data, length, &taskWoken);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline size_t sendFromISR(const void* data, const size_t length) const {
    return xMessageBufferSendFromISR(handle, data, length, NULL);
  }
 
  inline size_t receive(void* buffer, const size_t bufferLength,
                        const TickType_t ticksToWait = portMAX_DELAY) const {
    return xMessageBufferReceive(handle, buffer, bufferLength, ticksToWait);
  }
 
  inline size_t receiveFromISR(bool& higherPriorityTaskWoken, void* buffer,
                               const size_t bufferLength) const {
    BaseType_t taskWoken = pdFALSE;
    const size_t result =
        xMessageBufferReceiveFromISR(handle, buffer, bufferLength, &taskWoken);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline size_t receiveFromISR(void* buffer, const size_t bufferLength) const {
    return xMessageBufferReceiveFromISR(handle, buffer, bufferLength, NULL);
  }
 
  inline size_t spacesAvailable() const {
    return xMessageBufferSpacesAvailable(handle);
  }
 
  inline bool reset() const {
    return (xMessageBufferReset(handle) == pdPASS);
  }
 
  inline bool isEmpty() const {
    return (xMessageBufferIsEmpty(handle) == pdTRUE);
  }
 
  inline bool isFull() const {
    return (xMessageBufferIsFull(handle) == pdTRUE);
  }
 
 private:
  MessageBufferBase() = default;
 
  ~MessageBufferBase() {
    vMessageBufferDelete(this->handle);
  }
 
  MessageBufferBase(MessageBufferBase&&) noexcept = default;
  MessageBufferBase& operator=(MessageBufferBase&&) noexcept = default;
 
  MessageBufferHandle_t handle = NULL;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class MessageBuffer : public MessageBufferBase {
 public:
  explicit MessageBuffer(size_t size) {
    this->handle = xMessageBufferCreate(size);
  }
  ~MessageBuffer() = default;
 
  MessageBuffer(const MessageBuffer&) = delete;
  MessageBuffer& operator=(const MessageBuffer&) = delete;
 
  MessageBuffer(MessageBuffer&&) noexcept = default;
  MessageBuffer& operator=(MessageBuffer&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
template <size_t N>
class StaticMessageBuffer : public MessageBufferBase {
 public:
  StaticMessageBuffer() : MessageBufferBase() {
    this->handle = xMessageBufferCreateStatic(sizeof(storage), storage,
                                              &staticMessageBuffer);
  }
  ~StaticMessageBuffer() = default;
 
  StaticMessageBuffer(const StaticMessageBuffer&) = delete;
  StaticMessageBuffer& operator=(const StaticMessageBuffer&) = delete;
 
  StaticMessageBuffer(StaticMessageBuffer&&) noexcept = default;
  StaticMessageBuffer& operator=(StaticMessageBuffer&&) noexcept = default;
 
 private:
  StaticMessageBuffer_t staticMessageBuffer;
  uint8_t storage[N] = {0};
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
#endif  // FREERTOS_MESSAGEBUFFER_HPP