Changeset 11071 for code/trunk/src/libraries/core/object

Timestamp:

Jan 17, 2016, 10:29:21 PM (9 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/object/ClassFactory.h (modified) (1 diff)
• src/libraries/core/object/Context.cc (modified) (5 diffs)
• src/libraries/core/object/DestroyLaterManager.h (modified) (2 diffs)
• src/libraries/core/object/Destroyable.cc (modified) (2 diffs)
• src/libraries/core/object/Iterator.h (modified) (3 diffs)
• src/libraries/core/object/IteratorBase.h (modified) (6 diffs)
• src/libraries/core/object/Listable.cc (modified) (3 diffs)
• src/libraries/core/object/Listable.h (modified) (1 diff)
• src/libraries/core/object/ObjectList.h (modified) (2 diffs)
• src/libraries/core/object/ObjectListBase.cc (modified) (4 diffs)
• src/libraries/core/object/ObjectListBase.h (modified) (4 diffs)
• src/libraries/core/object/ObjectListIterator.h (modified) (5 diffs)
• src/libraries/core/object/StrongPtr.h (modified) (9 diffs)
• src/libraries/core/object/WeakPtr.h (modified) (12 diffs)

code/trunk/src/libraries/core/object/ClassFactory.h

@@ -53 +53 @@
     {
         public:
-            virtual ~Factory() {}
+            Factory() = default;
+            virtual ~Factory() = default;
             virtual Identifiable* fabricate(Context* context) = 0;
     };

code/trunk/src/libraries/core/object/Context.cc

@@ -40 +40 @@
     RegisterClass(Context);
 
-    Context* Context::rootContext_s = 0;
+    Context* Context::rootContext_s = nullptr;
 
     Context* getContextForInitializationOfOtherContexts()
@@ -46 +46 @@
         static size_t count = 0;
         // the first time this is called, ++count returns 1 and the context is created
-        // the second time this is called, ++count returns 2 and NULL is returned because we're in the constructor of the context itself
+        // the second time this is called, ++count returns 2 and nullptr is returned because we're in the constructor of the context itself
         // for each future call the context (now completely created) is returned
         if (++count == 2)
-            return NULL;
+            return nullptr;
         else
         {
-            static Context context(NULL);
+            static Context context(nullptr);
             return &context;
         }
@@ -70 +70 @@
         // unregister context from object lists before object lists are destroyed
         this->unregisterObject();
-        for (size_t i = 0; i < this->objectLists_.size(); ++i)
-            delete this->objectLists_[i];
+        for (ObjectListBase* objectList : this->objectLists_)
+            delete objectList;
     }
 
@@ -82 +82 @@
     {
         delete Context::rootContext_s;
-        Context::rootContext_s = NULL;
+        Context::rootContext_s = nullptr;
     }
 
     /*static*/ Context* Context::getRootContext()
     {
-        OrxVerify(Context::rootContext_s != NULL, "Root Context is undefined");
+        OrxVerify(Context::rootContext_s != nullptr, "Root Context is undefined");
         return Context::rootContext_s;
     }
@@ -105 +105 @@
         ObjectListBase* objectList = this->getObjectList(identifier);
         delete objectList;
-        this->objectLists_[identifier->getClassID()] = NULL;
+        this->objectLists_[identifier->getClassID()] = nullptr;
     }
 }

code/trunk/src/libraries/core/object/DestroyLaterManager.h

@@ -45 +45 @@
             virtual ~DestroyLaterManager();
 
-            virtual void preUpdate(const Clock& time) { /*no action*/ }
-            virtual void postUpdate(const Clock& time);
+            virtual void preUpdate(const Clock& time) override { /*no action*/ }
+            virtual void postUpdate(const Clock& time) override;
 
             void retain(Destroyable* instance)
@@ -52 +52 @@
 
         private:
