object.h

 
#pragma once
 
#include <defines.h>
 
#include <system/type_info.h>
#include <system/reflection.h>
#include <system/smart_ptr.h>
#include <system/weak_ptr.h>
#include <system/dynamic_weak_ptr.h>
#include <system/refcount.h>
 
#include <system/cycles_detection.h>
#include <system/details/dbg_tools.h>
#include <system/details/dbg_garbage_collection.h>
#include <system/details/leakage_detector.h>
#include <system/details/lock_context.h>
 
#include <type_traits>
#include <string>
#include <list>
#include <utility>
#include <map>
#include <memory>
#include <cmath>
#include <mutex>
 
namespace System
{
 
class String;
class Details_Exception;
 
class ASPOSECPP_SHARED_CLASS Object
{
public:
    typedef SmartPtr<Object> ptr;
#ifdef ASPOSE_GET_SHARED_MEMBERS
    typedef System::Details::SharedMembersType shared_members_type;
#endif
    ASPOSECPP_SHARED_API Object();
    virtual ASPOSECPP_SHARED_API ~Object();
 
    // the following 2 members needed for MemberwiseClone()
    ASPOSECPP_SHARED_API Object(Object const& x);
    Object& operator = (Object const& x){ ASPOSE_UNUSED(x); return *this; } // does nothing
    Object* SharedRefAdded();
    int SharedRefRemovedSafe();
    int RemovedSharedRefs(int count);
    Detail::SmartPtrCounter* WeakRefAdded();
    void WeakRefRemoved();
    inline Detail::SmartPtrCounter* GetCounter();
    int SharedCount() const;
    ASPOSECPP_SHARED_API void Lock();
    ASPOSECPP_SHARED_API void Unlock();
    virtual ASPOSECPP_SHARED_API bool Equals(ptr obj);
    static bool ReferenceEquals(ptr const& objA, ptr const& objB)
    {
        return objA == objB;
    }
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value, bool>::type ReferenceEquals(T const& objA, T const& objB)
    {
        return &objA == &objB;
    }
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value, bool>::type ReferenceEquals(T const& objA, std::nullptr_t)
    {
        return false;
    }
    template<typename T1, typename T2>
    static typename std::enable_if<IsSmartPtr<T1>::value && IsSmartPtr<T2>::value, bool>::type Equals(T1 const& objA, T2 const& objB)
    {
        return ReferenceEquals(objA, objB) || (objA != nullptr && objB != nullptr && objA->Equals(objB));
    }
    template<typename T1, typename T2>
    static typename std::enable_if<!IsSmartPtr<T1>::value && !IsSmartPtr<T2>::value, bool>::type Equals(T1 const& objA, T2 const& objB)
    {
        return objA == objB;
    }
    virtual ASPOSECPP_SHARED_API int32_t GetHashCode() const;
    virtual ASPOSECPP_SHARED_API String ToString() const;
    virtual ASPOSECPP_SHARED_API ptr MemberwiseClone() const;
    static const TypeInfo& Type()
    {
        return *static_holder<ThisTypeInfo>();
    }
    virtual ASPOSECPP_SHARED_API const TypeInfo& GetType() const;
    virtual ASPOSECPP_SHARED_API bool Is(const TypeInfo& targetType) const;
    virtual ASPOSECPP_SHARED_API void SetTemplateWeakPtr(uint32_t argument);
#ifdef ASPOSE_GET_SHARED_MEMBERS
    virtual ASPOSECPP_SHARED_API void GetSharedMembers(shared_members_type&) const;
#endif
    virtual ASPOSECPP_SHARED_API bool FastCast(const Details::FastRttiBase& helper, void** out_ptr) const;
 
#ifdef __DBG_TOOLS
private:
    friend struct ::System::Details::DbgTools;
 
    System::Details::DbgTools::stack_s_int_string_t m_personal_st;
    bool m_rec_personal_st;
    mutable int m_instanceNo;
#endif
 
#if defined(ENABLE_CYCLES_DETECTION_EXT)
private:
    friend class System::Debug::ExternalObjectCollector;
    unsigned m_instance_id;
#endif
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    virtual ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const;
    virtual const char* DBG_class_name() const { return "Object"; }
#endif
 
private:
    friend class ::System::Detail::SmartPtrCounter;
    friend class ::System::Details::LeakageDetector;
 
#ifdef ENABLE_EXTERNAL_REFCOUNT
    std::unique_ptr<Detail::SmartPtrCounter> m_external_count;
#else
    std::atomic<Detail::SmartPtrCounter*> m_external_count;
    Detail::RefCount m_shared_count;
#endif
 
