Raii.h

Go to the documentation of this file.

 
#pragma once
 
#include "esp_heap_caps.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "nvs.h"
 
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <memory>
 
namespace cdc::core {

struct CapsFreeDeleter {
    void operator()(void* p) const noexcept
    {
        if (p) heap_caps_free(p);
    }
};

template <typename T>
using PsramUniquePtr = std::unique_ptr<T[], CapsFreeDeleter>;

template <typename T>
PsramUniquePtr<T> psramAlloc(std::size_t count) noexcept
{
    auto* raw = static_cast<T*>(
        heap_caps_malloc(count * sizeof(T), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
    return PsramUniquePtr<T>{raw};
}

struct CStdFreeDeleter {
    void operator()(void* p) const noexcept
    {
        if (p) std::free(p);
    }
};

template <typename T>
using CStdUniquePtr = std::unique_ptr<T, CStdFreeDeleter>;

struct FileCloseDeleter {
    void operator()(std::FILE* fp) const noexcept
    {
        if (fp) std::fclose(fp);
    }
};

using FilePtr = std::unique_ptr<std::FILE, FileCloseDeleter>;

inline FilePtr openFile(const char* path, const char* mode) noexcept
{
    return FilePtr{std::fopen(path, mode)};
}

class NvsScope {
public:
    NvsScope() noexcept = default;

    NvsScope(const char* ns, nvs_open_mode_t mode) noexcept
    {
        status_ = nvs_open(ns, mode, &handle_);
        if (status_ != ESP_OK) handle_ = 0;
    }
 
    ~NvsScope() noexcept
    {
        if (handle_) nvs_close(handle_);
    }
 
    NvsScope(const NvsScope&) = delete;
    NvsScope& operator=(const NvsScope&) = delete;
 
    NvsScope(NvsScope&& other) noexcept : handle_(other.handle_), status_(other.status_)
    {
        other.handle_ = 0;
        other.status_ = ESP_FAIL;
    }
    NvsScope& operator=(NvsScope&& other) noexcept
    {
        if (this != &other) {
            if (handle_) nvs_close(handle_);
            handle_ = other.handle_;
            status_ = other.status_;
            other.handle_ = 0;
            other.status_ = ESP_FAIL;
        }
        return *this;
    }

    explicit operator bool() const noexcept { return status_ == ESP_OK; }

    operator nvs_handle_t() const noexcept { return handle_; }

    esp_err_t status() const noexcept { return status_; }

    esp_err_t commit() noexcept
    {
        return handle_ ? nvs_commit(handle_) : ESP_FAIL;
    }

    void close() noexcept
    {
        if (handle_) {
            nvs_close(handle_);
            handle_ = 0;
        }
        status_ = ESP_FAIL;
    }
 
private:
    nvs_handle_t handle_ = 0;
    esp_err_t    status_ = ESP_FAIL;
};

class MutexGuard {
public:
    explicit MutexGuard(SemaphoreHandle_t sem) noexcept : sem_(sem)
    {
        if (sem_) xSemaphoreTake(sem_, portMAX_DELAY);
    }
 
    ~MutexGuard() noexcept
    {
        if (sem_ && locked_) xSemaphoreGive(sem_);
    }
 
    MutexGuard(const MutexGuard&) = delete;
    MutexGuard& operator=(const MutexGuard&) = delete;
 
    MutexGuard(MutexGuard&& other) noexcept
        : sem_(other.sem_), locked_(other.locked_)
    {
        other.sem_ = nullptr;
        other.locked_ = false;
    }

    bool locked() const noexcept { return locked_; }

    void release() noexcept
    {
        if (sem_ && locked_) {
            xSemaphoreGive(sem_);
            locked_ = false;
        }
    }

    static MutexGuard tryLock(SemaphoreHandle_t sem, TickType_t ticks) noexcept
    {
        MutexGuard g{};
        g.sem_ = sem;
        if (sem && xSemaphoreTake(sem, ticks) == pdTRUE) {
            g.locked_ = true;
        }
        return g;
    }
 
private:
    MutexGuard() noexcept : sem_(nullptr), locked_(false) {}
 
    SemaphoreHandle_t sem_    = nullptr;
    bool              locked_ = true;
};

class RecursiveMutexGuard {
public:
    explicit RecursiveMutexGuard(SemaphoreHandle_t sem) noexcept : sem_(sem)
    {
        if (sem_) xSemaphoreTakeRecursive(sem_, portMAX_DELAY);
    }
 
    ~RecursiveMutexGuard() noexcept
    {
        if (sem_) xSemaphoreGiveRecursive(sem_);
    }
 
    RecursiveMutexGuard(const RecursiveMutexGuard&) = delete;
    RecursiveMutexGuard& operator=(const RecursiveMutexGuard&) = delete;
 
private:
    SemaphoreHandle_t sem_ = nullptr;
};
 
}  // namespace cdc::core