nullable.h

 
#ifndef _aspose_system_nullable_h_
#define _aspose_system_nullable_h_
 
#include <system/get_hash_code.h>
#include <system/boxable_traits.h>
#include <system/default.h>
#include <system/string.h>
#include <type_traits>
#include <functional>
#include <algorithm>
 
#include "detail.h"
 
namespace System
{
    template <typename T>
    class Nullable;
 
    template <class T>
    struct IsNullable : System::detail::is_a<T, System::Nullable> {};
 
    namespace Details {
        [[noreturn]]
        ASPOSECPP_SHARED_API void ThrowNullableObjectMustHaveAValue();
        ASPOSECPP_SHARED_API void ThrowNullableNullReference();
    }
    
    template<typename T>
    class Nullable
    {
        RTTI_INFO_VALUE_TYPE_TEMPLATE(Nullable<T>);
        template<class T2> friend class System::Nullable;
    public:
        typedef T ValueType;
 
        Nullable() : m_has_value(false)
        {}
 
        Nullable(std::nullptr_t) : m_has_value(false)
        {}
 
        template<typename T1>
        Nullable(const T1& value) : m_has_value(true), m_value(value)
        {}
        
        template<typename T1>
        Nullable(const Nullable<T1>& value) : m_has_value(value.m_has_value), m_value(value.m_value)
        {}
 
        template<typename T1, typename = typename std::enable_if<std::is_null_pointer<T1>::value>>
        Nullable<T> operator=(std::nullptr_t) { return Nullable<T>(); }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value && !std::is_null_pointer<T1>::value, Nullable<T>&>::type operator=(const T1& x)
        {
            this->m_has_value = true;
            this->m_value = static_cast<T>(x);
 
            return *this;
        }
 
        template<typename T1>
        Nullable<T>& operator=(const Nullable<T1>& x)
        {
            this->m_has_value = x.m_has_value;
            if (x.m_has_value)
            {
                this->m_value = x.m_value;
            }
 
            return *this;
        }
 
        T get_Value() const
        {
            if (!m_has_value)
                Details::ThrowNullableObjectMustHaveAValue();
 
            return m_value;
        }
 
        bool get_HasValue() const { return m_has_value; }
 
        operator const T&() const
        {
            if (!m_has_value)
                Details::ThrowNullableObjectMustHaveAValue();
 
            return m_value;
        }
 
        void reset() { m_has_value = false; }
 
        bool IsNull() const { return !m_has_value; }
 
        template<typename T1>
        bool NullableBoolHelper(const T1& other, const std::function<bool()>& f, bool default_if_both_are_null = false) const
        {
            if (IsNull())
            {
                if (other.IsNull())
                {
                    return default_if_both_are_null;
                }
                else
                {
                    return false;
                }
            }
 
            if (other.IsNull())
            {
                return false;
            }
 
            return f();
        }
 
        bool operator==(std::nullptr_t) const { return IsNull(); }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, bool>::type operator==(const T1& other) const
        {
            return m_has_value && m_value == other;
        }
 
        template<typename T1>
        bool operator==(const Nullable<T1>& other) const
        {
            return NullableBoolHelper<Nullable<T1>>(other,
                [&] {return m_value == other.get_Value(); },
            true);
        }
 
        template<typename T1>
        typename std::enable_if<IsNullable<T1>::value, bool>::type Equals(const T1& other) const
        {
            return ((!m_has_value) && (!other.m_has_value)) || (m_has_value && other.m_has_value && (m_value == other.get_Value()));
        }
 
        bool operator!=(std::nullptr_t) const { return !IsNull(); }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, bool>::type operator!=(const T1& other) const
        {
            return IsNull() ? true : m_value != other;
        }
 
        template<typename T1>
        bool operator!=(const Nullable<T1>& other) const
        {
            return NullableBoolHelper<Nullable<T1>>(other,
                [&] {return m_value != other.get_Value(); }
            );
        }
 
        bool operator>(std::nullptr_t) const { return false; }
        
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, bool>::type operator>(const T1& other) const
        {
            return m_has_value && m_value > other;
        }
 
        template<typename T1>
        bool operator>(const Nullable<T1>& other) const
        {
            return NullableBoolHelper<Nullable<T1>>(other,
                [&] {return m_value > other.get_Value(); }
            );
        }
 
        bool operator<(std::nullptr_t) const { return false; }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, bool>::type operator<(const T1& other) const
        {
            return m_has_value && m_value < other;
        }
 
        template<typename T1>
        bool operator<(const Nullable<T1>& other) const
        {
            return NullableBoolHelper<Nullable<T1>>(other,
                [&] {return m_value < other.get_Value(); }
            );
        }
 
