Changeset 9564 for code/branches

Timestamp:

Mar 24, 2013, 6:08:42 PM (12 years ago)

Author:

landauf

Message:

moved static functions from Identifier.cc/h to IdentifierManager.cc/h (still static though)

Location:

code/branches/core6/src/libraries

Files:

• core/Core.cc (modified) (2 diffs)
• core/CoreIncludes.h (modified) (4 diffs)
• core/Template.cc (modified) (1 diff)
• core/XMLPort.cc (modified) (1 diff)
• core/class/CMakeLists.txt (modified) (1 diff)
• core/class/Identifier.cc (modified) (7 diffs)
• core/class/Identifier.h (modified) (9 diffs)
• core/class/IdentifierManager.cc (copied) (copied from code/branches/core6/src/libraries/core/class/Identifier.cc) (13 diffs)
• core/class/IdentifierManager.h (copied) (copied from code/branches/core6/src/libraries/core/class/Identifier.h) (4 diffs)
• core/config/ConfigValueContainer.h (modified) (1 diff)
• network/packet/ClassID.cc (modified) (2 diffs)
• network/synchronisable/Synchronisable.cc (modified) (1 diff)

code/branches/core6/src/libraries/core/Core.cc

@@ -198 +198 @@
         // creates the class hierarchy for all classes with factories
         orxout(internal_info) << "creating class hierarchy" << endl;
-        Identifier::createClassHierarchy();
+        IdentifierManager::createClassHierarchy();
 
         // Load OGRE excluding the renderer and the render window
@@ -248 +248 @@
         safeObjectDelete(&configFileManager_);
         ConsoleCommand::destroyAll();
-        Identifier::destroyAllIdentifiers();
+        IdentifierManager::destroyAllIdentifiers();
         safeObjectDelete(&signalHandler_);
         safeObjectDelete(&dynLibManager_);

code/branches/core6/src/libraries/core/CoreIncludes.h

@@ -79 +79 @@
 
 #include "util/Output.h"
-#include "class/Identifier.h"
+#include "class/IdentifierManager.h"
 #include "object/ClassFactory.h"
 #include "object/ObjectList.h"
@@ -142 +142 @@
     inline Identifier* ClassByString(const std::string& name)
     {
-        return Identifier::getIdentifierByString(name);
+        return IdentifierManager::getIdentifierByString(name);
     }
 
@@ -151 +151 @@
     inline Identifier* ClassByLowercaseString(const std::string& name)
     {
-        return Identifier::getIdentifierByLowercaseString(name);
+        return IdentifierManager::getIdentifierByLowercaseString(name);
     }
 
@@ -160 +160 @@
     inline Identifier* ClassByID(uint32_t id)
     {
-        return Identifier::getIdentifierByID(id);
+        return IdentifierManager::getIdentifierByID(id);
     }
 

code/branches/core6/src/libraries/core/Template.cc

@@ -150 +150 @@
 
         // check if the template is applied on an object of the right type
-        Identifier* identifier = Identifier::getIdentifierByString(this->getXMLElement().Value());
+        Identifier* identifier = IdentifierManager::getIdentifierByString(this->getXMLElement().Value());
         if (!object->getIdentifier()->isA(identifier))
             orxout(internal_warning, context::templates) << "Template was defined for " << identifier->getName() << " but the object is of type " << object->getIdentifier()->getName() << endl;

code/branches/core6/src/libraries/core/XMLPort.cc

