immutable_value.hh

#pragma once
 
#include <cstddef>
#include <utility>
 
#ifdef __clang_analyzer__
#include <memory>
#endif
 
namespace CppClingo::Util {
 
 
template <typename T> class immutable_value {
  public:
    using element_type = T;
 
    constexpr immutable_value() noexcept = default;
 
    constexpr immutable_value(std::nullptr_t) noexcept {}
 
    // NOLINTNEXTLINE(bugprone-forwarding-reference-overload)
    template <class U> immutable_value(U &&value) : immutable_value{std::in_place, std::forward<U>(value)} {}
 
#ifdef __clang_analyzer__
    template <class... Args>
    immutable_value([[maybe_unused]] std::in_place_t tag, Args &&...args)
        : data_{std::make_shared<T>(std::forward<Args>(args)...)} {}
    immutable_value(immutable_value const &other) noexcept = default;
    immutable_value(immutable_value &&other) noexcept = default;
    auto operator=(immutable_value const &other) noexcept -> immutable_value & = default;
    auto operator=(immutable_value &&other) noexcept -> immutable_value & = default;
    ~immutable_value() noexcept = default;
#else
    template <class... Args>
    immutable_value([[maybe_unused]] std::in_place_t tag, Args &&...args)
        : data_{new data_type(std::forward<Args>(args)...)} {}
 
    immutable_value(immutable_value const &other) noexcept : data_{other.data_} { inc_(); }
 
    immutable_value(immutable_value &&other) noexcept : data_{std::exchange(other.data_, nullptr)} {}
 
    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
    auto operator=(immutable_value const &other) noexcept -> immutable_value & {
        other.inc_();
        dec_();
        data_ = other.data_;
        return *this;
    }
 
    auto operator=(immutable_value &&other) noexcept -> immutable_value & {
        if (this != &other) {
            dec_();
            data_ = std::exchange(other.data_, nullptr);
        }
        return *this;
    }
 
    ~immutable_value() noexcept { dec_(); }
#endif
 
    [[nodiscard]] auto has_value() const noexcept -> bool { return data_ != nullptr; }
 
    [[nodiscard]] explicit operator bool() const noexcept { return has_value(); }
 
    [[nodiscard]] auto get() const noexcept -> element_type const & {
#ifdef __clang_analyzer__
        return *data_;
#else
        return data_->value;
#endif
    }
 
    [[nodiscard]] auto operator*() const noexcept -> element_type const & { return get(); }
 
    auto operator->() const noexcept -> element_type const * { return &get(); }
 
    [[nodiscard]] operator T const &() const noexcept { return get(); }
 
  private:
#ifdef __clang_analyzer__
    std::shared_ptr<T> data_;
#else
    struct data_type {
        template <class... Args> data_type(Args &&...args) : value{std::forward<Args>(args)...} {}
        size_t refs = 1;
        element_type value;
    };
 
    void inc_() const noexcept {
        if (data_ != nullptr) {
            ++data_->refs;
        }
    }
 
    void dec_() noexcept {
        if (data_ != nullptr) {
            --data_->refs;
            if (data_->refs == 0) {
                delete data_;
            }
            data_ = nullptr;
        }
    }
 
    data_type *data_ = nullptr;
#endif
};
 
template <typename U, typename... Args> auto make_immutable(Args &&...args) -> immutable_value<U> {
    static_assert(std::is_constructible_v<U, Args...>);
    return immutable_value<U>{std::in_place, std::forward<Args>(args)...};
}
 
template <class X, class Y>
[[nodiscard]] auto operator==(const immutable_value<X> &lhs, const immutable_value<Y> &rhs) -> bool {
    if (lhs && rhs) {
        return *lhs == *rhs;
    }
    return lhs.get() == rhs.get();
}
 
template <class X, class Y>
[[nodiscard]] auto operator<=>(const immutable_value<X> &lhs, const immutable_value<Y> &rhs) {
    if (lhs && rhs) {
        return *lhs <=> *rhs;
    }
    return lhs.get() <=> rhs.get();
}
 
 
} // namespace CppClingo::Util