fifo.hpp

Go to the documentation of this file.

//
// Copyright (c) 2019 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef ZPP_INCLUDE_ZPP_FIFO_HPP
#define ZPP_INCLUDE_ZPP_FIFO_HPP
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <chrono>
#include <limits>
#include <type_traits>
#include <cstddef>
 
namespace zpp {
 
template<template<typename> typename T_BaseFifoType, typename T_BaseItemType>
class fifo_base {
public:
  using native_type = struct k_fifo;
  using native_pointer = native_type *;
  using native_const_pointer = native_type const *;
 
  using item_type = T_BaseItemType;
  using item_pointer = item_type*;
  using item_const_pointer = item_type const *;
protected:
  fifo_base() noexcept
  {
    static_assert(std::is_standard_layout_v<item_type>);
    static_assert(std::is_same_v<void*, decltype(item_type::fifo_reserved)>);
    static_assert(offsetof(item_type, fifo_reserved) == 0);
  }
public:
  [[nodiscard]] constexpr auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_BaseFifoType<item_type>*>(this)->native_handle();
  }
 
  [[nodiscard]] constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_BaseFifoType<item_type>*>(this)->native_handle();
  }
 
  void cancel_wait() noexcept
  {
    k_fifo_cancel_wait(native_handle());
  }
 
  void push_back(item_pointer item) noexcept
  {
    k_fifo_put(native_handle(), item);
  }
 
  [[nodiscard]] item_pointer
  pop_front() noexcept
  {
    return static_cast<item_pointer>(
      k_fifo_get(native_handle(), K_FOREVER));
  }
 
  [[nodiscard]] item_pointer
  try_pop_front() noexcept
  {
    return static_cast<item_pointer>(
      k_fifo_get(native_handle(), K_NO_WAIT));
  }
 
  template <class T_Rep, class T_Period>
  [[nodiscard]] item_pointer
  try_pop_front_for(const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    using namespace std::chrono;
 
    return static_cast<item_pointer>(
      k_fifo_get(native_handle(),
      duration_cast<milliseconds>(timeout).count()));
  }
 
  [[nodiscard]] item_pointer
  front() noexcept
  {
    return static_cast<item_pointer>(
      k_fifo_peek_head(native_handle()));
  }
 
  [[nodiscard]] item_pointer back() noexcept
  {
    return static_cast<item_pointer>(
      k_fifo_peek_tail(native_handle()));
  }
 
  [[nodiscard]] bool empty() noexcept
  {
    auto res  = k_fifo_is_empty(native_handle());
    if (res == 0) {
      return false;
    } else {
      return true;
    }
  }
public:
  fifo_base(const fifo_base&) = delete;
  fifo_base(fifo_base&&) = delete;
  fifo_base& operator=(const fifo_base&) = delete;
  fifo_base& operator=(fifo_base&&) = delete;
};
 
template<typename T_ItemType>
class fifo : public fifo_base<fifo, T_ItemType> {
public:
  using typename fifo_base<fifo, T_ItemType>::native_type;
  using typename fifo_base<fifo, T_ItemType>::native_pointer;
  using typename fifo_base<fifo, T_ItemType>::native_const_pointer;
public:
  fifo() noexcept
  {
    k_fifo_init(&m_fifo);
  }
 
  [[nodiscard]] constexpr auto native_handle() noexcept -> native_pointer
  {
    return &m_fifo;
  }
 
  [[nodiscard]] constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_fifo;
  }
private:
  native_type m_fifo;
public:
  fifo(const fifo&) = delete;
  fifo(fifo&&) = delete;
  fifo& operator=(const fifo&) = delete;
  fifo& operator=(fifo&&) = delete;
};
 
template<typename T_ItemType>
class fifo_ref : public fifo_base<fifo_ref, T_ItemType> {
public:
  using typename fifo_base<fifo_ref, T_ItemType>::native_type;
  using typename fifo_base<fifo_ref, T_ItemType>::native_pointer;
  using typename fifo_base<fifo_ref, T_ItemType>::native_const_pointer;
public:
  constexpr explicit fifo_ref(native_pointer f) noexcept
    : m_fifo_ptr(f)
  {
    __ASSERT_NO_MSG(m_fifo_ptr != nullptr);
  }
 
  template<template<class> class T_Fifo>
  constexpr explicit fifo_ref(T_Fifo<T_ItemType>& f) noexcept
    : m_fifo_ptr(f.native_handle())
  {
    __ASSERT_NO_MSG(m_fifo_ptr != nullptr);
  }
 
  constexpr fifo_ref& operator=(native_pointer f) noexcept
  {
    m_fifo_ptr = f;
    __ASSERT_NO_MSG(m_fifo_ptr != nullptr);
    return *this;
  }
 
  template<template<class> class T_Fifo>
  constexpr fifo_ref& operator=(const T_Fifo<T_ItemType>& f) noexcept
  {
    m_fifo_ptr = f.native_handle();
    __ASSERT_NO_MSG(m_fifo_ptr != nullptr);
    return *this;
  }
 
  [[nodiscard]] constexpr auto native_handle() noexcept -> native_pointer
  {
    return m_fifo_ptr;
  }
 
  [[nodiscard]] constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return m_fifo_ptr;
  }
private:
  native_pointer m_fifo_ptr{ nullptr };
public:
  fifo_ref() = delete;
};
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_FIFO_HPP