Changeset 9571 for code/branches/core6

Timestamp:

Mar 24, 2013, 9:03:22 PM (12 years ago)

Author:

landauf

Message:

using Destroyable instead of OrxonoxClass now wherever the destruction-related members are addressed

Location:

code/branches/core6/src

Files:

• libraries/core/command/Functor.h (modified) (2 diffs)
• libraries/core/object/SmartPtr.h (modified) (6 diffs)
• libraries/core/object/WeakPtr.h (modified) (7 diffs)
• libraries/util/ScopedSingletonManager.h (modified) (3 diffs)
• orxonox/interfaces/Pickupable.cc (modified) (2 diffs)
• orxonox/interfaces/Pickupable.h (modified) (1 diff)

code/branches/core6/src/libraries/core/command/Functor.h

@@ -120 +120 @@
 #include "util/Output.h"
 #include "util/MultiType.h"
-#include "core/class/OrxonoxClass.h"
+#include "core/object/Destroyable.h"
 #include "FunctorPtr.h"
 
@@ -303 +303 @@
             /// Casts the object and registers as destruction listener.
             inline void registerObject(O* object)
-                { OrxonoxClass* base = dynamic_cast<OrxonoxClass*>(object); if (base) { this->registerAsDestructionListener(base); } }
+                { Destroyable* base = dynamic_cast<Destroyable*>(object); if (base) { this->registerAsDestructionListener(base); } }
             /// Casts the object and unregisters as destruction listener.
             inline void unregisterObject(O* object)
-                { OrxonoxClass* base = dynamic_cast<OrxonoxClass*>(object); if (base) { this->unregisterAsDestructionListener(base); } }
-
-            /// Will be called by OrxonoxClass::~OrxonoxClass() if the stored object is deleted and the Functor is in safe mode.
+                { Destroyable* base = dynamic_cast<Destroyable*>(object); if (base) { this->unregisterAsDestructionListener(base); } }
+
+            /// Will be called by Destroyable::~Destroyable() if the stored object is deleted and the Functor is in safe mode.
             inline void objectDeleted()
                 { this->object_ = 0; }

code/branches/core6/src/libraries/core/object/SmartPtr.h

@@ -44 +44 @@
     object  and keeps this object alive until no SmartPtr points to this object anymore.
     In contrast to orxonox::SharedPtr, SmartPtr works only with classes that are derived
-    from orxonox::OrxonoxClass, because it's an intrusive implementation, meaning the
+    from orxonox::Destroyable, because it's an intrusive implementation, meaning the
     reference counter is stored in the object itself.
 
@@ -78 +78 @@
     };
     @endcode
-    In this example we assume that OtherClass is a child of OrxonoxClass. We don't care
+    In this example we assume that OtherClass is a child of Destroyable. We don't care
     about the inheritance of MyClass though.
 
@@ -123 +123 @@
 #include <cassert>
 
-#include "core/class/OrxonoxClass.h"
+#include "core/object/Destroyable.h"
 #include "WeakPtr.h"
 
@@ -227 +227 @@
             }
 
-            /// Returns the wrapped pointer as @c OrxonoxClass*
-            inline OrxonoxClass* getBase() const
+            /// Returns the wrapped pointer as @c Destroyable*
+            inline Destroyable* getBase() const
             {
                 return this->base_;
@@ -268 +268 @@
                 }
                 {
-                    OrxonoxClass* temp = this->base_;
+                    Destroyable* temp = this->base_;
                     this->base_ = other.base_;
                     other.base_ = temp;
@@ -282 +282 @@
         private:
             T* pointer_;            ///< The wrapped pointer to an object of type @a T
-            OrxonoxClass* base_;    ///< The wrapped pointer, casted up to OrxonoxClass (this is needed because with just a T* pointer, SmartPtr couln't be used with forward declarations)
+            Destroyable* base_;    ///< The wrapped pointer, casted up to Destroyable (this is needed because with just a T* pointer, SmartPtr couln't be used with forward declarations)
     };
 

code/branches/core6/src/libraries/core/object/WeakPtr.h

