UniqueHandle.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/TypeTraits.h" // ReturnType<T>
 
namespace SC
{
 
 
template <typename Definition>
struct UniqueHandle
{
    using Handle          = typename Definition::Handle;
    using CloseReturnType = typename TypeTraits::ReturnType<decltype(Definition::releaseHandle)>::type;
 
    static constexpr Handle Invalid = Definition::Invalid;
 
    UniqueHandle()                                     = default;
    UniqueHandle(const UniqueHandle& v)                = delete;
    UniqueHandle& operator=(const UniqueHandle& other) = delete;
    UniqueHandle(UniqueHandle&& v) : handle(v.handle) { v.detach(); }
    UniqueHandle(const Handle& externalHandle) : handle(externalHandle) {}
    ~UniqueHandle() { (void)close(); }
 
    [[nodiscard]] CloseReturnType assign(UniqueHandle&& other)
    {
        if (other.handle == handle)
            return CloseReturnType(false);
        if (close())
        {
            handle = other.handle;
            other.detach();
            return CloseReturnType(true);
        }
        return CloseReturnType(false);
    }
 
    [[nodiscard]] CloseReturnType assign(const Handle& externalHandle)
    {
        if (handle == externalHandle)
            return CloseReturnType(false);
        if (close())
        {
            handle = externalHandle;
            return CloseReturnType(true);
        }
        return CloseReturnType(false);
    }
 
    UniqueHandle& operator=(UniqueHandle&& other)
    {
        (void)(assign(forward<UniqueHandle>(other)));
        return *this;
    }
 
    [[nodiscard]] bool isValid() const { return handle != Invalid; }
 
    void detach() { handle = Invalid; }
 
    [[nodiscard]] CloseReturnType get(Handle& outHandle, CloseReturnType invalidReturnType) const
    {
        if (isValid())
        {
            outHandle = handle;
            return CloseReturnType(true);
        }
        return invalidReturnType;
    }
 
    [[nodiscard]] CloseReturnType close()
    {
        if (isValid())
        {
            Handle handleCopy = handle;
            detach();
            return Definition::releaseHandle(handleCopy);
        }
        return CloseReturnType(true);
    }
 
  protected:
    Handle handle = Invalid;
};
 
 
} // namespace SC