shared_handle.hpp

Go to the documentation of this file.

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

#pragma once
#ifndef PSYSTEM_FRAMEWORK_SHARED_HANDLE_HPP
#define PSYSTEM_FRAMEWORK_SHARED_HANDLE_HPP

#include "platform.hpp"

#include <atomic>

#include "default_close_handle.hpp"
#include "stack_allocated.hpp"
#include "unique_handle.hpp" // Needed?

namespace psystem {

template <typename T = HANDLE, T kInvalidHandle = INVALID_HANDLE_VALUE>
class shared_handle : public psystem::stack_allocated
{
private:
    struct shared_handle_data
    {
        shared_handle_data() noexcept
            : m_usage_count(1),
              m_weak_count(1)
        { }

        virtual ~shared_handle_data() noexcept { }

        virtual void delete_handle(T hndl) noexcept
        {
            default_close_handle<T>::close_handle(hndl);
        }

        std::atomic<size_t> m_usage_count;

        std::atomic<size_t> m_weak_count;
    };

    template <typename D>
    struct shared_handle_data_with_delete
        : public shared_handle_data
    {
        using deleter_type = D;

        explicit shared_handle_data_with_delete(deleter_type const& deleter)
            noexcept
            : shared_handle_data(),
              m_deleter(deleter)
        { }

        explicit shared_handle_data_with_delete(deleter_type&& deleter) noexcept
            : shared_handle_data(),
              m_deleter(std::move(deleter))
        { }

        virtual void delete_handle(T hndl) noexcept override
        {
            m_deleter(hndl);
        }

        deleter_type m_deleter;
    };

public:
    using handle_type = T;

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

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

public:
    explicit shared_handle(handle_type hndl = kInvalidHandle) noexcept
        : m_handle(hndl),
          m_control_block(
              (kInvalidHandle != hndl)
              ? new shared_handle_data
              : nullptr)
    { }

    template <typename D>
    shared_handle(handle_type hndl, D&& deleter) noexcept
        : m_handle(hndl),
          m_control_block(
              (kInvalidHandle != hndl)
              ? new shared_handle_data_with_delete<D>(std::forward<D>(deleter))
              : nullptr)
    { }

    shared_handle(shared_handle const& other) noexcept
        : m_handle(other.m_handle),
          m_control_block(other.m_control_block)
    {
        if (kInvalidHandle != m_handle) increment();
    }

    shared_handle(shared_handle&& other)
        : m_handle(other.m_handle),
          m_control_block(other.m_control_block)
    {
        other.m_handle        = kInvalidHandle;
        other.m_control_block = nullptr;
    }

    template <typename D>
    explicit shared_handle(psystem::unique_handle<T, D, kInvalidHandle>&& other)
        noexcept
        : m_handle(other.release()),
          m_control_block(
              (kInvalidHandle != m_handle)
              ? new shared_handle_data_with_delete<D>(
                  std::move(other.get_deleter()))
              : nullptr)
    { }

    explicit shared_handle(
        psystem::unique_handle<
            T, default_close_handle<T>, kInvalidHandle>&& other) noexcept
        : m_handle(other.release()),
          m_control_block(
              (kInvalidHandle != m_handle)
              ? new shared_handle_data
              : nullptr)
    { }

    ~shared_handle() noexcept
    {
        if (kInvalidHandle != m_handle) decrement();
    }

public:
    shared_handle& operator=(shared_handle const& o) noexcept
    {
        if (&o == this) return *this;

        shared_handle tmp = o; // Strong exception guarantee

        std::swap(tmp.m_handle,        m_handle);
        std::swap(tmp.m_control_block, m_control_block);

        return *this;
    }

    shared_handle& operator=(shared_handle&& o) noexcept
    {
        if (&o == this) return *this;

        shared_handle tmp = std::move(o); // Strong exception guarantee

        std::swap(tmp.m_handle,        m_handle);
        std::swap(tmp.m_control_block, m_control_block);

        return *this;
    }

    template <typename D>
    shared_handle& operator=(
        psystem::unique_handle<T, D, kInvalidHandle>&& o) noexcept
    {
        if (&o == this) return *this;

        shared_handle tmp = std::move(o); // Strong exception guarantee

        std::swap(tmp.m_handle,        m_handle);
        std::swap(tmp.m_control_block, m_control_block);

        return *this;
    }

    shared_handle& operator=(
        psystem::unique_handle<T, default_close_handle<T>, kInvalidHandle>&& o)
        noexcept
    {
        if (&o == this) return *this;

        shared_handle tmp = std::move(o); // Strong exception guarantee

        std::swap(tmp.m_handle,        m_handle);
        std::swap(tmp.m_control_block, m_control_block);

        return *this;
    }

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

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

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

    void reset(handle_type hndl = kInvalidHandle) noexcept
    {
        if (kInvalidHandle != m_handle) decrement();
        m_handle = hndl;
    }

    template <typename D>
    void reset(handle_type hndl, D&& deleter) noexcept
    {
        // Create a temporary copy to see that the parameters are valid before
        // even touching *this.
        shared_handle tmp(hndl, std::forward<D>(deleter));

        // Now that we succeeded, we can alter *this.
        if (kInvalidHandle != m_handle) decrement();
        std::swap(tmp.m_handle,        m_handle);
        std::swap(tmp.m_control_block, m_control_block);
    }

    void swap(shared_handle& o) noexcept
    {
        if (&o == this) return;

        std::swap(o.m_handle,        m_handle);
        std::swap(o.m_control_block, m_control_block);
    }

    bool unique() const noexcept
    {
        return ((m_control_block) && (m_control_block->m_usage_count == 1));
    }

    size_t use_count() const noexcept
    {
        return (!m_control_block) ? 0 : m_control_block->m_usage_count;
    }

private:
    void decrement() noexcept
    {
        ASSERT(m_control_block);

        auto const usage_count =
            m_control_block->m_usage_count.fetch_sub(
                1, std::memory_order_relaxed);
        ASSERT(0 < usage_count);

        if (1 == usage_count)
        {
            m_control_block->delete_handle(m_handle);
            m_handle = kInvalidHandle;

            auto const weak_count =
                m_control_block->m_weak_count.fetch_sub(1);
            ASSERT(0 < weak_count);

            if (1 == weak_count)
            {
                delete m_control_block;
                m_control_block = nullptr;
            }
        }
    }

    void increment() noexcept
    {
        ASSERT(m_control_block);

        // Use relaxed memory ordering for incrementing because nothing really
        // destructive happens as a result of incrementing the ref count...
        auto const usage_count = m_control_block->m_usage_count.fetch_add(
            1, std::memory_order_relaxed);

        // We just blew through the max number of shared_handles!
        ASSERT_USING_VAR(usage_count, SIZE_MAX > usage_count);
    }

private:
    handle_type m_handle;

    shared_handle_data *m_control_block;
};

} // namespace psystem

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

namespace std {

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

template <typename T, T kInvalidHandle>
struct hash< psystem::shared_handle<T, kInvalidHandle> >
{
    using shared_handle_type = psystem::shared_handle<T, kInvalidHandle>;

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

} // namespace std

// -----------------------------------------------------------------------------
// Free functions related to shared_handle
// -----------------------------------------------------------------------------

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

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

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

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

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

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

#endif // PSYSTEM_FRAMEWORK_SHARED_HANDLE_HPP