        bool operator>=(std::nullptr_t) const { return false; }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, bool>::type operator>=(const T1& other) const
        {
            return m_has_value && m_value >= other;
        }
 
        template<typename T1>
        bool operator>=(const Nullable<T1>& other) const
        {
            return NullableBoolHelper<Nullable<T1>>(other,
                [&] {return m_value >= other.get_Value(); }
            );
        }
 
        bool operator<=(std::nullptr_t) const { return false; }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, bool>::type operator<=(const T1& other) const
        {
            return m_has_value && m_value <= other;
        }
 
        template<typename T1>
        bool operator<=(const Nullable<T1>& other) const
        {
            return NullableBoolHelper<Nullable<T1>>(other,
                [&] {return m_value <= other.get_Value(); }
            );
        }
 
        Nullable<T> operator+(std::nullptr_t) const { return Nullable<T>(); }
 
        template<typename T1, typename = typename std::enable_if<!IsNullable<T1>::value, int>::type>
        auto operator+(const T1 &other) const -> Nullable<decltype(get_Value() + other)>
        {
            return IsNull() ? nullptr : Nullable<decltype(get_Value() + other)>
                (get_Value() + other);
        }
 
        template<typename T1>
        auto operator+(const Nullable<T1> &other) const -> System::Nullable<decltype(get_Value() + other.get_Value())>
        {
            return (IsNull() || other.IsNull()) ? nullptr :
                Nullable<decltype(get_Value() + other.get_Value())>
                (get_Value() + other.get_Value());
        }
 
        template<typename T1, typename = typename std::enable_if<std::is_null_pointer<T1>::value>::type>
        Nullable<T> operator-(T1) const {
            static_assert(std::is_null_pointer<T1>::value, "Operator '-' is ambiguous on operands of type 'Nullable<T>' and '<null>'");
            return Nullable<T>();
        }
 
        template<typename T1, typename = typename std::enable_if<!IsNullable<T1>::value, int>::type>
        auto operator-(const T1 &other) const -> Nullable<decltype(get_Value() - other)>
        {
            return IsNull() ? nullptr : Nullable<decltype(get_Value() - other)>
                (get_Value() - other);
        }
 
        template<typename T1>
        auto operator-(const Nullable<T1> &other) const -> System::Nullable<decltype(get_Value() - other.get_Value())>
        {
            return (IsNull() || other.IsNull()) ? nullptr :
                Nullable<decltype(get_Value() - other.get_Value())>
                (get_Value() - other.get_Value());
        }
 
        Nullable<T> operator+=(std::nullptr_t)
        {
            m_has_value = false;
            return *this;
        }
 
        template<typename T1>
        typename std::enable_if<!IsNullable<T1>::value, Nullable<T>>::type operator+=(const T1& other)
        {
            if (m_has_value) {
                m_value += other;
            }
            return *this;
        }
 
        template<typename T1>
        Nullable<T> operator+=(const Nullable<T1>& other)
        {
            m_has_value = m_has_value && !other.IsNull();
            if (m_has_value) {
                m_value += other.get_Value();
            }
            return *this;
        }
 
        template<typename T1, typename = typename std::enable_if<std::is_null_pointer<T1>::value>::type>
        Nullable<T> operator-=(T1) {
            static_assert(std::is_null_pointer<T1>::value, "Operator '-=' is ambiguous on operands of type 'Nullable<T>' and '<null>'");
            return Nullable<T>();
        }
 
        template<typename T1, typename = typename std::enable_if<!std::is_null_pointer<T1>::value, T1>::type>
        typename std::enable_if<!IsNullable<T1>::value, Nullable<T>>::type operator-=(const T1& other)
        {
            if (m_has_value) {
                m_value -= other;
            }
            return *this;
        }
        
        template<typename T1 = T>
        typename std::enable_if<std::is_same<T1, bool>::value, Nullable<T>>::type operator|=(bool other)
        {
            if (m_has_value)
            {
                m_value |= other;
            }
            else if (other)
            {
                m_has_value = true;
                m_value = other;
            }
            return *this;
        }
 
        template<typename T1 = T>
        typename std::enable_if<std::is_same<T1, bool>::value, Nullable<T>>::type operator&=(bool other)
        {
            if (m_has_value)
            {
                m_value &= other;
            }
            else if (!other)
            {
                m_has_value = true;
                m_value = other;
            }
            return *this;
        }
 
 
        template<typename T1>
        Nullable<T> operator-=(const Nullable<T1>& other)
        {
            m_has_value = m_has_value && !other.IsNull();
            if (m_has_value) {
                m_value -= other.get_Value();
            }
            return *this;
        }
 
        int GetHashCode() const
        {
            return m_has_value ? System::GetHashCode<T>(m_value) : 0;
        }
 
