RMonoHandle_Def.h

/*
    Copyright 2020 David "Alemarius Nexus" Lerch
 
    This file is part of RemoteMono.
 
    RemoteMono is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    RemoteMono is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with RemoteMono.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "../config.h"
 
#include <cstddef>
#include "RMonoHandle_FwdDef.h"
#include "RMonoTypes.h"
 
 
 
namespace remotemono
{
 
 
 
 
class RMonoAPIBase;
 
 
class RMonoHandleBackendBase
{
public:
    virtual void forceDelete() = 0;
};
 
 
 
 
 
inline void RMonoObjectHandleDelete(rmono_gchandle gchandle, RMonoAPIBase* mono);
 
 
 
 
struct RMonoHandleTag {};
 
template <
    typename HandleT,
    void (*deleter)(HandleT, RMonoAPIBase*),
    HandleT invalidHandle
    >
class RMonoHandle : public RMonoHandleTag
{
public:
    typedef HandleT HandleType;
    typedef RMonoHandle<HandleType, deleter, invalidHandle> Self;
 
private:
    struct Data : public RMonoHandleBackendBase
    {
        enum Flags
        {
            FlagOwned = 0x01
        };
 
        Data(HandleT handle, RMonoAPIBase* mono, bool owned)
                : handle(handle), mono(mono), flags(owned ? FlagOwned : 0)
        {
            if (owned) {
                registerBackend();
            }
        }
 
        ~Data()
        {
            if (mono) {
                if ((flags & FlagOwned)  !=  0) {
                    unregisterBackend();
                    deleter(handle, mono);
                }
            }
        }
 
        inline void registerBackend();
        inline void unregisterBackend();
 
        bool takeOwnership()
        {
            if ((flags & FlagOwned)  !=  0) {
                unregisterBackend();
                flags &= ~FlagOwned;
                return true;
            }
            return false;
        }
 
        virtual void forceDelete()
        {
            if ((flags & FlagOwned)  !=  0) {
                deleter(handle, mono);
                flags = 0;
                mono = nullptr;
                handle = invalidHandle;
            }
        }
 
        HandleT handle;
        RMonoAPIBase* mono;
        uint8_t flags;
        typename std::list<RMonoHandleBackendBase*>::iterator regIt; // TODO: Find a way to get this type from RMonoAPIBase
    };
 
public:
    RMonoHandle() {}
 
    RMonoHandle(std::nullptr_t) {}
 
    RMonoHandle(HandleType handle, RMonoAPIBase* mono, bool owned)
            : d(handle == invalidHandle ? std::shared_ptr<Data>() : std::make_shared<Data>(handle, mono, owned)) {}
 
    RMonoHandle(const Self& other) : d(other.d) {}
 
    RMonoHandle(Self&& other) : d(std::move(other.d)) {}
 
 
    Self& operator=(const Self& other)
    {
        if (this != &other)
            d = other.d;
        return *this;
    }
 
    Self& operator=(Self&& other)
    {
        if (this != &other)
            d = std::move(other.d);
        return *this;
    }
 
 
    bool operator==(const Self& other) const { return **this == *other; }
 
    bool operator!=(const Self& other) const { return !(*this == other); }
 
 
    HandleType operator*() const { return d ? d->handle : invalidHandle; }
 
    RMonoAPIBase* getMonoAPI() { return d ? d->mono : nullptr; }
 
 
    bool takeOwnership()
    {
        return d ? d->takeOwnership() : false;
    }
 
 
    void reset() { d.reset(); }
 
 
    bool isValid() const { return (bool) d; }
 
    bool isNull() const { return !isValid(); }
 
    operator bool() const { return isValid(); }
 
protected:
    std::shared_ptr<Data> d;
};
 
 
 
 
 
struct RMonoObjectHandleTag {};
 
template <typename RawPtrT>
class RMonoObjectHandle :
        public RMonoHandle<rmono_gchandle, &RMonoObjectHandleDelete, REMOTEMONO_GCHANDLE_INVALID>,
        public RMonoObjectHandleTag
{
public:
    typedef RMonoHandle<rmono_gchandle, &RMonoObjectHandleDelete, REMOTEMONO_GCHANDLE_INVALID> Base;
    typedef RMonoObjectHandle<RawPtrT> Self;
 
    typedef RawPtrT RawPtr;
 
public:
    RMonoObjectHandle() : RMonoHandle() {}
 
    RMonoObjectHandle(std::nullptr_t) : RMonoHandle(nullptr) {}
 
    RMonoObjectHandle(rmono_gchandle gchandle, RMonoAPIBase* mono, bool owned = true) : RMonoHandle(gchandle, mono, owned) {}
 
    RMonoObjectHandle(const Self& other) : RMonoHandle(other) {}
 
    RMonoObjectHandle(Self&& other) : RMonoHandle(std::move(other)) {}
 
 
    Self& operator=(const Self& other) { Base::operator=(other); return *this; }
 
    Self& operator=(Self&& other) { Base::operator=(std::move(other)); return *this; }
 
 
    inline bool operator==(const Self& other) const;
 
    bool operator!=(const Self& other) const { return !(*this == other); }
 
 
    inline Self pin() const;
 
    inline Self clone() const;
 
    inline RawPtr raw() const;
};
 
 
 
}
 
 
 
 
namespace std
{
 
 
template <
    typename HandleT,
    void (*deleter)(HandleT, remotemono::RMonoAPIBase*),
    HandleT invalidHandle
>
struct hash<typename remotemono::RMonoHandle<HandleT, deleter, invalidHandle>>
{
    typedef typename remotemono::RMonoHandle<HandleT, deleter, invalidHandle> HandleT;
 
    std::size_t operator()(HandleT const& h) const noexcept
    {
        return hh(*h);
    }
 
private:
    std::hash<typename HandleT::HandleType> hh;
};
 
 
}