PtrStore.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <concepts>
#include <iostream>
#include <string_view>
#include <utility>
 
namespace SlHelpers {

template <typename T, typename Deleter>
class PtrStore {
public:
    PtrStore() noexcept : PtrStore(nullptr) {}
    explicit PtrStore(T *t) noexcept : m_ptr(t), m_deleter(Deleter{}) {}
    ~PtrStore() { free(); }
 
    PtrStore(const PtrStore &) = delete;
    PtrStore &operator=(const PtrStore &) = delete;

    PtrStore(PtrStore &&other) noexcept : m_ptr(other.release()) {}
    PtrStore &operator=(PtrStore &&other) noexcept {
        if (this != &other)
            reset(other.release());
        return *this;
    }

    bool valid() const { return m_ptr; }
    operator bool() const { return valid(); }
    bool operator!() const { return !valid(); }

    std::string_view str() const noexcept
    requires std::same_as<T, char> { return m_ptr ? : ""; }

    const T *get() const noexcept { return m_ptr; }
    T *get() noexcept { return m_ptr; }
    T *operator*() noexcept { return m_ptr; }
    const T *operator*() const noexcept { return m_ptr; }
    T *operator->() noexcept { return m_ptr; }
    const T *operator->() const noexcept { return m_ptr; }

    T *release() {
        return std::exchange(m_ptr, nullptr);
    }

    void reset(T *t = nullptr) {
        free();
        m_ptr = t;
    }

    T **ptr() noexcept {
        free();
        return &m_ptr;
    }
private:
    void free() {
        m_deleter(m_ptr);
        m_ptr = nullptr;
    }
 
    T *m_ptr;
    [[no_unique_address]] Deleter m_deleter;
};
 
template<typename T, typename Deleter>
requires std::same_as<T, char>
std::ostream &operator<<(std::ostream &os, const PtrStore<T, Deleter> &err)
{
    return os << err.str();
}
 
}