marshal.h

 
#ifndef __aspose_system_marshal_h__
#define __aspose_system_marshal_h__
 
#include <memory.h>
#include <system/exceptions.h>
#include <fwd.h>
#include <cstdint>
 
namespace System { namespace Security { class SecureString; }}
 
namespace System { namespace Runtime { namespace InteropServices {
 
class Marshal
{
public:
    template<typename container>
    static void Copy(const IntPtr source, container&& destination, int startIndex, int length) {
        memcpy(&destination->data()[0]+startIndex, (const void *)source, length*sizeof(destination->data()[0]));
    }
    template<typename container>
    static void Copy(const void * source, container&& destination, int startIndex, int length) {
        memcpy(&destination->data()[0]+startIndex, source, length*sizeof(destination->data()[0]));
    }
 
    template<typename container>
    static void Copy(const container &source, int startIndex, void * destination, int length) {
        memcpy(destination, &source->data()[0]+startIndex, length*sizeof(typename container::ValueType));
    }
    template<typename container>
    static void Copy(const container &source, int startIndex, IntPtr destination, int length) {
        memcpy((void *)destination, &source->data()[0]+startIndex, length*sizeof(typename container::ValueType));
    }
 
    template<typename TDelegate>
    static TDelegate GetDelegateForFunctionPointer(IntPtr ptr)
    {
        if (ptr == 0)
        {
            throw ArgumentNullException(u"ptr");
        }
 
        return TDelegate().connect(reinterpret_cast<typename TDelegate::Function*>(ptr));
    }
 
    static void WriteByte(IntPtr ptr, int offset, uint8_t value)
    {
        *((uint8_t*)ptr + offset) = value;
    }
    static void WriteByte(IntPtr ptr, uint8_t value)
    {
        WriteByte(ptr, 0, value);
    }
 
    static void WriteInt16(IntPtr ptr, int offset, int16_t value)
    {
        *((int16_t*)((uint8_t*)ptr + offset)) = value;
    }
 
    static void WriteInt32(IntPtr ptr, int offset, int32_t value)
    {
        *((int32_t*)((uint8_t*)ptr + offset)) = value;
    }
 
    static void WriteInt64(IntPtr ptr, int offset, int64_t value)
    {
        *((int64_t*)((uint8_t*)ptr + offset)) = value;
    }
 
    static void WriteIntPtr(IntPtr ptr, int offset, IntPtr value)
    {
        *((IntPtr*)((uint8_t*)ptr + offset)) = value;
    }
 
    static uint8_t ReadByte(IntPtr ptr, int offset = 0)
    {
        return  *((uint8_t*)ptr + offset);
    }
 
    static int16_t ReadInt16(IntPtr ptr, int offset = 0)
    {
        return  *((int16_t*)((uint8_t*)ptr + offset));
    }
 
    static int32_t ReadInt32(IntPtr ptr, int offset = 0)
    {
        return  *((int32_t*)((uint8_t*)ptr + offset));
    }
 
    static IntPtr ReadIntPtr(IntPtr ptr, int offset = 0)
    {
        return *((IntPtr*)((uint8_t*)ptr + offset));
    }
 
    static int32_t GetHRForException(const System::Exception& exc)
    {
        return exc->get_HResult();
    }
 
    static ASPOSECPP_SHARED_API IntPtr SecureStringToGlobalAllocAnsi(const SharedPtr<Security::SecureString>& s);
 
    static ASPOSECPP_SHARED_API IntPtr SecureStringToGlobalAllocUnicode(const SharedPtr<Security::SecureString>& s);
 
    static ASPOSECPP_SHARED_API IntPtr AllocHGlobal(int32_t bytes_count);
 
    static ASPOSECPP_SHARED_API IntPtr AllocHGlobal(IntPtr bytes_count);
 
    static ASPOSECPP_SHARED_API void FreeHGlobal(IntPtr address);
 
    static ASPOSECPP_SHARED_API void ZeroFreeGlobalAllocAnsi(IntPtr s);
 
    static ASPOSECPP_SHARED_API void ZeroFreeGlobalAllocUnicode(IntPtr s);
 
    static ASPOSECPP_SHARED_API IntPtr StringToHGlobalAnsi(const String& s);
 
    static ASPOSECPP_SHARED_API IntPtr StringToHGlobalUni(const String& s);
 
    static ASPOSECPP_SHARED_API IntPtr StringToHGlobalAuto(const String& s);
 
    static ASPOSECPP_SHARED_API String PtrToStringAnsi(IntPtr ptr);
 
    static ASPOSECPP_SHARED_API String PtrToStringAnsi(IntPtr ptr, int length);
 
    static ASPOSECPP_SHARED_API String PtrToStringAuto(IntPtr ptr);
 
    static ASPOSECPP_SHARED_API String PtrToStringAuto(IntPtr ptr, int length);
 
    static ASPOSECPP_SHARED_API String PtrToStringUni(IntPtr ptr);
 
    static ASPOSECPP_SHARED_API String PtrToStringUni(IntPtr ptr, int length);
 
    static ASPOSECPP_SHARED_API String PtrToStringUTF8(IntPtr ptr);
 
    static ASPOSECPP_SHARED_API String PtrToStringUTF8(IntPtr ptr, int length);
};
 
}}} // namespace System::Runtime::InteropServices
 
#endif