-            std::vector<StrongPtr<Destroyable> > retainedInstances_;
+            std::vector<StrongPtr<Destroyable>> retainedInstances_;
 
             static DestroyLaterManager* singletonPtr_s;

code/trunk/src/libraries/core/object/Destroyable.cc

@@ -54 +54 @@
     Destroyable::~Destroyable()
     {
-        if (!this->requestedDestruction_ && !IdentifierManager::getInstance().isCreatingHierarchy())
+        if (!this->requestedDestruction_ && IdentifierManager::exists() && !IdentifierManager::getInstance().isCreatingHierarchy())
             orxout(internal_warning) << "Deleted destroyable object without destroy()" << endl;
 
@@ -70 +70 @@
     void Destroyable::destroy()
     {
-        assert(this); // Just in case someone tries to delete a NULL pointer
+        assert(this); // Just in case someone tries to delete a nullptr
         this->requestedDestruction_ = true;
         if (this->referenceCount_ == 0)

code/trunk/src/libraries/core/object/Iterator.h

@@ -70 +70 @@
     */
     template <class T>
-    class Iterator : public IteratorBase<T, Iterator<T> >
+    class Iterator : public IteratorBase<T, Iterator<T>>
     {
         public:
@@ -76 +76 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            inline Iterator() : IteratorBase<T, Iterator<T> >() {}
-
-            /**
-                @brief Constructor: Sets this element to a given element
-                @param element The element
-            */
-            inline Iterator(ObjectListBaseElement* element) : IteratorBase<T, Iterator<T> >(element) {}
+            inline Iterator() : IteratorBase<T, Iterator<T>>() {}
 
             /**
@@ -88 +82 @@
                 @param other The other Iterator
             */
-            inline Iterator(const IteratorBase<T, Iterator<T> >& other) : IteratorBase<T, Iterator<T> >(other) {}
+            template <class OT, class OI>
+            inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T>>(other) {}
 
             /**

code/trunk/src/libraries/core/object/IteratorBase.h

@@ -37 +37 @@
 
 #include "core/CorePrereqs.h"
-
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 
 #include "ObjectListBase.h"
@@ -52 +49 @@
     class IteratorBase : public ObjectListElementRemovalListener
     {
-        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
-
-        protected:
+        static_assert(std::is_base_of<Listable, T>::value, "IteratorBase can only be used with Listables");
+
+        public:
             /**
                 @brief Constructor: Sets the element, whereon the iterator points, to the given element.
-                This constructor is protected and only for internal usage (don't mess with the BaseElements directly).
-            */
-            inline IteratorBase(ObjectListBaseElement* element = NULL)
+            */
+            inline IteratorBase(ObjectListElement<T>* element = nullptr)
             {
                 this->element_ = element;
@@ -65 +61 @@
             }
 
-
-        public:
-            /**
-                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
-            */
-            inline IteratorBase(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
-                this->registerIterator();
-            }
-
             /**
                 @brief Constructor: Sets the element, whereon the iterator points, to the given element of another type.
                 The element's type O must be a derivative of the Iterator's type T.
             */
-            template <class O>
-            inline IteratorBase(ObjectListElement<O>* element)
-            {
-                (void)static_cast<T*>((O*)NULL); // Check type: The element's type O must be a derivative of the Iterator's type T.
-                this->element_ = element;
-                this->registerIterator();
-            }
-
-            /**
-                @brief Constructor: Sets this element to the element of another Iterator.
-                @param other The other Iterator
-            */
-            inline IteratorBase(const IteratorBase& other)
-            {
-                this->element_ = other.element_;
+            template <class OT, class OI>
+            inline IteratorBase(const IteratorBase<OT, OI>& other)
+            {
+                this->element_ = other.getElement();
                 this->registerIterator();
             }
@@ -172 +146 @@
                 @return True if the Iterator points to an existing object.
             */
-            inline operator bool() const
-            {
-                return (this->element_ != NULL);
+            inline explicit operator bool() const
+            {
+                return (this->element_ != nullptr);
             }
 
@@ -201 +175 @@
                 @param object The object to compare with
             */
-            virtual void removedElement(ObjectListBaseElement* element)
+            virtual void removedElement(ObjectListBaseElement* element) override
             {
                 if (this->element_ == element)
                     this->operator++();
+            }
+
+            inline ObjectListBaseElement* getElement() const
+            {
+                return this->element_;
             }
 
@@ -226 +205 @@
                 }
                 else
-                    this->list_ = NULL;
+                    this->list_ = nullptr;
             }
 

code/trunk/src/libraries/core/object/Listable.cc

@@ -44 +44 @@
         @brief Constructor: Allocates space in the element list.
     */
-    Listable::Listable()
+    Listable::Listable() : Listable(Context::getRootContext())
     {
-        this->context_ = Context::getRootContext();
-        this->elements_.reserve(6);
-
-        RegisterObject(Listable);
     }
 
@@ -76 +72 @@
     void Listable::unregisterObject()
     {
-        for (size_t i = 0; i < this->elements_.size(); ++i)
-            Listable::deleteObjectListElement(this->elements_[i]);
+        for (ObjectListBaseElement* element : this->elements_)
+            Listable::deleteObjectListElement(element);
         this->elements_.clear();
     }
@@ -91 +87 @@
         this->elements_.clear();
 
-        for (size_t i = 0; i < copy.size(); ++i)
+        for (ObjectListBaseElement* element : copy)
         {
-            copy[i]->changeContext(this->context_, context);
-            Listable::deleteObjectListElement(copy[i]);
+            element->changeContext(this->context_, context);
+            Listable::deleteObjectListElement(element);
         }
 

code/trunk/src/libraries/core/object/Listable.h

@@ -40 +40 @@
 #include <vector>
 
+#include "util/SmallObjectAllocator.h"
 #include "core/class/Identifiable.h"
 

code/trunk/src/libraries/core/object/ObjectList.h

@@ -47 +47 @@
 #include "core/CorePrereqs.h"
 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-
 #include "ObjectListBase.h"
 #include "ObjectListIterator.h"
@@ -69 +66 @@
     class ObjectList
     {
-        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
+        static_assert(std::is_base_of<Listable, T>::value, "ObjectList can only be used with Listables");
 
         public:
             typedef ObjectListIterator<T> iterator;
 
-            /// Returns the size of the list (for the root context)
-            inline static size_t size()
-            {   return size(Context::getRootContext());   }
+            ObjectList() : ObjectList(Context::getRootContext()) {}
+            ObjectList(Context* context) : ObjectList(context->getObjectList<T>()) {}
+            ObjectList(ObjectListBase* list) : list_(list) {}
+
             /// Returns the size of the list
-            inline static size_t size(Context* context)
-            {
-                return context->getObjectList<T>()->size();
-            }
+            inline size_t size()
+            {   return this->list_->size();   }
 
-            /// Returns an Iterator to the first element in the list (for the root context).
-            inline static ObjectListElement<T>* begin()
-            {   return begin(Context::getRootContext());   }
             /// Returns an Iterator to the first element in the list.
-            inline static ObjectListElement<T>* begin(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->begin());
-            }
+            inline ObjectListIterator<T> begin()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->begin());   }
+            /// Returns an Iterator to the element after the last element in the list.
+            inline ObjectListIterator<T> end()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->end());   }
 