    struct ThisTypeInfo : TypeInfoPtr
    {
        ThisTypeInfo()
            : TypeInfoPtr(u"System::Object")
        {}
 
        // Explicitly deleting several members to avoid warnings
        ThisTypeInfo(const ThisTypeInfo&) = delete;
        ThisTypeInfo(ThisTypeInfo&&) = delete;
        ThisTypeInfo& operator = (const ThisTypeInfo&) = delete;
        ThisTypeInfo& operator = (ThisTypeInfo&&) = delete;
    };
 
    typedef std::recursive_mutex mutex;
    class GlobalMutexHolder;
    static GlobalMutexHolder s_globalMutex;
 
    mutex* volatile m_objectMutex;
 
#ifdef ASPOSECPP_DEBUG
    mutable const std::string* m_currentConstructor;
#endif
 
#ifdef __DBG_GARBAGE_COLLECTION
    int m_generation;
    friend bool ASPOSECPP_SHARED_API System::Details::__buildIsolationIsland(Object *&last, std::map<const Object*, shared_members_type> &island, int generation);
#endif
};
 
template<>
inline bool Object::Equals<float, float>(float const& objA, float const& objB)
{
    return (std::isnan(objA) && std::isnan(objB)) ? true : objA == objB;
}
 
template<>
inline bool Object::Equals<double, double>(double const& objA, double const& objB)
{
    return (std::isnan(objA) && std::isnan(objB)) ? true : objA == objB;
}
 
inline Object* Object::SharedRefAdded()
{
#ifdef ENABLE_EXTERNAL_REFCOUNT
    return GetCounter()->SharedRefAdded();
#else
    ++m_shared_count;
    return this;
#endif
}
 
inline int Object::SharedRefRemovedSafe()
{
#ifdef ENABLE_EXTERNAL_REFCOUNT
    return GetCounter()->SharedRefRemovedSafe();
#else
    return --m_shared_count;
#endif
}
 
inline int Object::RemovedSharedRefs(int count)
{
#ifdef ENABLE_EXTERNAL_REFCOUNT
    return m_external_count->DecreaseSharedRef(count);
#else
    return (m_shared_count -= count);
#endif
}
 
inline Detail::SmartPtrCounter* Object::WeakRefAdded()
{
    return GetCounter()->WeakRefAdded();
}
 
inline void Object::WeakRefRemoved()
{
    GetCounter()->WeakRefRemoved();
}
 
inline Detail::SmartPtrCounter* Object::GetCounter()
{
#ifdef ENABLE_EXTERNAL_REFCOUNT
    return m_external_count.get();
#else
    Detail::SmartPtrCounter *counter = m_external_count.load();
    if (counter == nullptr)
    {
        std::unique_ptr<Detail::SmartPtrCounter> new_counter(new Detail::SmartPtrCounter(this));
        if (m_external_count.compare_exchange_strong(counter, new_counter.get()))
            return new_counter.release();
    }
    return counter;
#endif
}
 
inline int Object::SharedCount() const
{
#ifdef ENABLE_EXTERNAL_REFCOUNT
    return m_external_count->SharedCount();
#else
    return m_shared_count;
#endif
}
 
// ------------------------ casting implemetation --------------------------------
namespace Details {
    [[noreturn]] ASPOSECPP_SHARED_API void ThrowInvalidCastException();
    template <typename T>
    T ThrowInvalidCastException_helper()
    {
        ThrowInvalidCastException();
        return T();
    }
}
 
template <typename TTo>
struct CastResult
{
    typedef SmartPtr<TTo> type;
};
 
template <typename TTo>
struct CastResult<SmartPtr<TTo>>
{
    typedef SmartPtr<TTo> type;
};
 
struct ExceptionWrapperType {};
 
template <typename T> struct IsExceptionWrapper : std::is_base_of<System::ExceptionWrapperType, T> {};
 
template<typename TTo, typename TFrom>
typename std::enable_if<!IsExceptionWrapper<TTo>::value, typename CastResult<TTo>::type>::type 
Cast_noexcept(SmartPtr<TFrom> const& obj) // throw()
{
    return obj.template dynamic_pointer_cast<TTo>();    
}
 
template<typename TTo, typename TFrom>
typename std::enable_if<!IsExceptionWrapper<TTo>::value, typename CastResult<TTo>::type>::type
Cast(SmartPtr<TFrom> const& obj) // throw(System::InvalidCastException)
{
    auto casted = dynamic_cast<TTo*>(obj.get());
    return obj && !casted
        ? Details::ThrowInvalidCastException_helper<typename CastResult<TTo>::type>()
        : SmartPtr<TTo>(obj, casted, obj.get_Mode());
}
 
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<IsExceptionWrapper<TFrom>::value && IsExceptionWrapper<TTo>::value && (std::is_convertible<TTo, TFrom>::value || std::is_base_of<TTo, TFrom>::value), TTo>::type
DynamicCast_noexcept(const TFrom& obj) noexcept
{
    return
        (DynamicCast_noexcept<typename TTo::ExceptionType>(obj.Get()) != nullptr)
        ? TTo(obj.Get())
        : TTo(nullptr)
    ;
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<IsExceptionWrapper<TFrom>::value && IsExceptionWrapper<TTo>::value && (std::is_convertible<TTo, TFrom>::value || std::is_base_of<TTo, TFrom>::value), TTo>::type
DynamicCast(const TFrom& obj) // throw(System::InvalidCastException)
{
    return
        obj != nullptr
        ? ((DynamicCast_noexcept<typename TTo::ExceptionType>(obj.Get()) != nullptr)
            ? TTo(obj.Get())
            : Details::ThrowInvalidCastException_helper<TTo>())
        : TTo(nullptr)
    ;
}
 
// static cast
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<!IsExceptionWrapper<TTo>::value, typename CastResult<TTo>::type>::type 
StaticCast_noexcept(SmartPtr<TFrom> const& obj) // throw()
{
    return Cast_noexcept<TTo, TFrom>(obj);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<!IsExceptionWrapper<TTo>::value, typename CastResult<TTo>::type>::type
StaticCast(SmartPtr<TFrom> const& obj) // throw(System::InvalidCastException)
{
    return Cast<TTo, TFrom>(obj);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename CastResult<TTo>::type StaticCast_noexcept(WeakPtr<TFrom> const& obj) // throw()
{
    return Cast_noexcept<TTo, TFrom>(obj);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename CastResult<TTo>::type StaticCast(WeakPtr<TFrom> const& obj) // throw(System::InvalidCastException)
{
    return obj != nullptr ? Cast<TTo, TFrom>(obj) : typename CastResult<TTo>::type();
}
 
template<typename TTo>
[[deprecated]] typename CastResult<TTo>::type StaticCast(std::nullptr_t) // throw()
{
    // to process code like System::ExplicitCast<System::Object>(nullptr)
    return typename CastResult<TTo>::type(nullptr);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_arithmetic<TFrom>::value, TTo>::type StaticCast(TFrom value)
{
    return TTo(value);
}
 
template<typename TTo>
[[deprecated]] typename std::enable_if<std::is_same<TTo, System::String>::value, TTo>::type StaticCast(TTo value)
{
    return value;
};
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_arithmetic<TFrom>::value, TTo>::type StaticCast(const TFrom* value)
{
    return TTo(value);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<!std::is_same<TFrom, System::String>::value && !IsExceptionWrapper<TFrom>::value && !IsSmartPtr<TFrom>::value && !std::is_arithmetic<TFrom>::value, TTo>::type StaticCast(const TFrom& obj)
{
    //it is for special cases, like exception classes
    if (!obj.Is(TTo::Type()))
        Details::ThrowInvalidCastException();
    return static_cast<TTo&>(obj);
}
 
// dynamic cast
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<!IsExceptionWrapper<TTo>::value, typename CastResult<TTo>::type>::type
DynamicCast_noexcept(SmartPtr<TFrom> const& obj) noexcept
{
    return Cast_noexcept<TTo, TFrom>(obj);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<IsExceptionWrapper<TFrom>::value && IsExceptionWrapper<TTo>::value && (std::is_convertible<TTo, TFrom>::value || std::is_base_of<TTo, TFrom>::value), TTo>::type
StaticCast_noexcept(const TFrom& obj) // throw()
{
    return
        (DynamicCast_noexcept<typename TTo::ExceptionType>(obj.Get()) != nullptr)
        ? TTo(obj.Get())
        : TTo(nullptr)
    ;
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<IsExceptionWrapper<TFrom>::value && IsExceptionWrapper<TTo>::value && (std::is_convertible<TTo, TFrom>::value || std::is_base_of<TTo, TFrom>::value), TTo>::type
StaticCast(const TFrom& obj) // throw(System::InvalidCastException)
{
    return
        obj != nullptr
        ? ((DynamicCast_noexcept<typename TTo::ExceptionType>(obj.Get()) != nullptr)
            ? TTo(obj.Get())
            : Details::ThrowInvalidCastException_helper<TTo>())
        : TTo(nullptr)
    ;
}
 
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<!std::is_enum<TTo>::value && !IsExceptionWrapper<TTo>::value, typename CastResult<TTo>::type>::type
DynamicCast(SmartPtr<TFrom> const& obj) // throw(System::InvalidCastException)
{
    return Cast<TTo, TFrom>(obj);
}
 
namespace Detail {
    ASPOSECPP_SHARED_API uint64_t GetIEnumUnsignedLongLongValue(const SmartPtr<Object>& obj);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_enum<TTo>::value, TTo>::type DynamicCast(SmartPtr<TFrom> obj)
{
    return static_cast<TTo>(Detail::GetIEnumUnsignedLongLongValue(obj));
}
 
template<typename TTo>
[[deprecated]] typename CastResult<TTo>::type DynamicCast(std::nullptr_t) noexcept
{
    // to process code like System::ExplicitCast<System::Object>(nullptr)
    return SmartPtr<TTo>();
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<
    !IsExceptionWrapper<TFrom>::value && !IsSmartPtr<TFrom>::value && std::is_convertible<TTo, TFrom>::value /* check if TFrom is base for TTo */
    , TTo>::type DynamicCast(TFrom &obj)
{
    return *dynamic_cast<TTo*>(&obj);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_same<System::Object, TFrom>::value && IsExceptionWrapper<TTo>::value, TTo>::type
StaticCast_noexcept(SmartPtr<TFrom> obj) noexcept
{
    auto exception_ptr = DynamicCast_noexcept<typename TTo::ExceptionType>(obj);
    return exception_ptr != nullptr ? TTo(StaticCast_noexcept<System::Details_Exception>(exception_ptr)) : TTo(nullptr);
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_same<System::Object, TFrom>::value && IsExceptionWrapper<TTo>::value, TTo>::type
StaticCast(SmartPtr<TFrom> obj) noexcept
{
    if (obj == nullptr)
        return TTo(nullptr);
 
    auto exception_ptr = DynamicCast_noexcept<typename TTo::ExceptionType>(obj);
    return exception_ptr != nullptr ? TTo(StaticCast_noexcept<System::Details_Exception>(exception_ptr)) : Details::ThrowInvalidCastException_helper<TTo>();
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_same<System::Object, TFrom>::value && IsExceptionWrapper<TTo>::value, TTo>::type
DynamicCast_noexcept(SmartPtr<TFrom> obj) noexcept
{
    auto exception_ptr = DynamicCast_noexcept<typename TTo::ExceptionType>(obj);
    return exception_ptr != nullptr ? TTo(StaticCast_noexcept<System::Details_Exception>(exception_ptr)) : TTo(nullptr);
}
 
template <typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_same<System::Object, TFrom>::value && IsExceptionWrapper<TTo>::value, TTo>::type
DynamicCast(SmartPtr<TFrom> obj) // throw(System::InvalidCastException)
{
    if (obj == nullptr)
        return TTo(nullptr);
 
    auto exception_ptr = DynamicCast_noexcept<typename TTo::ExceptionType>(obj);
    return exception_ptr != nullptr ? TTo(StaticCast_noexcept<System::Details_Exception>(exception_ptr)) : Details::ThrowInvalidCastException_helper<TTo>();
}
 
template<typename TTo, typename TFrom>
[[deprecated]] typename std::enable_if<std::is_pointer<TTo>::value && std::is_same<IntPtr, TFrom>::value, TTo>::type DynamicCast(TFrom value) noexcept
{
    return reinterpret_cast<TTo>(value);
}
 
 
template<typename TTo, typename TFrom>
typename CastResult<TTo>::type ConstCast(const SmartPtr<TFrom>& obj) // throw()
{
    return obj->Is(TTo::Type()) ? System::const_pointer_cast<TTo>(obj) : SmartPtr<TTo>();
}
 
template <typename TTo, typename TFrom>
typename CastResult<TTo>::type ForceStaticCast(SmartPtr<TFrom> const& obj) // throw(System::InvalidCastException)
{
    return SmartPtr<TTo>(obj, static_cast<TTo*>(obj.get()));
}
 
template<typename T>
SmartPtr<Object> MemberwiseClone(T* ptr)
{
    return MakeObject<T>(*ptr);
}
 
template<typename T, typename A>
SharedPtr<T> With(const SharedPtr<T>& record, const A& initializer)
{
    auto result = MakeSharedPtr<T>(static_cast<T*>(record->_Clone_()));
    initializer(*result);
    return result;
}
 
template <typename T, typename A>
T With(const T& record, const A& initializer)
{
    auto result = record;
    initializer(result);
    return result;
}
 
namespace Runtime {
    namespace CompilerServices {
        class RuntimeHelpers
        {
        public:
            template<typename T>
            static int GetHashCode(SmartPtr<T> const& obj)
            {
                return obj->Object::GetHashCode();
            }
        };
    }
}
 
inline System::Object* System::Detail::SmartPtrCounter::Lock()
{
#ifdef ENABLE_EXTERNAL_REFCOUNT
    return SharedRefAdded();
#else
    return m_object->SharedRefAdded();
#endif
}
 
template <typename T>
SmartPtr<Object> SmartPtr<T>::ToObjectPtr() const
{
    return SmartPtr<Object>(GetObjectOrNull());
}
 
template <typename T>
void SmartPtr<T>::SetContainedTemplateWeakPtr(uint32_t argument) const
{
    if (Object *const object = GetObjectOrNull())
        object->SetTemplateWeakPtr(argument);
}
 
template <typename T>
bool SmartPtr<T>::Is(const System::TypeInfo &target) const
{
    if (m_data.IsNull())
        return false;
    else if (m_data.GetMode() == SmartPtrMode::Shared)
        return m_data.SharedGetObject()->Is(target);
    else
        return m_data.WeakGetCounter()->GetObject()->Is(target);
}
 
template <typename T>
Object* SmartPtr<T>::ReleaseSharedAndGetObjectToDelete(SharedRefReleaser *releaser)
{
    const int count = releaser->SharedRefRemovedSafe();
 
    System::Details::MakeObjectLeakageDetector::ReportLeakCycle(count);
 
#ifdef ENABLE_EXTERNAL_REFCOUNT
    if (releaser->GetOwnershipState() != System::Detail::SmartPtrCounter::ObjectOwnershipState::OwnedByPointers)
        return nullptr;
 
    Object *const object = releaser->GetObject();
#else
    Object *const& object = releaser;
#endif
 
    if (count == 0)
        return object;
 
    return nullptr;
}
 
 
namespace Details {
 
    template <unsigned int leaf, unsigned int ...leafs>
    void WeakLeafMaker<leaf, leafs...>::Apply(System::Object *ptr)
    {
        ptr->SetTemplateWeakPtr(leaf);
        WeakLeafMaker<leafs...>::Apply(ptr);
    }
}
 
ASPOSECPP_SHARED_API void PrintTo(const System::Object& value, std::ostream* stream);
 
ASPOSECPP_SHARED_API std::ostream& operator<<(std::ostream& stream, const System::Object& object);
 
ASPOSECPP_SHARED_API std::wostream& operator<<(std::wostream& stream, const System::Object& object);
 
} // namespace System
 
typedef System::Object object;
 
#include <system/details/this_protector.h>
#include <system/details/for_each_member_visitor.h>