unique_handle.hpp

Go to the documentation of this file.

// ===-- include/psystem/framework/unique_handle.hpp ------ -*- C++ -*- --=== //
// Copyright (c) 2014 Matt Bisson.  All rights reserved.

#pragma once
#ifndef PSYSTEM_FRAMEWORK_UNIQUE_HANDLE_HPP
#define PSYSTEM_FRAMEWORK_UNIQUE_HANDLE_HPP

#include "platform.hpp"

#include "default_close_handle.hpp"
#include "managed_handle_proxy.hpp"
#include "stack_allocated.hpp"

namespace psystem {

// -----------------------------------------------------------------------------
// Internal class template for unique_handle's deleterless API
// -----------------------------------------------------------------------------

template <typename T, typename D, T kInvalidHandle>
class unique_handle_impl : public psystem::stack_allocated
{
    template <typename T2, typename, T2 kInvalidHandle2>
    friend class unique_handle;

public:
    using deleter_type = D;

    using handle_type = T;

public:
#ifndef _MSC_VER
    static constexpr T invalid_handle_value = kInvalidHandle;
#endif

private:
    explicit unique_handle_impl(handle_type handle) noexcept
        : m_handle(handle) { }

public:
    unique_handle_impl(unique_handle_impl const&) = delete;

    unique_handle_impl& operator=(unique_handle_impl&) = delete;

public:
    handle_type get() const noexcept
    {
        return m_handle;
    }

    handle_type release() noexcept
    {
        handle_type handle = m_handle;
        m_handle = kInvalidHandle;
        return handle;
    }

public:
    explicit operator bool() const noexcept
    {
        return m_handle != kInvalidHandle;
    }

private:
    handle_type m_handle;
};

// -----------------------------------------------------------------------------
// Public-facing unique_handle class template
// -----------------------------------------------------------------------------

template <
    typename T = HANDLE,
    typename D = default_close_handle<T>,
    T kInvalidHandle = INVALID_HANDLE_VALUE>
class unique_handle
    : public unique_handle_impl<T, D, kInvalidHandle>
{
private:
    using base = unique_handle_impl<T, D, kInvalidHandle>;
public:
    using typename base::deleter_type;
    using typename base::handle_type;

    using safe_address_container =
        psystem::internal::managed_handle_proxy<
            handle_type,
            unique_handle<handle_type, deleter_type, kInvalidHandle>
        >;

public:
#ifndef _MSC_VER
    using base::invalid_handle_value;
#endif

public:
    explicit unique_handle(handle_type hndl = kInvalidHandle) noexcept
        : base(hndl),
          m_deleter()
    { }

    template <typename D2>
    unique_handle(handle_type hndl, D2&& deleter) noexcept
        : base(hndl),
          m_deleter(std::forward<D2>(deleter))
    { }

    unique_handle(unique_handle&& other) noexcept
        : base(other.release()),
          m_deleter(std::move(other.m_deleter))
    { }

    ~unique_handle() noexcept
    {
        if (kInvalidHandle != this->m_handle)
        {
            m_deleter(this->m_handle);
#ifdef _DEBUG
            this->m_handle = kInvalidHandle;
#endif
        }
    }

public:
    unique_handle& operator=(unique_handle&& o) noexcept
    {
        // Since we've overloaded the operator& for this class, our incoming
        // variable is basically unreference-able... until C++11.  See
        // std::addressof()!
        if (std::addressof(o) == this) return *this;

        reset(o.release());

        m_deleter = std::forward<deleter_type>(o.m_deleter);
        return *this;
    }

    safe_address_container operator&() noexcept
    {
        return safe_address_container(*this);
    }

public:
    deleter_type& get_deleter() noexcept
    {
        return m_deleter;
    }

    deleter_type const& get_deleter() const noexcept
    {
        return m_deleter;
    }

    void reset(handle_type hndl = kInvalidHandle) noexcept
    {
        if (hndl == this->m_handle) return;

        if (kInvalidHandle != this->m_handle)
        {
            m_deleter(this->m_handle);
        }
        this->m_handle = hndl;
    }

    void swap(unique_handle& o) noexcept
    {

        // This would be a pointless swap.
        if (UNLIKELY(&o == this)) return;

        // Make temp copies
        handle_type  tmp_handle  = o.m_handle;
        deleter_type tmp_deleter = std::move(o.m_deleter);

        // Make o valid
        o.m_handle  = this->m_handle;
        o.m_deleter = std::move(m_deleter);

        // Make *this valid
        this->m_handle = tmp_handle;
        m_deleter      = std::move(tmp_deleter);
    }

private:
    deleter_type m_deleter;
};

// -----------------------------------------------------------------------------
// Partial specialization to eliminate storage for deleter_type.
// -----------------------------------------------------------------------------

template <typename T, T kInvalidHandle>
class unique_handle<T, default_close_handle<T>, kInvalidHandle>
    : public unique_handle_impl<T, default_close_handle<T>, kInvalidHandle>
{
private:
    using base = unique_handle_impl<T, default_close_handle<T>, kInvalidHandle>;
public:
    using typename base::deleter_type;
    using typename base::handle_type;

    using safe_address_container =
        psystem::internal::managed_handle_proxy<
            handle_type,
            unique_handle<handle_type, deleter_type, kInvalidHandle>
        >;

public:
#ifndef _MSC_VER
    using base::invalid_handle_value;
#endif

public:
    explicit unique_handle(handle_type hndl = kInvalidHandle) noexcept
        : base(hndl)
    { }

    unique_handle(unique_handle&& other) noexcept
        : base(other.release())
    { }

    ~unique_handle() noexcept
    {
        if (kInvalidHandle != this->m_handle)
        {
            default_close_handle<T>::close_handle(this->m_handle);
#ifdef _DEBUG
            this->m_handle = kInvalidHandle;
#endif
        }
    }

public:
    unique_handle& operator=(unique_handle&& o) noexcept
    {
        reset(o.release());
        return *this;
    }

    safe_address_container operator&() noexcept
    {
        return safe_address_container(*this);
    }

public:
    void reset(handle_type hndl = kInvalidHandle) noexcept
    {
        if (hndl == this->m_handle) return;

        if (kInvalidHandle != this->m_handle)
        {
            default_close_handle<T>::close_handle(this->m_handle);
        }
        this->m_handle = hndl;
    }

    void swap(unique_handle& o) noexcept
    {
        // This would be a pointless swap.
        if (UNLIKELY(&o == this)) return;

        handle_type tmp_handle  = o.m_handle;
        o.m_handle = this->m_handle;
        this->m_handle   = tmp_handle;
    }
};

} // namespace psystem

