reference_wrapper.hpp

#pragma once
 
#include <type_traits>
#include <utility>
 
namespace plugify {
    template<typename T>
    class Ref {
    public:
        Ref() noexcept : _impl{nullptr} {}
        Ref(T& impl) noexcept : _impl{std::addressof(impl)} {}
 
        Ref(Ref const&) = default;
        Ref(Ref&&) = default;
 
        bool operator==(const Ref& other) const noexcept { return _impl == other._impl; }
        bool operator==(const T* impl) const noexcept { return _impl == impl; }
 
        Ref& operator=(const Ref&) & = default;
        Ref& operator=(const Ref&) && = delete;
        Ref& operator=(Ref&&) & = default;
        Ref& operator=(Ref&&) && = delete;
 
        explicit operator bool() const noexcept {
            return _impl != nullptr;
        }
 
        const void* const GetPtr() const noexcept {
            return _impl;
        }
 
    protected:
        T* _impl;
    };
 
    template<typename T> static constexpr bool is_ref_v = std::is_standard_layout_v<T> && sizeof(T) == sizeof(void*);
}
 
// Specialize std::hash for Ref<T>
template<typename T>
struct std::hash<plugify::Ref<T>> {
    std::size_t operator()(const plugify::Ref<T>& ref) const {
        return std::hash<void*>{}(ref.GetPtr());
    }
};