@@ -59 +59 @@
                 for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
                 {
-                    Identifier* identifier = Identifier::getIdentifierByString(child->Value());
+                    Identifier* identifier = IdentifierManager::getIdentifierByString(child->Value());
                     if (!identifier)
                     {

code/branches/core6/src/libraries/core/class/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(CORE_SRC_FILES
   Identifier.cc
+  IdentifierManager.cc
   OrxonoxClass.cc
 )

code/branches/core6/src/libraries/core/class/Identifier.cc

@@ -46 +46 @@
     // ###       Identifier        ###
     // ###############################
-    int Identifier::hierarchyCreatingCounter_s = 0;
-    unsigned int Identifier::classIDCounter_s = 0;
-
     /**
         @brief Constructor: No factory, no object created, new ObjectList and a unique networkID.
     */
     Identifier::Identifier()
-        : classID_(classIDCounter_s++)
+        : classID_(IdentifierManager::classIDCounter_s++)
     {
         this->objects_ = new ObjectListBase(this);
@@ -87 +84 @@
 
     /**
-        @brief Returns the identifier map with the names as received by typeid(). This is only used internally.
-    */
-    std::map<std::string, Identifier*>& Identifier::getTypeIDIdentifierMap()
-    {
-        static std::map<std::string, Identifier*> identifiers;    //!< The map to store all Identifiers.
-        return identifiers;
-    }
-
-    /**
-        @brief Returns an identifier by name and adds it if not available
-        @param name The name of the identifier as typeid().name() suggests
-        @param proposal A pointer to a newly created identifier for the case of non existence in the map
-        @return The identifier (unique instance)
-    */
-    Identifier* Identifier::getIdentifierSingleton(const std::string& name, Identifier* proposal)
-    {
-        std::map<std::string, Identifier*>::const_iterator it = getTypeIDIdentifierMap().find(name);
-
-        if (it != getTypeIDIdentifierMap().end())
-        {
-            // There is already an entry: return it and delete the proposal
-            delete proposal;
-            return it->second;
-        }
-        else
-        {
-            // There is no entry: put the proposal into the map and return it
-            getTypeIDIdentifierMap()[name] = proposal;
-            return proposal;
-        }
-    }
-
-    /**
         @brief Registers a class, which means that the name and the parents get stored.
         @param parents A list, containing the Identifiers of all parents of the class
@@ -127 +91 @@
     {
         // Check if at least one object of the given type was created
-        if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
+        if (!this->bCreatedOneObject_ && IdentifierManager::isCreatingHierarchy())
         {
             // If no: We have to store the information and initialize the Identifier
@@ -187 +151 @@
 
     /**
-        @brief Creates the class-hierarchy by creating and destroying one object of each type.
-    */
-    void Identifier::createClassHierarchy()
-    {
-        orxout(internal_status) << "Create class-hierarchy" << endl;
-        Identifier::startCreatingHierarchy();
-        for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMap().begin(); it != Identifier::getStringIdentifierMap().end(); ++it)
-        {
-            // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
-            if (it->second->hasFactory())
-            {
-                OrxonoxClass* temp = it->second->fabricate(0);
-                temp->destroy();
-            }
-        }
-        Identifier::stopCreatingHierarchy();
-        orxout(internal_status) << "Finished class-hierarchy creation" << endl;
-    }
-
-    /**
-        @brief Destroys all Identifiers. Called when exiting the program.
-    */
-    void Identifier::destroyAllIdentifiers()
-    {
-        for (std::map<std::string, Identifier*>::iterator it = Identifier::getTypeIDIdentifierMap().begin(); it != Identifier::getTypeIDIdentifierMap().end(); ++it)
-            delete (it->second);
-    }
-
-    /**
         @brief Sets the name of the class.
     */
@@ -224 +159 @@
             this->name_ = name;
             this->bSetName_ = true;
-            Identifier::getStringIdentifierMapIntern()[name] = this;
-            Identifier::getLowercaseStringIdentifierMapIntern()[getLowercase(name)] = this;
-            Identifier::getIDIdentifierMapIntern()[this->networkID_] = this;
+            IdentifierManager::getStringIdentifierMapIntern()[name] = this;
+            IdentifierManager::getLowercaseStringIdentifierMapIntern()[getLowercase(name)] = this;
+            IdentifierManager::getIDIdentifierMapIntern()[this->networkID_] = this;
         }
     }
@@ -256 +191 @@
     {
 //        Identifier::getIDIdentifierMapIntern().erase(this->networkID_);
-        Identifier::getIDIdentifierMapIntern()[id] = this;
+        IdentifierManager::getIDIdentifierMapIntern()[id] = this;
         this->networkID_ = id;
     }
