MarshalUtils.h

#pragma once
 
#include <msclr/gcroot.h>
#include <msclr/marshal.h>
#include <msclr/marshal_cppstd.h>
 
#include <chrono>
 
using namespace System;
 
// https://learn.microsoft.com/en-gb/cpp/dotnet/how-to-extend-the-marshaling-library?view=msvc-170#to-extend-the-marshaling-library-with-a-conversion-that-does-not-require-a-context
 
namespace detail
{
    template <typename ToType>
    struct MarshalTo
    {
        template <typename FromType>
        static ToType From(const FromType& from)
        {
            return msclr::interop::marshal_as<ToType>(from);
        }
 
        // Marshall is not needed when type is the same
        static ToType From(const ToType& from)
        {
            return from;
        }
    };
 
    // Specialization for std::string to avoid exception in case of null string
    template <>
    struct MarshalTo<std::string>
    {
        static std::string From(String^ const & mString)
        {
            if (mString == nullptr)
            {
                return std::string();
            }
 
            return msclr::interop::marshal_as<std::string>(mString);
        }
 
        template <typename FromType>
        static std::string From(const FromType& from)
        {
            return msclr::interop::marshal_as<std::string>(from);
        }
    };
 
    // Specialization for integer conversion to managed enum type
    template <>
    struct MarshalTo<Datamine::MineTrustConnector::Core::LogEvent>
    {
        static Datamine::MineTrustConnector::Core::LogEvent From(MineTrustConnector::CppCliInterop::LogEvent value)
        {
            return static_cast<Datamine::MineTrustConnector::Core::LogEvent>(value);
        }
    };
 
    // Specialization for integer conversion from managed enum type
    template <>
    struct MarshalTo<MineTrustConnector::CppCliInterop::LogEvent>
    {
        static MineTrustConnector::CppCliInterop::LogEvent From(Datamine::MineTrustConnector::Core::LogEvent value)
        {
            return static_cast<MineTrustConnector::CppCliInterop::LogEvent>(value);
        }
    };
 
    template <typename ToDataType>
    struct MarshalTo<std::unique_ptr<ToDataType>>
    {
        template <typename FromDataType>
        static std::unique_ptr<ToDataType> From(System::Nullable<FromDataType> value)
        {
            std::unique_ptr<ToDataType> res;
 
            if (value.HasValue)
            {
                res = std::make_unique<ToDataType>(MarshalTo<ToDataType>::From(value.Value));
            }
 
            return res;
        }
    };
 
    template <typename ToDataType>
    struct MarshalTo<System::Nullable<ToDataType>>
    {
        template <typename FromDataType>
        static System::Nullable<ToDataType> From(const std::unique_ptr<FromDataType>& value)
        {
            if (value)
            {
                return System::Nullable<ToDataType>(MarshalTo<ToDataType>::From(*value));
            }
            else
            {
                return System::Nullable<ToDataType>();
            }
        }
    };
 
    // Specialization for STL containers
    template <typename ToItemType>
    struct MarshalTo<std::vector<ToItemType>>
    {
        template <typename FromType, typename ... ExtraArgs>
        static auto From(FromType&& list, ExtraArgs&&... extraArgs)
        {
            std::vector<ToItemType> mList;
 
            if (nullptr == list)
            {
                return mList;
            }
 
            for each (auto item in list)
            {
                mList.emplace_back(MarshalTo<ToItemType>::From(item, std::forward<ExtraArgs>(extraArgs)...));
            }
 
            return mList;
        }
    };
 
    // Specialization for associative containers
    template <typename ToKeyType, typename ToValueType>
    struct MarshalTo<std::unordered_map<ToKeyType, ToValueType>>
    {
        template <typename FromType>
        static auto From(FromType&& dictionary)
        {
            std::unordered_map<ToKeyType, ToValueType> mDictionary;
 
            if (nullptr == dictionary)
            {
                return mDictionary;
            }
 
            mDictionary.reserve(dictionary->Count);
 
            for each (auto dictionaryEntry in dictionary)
            {
                mDictionary[MarshalTo<ToKeyType>::From(dictionaryEntry.Key)] = MarshalTo<ToValueType>::From(dictionaryEntry.Value);
            }
 
            return mDictionary;
        }
    };
 
    // Specialization for Managed containers
    template <typename ToItemType>
    struct MarshalTo<Collections::Generic::IEnumerable<ToItemType>^>
    {
        template <typename FromType, typename ... ExtraArgs>
        static Collections::Generic::List<ToItemType>^ From(FromType&& list, ExtraArgs&&... extraArgs)
        {
            if (list.empty())
            {
                return nullptr;
            }
 
            auto mList = gcnew Collections::Generic::List<ToItemType>(static_cast<int>(list.size()));
 
            for (const auto& item : list)
            {
                mList->Add(MarshalTo<ToItemType>::From(item, std::forward<ExtraArgs>(extraArgs)...));
            }
 
            return mList;
        }
    };
 
    template <typename ToItemType>
    struct MarshalTo<array<ToItemType>^>
    {
        template <typename FromType, typename ... ExtraArgs>
        static array<ToItemType>^ From(FromType&& list, ExtraArgs&&... extraArgs)
        {
            if (list.empty())
            {
                return nullptr;
            }
 
            auto mArray = gcnew array<ToItemType>(static_cast<int>(list.size()));
            int index = 0;
 
            for (const auto& item : list)
            {
                mArray[index] = MarshalTo<ToItemType>::From(item, std::forward<ExtraArgs>(extraArgs)...);
                ++index;
            }
 
            return mArray;
        }
    };
 
    // Specialization for Managed associative containers
    template <typename ToKeyType, typename ToValueType>
    struct MarshalTo<Collections::Generic::IDictionary<ToKeyType, ToValueType>^>
    {
        template <typename FromType>
        static Collections::Generic::Dictionary<ToKeyType, ToValueType>^ From(FromType&& dictionary)
        {
            if (dictionary.empty())
            {
                return nullptr;
            }
 
            auto mDictionary = gcnew Collections::Generic::Dictionary<ToKeyType, ToValueType>();
 
            for (const auto& it : dictionary)
            {
                mDictionary[MarshalTo<ToKeyType>::From(it.first)] = MarshalTo<ToValueType>::From(it.second);
            }
 
            return mDictionary;
        }
    };
 
    // Specialization for std::chrono::system_clock::time_point <-> DateTime
    template <>
    struct MarshalTo<std::chrono::system_clock::time_point>
    {
        // https://stackoverflow.com/a/39460722
 
        using clock = std::chrono::system_clock;
        using duration = clock::duration;
        using time_point = clock::time_point;
 
        static time_point From(DateTime value)
        {
            const DateTime epochCpp(1970, 1, 1);
            const DateTime epochClr(1, 1, 1);
            const TimeSpan epochDiff = epochCpp - epochClr;
            return time_point(duration((value - epochDiff).Ticks));
        }
    };
}
 
template <typename ToType, typename FromType, typename ... ExtraArgs>
ToType Marshal(const FromType& fromObject, ExtraArgs&&... extraArgs)
{
    return detail::MarshalTo<ToType>::From(fromObject, std::forward<ExtraArgs>(extraArgs)...);
}
 
template <typename ManagedType>
msclr::gcroot<ManagedType^> MakeGcRoot(ManagedType^ managedType)
{
    return managedType;
}