boxed_value.h

 
#ifndef _aspose_system_boxed_value_h_
#define _aspose_system_boxed_value_h_
 
#include <fwd.h>
#include <system/get_hash_code.h>
#include <system/object.h>
#include <system/object_type.h>
#include <system/boxable_traits.h>
#include <system/timespan.h>
#include <system/decimal.h>
#include <system/guid.h>
#include <system/value_type.h>
#include <system/type_code.h>
 
#include <typeinfo>
#include <type_traits>
 
namespace System
{
    template <typename T> class Nullable;
 
    namespace BoxedValueDetail
    {
        // Although two floating point NaNs are defined by IEC 60559:1989 to always compare as unequal, the contract for System.Object.Equals,
        // requires that overrides must satisfy the requirements for an equivalence operator. Therefore, System.Double.Equals and System.Single.Equals
        // return True when comparing two NaNs, while the equality operator returns False in that case, as required by the standard.
        template<typename T>
        typename std::enable_if<detail::has_operator_equal<T>::value, bool>::type
        Equals(T value1, T value2)
        {
            return value1 == value2;
        }
 
        template<typename T>
        typename std::enable_if<detail::has_only_method_equals<T>::value, bool>::type
        Equals(T value1, T value2)
        {
            return value1.Equals(value2);
        }
 
        template<>
        inline bool Equals<float>(float value1, float value2)
        {
            return (std::isnan(value1) && std::isnan(value2)) ? true : value1 == value2;
        }
 
        template<>
        inline bool Equals<double>(double value1, double value2)
        {
            return (std::isnan(value1) && std::isnan(value2)) ? true : value1 == value2;
        }
 
        template <typename T>
        struct ImplementsInterface<T, IComparable<T>>
            : std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_enum<T>::value>
        {};
 
        template<typename T, typename Self>
        class Comparable : public System::IComparable<T>
        {
            typedef System::BoxedValueDetail::Comparable<T, Self> ThisType;
            typedef System::IComparable<T> BaseType;
 
            typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
            RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
        public:
            int CompareTo(T other) override
            {
                auto& self = static_cast<Self*>(this)->unbox();
                return self < other ? -1 : other < self ? 1 : 0;
            }
        };
        class NonComparable
        {
        };
 
        class ASPOSECPP_SHARED_CLASS BoxedStringBase : public System::Collections::Generic::IEnumerable<char16_t>
        {
        public:
            ASPOSECPP_SHARED_API System::SharedPtr<System::Collections::Generic::IEnumerator<char16_t>> GetEnumerator() override;
        };
        class NonBoxedStringBase
        {
        };
 
        } // namespace BoxedValueDetail
 
    class ASPOSECPP_SHARED_CLASS BoxedValueBase : public virtual Object
    {
        RTTI_INFO(System::BoxedValueBase, ::System::BaseTypesInfo<System::Object>);
 
    public:
        virtual ASPOSECPP_SHARED_API bool IsBoxedEnum() = 0;
 
        virtual ASPOSECPP_SHARED_API uint64_t GetUnsignedLongLongValue() const = 0;
 
        virtual ASPOSECPP_SHARED_API TypeCode GetTypeCode() const = 0;
 
        using Object::ToString;
 
        ASPOSECPP_SHARED_API System::String ToString(const System::String& format) const;
 
        // Parsing enums
        static ASPOSECPP_SHARED_API SharedPtr<Object> Parse(const TypeInfo& type, const String& str, bool ignoreCase);
        static ASPOSECPP_SHARED_API SharedPtr<Object> Parse(const TypeInfo& type, const String& str);
    };
 
    namespace TypeCodeHelper
    {
        template<typename T>
        TypeCode GetTypeCodeFor()
        {
            return TypeCode::Object;
        }
 
        template<> inline TypeCode GetTypeCodeFor<bool>() { return TypeCode::Boolean; }
        template<> inline TypeCode GetTypeCodeFor<char_t>() { return TypeCode::Char; }
        template<> inline TypeCode GetTypeCodeFor<int8_t>() { return TypeCode::SByte; }
        template<> inline TypeCode GetTypeCodeFor<uint8_t>() { return TypeCode::Byte; }
        template<> inline TypeCode GetTypeCodeFor<int16_t>() { return TypeCode::Int16; }
        template<> inline TypeCode GetTypeCodeFor<uint16_t>() { return TypeCode::UInt16; }
        template<> inline TypeCode GetTypeCodeFor<int32_t>() { return TypeCode::Int32; }
        template<> inline TypeCode GetTypeCodeFor<uint32_t>() { return TypeCode::UInt32; }
        template<> inline TypeCode GetTypeCodeFor<int64_t>() { return TypeCode::Int64; }
        template<> inline TypeCode GetTypeCodeFor<uint64_t>() { return TypeCode::UInt64; }
        template<> inline TypeCode GetTypeCodeFor<float>() { return TypeCode::Single; }
        template<> inline TypeCode GetTypeCodeFor<double>() { return TypeCode::Double; }
        template<> inline TypeCode GetTypeCodeFor<Decimal>() { return TypeCode::Decimal; }
        template<> inline TypeCode GetTypeCodeFor<DateTime>() { return TypeCode::DateTime; }
        template<> inline TypeCode GetTypeCodeFor<String>() { return TypeCode::String; }
    }
 
