buffer.h

#pragma once
 
#include <functional>
#include <dsplib/span.h>
#include <dsplib/math.h>
 
namespace dsplib {
 
template<class Fn>
class ScopeGuard
{
public:
    explicit ScopeGuard(Fn f)
      : f_(std::move(f)) {
    }
    ~ScopeGuard() {
        f_();
    }
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;
 
private:
    Fn f_;
};
 
template<typename T>
class FIFOBuffer
{
public:
    static_assert(!std::is_same_v<T, bool>, "boolean buffer is not supported");
    static_assert(std::is_trivially_copyable<T>(), "type must be trivially copyable");
 
    FIFOBuffer() = default;
 
    void write(span_t<T> data) noexcept {
        if (data.empty()) {
            return;
        }
        buf_.insert(buf_.end(), data.begin(), data.end());
    }
 
    void write(const T& value) noexcept {
        buf_.push_back(value);
    }
 
    int read(mut_span_t<T> out) noexcept {
        const int n = min(out.size(), int(buf_.size()));
        if (n == 0) {
            return 0;
        }
 
        std::memcpy(out.data(), buf_.data(), n * sizeof(T));
        if (n == buf_.size()) {
            buf_.clear();
        } else {
            std::memmove(buf_.data(), buf_.data() + n, (buf_.size() - n) * sizeof(T));
            buf_.resize(buf_.size() - n);
        }
        return n;
    }
 
    std::vector<T> read(int n) noexcept {
        n = min(n, buf_.size());
        std::vector<T> out(n);
        this->read(out);
        return out;
    }
 
    [[nodiscard]] int size() const noexcept {
        return buf_.size();
    }
 
    [[nodiscard]] bool empty() const noexcept {
        return buf_.empty();
    }
 
    void reset() noexcept {
        buf_.clear();
    }
 
    [[nodiscard]] span_t<T> view() const noexcept {
        return make_span(buf_);
    }
 
private:
    std::vector<T> buf_;
};
 
template<typename T>
class ChunkBuffer
{
public:
    using Callback = std::function<void(span_t<T>)>;
 
    static_assert(!std::is_same_v<T, bool>, "boolean buffer is not supported");
    static_assert(std::is_trivially_copyable<T>(), "type must be trivially copyable");
 
    explicit ChunkBuffer(int chunk_size)
      : chunk_size_{chunk_size} {
        DSPLIB_ASSERT(chunk_size > 1, "chunk size must be greater than 1");
        buf_.reserve(chunk_size * 2);
    }
 
    void write(span_t<T> data, Callback fn) {
        if (data.empty()) {
            return;
        }
 
        DSPLIB_ASSERT(!in_write_, "recursive write call detected");
        in_write_ = true;
        const auto guard = ScopeGuard([this] {
            in_write_ = false;
        });
 
        if (buf_.empty() && (data.size() % chunk_size_ == 0)) {
            const auto* pdata = data.data();
            int psize = data.size();
            while (psize >= chunk_size_) {
                fn(make_span(pdata, chunk_size_));
                pdata += chunk_size_;
                psize -= chunk_size_;
            }
        } else {
            buf_.insert(buf_.end(), data.begin(), data.end());
            const auto* pdata = buf_.data();
            int psize = buf_.size();
            while (psize >= chunk_size_) {
                fn(make_span(pdata, chunk_size_));
                pdata += chunk_size_;
                psize -= chunk_size_;
            }
            std::memmove(buf_.data(), buf_.data() + buf_.size() - psize, psize * sizeof(T));
            buf_.resize(psize);
        }
    }
 
    void flush(Callback fn) {
        DSPLIB_ASSERT(!in_write_, "flush during callback is unsafe");
        in_write_ = true;
        const auto guard = ScopeGuard([this] {
            in_write_ = false;
        });
 
        fn(span_t<T>(buf_.data(), buf_.size()));
        buf_.clear();
    }
 
    void reset() {
        DSPLIB_ASSERT(!in_write_, "reset during callback is unsafe");
        buf_.clear();
    }
 
    int size() const noexcept {
        return buf_.size();
    }
 
private:
    int chunk_size_;
    std::vector<T> buf_;
    bool in_write_{false};
};
 
}   // namespace dsplib