-            /// Returns an Iterator to the element after the last element in the list (for the root context).
-            inline static ObjectListElement<T>* end()
-            {   return end(Context::getRootContext());   }
-            /// Returns an Iterator to the element after the last element in the list.
-            inline static ObjectListElement<T>* end(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->end());
-            }
+            /// Returns an Iterator to the last element in the list.
+            inline ObjectListIterator<T> rbegin()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->rbegin());   }
+            /// Returns an Iterator to the element before the first element in the list.
+            inline ObjectListIterator<T> rend()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->rend());   }
 
-            /// Returns an Iterator to the last element in the list (for the root context).
-            inline static ObjectListElement<T>* rbegin()
-            {   return rbegin(Context::getRootContext());   }
-            /// Returns an Iterator to the last element in the list.
-            inline static ObjectListElement<T>* rbegin(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->rbegin());
-            }
-
-            /// Returns an Iterator to the element before the first element in the list (for the root context).
-            inline static ObjectListElement<T>* rend()
-            {   return rend(Context::getRootContext());   }
-            /// Returns an Iterator to the element before the first element in the list.
-            inline static ObjectListElement<T>* rend(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->rend());
-            }
+        private:
+            ObjectListBase* list_;
     };
 }

code/trunk/src/libraries/core/object/ObjectListBase.cc