        String ToString() const
        {
            return m_has_value ? ToStringHelper(m_value) : u"";
        }
 
        T GetValueOrDefault(T default_value)
        {
            return m_has_value ? m_value : default_value;
        }
 
        T GetValueOrDefault()
        {
            return m_has_value ? m_value : Default<T>();
        }
    private:
 
        bool m_has_value;
 
        T m_value;
 
        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 && !IsExceptionWrapper<C>::value), String>::type
        ToStringHelper(const C& obj)
        {
            return obj.ToString();
        }
 
        template<typename C>
        static typename std::enable_if<
            IsSmartPtr<C>::value || IsExceptionWrapper<C>::value, String>::type
        ToStringHelper(const C& obj)
        {
            return obj->ToString();
        }
 
        static String ToStringHelper(bool b)
        {
            return b ? u"True" : u"False";
        }
    };
 
    template<typename T>
    bool operator==(std::nullptr_t, const Nullable<T>& other) { return other.IsNull(); }
 
    template<typename T>
    bool operator!=(std::nullptr_t, const Nullable<T>& other) { return !other.IsNull(); }
    
    template<typename T>
    bool operator>(std::nullptr_t, const Nullable<T>&) { return false; }
    
    template<typename T>
    bool operator<(std::nullptr_t, const Nullable<T>&) { return false; }
    
    template<typename T>
    bool operator>=(std::nullptr_t, const Nullable<T>&) { return false; }
    
    template<typename T>
    bool operator<=(std::nullptr_t, const Nullable<T>&) { return false; }
 
 
    template<typename T1, typename T2>
    typename std::enable_if<!IsNullable<T1>::value, bool>::type
        operator==(const T1& some, const Nullable<T2>& other) { return other.IsNull() ? false : some == other.get_Value(); }
 
    template<typename T1, typename T2>
    typename std::enable_if<!IsNullable<T1>::value, bool>::type
        operator!=(const T1& some, const Nullable<T2>& other) { return other.IsNull() ? true : some != other.get_Value(); }
 
    template<typename T1, typename T2>
    typename std::enable_if<!IsNullable<T1>::value, bool>::type
        operator>(const T1& some, const Nullable<T2>& other) { return other.IsNull() ? false : some > other.get_Value(); }
 
    template<typename T1, typename T2>
    typename std::enable_if<!IsNullable<T1>::value, bool>::type
        operator<(const T1& some, const Nullable<T2>& other) { return other.IsNull() ? false : some < other.get_Value(); }
 
    template<typename T1, typename T2>
    typename std::enable_if<!IsNullable<T1>::value, bool>::type
        operator>=(const T1& some, const Nullable<T2>& other) { return other.IsNull() ? false : some >= other.get_Value(); }
 
    template<typename T1, typename T2>
    typename std::enable_if<!IsNullable<T1>::value, bool>::type
        operator<=(const T1& some, const Nullable<T2>& other) { return other.IsNull() ? false : some <= other.get_Value(); }
 
    template<
        typename T1, 
        typename T2, 
        typename = typename std::enable_if<!IsNullable<T1>::value && !IsNullable<T2>::value && !std::is_same<T1, System::String>::value, int>::type
    > auto operator + (const T1& some, const Nullable<T2> &other) -> System::Nullable<decltype(some + other.get_Value())>
    {
        return other.IsNull() ? nullptr : Nullable<decltype(some + other.get_Value())>(some + other.get_Value());
    }
 
    template<
        typename T1, 
        typename T2, 
        typename = typename std::enable_if<!IsNullable<T1>::value && !IsNullable<T2>::value && !std::is_same<T1, System::String>::value, int>::type
    > auto operator - (const T1& some, const Nullable<T2> &other) -> System::Nullable<decltype(some - other.get_Value())>
    {
        return other.IsNull() ? nullptr : Nullable<decltype(some - other.get_Value())>(some - other.get_Value());
    }
 
    template <typename T>
    struct IsBoxable<Nullable<T>> : std::true_type {};
 
    template <typename T>
    void PrintTo(const Nullable<T>& value, std::ostream* stream)
    {
        if (value == nullptr)
            *stream << "nullptr";
        else
            *stream << value.ToString().ToUtf8String();
    }
 
    template <typename T>
    std::ostream& operator<<(std::ostream& stream, const Nullable<T>& value)
    {
        stream << value.ToString();
        return stream;
    }
 
    template <typename T>
    std::wostream& operator<<(std::wostream& stream, const Nullable<T>& value)
    {
        stream << value.ToString();
        return stream;
    }
 
    class NullableUtils final
    {
    public:
        static ASPOSECPP_SHARED_API const System::TypeInfo& GetUnderlyingType(const System::TypeInfo& nullableType);
    };
}
 
#endif