Changeset 9667 for code/trunk/src/libraries/core/class/Identifier.h

Timestamp:

Aug 25, 2013, 9:08:42 PM (12 years ago)

Author:

landauf

Message:

merged core6 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/class (copied) (copied from code/branches/core6/src/libraries/core/class)
• src/libraries/core/class/Identifier.h (modified) (16 diffs)

code/trunk/src/libraries/core/class/Identifier.h

@@ -56 +56 @@
     object->getIdentifier()->getName();                                         // returns "MyClass"
 
-    OrxonoxClass* other = object->getIdentifier()->fabricate(0);                // fabricates a new instance of MyClass
-
-
-    // iterate through all objects of type MyClass:
-    ObjectListBase* objects = object->getIdentifier()->getObjects();            // get a pointer to the object-list
-    int count;
-    for (Iterator<MyClass> it = objects.begin(); it != objects.end(); ++it)     // iterate through the objects
-        ++count;
-    orxout() << count << endl;                                                  // prints "2" because we created 2 instances of MyClass so far
+    Identifiable* other = object->getIdentifier()->fabricate(0);                // fabricates a new instance of MyClass
 
 
@@ -90 +82 @@
 
 #include "util/Output.h"
-#include "core/object/MetaObjectList.h"
 #include "core/object/ObjectList.h"
-#include "core/object/ObjectListBase.h"
+#include "core/object/Listable.h"
+#include "core/object/Context.h"
+#include "core/object/Destroyable.h"
+#include "core/object/WeakPtr.h"
 #include "IdentifierManager.h"
 #include "Super.h"
@@ -112 +106 @@
         @note You can't directly create an Identifier, it's just the base-class of ClassIdentifier<T>.
     */
-    class _CoreExport Identifier
-    {
-        friend class IdentifierManager;
-
+    class _CoreExport Identifier : public Destroyable
+    {
         public:
+            Identifier();
+            Identifier(const Identifier& identifier); // don't copy
+            virtual ~Identifier();
+
             /// Returns the name of the class the Identifier belongs to.
             inline const std::string& getName() const { return this->name_; }
             void setName(const std::string& name);
 
+            /// Returns the name of the class as it is returned by typeid(T).name()
+            virtual const std::string& getTypeidName() = 0;
+
             /// Returns the network ID to identify a class through the network.
             inline uint32_t getNetworkID() const { return this->networkID_; }
@@ -128 +127 @@
             ORX_FORCEINLINE unsigned int getClassID() const { return this->classID_; }
 
-            /// Returns the list of all existing objects of this class.
-            inline ObjectListBase* getObjects() const { return this->objects_; }
-
             /// Sets the Factory.
-            inline void addFactory(Factory* factory) { this->factory_ = factory; }
+            void setFactory(Factory* factory);
             /// Returns true if the Identifier has a Factory.
             inline bool hasFactory() const { return (this->factory_ != 0); }
 
-            OrxonoxClass* fabricate(BaseObject* creator);
+            Identifiable* fabricate(Context* context);
 
             /// Returns true if the class can be loaded through XML.
@@ -142 +138 @@
             /// Set the class to be loadable through XML or not.
             inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
+
+            /// Returns true if the Identifier was completely initialized.
+            inline bool isInitialized() const { return this->bInitialized_; }
+
+
+            /////////////////////////////
+            ////// Class Hierarchy //////
+            /////////////////////////////
+            Identifier& inheritsFrom(Identifier* directParent);
+
+            void initializeParents(const std::set<const Identifier*>& identifiers);
+            void initializeDirectParentsOfAbstractClass();
+            void finishInitialization();
 
             bool isA(const Identifier* identifier) const;
@@ -150 +159 @@
             bool isDirectParentOf(const Identifier* identifier) const;
 
-
-            /////////////////////////////
-            ////// Class Hierarchy //////
-            /////////////////////////////
             /// Returns the parents of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
@@ -220 +225 @@
 
         protected:
-            Identifier();
-            Identifier(const Identifier& identifier); // don't copy
-            virtual ~Identifier();
-
             virtual void createSuperFunctionCaller() const = 0;
 
-            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
-
-            /// Returns the children of the class the Identifier belongs to.
-            inline std::set<const Identifier*>& getChildrenIntern() const { return this->children_; }
-            /// Returns the direct children of the class the Identifier belongs to.
-            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
-
-            ObjectListBase* objects_;                                      //!< The list of all objects of this class
-
         private:
-            void initialize(std::set<const Identifier*>* parents);
-
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
-            mutable std::set<const Identifier*> children_;                 //!< The children of the class the Identifier belongs to
+            std::set<const Identifier*> children_;                         //!< The children of the class the Identifier belongs to
 
             std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
-            mutable std::set<const Identifier*> directChildren_;           //!< The direct children of the class the Identifier belongs to
-
-            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
-            bool bSetName_;                                                //!< True if the name is set
+            std::set<const Identifier*> directChildren_;                   //!< The direct children of the class the Identifier belongs to
+
+            bool bInitialized_;                                            //!< Is true if the Identifier was completely initialized
             bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
             std::string name_;                                             //!< The name of the class the Identifier belongs to
@@ -287 +276 @@
             static ClassIdentifier<T>* getIdentifier(const std::string& name);
 
-            bool initialiseObject(T* object, const std::string& className, bool bRootClass);
+            bool initializeObject(T* object);
 
             void setConfigValues(T* object, Configurable*) const;
@@ -295 +284 @@
             void addObjectToList(T* object, Identifiable*);
 
-            void updateConfigValues(bool updateChildren = true) const;
+            virtual void updateConfigValues(bool updateChildren = true) const;
+
+            virtual const std::string& getTypeidName()
+                { return this->typeidName_; }
 
         private:
-            static void initialiseIdentifier();
+            static void initializeIdentifier();
+
             ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
             ClassIdentifier()
             {
+                this->typeidName_ = typeid(T).name();
                 SuperFunctionInitialization<0, T>::initialize(this);
             }
@@ -309 +303 @@
             }
 
-            static ClassIdentifier<T>* classIdentifier_s;
+            void updateConfigValues(bool updateChildren, Listable*) const;
+            void updateConfigValues(bool updateChildren, Identifiable*) const;
+
+            std::string typeidName_;
+            static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
     };
 
     template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
