LastError.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <string>
#include <sstream>
#include <tuple>
 
namespace SlHelpers {

template<typename... More>
class LastErrorBase {
    using Tuple = std::tuple<More...>;
public:
    LastErrorBase() noexcept {}

    template<size_t idx>
    std::tuple_element_t<idx, Tuple> &get() noexcept {
        return std::get<idx>(m_members);
    }

    template<size_t idx>
    const std::tuple_element_t<idx, Tuple> &get() const noexcept {
        return std::get<idx>(m_members);
    }

    template<size_t idx, typename Arg>
    void set(Arg &&val) noexcept {
        std::get<idx>(m_members) = std::forward<Arg>(val);
    }
protected:
    void resetMembers() noexcept {
        std::apply([](auto &... args) { ((args = {}), ...); }, m_members);
    }
private:
    Tuple m_members;
};

template<typename... More>
class LastErrorStr : public LastErrorBase<More...> {
public:
    LastErrorStr &reset() noexcept {
        m_lastError.clear();
        this->resetMembers();
        return *this;
    }

    template <typename T>
    void setError(T &&str)
    requires (std::is_convertible_v<T, std::string_view>) {
        m_lastError = std::forward<T>(str);
    }

    const std::string &lastError() const & noexcept { return m_lastError; }
 
private:
    std::string m_lastError;
};

template<typename... More>
class LastErrorStream : public LastErrorBase<More...> {
public:
    LastErrorStream &reset() noexcept {
        m_lastError.str({});
        m_lastError.clear();
        this->resetMembers();
        return *this;
    }

    template<typename T>
    LastErrorStream &operator<<(const T &x) {
        m_lastError << x;
        return *this;
    }

    std::string lastError() const noexcept { return m_lastError.str(); }
 
private:
    std::ostringstream m_lastError;
};
 
}