common.hpp

/*
    SPDX-License-Identifier: MIT
    Copyright © 2023-2024 Amebis
*/
 
#pragma once
 
#include <stddef.h>
 
#define MACSTD_NONCOPYABLE(C) \
private: \
       C        (_In_ const C &h) noexcept; \
    C& operator=(_In_ const C &h) noexcept;
 
#define MACSTD_NONMOVABLE(C) \
private: \
       C        (_Inout_ C &&h) noexcept; \
    C& operator=(_Inout_ C &&h) noexcept;
 
#define MACSTD_STACK_BUFFER_BYTES 1024
 
#define MACSTD_HANDLE_IMPL(C, T, INVAL) \
public: \
       C        (              ) noexcept                                  {} \
       C        (_In_opt_ T   h) noexcept : handle<T, INVAL>(          h ) {} \
       C        (_Inout_  C &&h) noexcept : handle<T, INVAL>(std::move(h)) {} \
    C& operator=(_In_opt_ T   h) noexcept                                  { handle<T, INVAL>::operator=(          h ); return *this; } \
    C& operator=(_Inout_  C &&h) noexcept                                  { handle<T, INVAL>::operator=(std::move(h)); return *this; } \
MACSTD_NONCOPYABLE(C)
 
#define MACSTD_DPLHANDLE_IMPL(C, T, INVAL) \
public: \
       C        (                    ) noexcept                                                  {} \
       C        (_In_opt_       T   h) noexcept : dplhandle<T, INVAL>(                   h     ) {} \
       C        (_In_     const C  &h) noexcept : dplhandle<T, INVAL>(duplicate_internal(h.m_h)) {} \
       C        (_Inout_        C &&h) noexcept : dplhandle<T, INVAL>(std::move         (h    )) {} \
    C& operator=(_In_opt_       T   h) noexcept                                                  { dplhandle<T, INVAL>::operator=(          h ); return *this; } \
    C& operator=(_In_     const C  &h) noexcept                                                  { dplhandle<T, INVAL>::operator=(          h ); return *this; } \
    C& operator=(_Inout_        C &&h) noexcept                                                  { dplhandle<T, INVAL>::operator=(std::move(h)); return *this; } \
private:
 
namespace macstd
{
    template <class T, const T INVAL>
    class handle
    {
    public:
        handle() noexcept : m_h(INVAL)
        {}
 
        handle(_In_opt_ T h) noexcept : m_h(h)
        {}
 
        handle(_Inout_ handle<T, INVAL> &&h) noexcept
        {
            // Transfer handle.
            m_h   = h.m_h;
            h.m_h = INVAL;
        }
 
    private:
        // This class is noncopyable.
        handle(_In_ const handle<T, INVAL> &h) noexcept {};
        handle<T, INVAL>& operator=(_In_ const handle<T, INVAL> &h) noexcept {};
 
    public:
        handle<T, INVAL>& operator=(_In_opt_ T h) noexcept
        {
            attach(h);
            return *this;
        }
 
        #pragma warning(suppress: 26432) // Move constructor is also present, but not detected by code analysis somehow.
        handle<T, INVAL>& operator=(_Inout_ handle<T, INVAL> &&h) noexcept
        {
            if (this != std::addressof(h)) {
                // Transfer handle.
                if (m_h != INVAL)
                    free_internal();
                m_h   = h.m_h;
                h.m_h = INVAL;
            }
            return *this;
        }
 
        operator T() const
        {
            return m_h;
        }
 
        T*& operator*() const
        {
            assert(m_h != INVAL);
            return *m_h;
        }
 
        T* operator&()
        {
            assert(m_h == INVAL);
            return &m_h;
        }
 
        T operator->() const
        {
            assert(m_h != INVAL);
            return m_h;
        }
 
        bool operator!() const
        {
            return m_h == INVAL;
        }
 
        bool operator<(_In_opt_ T h) const
        {
            return m_h < h;
        }
 
        bool operator<=(_In_opt_ T h) const
        {
            return !operator>(h);
        }
 
        bool operator>=(_In_opt_ T h) const
        {
            return !operator<(h);
        }
 
        bool operator>(_In_opt_ T h) const
        {
            return h < m_h;
        }
 
        bool operator!=(_In_opt_ T h) const
        {
            return !operator==(h);
        }
 
        bool operator==(_In_opt_ T h) const
        {
            return m_h == h;
        }
 
        void attach(_In_opt_ T h) noexcept
        {
            if (m_h != INVAL)
                free_internal();
            m_h = h;
        }
 
        T detach()
        {
            T h = m_h;
            m_h = INVAL;
            return h;
        }
 
        void free()
        {
            if (m_h != INVAL) {
                free_internal();
                m_h = INVAL;
            }
        }
 
    protected:
        virtual void free_internal() noexcept = 0;
 
    protected:
        T m_h; 
    };
 
    template <class T, T INVAL>
    class dplhandle : public handle<T, INVAL>
    {
    public:
        dplhandle() noexcept
        {}
 
        dplhandle(_In_opt_ T h) noexcept : handle<T, INVAL>(h)
        {}
 
        dplhandle<T, INVAL>(_In_ const dplhandle<T, INVAL> &h) : handle<T, INVAL>(duplicate_internal(h.m_h))
        {}
 
        dplhandle<T, INVAL>(_Inout_ dplhandle<T, INVAL> &&h) noexcept : handle<T, INVAL>(std::move(h))
        {}
 
        dplhandle<T, INVAL>& operator=(_In_opt_ T h) noexcept
        {
            handle<T, INVAL>::operator=(h);
            return *this;
        }
 
        dplhandle<T, INVAL>& operator=(_In_ const dplhandle<T, INVAL> &h) noexcept
        {
            if (this != std::addressof(h)) {
                if (h.m_h != INVAL) {
                    T h_new = duplicate_internal(h.m_h);
 
                    if (this->m_h != INVAL)
                        this->free_internal();
 
                    this->m_h = h_new;
                } else {
                    if (this->m_h != INVAL)
                        this->free_internal();
 
                    this->m_h = INVAL;
                }
            }
            return *this;
        }
 
        #pragma warning(disable: 26432) // Move constructor is also present, but not detected by code analysis somehow.
        dplhandle<T, INVAL>& operator=(_Inout_ dplhandle<T, INVAL> &&h) noexcept
        {
            handle<T, INVAL>::operator=(std::move(h));
            return *this;
        }
 
        T duplicate() const
        {
            return this->m_h != INVAL ? duplicate_internal(this->m_h) : INVAL;
        }
 
        void attach_duplicated(_In_opt_ T h)
        {
            if (this->m_h != INVAL)
                this->free_internal();
 
            this->m_h = h != INVAL ? duplicate_internal(h) : INVAL;
        }
 
    protected:
        virtual T duplicate_internal(_In_ T h) const = 0;
    };
}