Changeset 9565 for code/branches/core6/src/libraries/core/class/Identifiable.h

Timestamp:

Mar 24, 2013, 6:34:23 PM (11 years ago)

Author:

landauf

Message:

moved functions and attributes needed to identify the class from OrxonoxClass to Identifiable

File:

• code/branches/core6/src/libraries/core/class/Identifiable.h (copied) (copied from code/branches/core6/src/libraries/core/class/OrxonoxClass.h) (4 diffs)

code/branches/core6/src/libraries/core/class/Identifiable.h

@@ -28 +28 @@
 
 /**
-    @defgroup OrxonoxClass OrxonoxClass
-    @ingroup Class
-*/
+    @file
+    @ingroup Class Identifier
+    @brief Declaration of Identifiable, the base of all classes that should own an Identifier.
 
-/**
-    @file
-    @ingroup Class OrxonoxClass
-    @brief Declaration of OrxonoxClass, the base class of all objects and interfaces in Orxonox.
-
-    All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.
     It stores the Identifier and the MetaObjectList and has all needed functions to create and use the class-hierarchy.
 */
 
-#ifndef _OrxonoxClass_H__
-#define _OrxonoxClass_H__
+#ifndef _Identifiable_H__
+#define _Identifiable_H__
 
 #include "core/CorePrereqs.h"
@@ -48 +42 @@
 #include <set>
 #include <vector>
-#include "Super.h"
 
 namespace orxonox
 {
     /**
-        @brief The class all objects and interfaces of the game-logic (not the engine) are derived from.
-
-        The BaseObject and Interfaces are derived with @c virtual @c public @c OrxonoxClass from OrxonoxClass.
-        OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the
-        MetaObjectList, as well as to provide an interface for SmartPtr and WeakPtr.
+        @brief Identifiable is needed to create the class-hierarchy at startup and to store the Identifier and the MetaObjectList.
     */
-    class _CoreExport OrxonoxClass
+    class _CoreExport Identifiable
     {
         template <class T>
         friend class ClassIdentifier;
 
-        template <class T>
-        friend class SmartPtr;
-
-        friend class DestructionListener;
-
         public:
-            OrxonoxClass();
-            virtual ~OrxonoxClass();
+            Identifiable();
+            virtual ~Identifiable();
 
             void destroy();
             void unregisterObject();
-
-            /// Function to collect the SetConfigValue-macro calls.
-            void setConfigValues() {};
 
             /// Returns the Identifier of the object.
@@ -108 +89 @@
                 { return this->isDirectParentOf(*identifier); }
 
-            bool isA(const OrxonoxClass* object);
-            bool isExactlyA(const OrxonoxClass* object);
-            bool isChildOf(const OrxonoxClass* object);
-            bool isDirectChildOf(const OrxonoxClass* object);
-            bool isParentOf(const OrxonoxClass* object);
-            bool isDirectParentOf(const OrxonoxClass* object);
-
-            /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
-            inline unsigned int getReferenceCount() const
-                { return this->referenceCount_; }
+            bool isA(const Identifiable* object);
+            bool isExactlyA(const Identifiable* object);
+            bool isChildOf(const Identifiable* object);
+            bool isDirectChildOf(const Identifiable* object);
+            bool isParentOf(const Identifiable* object);
+            bool isDirectParentOf(const Identifiable* object);
 
             /**
@@ -141 +118 @@
             /// Const version of getDerivedPointer with template
             template <class T> ORX_FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
-            {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
-
-        protected:
-            /// This virtual function is called if destroy() is called and no SmartPtr points to this object. Used in some cases to create a new SmartPtr to prevent destruction.
-            virtual void preDestroy() {}
+            {   return const_cast<Identifiable*>(this)->getDerivedPointer<T>(classID);   }
 
         private:
-            /// Increments the reference counter (for smart pointers).
-            inline void incrementReferenceCount()
-                { ++this->referenceCount_; }
-            /// Decrements the reference counter (for smart pointers).
-            inline void decrementReferenceCount()
-            {
-                --this->referenceCount_;
-                if (this->referenceCount_ == 0 && this->requestedDestruction_)
-                    this->destroy();
-            }
-
-            /// Register a destruction listener (for example a weak pointer which points to this object).
-            inline void registerDestructionListener(DestructionListener* pointer)
-                { this->destructionListeners_.insert(pointer); }
-            /// Unegister a destruction listener (for example a weak pointer which pointed to this object before).
-            inline void unregisterDestructionListener(DestructionListener* pointer)
-                { this->destructionListeners_.erase(pointer); }
-
             Identifier* identifier_;                                //!< The Identifier of the object
             std::set<const Identifier*>* parents_;                  //!< List of all parents of the object
             MetaObjectList* metaList_;                              //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
-            int referenceCount_;                                    //!< Counts the references from smart pointers to this object
-            bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
-            std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)
 
             /// 'Fast map' that holds this-pointers of all derived types
             std::vector<std::pair<unsigned int, void*> > objectPointers_;
     };
-
-    /**
-        @brief This listener is used to inform weak pointers if an object of type OrxonoxClass gets destroyed.
-    */
-    class _CoreExport DestructionListener
-    {
-        friend class OrxonoxClass;
-
-        protected:
-            virtual ~DestructionListener() {}
-
-            inline void registerAsDestructionListener(OrxonoxClass* object)
-                { if (object) { object->registerDestructionListener(this); } }
-            inline void unregisterAsDestructionListener(OrxonoxClass* object)
-                { if (object) { object->unregisterDestructionListener(this); } }
-
-            virtual void objectDeleted() = 0;
-    };
-
 }
 
-#endif /* _OrxonoxClass_H__ */
+#endif /* _Identifiable_H__ */