// -----------------------------------------------------------------------------
// Template specializations injected into the std namespace
// -----------------------------------------------------------------------------

namespace std {

template <typename T, typename D, T kInvalidHandle>
void
swap(
    psystem::unique_handle<T, D, kInvalidHandle>& o1,
    psystem::unique_handle<T, D, kInvalidHandle>& o2)
    noexcept
{
    o1.swap(o2);
}

template <typename T, typename D, T kInvalidHandle>
struct hash< psystem::unique_handle<T, D, kInvalidHandle> >
{
    using unique_handle_type = psystem::unique_handle<T, D, kInvalidHandle>;

    size_t operator()(unique_handle_type const& value) const
    {
        return std::hash<typename unique_handle_type::handle_type>()(
            value.get());
    }
};

} // namespace std

// -----------------------------------------------------------------------------
// Free functions related to unique_handle
// -----------------------------------------------------------------------------

template <typename T, typename D, T kInvalidHandle>
inline bool operator==(
    psystem::unique_handle<T, D, kInvalidHandle> const& h1,
    psystem::unique_handle<T, D, kInvalidHandle> const& h2) noexcept
{
    return (h1.get() == h2.get());
}

template <typename T, typename D, T kInvalidHandle>
inline bool operator!=(
    psystem::unique_handle<T, D, kInvalidHandle> const& h1,
    psystem::unique_handle<T, D, kInvalidHandle> const& h2) noexcept
{
    return !(h1 == h2);
}

template <typename T, typename D, T kInvalidHandle>
inline bool operator<(
    psystem::unique_handle<T, D, kInvalidHandle> const& h1,
    psystem::unique_handle<T, D, kInvalidHandle> const& h2) noexcept
{
    return std::less<
        typename psystem::unique_handle<T, D, kInvalidHandle>::handle_type>(
            h1.get(), h2.get());
}

template <typename T, typename D, T kInvalidHandle>
inline bool operator<=(
    psystem::unique_handle<T, D, kInvalidHandle> const& h1,
    psystem::unique_handle<T, D, kInvalidHandle> const& h2) noexcept
{
    return !(h2 < h1);
}

template <typename T, typename D, T kInvalidHandle>
inline bool operator>(
    psystem::unique_handle<T, D, kInvalidHandle> const& h1,
    psystem::unique_handle<T, D, kInvalidHandle> const& h2) noexcept
{
    return (h2 < h1);
}

template <typename T, typename D, T kInvalidHandle>
inline bool operator>=(
    psystem::unique_handle<T, D, kInvalidHandle> const& h1,
    psystem::unique_handle<T, D, kInvalidHandle> const& h2) noexcept
{
    return !(h1 < h2);
}

#endif // PSYSTEM_FRAMEWORK_UNIQUE_HANDLE_HPP