    template<class T>
    class ASPOSECPP_SHARED_CLASS BoxedValue : public BoxedValueBase,
        // If boxed type implements IComparable, then boxed value supports it too
        public std::conditional_t<BoxedValueDetail::ImplementsInterface_v<T, IComparable<T>>,
                                  BoxedValueDetail::Comparable<T, BoxedValue<T>>, BoxedValueDetail::NonComparable>,
        // If boxed type is string, it may support IEnumerable<char16_t>
        public std::conditional_t<std::is_same<T, System::String>::value, BoxedValueDetail::BoxedStringBase,
                                  BoxedValueDetail::NonBoxedStringBase>
    {
        typedef System::BoxedValue<T> thisType;
        typedef System::BaseTypesInfo<System::Object> baseTypes;
 
        typedef TypeInfo::BoxedValue<T> ThisTypeInfo;
 
        RTTI_INFO_BOXED_CUSTOM(System::BoxedValue<T>, System::BaseTypesInfo<System::Object>);
 
        friend class System::Nullable<T>;
 
    public:
        const System::TypeInfo& GetType() const override
        {
            return System::ObjectType::GetType<T>();
        }
 
        BoxedValue(const T& value)
          : m_original_typeid_hash( typeid(T).hash_code() )
          , m_value_holder(value)
        {
            static_assert(System::IsBoxable<T>::value,
                "Only arithmetic, enums and specified in IsBoxable<> types are supported, use specializations to extend");
        }
 
        const T& unbox() const
        {
            return m_value_holder;
        }
 
        template<class V>
        bool is() const
        {
            return typeid(V).hash_code() == m_original_typeid_hash;
        }
 
        bool Equals(ptr obj) override
        {
            if( !obj || !obj->Is(GetType()) )
                return false;
 
            auto boxed = obj.Cast<BoxedValue<T>>();
            return BoxedValueDetail::Equals(m_value_holder, boxed->m_value_holder);
        }
 
        int GetHashCode() const override
        {
            return System::GetHashCode<T>(m_value_holder);
        }
 
        String ToString() const override
        {
            return ToStringHelper(m_value_holder);
        }
 
        bool IsBoxedEnum() override
        {
            return false;
        }
 
        uint64_t GetUnsignedLongLongValue() const override
        {
            return ToUInt64Helper(m_value_holder);
        }
 
        TypeCode GetTypeCode() const override
        {
            return TypeCodeHelper::GetTypeCodeFor<T>();
        }
 
    private:
 
        //  Do not make m_original_typeid_hash public!
        //  The particular values returned by typeid(T).hash_code() are implementation-defined and may vary between executions of the same program
        size_t m_original_typeid_hash;
 
        T m_value_holder;
 
        template<class C>
        static typename std::enable_if<
                std::is_arithmetic<C>::value || std::is_enum<C>::value, String>::type
        ToStringHelper(const C& value)
        {
            return String::Format(u"{0}", value);
        }
 
        template<typename C>
        static typename std::enable_if<
            (!std::is_arithmetic<C>::value && !std::is_enum<C>::value && !IsSmartPtr<C>::value), String>::type
        ToStringHelper(const C& obj)
        {
            return obj.ToString();
        }
 
        template<typename C>
        static typename std::enable_if<IsSmartPtr<C>::value, String>::type
        ToStringHelper(const C& obj)
        {
            return obj->ToString();
        }
 
        static String ToStringHelper(bool b)
        {
            return b ? u"True" : u"False";
        }
 
        template <typename C>
        static typename std::enable_if<std::is_convertible<C, uint64_t>::value, uint64_t>::type
        ToUInt64Helper(C value)
        {
            return static_cast<uint64_t>(value);
        }
 
        template <typename C>
        static typename std::enable_if<!std::is_convertible<C, uint64_t>::value, uint64_t>::type
        ToUInt64Helper(C)
        {
            return 0;
        }
    };
 
    template <class T>
    class ASPOSECPP_SHARED_CLASS DefaultBoxedValue : public Object
    {
        typedef System::DefaultBoxedValue<T> thisType;
        typedef System::BaseTypesInfo<System::Object> baseTypes;
 
        typedef TypeInfo::BoxedValue<T> ThisTypeInfo;
 
        RTTI_INFO_BOXED_CUSTOM(System::DefaultBoxedValue<T>, System::BaseTypesInfo<System::Object>);
 
    public:
        const System::TypeInfo& GetType() const override
        {
            return System::ObjectType::GetType<T>();
        }
 
        DefaultBoxedValue(const T& value)
            : m_original_typeid_hash(typeid(T).hash_code())
            , m_value_holder(value)
        {
        }
 
        const T& unbox() const
        {
            return m_value_holder;
        }
 
        template<class V>
        bool is() const
        {
            return typeid(V).hash_code() == m_original_typeid_hash;
        }
 
        bool Equals(ptr obj) override
        {
            if (!obj || !obj->Is(Type()))
                return false;
 
            auto boxed = obj.Cast<BoxedValue<T>>();
            return m_value_holder == boxed->unbox();
        }
 
        int GetHashCode() const override
        {
            return m_value_holder.GetHashCode();
        }
 
        String ToString() const override
        {
            return m_value_holder.ToString();
        }
 
    private:
        //  Do not make m_original_typeid_hash public!
        //  The particular values returned by typeid(T).hash_code() are implementation-defined and may vary between executions of the same program
        size_t m_original_typeid_hash;
        T m_value_holder;
    };
 
 
    template <typename T>
    struct IsBoxedValue : std::false_type {};
 
    template <typename T>
    struct IsBoxedValue<BoxedValue<T>> : std::true_type {};
 
 
} // namespace System
 
#endif // _aspose_system_boxed_value_h_