@@ -40 +40 @@
     destroyed.
 
-    WeakPtr works only with objects that are derived from orxonox::OrxonoxClass, because
+    WeakPtr works only with objects that are derived from orxonox::Destroyable, because
     WeakPtr is intrusive and registers itself in the stored object, to get a notification if
     the object is being deleted.
@@ -58 +58 @@
         pointer->someFunction();                        // this will not be executed
     @endcode
-    In this example we assumed that MyClass is derived of OrxonoxClass (otherwise it couldn't
+    In this example we assumed that MyClass is derived of Destroyable (otherwise it couldn't
     be used with a WeakPtr).
 
@@ -85 +85 @@
 #include <cassert>
 
-#include "core/class/OrxonoxClass.h"
+#include "core/object/Destroyable.h"
 #include "core/command/Functor.h"
 
@@ -169 +169 @@
             }
 
-            /// Returns the wrapped pointer as @c OrxonoxClass*
-            inline OrxonoxClass* getBase() const
+            /// Returns the wrapped pointer as @c Destroyable*
+            inline Destroyable* getBase() const
             {
                 return this->base_;
@@ -213 +213 @@
                 }
                 {
-                    OrxonoxClass* temp = this->base_;
+                    Destroyable* temp = this->base_;
                     this->base_ = other.base_;
                     other.base_ = temp;
@@ -241 +241 @@
 
         private:
-            /// Will be called by OrxonoxClass::~OrxonoxClass() if the stored object is deleted. Resets the wrapped pointer and executes the callback.
+            /// Will be called by Destroyable::~Destroyable() if the stored object is deleted. Resets the wrapped pointer and executes the callback.
             inline void objectDeleted()
             {
@@ -251 +251 @@
 
             T* pointer_;            ///< The wrapped pointer to an object of type @a T
-            OrxonoxClass* base_;    ///< The wrapped pointer, casted up to OrxonoxClass (this is needed because with just a T* pointer, WeakPtr couln't be used with forward declarations)
+            Destroyable* base_;    ///< The wrapped pointer, casted up to Destroyable (this is needed because with just a T* pointer, WeakPtr couln't be used with forward declarations)
             FunctorPtr callback_;   ///< This callback will be executed if the stored object is deleted
     };

code/branches/core6/src/libraries/util/ScopedSingletonManager.h

@@ -68 +68 @@
 namespace orxonox
 {
-    class OrxonoxClass;
+    class Destroyable;
 
     /**
@@ -166 +166 @@
         }
 
-        //! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
-        void destroy(OrxonoxClass*)
+        //! Destroys the singleton instance - overloaded for Destroyable, calls Destroyable::destroy()
+        void destroy(Destroyable*)
         {
             singletonPtr_->destroy();
@@ -246 +246 @@
         }
 
-        //! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
-        void destroy(OrxonoxClass*)
+        //! Destroys the singleton instance - overloaded for Destroyable, calls Destroyable::destroy()
+        void destroy(Destroyable*)
         {
             singletonPtr_->destroy();

code/branches/core6/src/orxonox/interfaces/Pickupable.cc

@@ -71 +71 @@
     /**
     @brief
-        A method that is called by OrxonoxClass::destroy() before the object is actually destroyed.
+        A method that is called by Destroyable::destroy() before the object is actually destroyed.
     */
     void Pickupable::preDestroy(void)
@@ -98 +98 @@
     {
         if(!this->isBeingDestroyed())
-            this->OrxonoxClass::destroy();
+            this->Destroyable::destroy();
         else
             orxout(internal_warning, context::pickups) << this->getIdentifier()->getName() << " may be unsafe. " << endl;

code/branches/core6/src/orxonox/interfaces/Pickupable.h

@@ -144 +144 @@
 
         protected:
-            virtual void preDestroy(void); //!< A method that is called by OrxonoxClass::destroy() before the object is actually destroyed.
+            virtual void preDestroy(void); //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
             virtual void destroyPickup(void); //!< Destroys a Pickupable.
             virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.