handle.hpp

Go to the documentation of this file.

//
// libcppwrap - A collection of C++ wrappers for native APIs
// Copyright (C) 2021-2023 David A. Norris <danorris@gmail.com>
// Published under the MIT license - https://opensource.org/licenses/MIT
//
 
#pragma once
 
#include <type_traits>
#include <utility>
 
namespace w
{
    template <
        typename    Resource,
        Resource    Closed,
        auto        CloseFunc,
        std::enable_if_t<
            std::is_nothrow_copy_constructible_v<Resource> &&
            std::is_nothrow_swappable_v<Resource> &&
            std::is_function_v<std::remove_pointer_t<decltype(CloseFunc)>> && (
                std::is_invocable_v<decltype(CloseFunc), Resource> ||
                std::is_invocable_v<decltype(CloseFunc)>)> * = nullptr>
 
    class handle
    {
        public:
 
            handle() noexcept : handle(Closed) { }
 
            handle(Resource resource) noexcept : _resource(resource) { }
 
            handle(const handle&) = delete;
            handle& operator=(const handle&) = delete;
 
            handle(handle&& other) noexcept : _resource(Closed)
            {
                std::swap(_resource, other._resource);
            }
 
            handle& operator=(handle&& other) noexcept
            {
                if (&other != this)
                {
                    close();
                    std::swap(_resource, other._resource);
                }
 
                return *this;
            }
 
            ~handle() noexcept { close(); }
 
            Resource get() noexcept { return _resource; }
 
            const Resource get() const noexcept { return _resource; }
 
            operator Resource() noexcept { return _resource; }
 
            operator const Resource() const noexcept { return _resource; }
 
            operator bool() const noexcept { return Closed != _resource; }
 
            void close() noexcept
            {
                Resource resource(Closed);
                std::swap(resource, _resource);
                if (Closed != resource)
                {
                    if constexpr (std::is_invocable_v<decltype(CloseFunc), Resource>)
                        CloseFunc(resource);
                    else
                        CloseFunc();
                }
            }
 
            Resource release() noexcept
            {
                Resource resource = Closed;
                std::swap(resource, _resource);
                return resource;
            }
 
        private:
 
            Resource _resource;
    };
}