object_type.h

 
#pragma once
 
#include <system/object.h>
#include <system/smart_ptr.h>
#include <system/weak_ptr.h>
#include <system/convert.h>
#include <system/decimal.h>
#include <system/nullable.h>
#include <system/int32.h>
#include <system/int64.h>
#include <system/void.h>
 
#include <initializer_list>
#include <array>
#include <utility>
#include <type_traits>
 
namespace System
{
 
class ObjectType
{
public:
    template<typename T>
    static inline typename std::enable_if<IsSmartPtr<T>::value, const System::TypeInfo&>::type GetType(const T& obj)
    {
        return obj->GetType();
    }
 
    template<typename T>
    static inline typename std::enable_if<!IsExceptionWrapper<T>::value && !IsSmartPtr<T>::value && !std::is_fundamental<T>::value && !std::is_enum<T>::value && !IsNullable<T>::value, const System::TypeInfo&>::type GetType(const T& obj)
    {
        return obj.GetType();
    }
 
    template<typename T>
    static inline typename std::enable_if<IsExceptionWrapper<T>::value, const System::TypeInfo&>::type GetType(const T& obj)
    {
        return obj.Get()->GetType();
    }
 
    template<typename T>
    static inline typename std::enable_if<std::is_fundamental<T>::value || std::is_enum<T>::value, const System::TypeInfo&>::type GetType(const T obj)
    {
        return GetType<T>();
    }
 
    template<typename T>
    static inline typename std::enable_if<IsNullable<T>::value, const System::TypeInfo&>::type GetType(const T obj)
    {
        if (!obj.get_HasValue())
        {
            // Getting type of empty nullable throws an exception
            Details::ThrowNullableNullReference();
        }
 
        return GetType<typename T::ValueType>();
    }
 
    template <typename T>
    static inline typename std::enable_if<std::is_fundamental<T>::value && !std::is_enum<T>::value, const System::TypeInfo&>::type GetType()
    {
        return TypeInfo::BoxedValueType<T>();
    }
 
    template <typename T>
    static inline typename std::enable_if<std::is_enum<T>::value, const System::TypeInfo&>::type GetType()
    {
        return TypeInfo::BoxedValueType<T>();
    }
 
    template <typename T>
    static inline typename std::enable_if<(!std::is_fundamental<T>::value && !std::is_enum<T>::value && !IsBoxable<T>::value) || IsExceptionWrapper<T>::value, const System::TypeInfo&>::type GetType()
    {
        return T::Type(); // Works for pointers as well - they redirect Type() call to Pointee_::Type()
    }
 
    template <typename T>
    static inline typename std::enable_if<IsNullable<T>::value, const System::TypeInfo&>::type GetType()
    {
        return T::Type(); // Works for pointers as well - they redirect Type() call to Pointee_::Type()
    }
 
    template <typename T>
    static inline typename std::enable_if<detail::is_a<T, MulticastDelegate>::value, const System::TypeInfo&>::type GetType()
    {
        return T::Type(); // Works for pointers as well - they redirect Type() call to Pointee_::Type()
    }
 
    template <typename T>
    static inline typename std::enable_if<
        !std::is_fundamental<T>::value &&
        !std::is_enum<T>::value &&
        IsBoxable<T>::value &&
        !detail::is_a<T, MulticastDelegate>::value &&
        !IsNullable<T>::value,
        const System::TypeInfo&>::type GetType()
    {
        return TypeInfo::BoxedValueType<T>(); // Works for pointers as well - they redirect Type() call to Pointee_::Type()
    }
 
    static inline const System::TypeInfo& GetType(const String& obj)
    {
        ASPOSE_UNUSED(obj);
        return System::String::Type();
    }
};
 
template <>
inline const System::TypeInfo& ObjectType::GetType<uint8_t>()
{
    return System::Byte::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<char16_t>()
{
    return System::Char::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<int32_t>()
{
    return System::Int32::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<int64_t>()
{
    return System::Int64::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<bool>()
{
    return System::Boolean::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<System::String>()
{
    return System::String::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<System::DateTime>()
{
    return System::DateTime::Type();
}
 
template <>
inline const System::TypeInfo& ObjectType::GetType<void>()
{
    return System::Void::Type();
}
 
} // namespace System