+    WeakPtr<ClassIdentifier<T> > ClassIdentifier<T>::classIdentifier_s;
 
     /**
@@ -324 +322 @@
         // check if the Identifier already exists
         if (!ClassIdentifier<T>::classIdentifier_s)
-            ClassIdentifier<T>::initialiseIdentifier();
+            ClassIdentifier<T>::initializeIdentifier();
 
         return ClassIdentifier<T>::classIdentifier_s;
@@ -346 +344 @@
     */
     template <class T>
-    void ClassIdentifier<T>::initialiseIdentifier()
-    {
-        // Get the name of the class
-        std::string name = typeid(T).name();
-
-        // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
+    /*static */ void ClassIdentifier<T>::initializeIdentifier()
+    {
+        // create a new identifier anyway. Will be deleted if not used.
         ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
 
         // Get the entry from the map
-        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getIdentifierSingleton(name, proposal);
+        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getInstance().getGloballyUniqueIdentifier(proposal);
 
         if (ClassIdentifier<T>::classIdentifier_s == proposal)
-        {
-            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was not yet existing and got created." << endl;
-        }
+            orxout(verbose, context::identifier) << "Requested Identifier for " << proposal->getTypeidName() << " was not yet existing and got created." << endl;
         else
         {
-            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was already existing and got assigned." << endl;
+            orxout(verbose, context::identifier) << "Requested Identifier for " << proposal->getTypeidName() << " was already existing and got assigned." << endl;
+            delete proposal; // delete proposal (it is not used anymore)
         }
     }
@@ -370 +364 @@
         @brief Adds an object of the given type to the ObjectList.
         @param object The object to add
-        @param className The name of the class T
-        @param bRootClass True if this is a root class (i.e. it inherits directly from OrxonoxClass)
-    */
-    template <class T>
-    bool ClassIdentifier<T>::initialiseObject(T* object, const std::string& className, bool bRootClass)
-    {
-        if (bRootClass)
-            orxout(verbose, context::object_list) << "Register Root-Object: " << className << endl;
-        else
-            orxout(verbose, context::object_list) << "Register Object: " << className << endl;
+    */
+    template <class T>
+    bool ClassIdentifier<T>::initializeObject(T* object)
+    {
+        orxout(verbose, context::object_list) << "Register Object: " << this->getName() << endl;
 
         object->identifier_ = this;
-        if (IdentifierManager::isCreatingHierarchy())
+        if (IdentifierManager::getInstance().isCreatingHierarchy())
         {
-            if (bRootClass && !object->parents_)
-                object->parents_ = new std::set<const Identifier*>();
-
-            if (object->parents_)
-            {
-                this->initializeClassHierarchy(object->parents_, bRootClass);
-                object->parents_->insert(object->parents_->end(), this);
-            }
+            IdentifierManager::getInstance().createdObject(object);
 
             this->setConfigValues(object, object);
@@ -425 +407 @@
      */
     template <class T>
-    void ClassIdentifier<T>::addObjectToList(T* object, Listable*)
-    {
-        orxout(verbose, context::object_list) << "Added object to " << this->getName() << "-list." << endl;
-        object->metaList_->add(this->objects_, this->objects_->add(object));
+    void ClassIdentifier<T>::addObjectToList(T* object, Listable* listable)
+    {
+        if (listable->getContext())
+            listable->getContext()->addObject(object);
     }
 
@@ -442 +424 @@
     template <class T>
     void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
+    {
+        this->updateConfigValues(updateChildren, static_cast<T*>(NULL));
+    }
+
+    template <class T>
+    void ClassIdentifier<T>::updateConfigValues(bool updateChildren, Listable*) const
     {
         if (!this->hasConfigValues())
@@ -452 +440 @@
             for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
                 (*it)->updateConfigValues(false);
+    }
+
+    template <class T>
+    void ClassIdentifier<T>::updateConfigValues(bool updateChildren, Identifiable*) const
+    {
+        // no action
     }