heap.hpp

Go to the documentation of this file.

//
// Copyright (c) 2021 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef ZPP_INCLUDE_ZPP_HEAP_HPP
#define ZPP_INCLUDE_ZPP_HEAP_HPP
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <chrono>
#include <array>
#include <cstdint>
 
namespace zpp {
 
template <class T_Heap>
class base_heap {
public:
  using native_type = struct k_heap;
  using native_pointer = native_type*;
  using native_const_pointer = native_type const *;
protected:
  constexpr base_heap() noexcept { }
public:
  [[nodiscard]] void*
  allocate(size_t bytes) noexcept
  {
    return k_heap_alloc(native_handle(), bytes, K_FOREVER);
  }
 
  [[nodiscard]] void*
  allocate(size_t bytes, size_t align) noexcept
  {
    return k_heap_aligned_alloc(native_handle(), align, bytes, K_FOREVER);
  }
 
  [[nodiscard]] void*
  try_allocate(size_t bytes) noexcept
  {
    return k_heap_alloc(native_handle(), bytes, K_NO_WAIT);
  }
 
  [[nodiscard]] void*
  try_allocate(size_t bytes, size_t align) noexcept
  {
    return k_heap_aligned_alloc(native_handle(), align, bytes, K_NO_WAIT);
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] void*
  try_allocate_for(size_t bytes, const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    return k_heap_alloc(native_handle(), bytes, to_timeout(timeout));
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] void*
  try_allocate_for(size_t bytes, size_t align, const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    return k_heap_aligned_alloc(native_handle(), align, bytes, to_timeout(timeout));
  }
 
  void deallocate(void* mem) noexcept
  {
    k_heap_free(native_handle(), mem);
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_Heap*>(this)->native_handle();
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_Heap*>(this)->native_handle();
  }
public:
  base_heap(const base_heap&) = delete;
  base_heap(base_heap&&) = delete;
  base_heap& operator=(const base_heap&) = delete;
  base_heap& operator=(base_heap&&) = delete;
};
 
template <size_t T_Size>
class heap : public base_heap<heap<T_Size>> {
public:
  using typename base_heap<heap<T_Size>>::native_type;
  using typename base_heap<heap<T_Size>>::native_pointer;
  using typename base_heap<heap<T_Size>>::native_const_pointer;
public:
  heap() noexcept {
    k_heap_init(&m_heap, m_mem.data(), m_mem.size());
  }
 
  static constexpr size_t size() noexcept {
    return T_Size;
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return &m_heap;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_heap;
  }
private:
  native_type                 m_heap{};
  std::array<uint8_t, T_Size> m_mem;
public:
  heap(const heap&) = delete;
  heap(heap&&) = delete;
  heap& operator=(const heap&) = delete;
  heap& operator=(heap&&) = delete;
};
 
class heap_ref : public base_heap<heap_ref> {
public:
  constexpr explicit heap_ref(native_pointer h) noexcept
    : m_heap(h)
  {
    __ASSERT_NO_MSG(m_heap != nullptr);
  }
 
  template<class T_Heap>
  constexpr explicit heap_ref(T_Heap& h) noexcept
    : m_heap(h.native_handle())
  {
    __ASSERT_NO_MSG(m_heap != nullptr);
  }
 
  constexpr heap_ref& operator=(native_pointer h) noexcept
  {
    m_heap = h;
    __ASSERT_NO_MSG(m_heap != nullptr);
    return *this;
  }
 
  template<class T_Heap>
  constexpr heap_ref& operator=(T_Heap& rhs) noexcept
  {
    m_heap = rhs.native_handle();
    __ASSERT_NO_MSG(m_heap != nullptr);
    return *this;
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return m_heap;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return m_heap;
  }
private:
  native_pointer m_heap{nullptr};
public:
  heap_ref() = delete;
};
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_HEAP_HPP