StreamBuffer.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_STREAMBUFFER_HPP
#define FREERTOS_STREAMBUFFER_HPP
 
#include "FreeRTOS.h"
#include "stream_buffer.h"
 
#if (configUSE_STREAM_BUFFERS == 1)
 
namespace FreeRTOS {
 
class StreamBufferBase {
 public:
  friend class StreamBuffer;
  template <size_t>
  friend class StaticStreamBuffer;
 
  StreamBufferBase(const StreamBufferBase&) = delete;
  StreamBufferBase& operator=(const StreamBufferBase&) = 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 xStreamBufferSend(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 =
        xStreamBufferSendFromISR(handle, data, length, &taskWoken);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline size_t sendFromISR(const void* data, const size_t length) const {
    return xStreamBufferSendFromISR(handle, data, length, NULL);
  }
 
  inline size_t receive(void* buffer, const size_t bufferLength,
                        const TickType_t ticksToWait = portMAX_DELAY) const {
    return xStreamBufferReceive(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 =
        xStreamBufferReceiveFromISR(handle, buffer, bufferLength, &taskWoken);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline size_t receiveFromISR(void* buffer, const size_t bufferLength) const {
    return xStreamBufferReceiveFromISR(handle, buffer, bufferLength, NULL);
  }
 
  inline size_t bytesAvailable() const {
    return xStreamBufferBytesAvailable(handle);
  }
 
  inline size_t spacesAvailable() const {
    return xStreamBufferSpacesAvailable(handle);
  }
 
  inline bool setTriggerLevel(const size_t triggerLevel = 0) const {
    return (xStreamBufferSetTriggerLevel(handle, triggerLevel) == pdTRUE);
  }
 
  inline bool reset() const {
    return (xStreamBufferReset(handle) == pdPASS);
  }
 
  inline bool isEmpty() const {
    return (xStreamBufferIsEmpty(handle) == pdTRUE);
  }
 
  inline bool isFull() const {
    return (xStreamBufferIsFull(handle) == pdTRUE);
  }
 
 private:
  StreamBufferBase() = default;
 
  ~StreamBufferBase() {
    vStreamBufferDelete(this->handle);
  }
 
  StreamBufferBase(StreamBufferBase&&) noexcept = default;
  StreamBufferBase& operator=(StreamBufferBase&&) noexcept = default;
 
  StreamBufferHandle_t handle = NULL;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class StreamBuffer : public StreamBufferBase {
 public:
  explicit StreamBuffer(const size_t size, const size_t triggerLevel = 0) {
    this->handle = xStreamBufferCreate(size, triggerLevel);
  }
  ~StreamBuffer() = default;
 
  StreamBuffer(const StreamBuffer&) = delete;
  StreamBuffer& operator=(const StreamBuffer&) = delete;
 
  StreamBuffer(StreamBuffer&&) noexcept = default;
  StreamBuffer& operator=(StreamBuffer&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
template <size_t N>
class StaticStreamBuffer : public StreamBufferBase {
 public:
  explicit StaticStreamBuffer(const size_t triggerLevel = 0) {
    this->handle = xStreamBufferCreateStatic(sizeof(storage), triggerLevel,
                                             storage, &staticStreamBuffer);
  }
  ~StaticStreamBuffer() = default;
 
  StaticStreamBuffer(const StaticStreamBuffer&) = delete;
  StaticStreamBuffer& operator=(const StaticStreamBuffer&) = delete;
 
  StaticStreamBuffer(StaticStreamBuffer&&) noexcept = default;
  StaticStreamBuffer& operator=(StaticStreamBuffer&&) noexcept = default;
 
 private:
  StaticStreamBuffer_t staticStreamBuffer;
  uint8_t storage[N];
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
#endif /* configUSE_STREAM_BUFFERS */
 
#endif  // FREERTOS_STREAMBUFFER_HPP