RMonoVariant_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 <cstdlib>
#include <stdint.h>
#include <string>
#include "RMonoTypes.h"
#include "RMonoHandle_Def.h"
 
 
 
namespace remotemono
{
 
 
 
class RMonoAPIBase;
 
 
 
 
class RMonoVariant
{
public:
    typedef RMonoVariant Self;
 
public:
    enum Type
    {
        TypeInvalid = 0,
 
        TypeValue = 1,
 
        TypeMonoObjectPtr = 2,
 
        TypeRawPtr = 3
    };
 
    enum Direction
    {
        DirectionDefault = 0 << 3,
 
        DirectionIn = 1 << 3,
 
        DirectionOut = 2 << 3,
 
        DirectionInOut = 3 << 3
    };
 
    static inline const struct RawPtr {} rawPtr = {};
 
    class MonoObjectPtrWrapper
    {
    public:
        virtual RMonoObjectPtr getWrappedMonoObjectPtr() const = 0;
    };
 
private:
    enum Flags
    {
        FlagMaskType = 0x0007,
        FlagMaskDirection = 0x0018,
 
        FlagDisableAutoUnbox = 0x0100,
 
        FlagOwnMemory = 0x0200,
 
        FlagIsAlias = 0x0400
    };
 
public:
    static constexpr size_t getMaxRequiredAlignment()
    {
        // TODO: I have no clue what value this should actually be.
        return 16;
    }
 
public:
    RMonoVariant() : flags(TypeInvalid) {}
 
    RMonoVariant(const Self& other)
    {
        copyFromOther(other);
    }
 
    template <typename T, typename Enable = std::enable_if_t<!std::is_base_of_v<MonoObjectPtrWrapper, T>>>
    RMonoVariant(T val)
            : flags(TypeValue | FlagOwnMemory)
    {
        if constexpr(sizeof(T) <= sizeof(v.sdata)) {
            *((T*) v.sdata) = val;
        } else {
            v.ddata = new char[sizeof(T)];
            *((T*) v.ddata) = val;
        }
        v.size = sizeof(T);
    }
 
    template <typename T>
    RMonoVariant(T* val)
            : flags(TypeValue)
    {
        v.ddata = val;
        v.size = sizeof(T);
    }
 
    RMonoVariant(void* data, size_t size, bool copy = false)
            : flags(TypeValue)
    {
        if (data  &&  copy) {
            flags |= FlagOwnMemory;
            if (size <= sizeof(v.sdata)) {
                memcpy(v.sdata, data, size);
            } else {
                v.ddata = new char[size];
                memcpy(v.ddata, data, size);
            }
        } else {
            v.ddata = data;
        }
        v.size = size;
    }
 
    RMonoVariant(const RMonoObjectPtr& v, bool autoUnbox = true)
            : flags(TypeMonoObjectPtr | FlagOwnMemory | (autoUnbox ? 0 : FlagDisableAutoUnbox)), o(v) {}
 
    RMonoVariant(RMonoObjectPtr&& v, bool autoUnbox = true)
            : flags(TypeMonoObjectPtr | FlagOwnMemory | (autoUnbox ? 0 : FlagDisableAutoUnbox)), o(v) {}
 
    RMonoVariant(RMonoObjectPtr* v, bool autoUnbox = true)
            : flags(TypeMonoObjectPtr | (autoUnbox ? 0 : FlagDisableAutoUnbox)), op(v) {}
 
    RMonoVariant(const MonoObjectPtrWrapper& v, bool autoUnbox = true)
            : flags(TypeMonoObjectPtr | FlagOwnMemory | (autoUnbox ? 0 : FlagDisableAutoUnbox)), o(v.getWrappedMonoObjectPtr()) {}
 
    RMonoVariant(std::nullptr_t) : flags(TypeRawPtr | FlagOwnMemory), p(0) {}
 
    explicit RMonoVariant(rmono_voidp v, RawPtr) : flags(TypeRawPtr | FlagOwnMemory), p(v) {}
 
    explicit RMonoVariant(rmono_voidp* v, RawPtr) : flags(TypeRawPtr), pp(v) {}
 
    ~RMonoVariant()
    {
        if (getType() == TypeValue  &&  (flags & FlagOwnMemory)  !=  0  &&  !usesStaticValueData()) {
            delete[] v.ddata;
        }
    }
 
 
 
 
    Self& operator=(const Self& other)
    {
        if (this != &other) {
            copyFromOther(other);
        }
        return *this;
    }
 
 
    Self forDirection(Direction dir) const { return Self(const_cast<Self*>(this), dir); }
 
 
    Self in() const { return forDirection(DirectionIn); }
 
