smart_ptr_counter.h

 
#ifndef _aspose_system_smart_ptr_counter_h_
#define _aspose_system_smart_ptr_counter_h_
 
 
#include "refcount.h"
 
 
namespace System {
 
class Object;
 
}
 
 
namespace System { namespace Detail { 
 
class SmartPtrCounter
{
public:
    enum ObjectOwnershipState {
        BeingConstructed,
        OwnedByPointers,
        Deleted
    };
 
    SmartPtrCounter(Object *o)
        : m_object(o)
#ifdef ENABLE_EXTERNAL_REFCOUNT
        // A little messy logic here.
        // OwnedByPointers flag shows whether the object should be deleted when the reference count reaches zero.
        // When the object is created by MakeObject(), it is false at the beginning and then turns true when all constructors succeed (no exception thrown).
        // Both global (NextOwnedByPointers) and object-local (m_ownedByPointers) flags are explicitly modified by MakeObject() in this case.
        // But, if the object is created by operator new, no such control is possible, so it is considered owned by pointers from the beginning.
        // That's why we can only set NextOwnedByPointers value to false for a short time (until the next object gets created).
        // The better approach is to forbid creating objects with operator new() rather than with MakeObject() call, but this requires revising the whole asposecpp library and will
        // inevitably be broken again anyway.
        // So, this messy magic seems the most reliable way to allow for what we want.
        , m_ownership(NextOwnership())
#endif
    {}
 
    Object* GetObject() const 
    { 
        return m_object; 
    }
    SmartPtrCounter* WeakRefAdded()
    {
        ++m_pointers;
        return this;
    }
    void WeakRefRemoved()
    {
        if (--m_pointers == 0 && m_object == nullptr)
            delete this;
    }
 
#ifdef ENABLE_EXTERNAL_REFCOUNT
    Object* SharedRefAdded()
    {
        ++m_pointers;
        ++m_shared_pointers;
        return m_object;
    }
    int SharedRefRemovedSafe()
    {
        const int result = --m_shared_pointers;
        --m_pointers;
        return result;
    }
    int DecreaseSharedRef(int count)
    {
        const int shared_pointers_left = m_shared_pointers -= count;
        m_pointers -= count;
        return shared_pointers_left;
    }
    int SharedCount() const
    {
        return m_shared_pointers;
    }
    ASPOSECPP_SHARED_API static ObjectOwnershipState& NextOwnership();
    void CreatedSuccessfully()
    {
        m_ownership = OwnedByPointers;
    }
    ObjectOwnershipState GetOwnershipState() const
    {
        return m_ownership;
    }
#endif
 
    [[noreturn]] ASPOSECPP_SHARED_API static void ThrowNullReferenceException();
 
    [[noreturn]] ASPOSECPP_SHARED_API static void ThrowInvalidCastException();
 
    ASPOSECPP_SHARED_API Object* Lock();
 
    bool CanBeDeleted() const
    {
        return m_pointers == 0;
    }
    void Detach()
    {
        m_object = nullptr;
#ifdef ENABLE_EXTERNAL_REFCOUNT
        m_ownership = Deleted;
#endif
    }
 
private:
    Object *m_object;
    RefCount m_pointers;
#ifdef ENABLE_EXTERNAL_REFCOUNT
    RefCount m_shared_pointers;
    ObjectOwnershipState m_ownership;
#endif
 
    // Explicitly deleting some members to avoid warnings.
    SmartPtrCounter(const SmartPtrCounter&) = delete;
    SmartPtrCounter(SmartPtrCounter&&) = delete;
    SmartPtrCounter& operator = (const SmartPtrCounter&) = delete;
    SmartPtrCounter& operator = (SmartPtrCounter&&) = delete;
};
 
 
} } //namespace System::Detail
 
 
#endif //_aspose_system_smart_ptr_counter_h_