@@ -58 +58 @@
     ObjectListBase::ObjectListBase()
     {
-        this->first_ = 0;
-        this->last_ = 0;
+        this->first_ = nullptr;
+        this->last_ = nullptr;
         this->size_ = 0;
     }
@@ -73 +73 @@
             ObjectListBaseElement* next = current->next_;
 
-            current->list_ = 0;
-            current->next_ = 0;
-            current->prev_ = 0;
+            current->list_ = nullptr;
+            current->next_ = nullptr;
+            current->prev_ = nullptr;
 
             current = next;
@@ -92 +92 @@
     void ObjectListBase::notifyRemovalListeners(ObjectListBaseElement* element) const
     {
-        for (std::vector<ObjectListElementRemovalListener*>::const_iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-            (*it)->removedElement(element);
+        for (ObjectListElementRemovalListener* listener : this->listeners_)
+            listener->removedElement(element);
     }
 
@@ -155 +155 @@
             this->first_ = element->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
 
-        element->list_ = 0;
-        element->next_ = 0;
-        element->prev_ = 0;
+        element->list_ = nullptr;
+        element->next_ = nullptr;
+        element->prev_ = nullptr;
         --this->size_;
     }

code/trunk/src/libraries/core/object/ObjectListBase.h

@@ -57 +57 @@
                 @param objectBase The object to store
             */
-            ObjectListBaseElement(Listable* object) : next_(0), prev_(0), objectBase_(object), list_(0) {}
+            ObjectListBaseElement(Listable* object) : next_(nullptr), prev_(nullptr), objectBase_(object), list_(nullptr) {}
             virtual ~ObjectListBaseElement() { this->removeFromList(); }
 
@@ -82 +82 @@
             ObjectListElement(T* object) : ObjectListBaseElement(static_cast<Listable*>(object)), object_(object) {}
 