@@ -312 +247 @@
     {
         return (this->directChildren_.find(identifier) != this->directChildren_.end());
-    }
-
-    /**
-        @brief Returns the map that stores all Identifiers with their names.
-        @return The map
-    */
-    std::map<std::string, Identifier*>& Identifier::getStringIdentifierMapIntern()
-    {
-        static std::map<std::string, Identifier*> identifierMap;
-        return identifierMap;
-    }
-
-    /**
-        @brief Returns the map that stores all Identifiers with their names in lowercase.
-        @return The map
-    */
-    std::map<std::string, Identifier*>& Identifier::getLowercaseStringIdentifierMapIntern()
-    {
-        static std::map<std::string, Identifier*> lowercaseIdentifierMap;
-        return lowercaseIdentifierMap;
-    }
-
-    /**
-        @brief Returns the map that stores all Identifiers with their network IDs.
-        @return The map
-    */
-    std::map<uint32_t, Identifier*>& Identifier::getIDIdentifierMapIntern()
-    {
-        static std::map<uint32_t, Identifier*> identifierMap;
-        return identifierMap;
-    }
-
-    /**
-        @brief Returns the Identifier with a given name.
-        @param name The name of the wanted Identifier
-        @return The Identifier
-    */
-    Identifier* Identifier::getIdentifierByString(const std::string& name)
-    {
-        std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapIntern().find(name);
-        if (it != Identifier::getStringIdentifierMapIntern().end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    /**
-        @brief Returns the Identifier with a given name in lowercase.
-        @param name The name of the wanted Identifier
-        @return The Identifier
-    */
-    Identifier* Identifier::getIdentifierByLowercaseString(const std::string& name)
-    {
-        std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapIntern().find(name);
-        if (it != Identifier::getLowercaseStringIdentifierMapIntern().end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    /**
-        @brief Returns the Identifier with a given network ID.
-        @param id The network ID of the wanted Identifier
-        @return The Identifier
-    */
-    Identifier* Identifier::getIdentifierByID(const uint32_t id)
-    {
-        std::map<uint32_t, Identifier*>::const_iterator it = Identifier::getIDIdentifierMapIntern().find(id);
-        if (it != Identifier::getIDIdentifierMapIntern().end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    /**
-        @brief Cleans the NetworkID map (needed on clients for correct initialization)
-    */
-    void Identifier::clearNetworkIDs()
-    {
-        Identifier::getIDIdentifierMapIntern().clear();
     }
 

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

@@ -93 +93 @@
 #include "core/object/ObjectList.h"
 #include "core/object/ObjectListBase.h"
+#include "IdentifierManager.h"
 #include "Super.h"
 
@@ -113 +114 @@
     class _CoreExport Identifier
     {
+        friend class IdentifierManager;
+
         public:
             /// Returns the name of the class the Identifier belongs to.
@@ -151 +154 @@
             ////// Class Hierarchy //////
             /////////////////////////////
-            static void createClassHierarchy();
-
-            /// Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents.
-            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
-
             /// Returns the parents of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
@@ -183 +181 @@
             /// Returns the end-iterator of the direct-children-list.
             inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
-
-
-            //////////////////////////
-            ///// Identifier Map /////
-            //////////////////////////
-            static void destroyAllIdentifiers();
-
-            static Identifier* getIdentifierByString(const std::string& name);
-            static Identifier* getIdentifierByLowercaseString(const std::string& name);
-            static Identifier* getIdentifierByID(uint32_t id);
-
-            static void clearNetworkIDs();
-
-            /// Returns the map that stores all Identifiers with their names.
-            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
-            /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names.
-            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
-            /// Returns a const_iterator to the end of the map that stores all Identifiers with their names.
-            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
-
-            /// Returns the map that stores all Identifiers with their names in lowercase.
-            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
-            /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase.
-            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
-            /// Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase.
-            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
-
-            /// Returns the map that stores all Identifiers with their IDs.
-            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
-            /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs.
-            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
-            /// Returns a const_iterator to the end of the map that stores all Identifiers with their IDs.
-            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
 
 
@@ -259 +224 @@
             virtual ~Identifier();
 
-            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
             virtual void createSuperFunctionCaller() const = 0;
 
             void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
-
-            /// Returns the map that stores all Identifiers with their names.
-            static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
-            /// Returns the map that stores all Identifiers with their names in lowercase.
-            static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
-            /// Returns the map that stores all Identifiers with their network IDs.
-            static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
 
             /// Returns the children of the class the Identifier belongs to.
@@ -279 +236 @@
 
         private:
-            /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
-            inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
-            /// Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
-            inline static void stopCreatingHierarchy()  { hierarchyCreatingCounter_s--; }
-
-            static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
-
             void initialize(std::set<const Identifier*>* parents);
 
@@ -299 +249 @@
             std::string name_;                                             //!< The name of the class the Identifier belongs to
             Factory* factory_;                                             //!< The Factory, able to create new objects of the given class (if available)
-            static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
             uint32_t networkID_;                                           //!< The network ID to identify a class through the network
             const unsigned int classID_;                                   //!< Uniquely identifies a class (might not be the same as the networkID_)
-            static unsigned int classIDCounter_s;                          //!< Static counter for the unique classIDs
 
             bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
@@ -401 +349 @@
 
         // Get the entry from the map
-        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
+        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getIdentifierSingleton(name, proposal);
 
         if (ClassIdentifier<T>::classIdentifier_s == proposal)
@@ -428 +376 @@
 
         object->identifier_ = this;
-        if (Identifier::isCreatingHierarchy())
+        if (IdentifierManager::isCreatingHierarchy())
         {
             if (bRootClass && !object->parents_)

code/branches/core6/src/libraries/core/class/IdentifierManager.cc

@@ -32 +32 @@
 */
 
-#include "Identifier.h"
+#include "IdentifierManager.h"
 
 #include <ostream>
@@ -43 +43 @@
 namespace orxonox
 {
-    // ###############################
-    // ###       Identifier        ###
-    // ###############################
-    int Identifier::hierarchyCreatingCounter_s = 0;
-    unsigned int Identifier::classIDCounter_s = 0;
-
-    /**
-        @brief Constructor: No factory, no object created, new ObjectList and a unique networkID.
-    */
-    Identifier::Identifier()
-        : classID_(classIDCounter_s++)
-    {
-        this->objects_ = new ObjectListBase(this);
-
-        this->bCreatedOneObject_ = false;
-        this->bSetName_ = false;
-        this->factory_ = 0;
-        this->bLoadable_ = false;
-
-        this->bHasConfigValues_ = false;
-
-        // Default network ID is the class ID
-        this->networkID_ = this->classID_;
-    }
-
-    /**
-        @brief Destructor: Deletes the list containing the children.
-    */
-    Identifier::~Identifier()
-    {
-        delete this->objects_;
-
-        if (this->factory_)
-            delete this->factory_;
-
-        for (std::map<std::string, ConfigValueContainer*>::iterator it = this->configValues_.begin(); it != this->configValues_.end(); ++it)
-            delete (it->second);
-        for (std::map<std::string, XMLPortParamContainer*>::iterator it = this->xmlportParamContainers_.begin(); it != this->xmlportParamContainers_.end(); ++it)
-            delete (it->second);
-        for (std::map<std::string, XMLPortObjectContainer*>::iterator it = this->xmlportObjectContainers_.begin(); it != this->xmlportObjectContainers_.end(); ++it)
-            delete (it->second);
-    }
+    int IdentifierManager::hierarchyCreatingCounter_s = 0;
+    unsigned int IdentifierManager::classIDCounter_s = 0;
 
     /**
         @brief Returns the identifier map with the names as received by typeid(). This is only used internally.
     */
-    std::map<std::string, Identifier*>& Identifier::getTypeIDIdentifierMap()
+    std::map<std::string, Identifier*>& IdentifierManager::getTypeIDIdentifierMap()
     {
         static std::map<std::string, Identifier*> identifiers;    //!< The map to store all Identifiers.
@@ -101 +61 @@
         @return The identifier (unique instance)
     */
-    Identifier* Identifier::getIdentifierSingleton(const std::string& name, Identifier* proposal)
+    Identifier* IdentifierManager::getIdentifierSingleton(const std::string& name, Identifier* proposal)
     {
         std::map<std::string, Identifier*>::const_iterator it = getTypeIDIdentifierMap().find(name);
@@ -120 +80 @@
 
     /**
-        @brief Registers a class, which means that the name and the parents get stored.
-        @param parents A list, containing the Identifiers of all parents of the class
-        @param bRootClass True if the class is either an Interface or the BaseObject itself
-    */
-    void Identifier::initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass)
-    {
-        // Check if at least one object of the given type was created
-        if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
-        {
-            // If no: We have to store the information and initialize the Identifier
-            orxout(verbose, context::identifier) << "Register Class in ClassIdentifier<" << this->getName() << ">-Singleton -> Initialize Singleton." << endl;
-            if (bRootClass)
-                this->initialize(0); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
-            else
-                this->initialize(parents);
-        }
-    }
-
-    /**
-        @brief Initializes the Identifier with a list containing all parents of the class the Identifier belongs to.
-        @param parents A list containing all parents
-    */
-    void Identifier::initialize(std::set<const Identifier*>* parents)
-    {
-        orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << this->name_ << ">-Singleton." << endl;
-        this->bCreatedOneObject_ = true;
-
-        if (parents)
-        {
-            this->parents_ = (*parents);
-            this->directParents_ = (*parents);
-
-            // Iterate through all parents
-            for (std::set<const Identifier*>::iterator it = parents->begin(); it != parents->end(); ++it)
-            {
-                // Tell the parent we're one of it's children
-                (*it)->children_.insert((*it)->children_.end(), this);
-
-                // Erase all parents of our parent from our direct-parent-list
-                for (std::set<const Identifier*>::const_iterator it1 = (*it)->getParents().begin(); it1 != (*it)->getParents().end(); ++it1)
-                {
-                    // Search for the parent's parent in our direct-parent-list
-                    for (std::set<const Identifier*>::iterator it2 = this->directParents_.begin(); it2 != this->directParents_.end(); ++it2)
-                    {
-                        if ((*it1) == (*it2))
-                        {
-                            // We've found a non-direct parent in our list: Erase it
-                            this->directParents_.erase(it2);
-                            break;
-                        }
-                    }
-                }
-            }
-
-            // Now iterate through all direct parents
-            for (std::set<const Identifier*>::iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-            {
-                // Tell the parent we're one of it's direct children
-                (*it)->directChildren_.insert((*it)->directChildren_.end(), this);
-
-                // Create the super-function dependencies
-                (*it)->createSuperFunctionCaller();
-            }
-        }
-    }
-
-    /**
         @brief Creates the class-hierarchy by creating and destroying one object of each type.
     */
-    void Identifier::createClassHierarchy()
+    void IdentifierManager::createClassHierarchy()
     {
         orxout(internal_status) << "Create class-hierarchy" << endl;
-        Identifier::startCreatingHierarchy();
-        for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMap().begin(); it != Identifier::getStringIdentifierMap().end(); ++it)
+        IdentifierManager::startCreatingHierarchy();
+        for (std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getStringIdentifierMap().begin(); it != IdentifierManager::getStringIdentifierMap().end(); ++it)
         {
             // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
@@ -202 +95 @@
             }
         }
-        Identifier::stopCreatingHierarchy();
+        IdentifierManager::stopCreatingHierarchy();
         orxout(internal_status) << "Finished class-hierarchy creation" << endl;
     }
@@ -209 +102 @@
         @brief Destroys all Identifiers. Called when exiting the program.
     */
-    void Identifier::destroyAllIdentifiers()
+    void IdentifierManager::destroyAllIdentifiers()
     {
-        for (std::map<std::string, Identifier*>::iterator it = Identifier::getTypeIDIdentifierMap().begin(); it != Identifier::getTypeIDIdentifierMap().end(); ++it)
+        for (std::map<std::string, Identifier*>::iterator it = IdentifierManager::getTypeIDIdentifierMap().begin(); it != IdentifierManager::getTypeIDIdentifierMap().end(); ++it)
             delete (it->second);
-    }
-
-    /**
-        @brief Sets the name of the class.
-    */
-    void Identifier::setName(const std::string& name)
-    {
-        if (!this->bSetName_)
-        {
-            this->name_ = name;
-            this->bSetName_ = true;
-            Identifier::getStringIdentifierMapIntern()[name] = this;
-            Identifier::getLowercaseStringIdentifierMapIntern()[getLowercase(name)] = this;
-            Identifier::getIDIdentifierMapIntern()[this->networkID_] = this;
-        }
-    }
-
-    /**
-        @brief Creates an object of the type the Identifier belongs to.
-        @return The new object
-    */
-    OrxonoxClass* Identifier::fabricate(BaseObject* creator)
-    {
-        if (this->factory_)
-        {
-            return this->factory_->fabricate(creator);
-        }
-        else
-        {
-            orxout(user_error) << "An error occurred in Identifier.cc:" << endl;
-            orxout(user_error) << "Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << endl;
-            orxout(user_error) << "Aborting..." << endl;
-            abort();
-            return 0;
-        }
-    }
-
-    /**
-        @brief Sets the network ID to a new value and changes the entry in the ID-Identifier-map.
-    */
-    void Identifier::setNetworkID(uint32_t id)
-    {
-//        Identifier::getIDIdentifierMapIntern().erase(this->networkID_);
-        Identifier::getIDIdentifierMapIntern()[id] = this;
-        this->networkID_ = id;
-    }
-
-    /**
-        @brief Returns true, if the Identifier is at least of the given type.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isA(const Identifier* identifier) const
-    {
-        return (identifier == this || (this->parents_.find(identifier) != this->parents_.end()));
-    }
-
-    /**
-        @brief Returns true, if the Identifier is exactly of the given type.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isExactlyA(const Identifier* identifier) const
-    {
-        return (identifier == this);
-    }
-
-    /**
-        @brief Returns true, if the assigned identifier is a child of the given identifier.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isChildOf(const Identifier* identifier) const
-    {
-        return (this->parents_.find(identifier) != this->parents_.end());
-    }
-
-    /**
-        @brief Returns true, if the assigned identifier is a direct child of the given identifier.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isDirectChildOf(const Identifier* identifier) const
-    {
-        return (this->directParents_.find(identifier) != this->directParents_.end());
-    }
-
-    /**
-        @brief Returns true, if the assigned identifier is a parent of the given identifier.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isParentOf(const Identifier* identifier) const
-    {
-        return (this->children_.find(identifier) != this->children_.end());
-    }
-
-    /**
-        @brief Returns true, if the assigned identifier is a direct parent of the given identifier.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isDirectParentOf(const Identifier* identifier) const
-    {
-        return (this->directChildren_.find(identifier) != this->directChildren_.end());
     }
 
@@ -318 +112 @@
         @return The map
     */
-    std::map<std::string, Identifier*>& Identifier::getStringIdentifierMapIntern()
+    std::map<std::string, Identifier*>& IdentifierManager::getStringIdentifierMapIntern()
     {
         static std::map<std::string, Identifier*> identifierMap;
@@ -328 +122 @@
         @return The map
     */
-    std::map<std::string, Identifier*>& Identifier::getLowercaseStringIdentifierMapIntern()
+    std::map<std::string, Identifier*>& IdentifierManager::getLowercaseStringIdentifierMapIntern()
     {
         static std::map<std::string, Identifier*> lowercaseIdentifierMap;
@@ -338 +132 @@
         @return The map
     */
-    std::map<uint32_t, Identifier*>& Identifier::getIDIdentifierMapIntern()
+    std::map<uint32_t, Identifier*>& IdentifierManager::getIDIdentifierMapIntern()
     {
         static std::map<uint32_t, Identifier*> identifierMap;
@@ -349 +143 @@
         @return The Identifier
     */
-    Identifier* Identifier::getIdentifierByString(const std::string& name)
+    Identifier* IdentifierManager::getIdentifierByString(const std::string& name)
     {
-        std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapIntern().find(name);
-        if (it != Identifier::getStringIdentifierMapIntern().end())
+        std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getStringIdentifierMapIntern().find(name);
+        if (it != IdentifierManager::getStringIdentifierMapIntern().end())
             return it->second;
         else
@@ -363 +157 @@
         @return The Identifier
     */
-    Identifier* Identifier::getIdentifierByLowercaseString(const std::string& name)
+    Identifier* IdentifierManager::getIdentifierByLowercaseString(const std::string& name)
     {
-        std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapIntern().find(name);
-        if (it != Identifier::getLowercaseStringIdentifierMapIntern().end())
+        std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getLowercaseStringIdentifierMapIntern().find(name);
+        if (it != IdentifierManager::getLowercaseStringIdentifierMapIntern().end())
             return it->second;
         else
@@ -377 +171 @@
         @return The Identifier
     */
-    Identifier* Identifier::getIdentifierByID(const uint32_t id)
+    Identifier* IdentifierManager::getIdentifierByID(const uint32_t id)
     {
-        std::map<uint32_t, Identifier*>::const_iterator it = Identifier::getIDIdentifierMapIntern().find(id);
-        if (it != Identifier::getIDIdentifierMapIntern().end())
+        std::map<uint32_t, Identifier*>::const_iterator it = IdentifierManager::getIDIdentifierMapIntern().find(id);
+        if (it != IdentifierManager::getIDIdentifierMapIntern().end())
             return it->second;
         else
@@ -389 +183 @@
         @brief Cleans the NetworkID map (needed on clients for correct initialization)
     */
-    void Identifier::clearNetworkIDs()
+    void IdentifierManager::clearNetworkIDs()
     {
-        Identifier::getIDIdentifierMapIntern().clear();
-    }
-
-    /**
-        @brief Adds the ConfigValueContainer of a variable, given by the string of its name.
-        @param varname The name of the variablee
-        @param container The container
-    */
-    void Identifier::addConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
-    {
-        std::map<std::string, ConfigValueContainer*>::const_iterator it = this->configValues_.find(varname);
-        if (it != this->configValues_.end())
-        {
-            orxout(internal_warning) << "Overwriting config-value with name " << varname << " in class " << this->getName() << '.' << endl;
-            delete (it->second);
-        }
-
-        this->bHasConfigValues_ = true;
-        this->configValues_[varname] = container;
-    }
-
-    /**
-        @brief Returns the ConfigValueContainer of a variable, given by the string of its name.
-        @param varname The name of the variable
-        @return The ConfigValueContainer
-    */
-    ConfigValueContainer* Identifier::getConfigValueContainer(const std::string& varname)
-    {
-        std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_.find(varname);
-        if (it != configValues_.end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    /**
-        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
-        @param paramname The name of the parameter
-        @return The container
-    */
-    XMLPortParamContainer* Identifier::getXMLPortParamContainer(const std::string& paramname)
-    {
-        std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
-        if (it != this->xmlportParamContainers_.end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    /**
-        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
-        @param paramname The name of the parameter
-        @param container The container
-    */
-    void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
-    {
-        std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
-        if (it != this->xmlportParamContainers_.end())
-        {
-            orxout(internal_warning) << "Overwriting XMLPortParamContainer in class " << this->getName() << '.' << endl;
-            delete (it->second);
-        }
-
-        this->xmlportParamContainers_[paramname] = container;
-    }
-
-    /**
-        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
-        @param sectionname The name of the section that contains the attachable objects
-        @return The container
-    */
-    XMLPortObjectContainer* Identifier::getXMLPortObjectContainer(const std::string& sectionname)
-    {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
-        if (it != this->xmlportObjectContainers_.end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    /**
-        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
-        @param sectionname The name of the section that contains the attachable objects
-        @param container The container
-    */
-    void Identifier::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
-    {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
-        if (it != this->xmlportObjectContainers_.end())
-        {
-            orxout(internal_warning) << "Overwriting XMLPortObjectContainer in class " << this->getName() << '.' << endl;
-            delete (it->second);
-        }
-
-        this->xmlportObjectContainers_[sectionname] = container;
-    }
-
-    /**
-        @brief Lists the names of all Identifiers in a std::set<const Identifier*>.
-        @param out The outstream
-        @param list The list (or set) of Identifiers
-        @return The outstream
-    */
-    std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list)
-    {
-        for (std::set<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            if (it != list.begin())
-                out << ' ';
-            out << (*it)->getName();
-        }
-
-        return out;
+        IdentifierManager::getIDIdentifierMapIntern().clear();
     }
 }

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

@@ -28 +28 @@
 
 /**
-    @defgroup Identifier Identifier
-    @ingroup Class
+    @file
+    @ingroup Class Identifier
 */
 
-/**
-    @file
-    @ingroup Class Identifier
-    @brief Declaration of Identifier, definition of ClassIdentifier<T>; used to identify the class of an object.
-
-    @anchor IdentifierExample
-
-    An Identifier "identifies" the class of an object. It contains different information about
-    the class: Its name and ID, a list of all instances of this class, a factory to create new
-    instances of this class, and more.
-
-    It also contains information about the inheritance of this class: It stores a list of the
-    Identifiers of all parent-classes as well as a list of all child-classes. These relationships
-    can be tested using functions like @c isA(), @c isChildOf(), @c isParentOf(), and more.
-
-    Every Identifier is in fact a ClassIdentifier<T> (where T is the class that is identified
-    by the Identifier), Identifier is just the common base-class.
-
-    Example:
-    @code
-    MyClass* object = new MyClass();                                            // create an instance of MyClass
-
-    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
-
-
-    // test the class hierarchy
-    object->getIdentifier()->isA(Class(MyClass));                               // returns true
-    object->isA(Class(MyClass));                                                // returns true (short version)
-
-    object->isA(Class(BaseClass));                                              // returns true if MyClass is a child of BaseClass
-
-    Class(ChildClass)->isChildOf(object->getIdentifier());                      // returns true if ChildClass is a child of MyClass
-    @endcode
-*/
-
-#ifndef _Identifier_H__
-#define _Identifier_H__
+#ifndef _IdentifierManager_H__
+#define _IdentifierManager_H__
 
 #include "core/CorePrereqs.h"
 
-#include <cassert>
 #include <map>
-#include <set>
 #include <string>
-#include <typeinfo>
-#include <loki/TypeTraits.h>
-
-#include "util/Output.h"
-#include "core/object/MetaObjectList.h"
-#include "core/object/ObjectList.h"
-#include "core/object/ObjectListBase.h"
-#include "Super.h"
 
 namespace orxonox
 {
-    // ###############################
-    // ###       Identifier        ###
-    // ###############################
-    /**
-        @brief The Identifier is used to identify the class of an object and to store information about the class.
+    class _CoreExport IdentifierManager
+    {
+        friend class Identifier;
+        template <class T> friend class ClassIdentifier;
 
-        Each Identifier stores information about one class. The Identifier can then be used to identify
-        this class. On the other hand it's also possible to get the corresponding Identifier of a class,
-        for example by using the macro Class().
-
-        @see See @ref IdentifierExample "Identifier.h" for more information and some examples.
-
-        @note You can't directly create an Identifier, it's just the base-class of ClassIdentifier<T>.
-    */
-    class _CoreExport Identifier
-    {
         public:
-            /// 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 network ID to identify a class through the network.
-            inline uint32_t getNetworkID() const { return this->networkID_; }
-            void setNetworkID(uint32_t id);
-
-            /// Returns the unique ID of the class.
-            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; }
-            /// Returns true if the Identifier has a Factory.
-            inline bool hasFactory() const { return (this->factory_ != 0); }
-
-            OrxonoxClass* fabricate(BaseObject* creator);
-
-            /// Returns true if the class can be loaded through XML.
-            inline bool isLoadable() const { return this->bLoadable_; }
-            /// Set the class to be loadable through XML or not.
-            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
-
-            bool isA(const Identifier* identifier) const;
-            bool isExactlyA(const Identifier* identifier) const;
-            bool isChildOf(const Identifier* identifier) const;
-            bool isDirectChildOf(const Identifier* identifier) const;
-            bool isParentOf(const Identifier* identifier) const;
-            bool isDirectParentOf(const Identifier* identifier) const;
-
-
             /////////////////////////////
             ////// Class Hierarchy //////
@@ -154 +54 @@
 
             /// Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents.
-            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
-
-            /// Returns the parents of the class the Identifier belongs to.
-            inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
-            /// Returns the begin-iterator of the parents-list.
-            inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
-            /// Returns the end-iterator of the parents-list.
-            inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
-
-            /// Returns the children of the class the Identifier belongs to.
-            inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
-            /// Returns the begin-iterator of the children-list.
-            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
-            /// Returns the end-iterator of the children-list.
-            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
-
-            /// Returns the direct parents of the class the Identifier belongs to.
-            inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
-            /// Returns the begin-iterator of the direct-parents-list.
-            inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
-            /// Returns the end-iterator of the direct-parents-list.
-            inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
-
-            /// Returns the direct children the class the Identifier belongs to.
-            inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
-            /// Returns the begin-iterator of the direct-children-list.
-            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
-            /// Returns the end-iterator of the direct-children-list.
-            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
+            inline static bool isCreatingHierarchy()
+                { return (hierarchyCreatingCounter_s > 0); }
 
 
@@ -197 +70 @@
 
             /// Returns the map that stores all Identifiers with their names.
-            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
+            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap()
+                { return IdentifierManager::getStringIdentifierMapIntern(); }
             /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names.
-            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin()
+                { return IdentifierManager::getStringIdentifierMap().begin(); }
             /// Returns a const_iterator to the end of the map that stores all Identifiers with their names.
-            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd()
+                { return IdentifierManager::getStringIdentifierMap().end(); }
 
             /// Returns the map that stores all Identifiers with their names in lowercase.
-            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
+            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap()
+                { return IdentifierManager::getLowercaseStringIdentifierMapIntern(); }
             /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase.
-            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin()
+                { return IdentifierManager::getLowercaseStringIdentifierMap().begin(); }
             /// Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase.
-            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd()
+                { return IdentifierManager::getLowercaseStringIdentifierMap().end(); }
 
             /// Returns the map that stores all Identifiers with their IDs.
-            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
+            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap()
+                { return IdentifierManager::getIDIdentifierMapIntern(); }
             /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs.
-            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
+            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin()
+                { return IdentifierManager::getIDIdentifierMap().begin(); }
             /// Returns a const_iterator to the end of the map that stores all Identifiers with their IDs.
-            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
-
-
-            /////////////////////////
-            ///// Config Values /////
-            /////////////////////////
-            virtual void updateConfigValues(bool updateChildren = true) const = 0;
-
-            /// Returns true if this class has at least one config value.
-            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
-
-            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
-            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
-
-
-            ///////////////////
-            ///// XMLPort /////
-            ///////////////////
-            /// Returns the map that stores all XMLPort params.
-            inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
-            /// Returns a const_iterator to the beginning of the map that stores all XMLPort params.
-            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
-            /// Returns a const_iterator to the end of the map that stores all XMLPort params.
-            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
-
-            /// Returns the map that stores all XMLPort objects.
-            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
-            /// Returns a const_iterator to the beginning of the map that stores all XMLPort objects.
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
-            /// Returns a const_iterator to the end of the map that stores all XMLPort objects.
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
-
-            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
-            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
-
-            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
-            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
-
+            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd()
+                { return IdentifierManager::getIDIdentifierMap().end(); }
 
         protected:
-            Identifier();
-            Identifier(const Identifier& identifier); // don't copy
-            virtual ~Identifier();
-
             static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
-            virtual void createSuperFunctionCaller() const = 0;
-
-            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
 
             /// Returns the map that stores all Identifiers with their names.
@@ -271 +109 @@
             static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
 
-            /// 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:
             /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
-            inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
+            inline static void startCreatingHierarchy()
+                { hierarchyCreatingCounter_s++; }
             /// Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
-            inline static void stopCreatingHierarchy()  { hierarchyCreatingCounter_s--; }
+            inline static void stopCreatingHierarchy()
+                { hierarchyCreatingCounter_s--; }
 
             static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
 
-            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*> 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
-            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
-            Factory* factory_;                                             //!< The Factory, able to create new objects of the given class (if available)
             static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
-            uint32_t networkID_;                                           //!< The network ID to identify a class through the network
-            const unsigned int classID_;                                   //!< Uniquely identifies a class (might not be the same as the networkID_)
             static unsigned int classIDCounter_s;                          //!< Static counter for the unique classIDs
-
-            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
-            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
-
-            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
-            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
     };
-
-    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
-
-
-    // ###############################
-    // ###     ClassIdentifier     ###
-    // ###############################
-    /**
-        @brief The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
-
-        ClassIdentifier is a Singleton, which means that only one ClassIdentifier for a given type T exists.
-        This makes it possible to store information about a class, sharing them with all
-        objects of that class without defining static variables in every class.
-
-        To be really sure that not more than exactly one object exists (even with libraries),
-        ClassIdentifiers are stored in a static map in Identifier.
-    */
-    template <class T>
-    class ClassIdentifier : public Identifier
-    {
-        #ifndef DOXYGEN_SHOULD_SKIP_THIS
-          #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
-          #include "Super.h"
-        #endif
-
-        public:
-            static ClassIdentifier<T>* getIdentifier();
-            static ClassIdentifier<T>* getIdentifier(const std::string& name);
-
-            bool initialiseObject(T* object, const std::string& className, bool bRootClass);
-
-            void updateConfigValues(bool updateChildren = true) const;
-
-        private:
-            static void initialiseIdentifier();
-            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
-            ClassIdentifier()
-            {
-                SuperFunctionInitialization<0, T>::initialize(this);
-            }
-            ~ClassIdentifier()
-            {
-                SuperFunctionDestruction<0, T>::destroy(this);
-            }
-
-            static ClassIdentifier<T>* classIdentifier_s;
-    };
-
-    template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
-
-    /**
-        @brief Returns the only instance of this class.
-        @return The unique Identifier
-    */
-    template <class T>
-    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
-    {
-        // check if the Identifier already exists
-        if (!ClassIdentifier<T>::classIdentifier_s)
-            ClassIdentifier<T>::initialiseIdentifier();
-
-        return ClassIdentifier<T>::classIdentifier_s;
-    }
-
-    /**
-        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
-        @param name The name of this Identifier
-        @return The Identifier
-    */
-    template <class T>
-    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
-    {
-        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
-        identifier->setName(name);
-        return identifier;
-    }
-
-    /**
-        @brief Assigns the static field for the identifier singleton.
-    */
-    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.
-        ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
-
-        // Get the entry from the map
-        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
-
-        if (ClassIdentifier<T>::classIdentifier_s == proposal)
-        {
-            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was not yet existing and got created." << endl;
-        }
-        else
-        {
-            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was already existing and got assigned." << endl;
-        }
-    }
-
-    /**
-        @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;
-
-        object->identifier_ = this;
-        if (Identifier::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);
-            }
-
-            object->setConfigValues();
-            return true;
-        }
-        else
-        {
-            orxout(verbose, context::object_list) << "Added object to " << this->getName() << "-list." << endl;
-            object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
-
-            // Add pointer of type T to the map in the OrxonoxClass instance that enables "dynamic_casts"
-            object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
-            return false;
-        }
-    }
-
-    /**
-        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
-    */
-    template <class T>
-    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
-    {
-        if (!this->hasConfigValues())
-            return;
-
-        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
-            it->setConfigValues();
-
-        if (updateChildren)
-            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
-                (*it)->updateConfigValues(false);
-    }
-
-
-    // ###############################
-    // ###      orxonox_cast       ###
-    // ###############################
-    /**
-    @brief
-        Casts on object of type OrxonoxClass to any derived type that is
-        registered in the class hierarchy.
-    @return
-        Returns NULL if the cast is not possible
-    @note
-        In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
-        a class forgot to register its objects.
-        Also note that the function is implemented differently for GCC/MSVC.
-    */
-    template <class T, class U>
-    ORX_FORCEINLINE T orxonox_cast(U* source)
-    {
-#ifdef ORXONOX_COMPILER_MSVC
-        typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
-        if (source != NULL)
-            return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
-        else
-            return NULL;
-#else
-        return dynamic_cast<T>(source);
-#endif
-    }
 }
 
-#endif /* _Identifier_H__ */
+#endif /* _IdentifierManager_H__ */

code/branches/core6/src/libraries/core/config/ConfigValueContainer.h

@@ -70 +70 @@
             inline virtual void call(void* object)
             {
-                if (!Identifier::isCreatingHierarchy())
+                if (!IdentifierManager::isCreatingHierarchy())
                     (static_cast<T*>(object)->*this->function_)();
             }

code/branches/core6/src/libraries/network/packet/ClassID.cc

@@ -55 +55 @@
 
   //calculate total needed size (for all strings and integers)
-  std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin();
-  for(;it != Identifier::getStringIdentifierMapEnd();++it){
+  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getStringIdentifierMapBegin();
+  for(;it != IdentifierManager::getStringIdentifierMapEnd();++it){
     id = it->second;
     if(id == NULL || !id->hasFactory())
@@ -129 +129 @@
 
   //clear the map of network ids
-  Identifier::clearNetworkIDs();
+  IdentifierManager::clearNetworkIDs();
 
   orxout(verbose, context::packets) << "=== processing classids: " << endl;

code/branches/core6/src/libraries/network/synchronisable/Synchronisable.cc

@@ -83 +83 @@
   {
     // delete callback function objects
-    if(!Identifier::isCreatingHierarchy()){
+    if(!IdentifierManager::isCreatingHierarchy()){
       // remove object from the static objectMap
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))