    Self out() const { return forDirection(DirectionOut); }
 
    Self inout() const { return forDirection(DirectionInOut); }
 
 
    bool isValid() const { return getType() != TypeInvalid; }
 
 
    Type getType() const { return (Type) (flags & FlagMaskType); }
 
    Direction getDirection() const { return (Direction) (flags & FlagMaskDirection); }
    void setDirection(Direction dir) { flags = (flags & ~FlagMaskDirection) | dir; }
 
    void setAutoUnboxEnabled(bool autoUnbox)
    {
        if ((flags & FlagIsAlias)  !=  0) {
            alias->setAutoUnboxEnabled(autoUnbox);
        }
        if (autoUnbox) {
            flags &= ~FlagDisableAutoUnbox;
        } else {
            flags |= FlagDisableAutoUnbox;
        }
    }
 
    bool isAutoUnboxEnabled() const
    {
        return (flags & FlagDisableAutoUnbox) == 0;
    }
 
    inline bool isNullPointer() const;
 
 
    size_t getValueSize() const
    {
        assert(getType() == TypeValue);
        if ((flags & FlagIsAlias)  !=  0) {
            return alias->getValueSize();
        }
        return v.size;
    }
 
    void* getValueData()
    {
        assert(getType() == TypeValue);
        if ((flags & FlagIsAlias)  !=  0) {
            return alias->getValueData();
        }
        return usesStaticValueData() ? v.sdata : v.ddata;
    }
 
    const void* getValueData() const
    {
        assert(getType() == TypeValue);
        if ((flags & FlagIsAlias)  !=  0) {
            return alias->getValueData();
        }
        return usesStaticValueData() ? v.sdata : v.ddata;
    }
 
    template <typename T>
    T getValue() const
    {
        assert(getType() == TypeValue);
        return *((T*) getValueData());
    }
 
    RMonoObjectPtr getMonoObjectPtr() const
    {
        assert(getType() == TypeMonoObjectPtr);
        if ((flags & FlagIsAlias)  !=  0) {
            return alias->getMonoObjectPtr();
        }
        if ((flags & FlagOwnMemory)  !=  0) {
            return o;
        } else {
            return (op ? *op : RMonoObjectPtr());
        }
    }
 
    rmono_voidp getRawPtr() const
    {
        assert(getType() == TypeRawPtr);
        if ((flags & FlagIsAlias)  !=  0) {
            return alias->getRawPtr();
        }
        if ((flags & FlagOwnMemory)  !=  0) {
            return p;
        } else {
            return (pp ? *pp : 0);
        }
    }
 
 
    template <typename ABI>
    size_t getRemoteMemorySize(ABI& abi, size_t& alignment) const;
 
    template <typename ABI>
    void copyForRemoteMemory(ABI& abi, void* buf) const;
 
    template <typename ABI>
    void updateFromRemoteMemory(ABI& abi, RMonoAPIBase& mono, void* buf);
 
private:
    explicit RMonoVariant::RMonoVariant(RMonoVariant* other, Direction dir)
            : flags((other->flags & ~FlagMaskDirection) | FlagIsAlias | dir), alias(other) {}
 
    void copyFromOther(const Self& other)
    {
        if ((other.flags & FlagIsAlias)  !=  0) {
            flags = other.flags;
            alias = other.alias;
        } else if (other.getType() == TypeMonoObjectPtr  &&  (other.flags & FlagOwnMemory) != 0) {
            flags = other.flags;
            o = other.o;
        } else if (other.getType() == TypeValue  &&  (other.flags & FlagOwnMemory) != 0  &&  !other.usesStaticValueData()) {
            v.size = other.v.size;
            v.ddata = new char[v.size];
            memcpy(v.ddata, other.v.ddata, v.size);
            flags = other.flags;
        } else {
            memcpy(this, &other, sizeof(Self));
        }
    }
 
    bool usesStaticValueData() const
    {
        if ((flags & FlagIsAlias)  !=  0) {
            return alias->usesStaticValueData();
        }
        return ((flags & FlagOwnMemory) != 0)  &&  v.size <= sizeof(v.sdata);
    }
 
private:
    uint16_t flags;
 
    union {
        struct {
            union
            {
                char sdata[32];
                void* ddata;
            };
            size_t size;
        } v;
        RMonoObjectPtr* op;
        rmono_voidp p;
        rmono_voidp* pp;
        RMonoVariant* alias;
    };
    RMonoObjectPtr o;
};
 
 
};
 
 
 
 
 
#include "RMonoVariant_Impl.h"