-            virtual void changeContext(Context* oldContext, Context* newContext)
+            virtual void changeContext(Context* oldContext, Context* newContext) override
             {
                 // add object to new context, but only if this element belongs exactly to the old context (and not to a sub-context to avoid re-adding objects
@@ -104 +104 @@
     {
         public:
-            virtual ~ObjectListElementRemovalListener() {}
+            ObjectListElementRemovalListener() = default;
+            virtual ~ObjectListElementRemovalListener() = default;
             virtual void removedElement(ObjectListBaseElement* element) = 0;
     };
@@ -136 +137 @@
             inline ObjectListBaseElement* begin() const { return this->first_; }
             /// Returns a pointer to the element after the last element in the list. Works only with Iterator.
-            inline ObjectListBaseElement* end() const { return 0; }
+            inline ObjectListBaseElement* end() const { return nullptr; }
             /// Returns a pointer to the last element in the list. Works only with Iterator.
             inline ObjectListBaseElement* rbegin() const { return this->last_; }
             /// Returns a pointer to the element in front of the first element in the list. Works only with Iterator.
-            inline ObjectListBaseElement* rend() const { return 0; }
+            inline ObjectListBaseElement* rend() const { return nullptr; }
 
             inline void registerRemovalListener(ObjectListElementRemovalListener* listener) { this->listeners_.push_back(listener); }

code/trunk/src/libraries/core/object/ObjectListIterator.h

@@ -41 +41 @@
     Usage:
     @code
-    for (ObjectListIterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
+    ObjectList<myClass> list;
+    for (ObjectListIterator<myClass> it = list.begin(); it != list.end(); ++it)
     {
         it->someFunction(...);
@@ -68 +69 @@
     */
     template <class T>
-    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T> >
+    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T>>
     {
         public:
@@ -74 +75 @@
                 @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
             */
-            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
+            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T>>() {}
 
             /**
@@ -80 +81 @@
                 @param element The element to start with
             */
-            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T> >(element) {}
+            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T>>(element) {}
 
             /**
@@ -86 +87 @@
                 @param other The other ObjectListIterator
             */
-            inline ObjectListIterator(const IteratorBase<T, ObjectListIterator<T> >& other) : IteratorBase<T, ObjectListIterator<T> >(other) {}
+            template <class OI>
+            inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T>>(other) {}
 
             /**

code/trunk/src/libraries/core/object/StrongPtr.h

@@ -43 +43 @@
     orxonox::StrongPtr is an implementation of a smart pointer - it wraps a pointer to an
     object  and keeps this object alive until no StrongPtr points to this object anymore.
-    In contrast to orxonox::SharedPtr, StrongPtr works only with classes that are derived
+    In contrast to std::shared_ptr, StrongPtr works only with classes that are derived
     from orxonox::Destroyable, because it's an intrusive implementation, meaning the
     reference counter is stored in the object itself.
@@ -51 +51 @@
     at any time and also convert it back to a normal pointer if you like. This is possible
     because the reference counter is stored in the object itself and not in StrongPtr (in
-    contrast to SharedPtr).
+    contrast to std::shared_ptr).
 
     @b Important: If you want to delete an object, you must not use @c delete @c object but
@@ -138 +138 @@
         public:
             /// Constructor: Initializes the strong pointer with a null pointer.
-            inline StrongPtr() : pointer_(0), base_(0)
+            inline StrongPtr() : pointer_(nullptr), base_(nullptr)
             {
             }
@@ -158 +158 @@
             /// Copy-constructor for strong pointers to objects of another class.
             template <class O>
-            inline StrongPtr(const StrongPtr<O>& other) : pointer_(other.get()), base_(other.base_)
+            inline StrongPtr(const StrongPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
             {
                 if (this->base_)
@@ -172 +172 @@
             }
 
+            /// Move-constructor
+            inline StrongPtr(StrongPtr&& other) : pointer_(other.pointer_), base_(other.base_)
+            {
+                other.pointer_ = nullptr;
+                other.base_ = nullptr;
+            }
+
             /// Destructor: Decrements the reference counter.
             inline ~StrongPtr()
@@ -187 +194 @@
 
             /// Assigns the wrapped pointer of another StrongPtr.
-            inline StrongPtr& operator=(const StrongPtr& other)
-            {
-                StrongPtr(other).swap(*this);
+            inline StrongPtr& operator=(StrongPtr other)
+            {
+                other.swap(*this);
                 return *this;
             }
@@ -230 +237 @@
             inline T* operator->() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
             }
@@ -237 +244 @@
             inline T& operator*() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return *this->pointer_;
             }
 
-            /// Returns true if the wrapped pointer is NULL.
-            inline bool operator!() const
-            {
-                return (this->pointer_ == 0);
+            /// Returns true if the pointer is not nullptr.
+            inline explicit operator bool() const
+            {
+                return (this->pointer_ != nullptr);
             }
 
@@ -262 +269 @@
             }
 
-            /// Resets the strong pointer (equivalent to assigning a NULL pointer).
+            /// Resets the strong pointer (equivalent to assigning a nullptr).
             inline void reset()
             {

code/trunk/src/libraries/core/object/WeakPtr.h

@@ -37 +37 @@
 
     A WeakPtr wraps a pointer to an object. If the object gets deleted, the WeakPtr becomes
-    NULL. This can be used to store pointers to objects without knowing when they will be
+    nullptr. This can be used to store pointers to objects without knowing when they will be
     destroyed.
 
@@ -50 +50 @@
     WeakPtr<MyClass> pointer = object;                  // create a WeakPtr and assign the object
 
-    if (pointer)                                        // checks if pointer is not NULL (which is true)
+    if (pointer)                                        // checks if pointer is not nullptr (which is true)
         pointer->someFunction();                        // calls MyClass::someFunction()
 
     object->destroy();                                  // calls destroy() which deletes the object
 
-    if (pointer)                                        // checks if pointer is not NULL (which is now false)
+    if (pointer)                                        // checks if pointer is not nullptr (which is now false)
         pointer->someFunction();                        // this will not be executed
     @endcode
@@ -91 +91 @@
 {
     /**
-        @brief WeakPtr wraps a pointer to an object, which becomes NULL if the object is deleted.
+        @brief WeakPtr wraps a pointer to an object, which becomes nullptr if the object is deleted.
 
         @see See @ref WeakPtrExample "this description" for more information and an example.
@@ -100 +100 @@
         public:
             /// Constructor: Initializes the weak pointer with a null pointer.
-            inline WeakPtr() : pointer_(0), base_(0), callback_(0)
+            inline WeakPtr() : pointer_(nullptr), base_(nullptr), callback_(nullptr)
             {
             }
 
             /// Constructor: Initializes the weak pointer with a pointer to an object.
-            inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
+            inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(nullptr)
             {
                 this->registerAsDestructionListener(this->base_);
@@ -111 +111 @@
 
             /// Copy-constructor
-            inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(0)
+            inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(nullptr)
             {
                 this->registerAsDestructionListener(this->base_);
@@ -118 +118 @@
             /// Copy-constructor for weak pointers to objects of another class.
             template <class O>
-            inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.base_), callback_(0)
+            inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase()), callback_(nullptr)
             {
                 this->registerAsDestructionListener(this->base_);
@@ -124 +124 @@
 
             /// Destructor
-            inline virtual ~WeakPtr()
+            virtual inline ~WeakPtr()
             {
                 this->unregisterAsDestructionListener(this->base_);
@@ -137 +137 @@
 
             /// Assigns the wrapped pointer of another WeakPtr.
-            inline WeakPtr& operator=(const WeakPtr& other)
-            {
-                WeakPtr(other).swap(*this);
+            inline WeakPtr& operator=(WeakPtr other)
+            {
+                other.swap(*this);
                 return *this;
             }
@@ -172 +172 @@
             inline T* operator->() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
             }
@@ -179 +179 @@
             inline T& operator*() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return *this->pointer_;
             }
 
-            /// Returns true if the wrapped pointer is NULL.
-            inline bool operator!() const
-            {
-                return (this->pointer_ == 0);
+            /// Returns true if the pointer is not nullptr.
+            inline explicit operator bool() const
+            {
+                return (this->pointer_ != nullptr);
             }
 
@@ -210 +210 @@
             }
 
-            /// Resets the weak pointer (equivalent to assigning a NULL pointer).
+            /// Resets the weak pointer (equivalent to assigning a nullptr).
             inline void reset()
             {
@@ -230 +230 @@
         private:
             /// Will be called by Destroyable::~Destroyable() if the stored object is deleted. Resets the wrapped pointer and executes the callback.
-            inline void objectDeleted()
-            {
-                this->base_ = 0;
-                this->pointer_ = 0;
+            virtual inline void objectDeleted() override
+            {
+                this->base_ = nullptr;
+                this->pointer_ = nullptr;
                 if (this->callback_)
                     (*this->callback_)();