ErrorHistory.h

Go to the documentation of this file.

 
#ifndef HF_UTILS_RTOS_WRAP_ERRORHISTORY_H_
#define HF_UTILS_RTOS_WRAP_ERRORHISTORY_H_
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <mutex>
#include <type_traits>
 
#include "RtosMutex.h"
 
namespace hf {
 
template <typename Record>
class ErrorHistoryReader {
public:
    virtual ~ErrorHistoryReader() noexcept = default;
 
    [[nodiscard]] virtual std::size_t Size() const noexcept = 0;
 
    [[nodiscard]] virtual std::size_t Capacity() const noexcept = 0;
 
    [[nodiscard]] virtual uint32_t Seq() const noexcept = 0;
 
    [[nodiscard]] virtual uint32_t OverwriteCount() const noexcept = 0;
 
    virtual std::size_t Snapshot(Record* out, std::size_t max_out) const noexcept = 0;
};
 
template <typename Record>
class ErrorHistoryWriter {
public:
    virtual ~ErrorHistoryWriter() noexcept = default;
 
    virtual bool Push(const Record& record) noexcept = 0;
 
    virtual bool Pop(Record& out) noexcept = 0;
 
    virtual bool Clear() noexcept = 0;
};
 
template <typename Record, std::size_t kCapacity>
class ErrorHistory final
    : public ErrorHistoryReader<Record>
    , public ErrorHistoryWriter<Record>
{
    static_assert(kCapacity > 0, "ErrorHistory kCapacity must be > 0");
    static_assert(std::is_trivially_copyable_v<Record>,
                  "ErrorHistory<Record, N> requires a trivially copyable Record");
 
public:
    ErrorHistory() noexcept = default;
 
    ErrorHistory(const ErrorHistory&)            = delete;
    ErrorHistory& operator=(const ErrorHistory&) = delete;
 
    /* ── Writer ──────────────────────────────────────────────────── */
 
    bool Push(const Record& record) noexcept override
    {
        std::lock_guard<RtosMutex> guard(mutex_);
        std::memcpy(&records_[head_], &record, sizeof(Record));
        head_ = (head_ + 1U) % kCapacity;
        if (size_ < kCapacity) {
            ++size_;
        } else {
            tail_ = (tail_ + 1U) % kCapacity;
            ++overwrite_count_;
        }
        ++seq_;
        return true;
    }
 
    bool Pop(Record& out) noexcept override
    {
        std::lock_guard<RtosMutex> guard(mutex_);
        if (size_ == 0U) return false;
        std::memcpy(&out, &records_[tail_], sizeof(Record));
        tail_ = (tail_ + 1U) % kCapacity;
        --size_;
        ++seq_;
        return true;
    }
 
    bool Clear() noexcept override
    {
        std::lock_guard<RtosMutex> guard(mutex_);
        head_ = tail_ = size_ = 0U;
        ++seq_;
        return true;
    }
 
    /* ── Reader ──────────────────────────────────────────────────── */
 
    [[nodiscard]] std::size_t Size() const noexcept override
    {
        std::lock_guard<RtosMutex> guard(mutex_);
        return size_;
    }
 
    [[nodiscard]] std::size_t Capacity() const noexcept override
    {
        return kCapacity;
    }
 
    [[nodiscard]] uint32_t Seq() const noexcept override
    {
        std::lock_guard<RtosMutex> guard(mutex_);
        return seq_;
    }
 
    [[nodiscard]] uint32_t OverwriteCount() const noexcept override
    {
        std::lock_guard<RtosMutex> guard(mutex_);
        return overwrite_count_;
    }
 
    std::size_t Snapshot(Record* out, std::size_t max_out) const noexcept override
    {
        if (out == nullptr || max_out == 0U) return 0U;
        std::lock_guard<RtosMutex> guard(mutex_);
        const std::size_t n = (size_ < max_out) ? size_ : max_out;
        std::size_t       idx = tail_;
        for (std::size_t i = 0; i < n; ++i) {
            std::memcpy(&out[i], &records_[idx], sizeof(Record));
            idx = (idx + 1U) % kCapacity;
        }
        return n;
    }
 
private:
    mutable RtosMutex mutex_{};
    Record            records_[kCapacity]{};
    std::size_t       head_{0};
    std::size_t       tail_{0};
    std::size_t       size_{0};
    uint32_t          seq_{0};
    uint32_t          overwrite_count_{0};
};
 
}  // namespace hf
 
#endif /* HF_UTILS_RTOS_WRAP_ERRORHISTORY_H_ */