Changeset 1583

Timestamp:

Jun 10, 2008, 3:01:24 AM (17 years ago)

Author:

landauf

Message:

changed Identifier initialization

Location:

code/branches/core3/src/core

Files:

• ClassFactory.h (modified) (1 diff)
• ConsoleCommand.h (modified) (1 diff)
• CoreIncludes.h (modified) (1 diff)
• IRC.cc (modified) (1 diff)
• Identifier.cc (modified) (3 diffs)
• Identifier.h (modified) (13 diffs)
• TclThreadManager.cc (modified) (1 diff)

code/branches/core3/src/core/ClassFactory.h

@@ -74 +74 @@
     {
         COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
-        ClassIdentifier<T>::getIdentifier()->addFactory(new ClassFactory<T>);
+        ClassIdentifier<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
         Factory::add(name, ClassIdentifier<T>::getIdentifier());
 

code/branches/core3/src/core/ConsoleCommand.h

@@ -42 +42 @@
 
 #define SetConsoleCommandGeneric(fakevariable, classname, command, bCreateShortcut) \
-    orxonox::ConsoleCommand& fakevariable = orxonox::ClassIdentifier<classname>::getIdentifier()->addConsoleCommand(command, bCreateShortcut)
+    orxonox::ConsoleCommand& fakevariable = orxonox::ClassIdentifier<classname>::getIdentifier(#classname)->addConsoleCommand(command, bCreateShortcut)
 
 

code/branches/core3/src/core/CoreIncludes.h

@@ -55 +55 @@
 */
 #define InternRegisterObject(ClassName, bRootClass) \
-    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::getIdentifier()->registerClass(this->getParents(), #ClassName, bRootClass)); \
-    if (orxonox::Identifier::isCreatingHierarchy() && this->getParents()) \
-        this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
-    orxonox::ClassIdentifier<ClassName>::getIdentifier()->addObject(this); \
+    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::getIdentifier(#ClassName)); \
     if (orxonox::Identifier::isCreatingHierarchy()) \
-      return
+    { \
+        if (this->getParents()) \
+        { \
+            orxonox::ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeClassHierarchy(this->getParents(), bRootClass); \
+            this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
+        } \
+        this->setConfigValues(); \
+        return; \
+    } \
+    orxonox::ClassIdentifier<ClassName>::getIdentifier()->addObject(this)
 
 /**

code/branches/core3/src/core/IRC.cc

@@ -42 +42 @@
     SetConsoleCommand(IRC, msg,  false).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(IRC, nick, false).setAccessLevel(AccessLevel::User);
-
-    IRC* instance_irc = &IRC::getInstance();
 
     IRC::IRC()

code/branches/core3/src/core/Identifier.cc

@@ -58 +58 @@
 
         this->bCreatedOneObject_ = false;
+        this->bSetName_ = false;
         this->factory_ = 0;
 
@@ -86 +87 @@
         @return The identifier (unique instance)
     */
-    Identifier *Identifier::getIdentifier(std::string &name, Identifier *proposal)
+    Identifier* Identifier::getIdentifierSingleton(const std::string& name, Identifier* proposal)
     {
         static std::map<std::string, Identifier*> identifiers;    //!< The map to store all Identifiers.
         std::map<std::string, Identifier*>::const_iterator it = identifiers.find(name);
-        if (it == identifiers.end())
-        {
-            // there isn't an entry yet, put the proposal in it
+
+        if (it != identifiers.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
             identifiers[name] = proposal;
-        }
-        else
-        {
-            // this happens when a template exists twice --> delete the proposal
-            delete proposal;
-        }
-        return identifiers[name];
+            return proposal;
+        }
     }
 
@@ -149 +152 @@
 
     /**
+        @brief Sets the name of the class.
+        @param name The name
+    */
+    void Identifier::setName(const std::string& name)
+    {
+        if (!this->bSetName_)
+        {
+            this->name_ = name;
+            this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
+        }
+    }
+
+    /**
         @brief Creates an object of the type the Identifier belongs to.
         @return The new object

code/branches/core3/src/core/Identifier.h

@@ -87 +87 @@
     {
         template <class T>
-        friend class ClassIdentifier;
-
-        template <class T>
         friend class SubclassIdentifier;
 
@@ -114 +111 @@
             /** @brief Returns the name of the class the Identifier belongs to. @return The name */
             inline const std::string& getName() const { return this->name_; }
+            void setName(const std::string& name);
 
             virtual void updateConfigValues() const = 0;
@@ -220 +218 @@
 
         protected:
+            Identifier();
+            Identifier(const Identifier& identifier); // don't copy
+            virtual ~Identifier();
+
+            void initialize(std::set<const Identifier*>* parents);
+            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
+
             /** @brief Returns the map that stores all Identifiers. @return The map */
             static std::map<std::string, Identifier*>& getIdentifierMapIntern();
@@ -225 +230 @@
             static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
 
+            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
+
         private:
-            Identifier();
-            Identifier(const Identifier& identifier); // don't copy
-            virtual ~Identifier();
-            void initialize(std::set<const Identifier*>* parents);
-
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
@@ -254 +256 @@
             }
 
-            static Identifier* getIdentifier(std::string &name, Identifier *proposal);
-
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
             std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
@@ -262 +262 @@
             std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
 
+            bool bSetName_;                                                //!< True if the name is set
             std::string name_;                                             //!< The name of the class the Identifier belongs to
-
             ObjectListBase* objects_;                                      //!< The list of all objects of this class
             BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
-            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
             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)
             unsigned int classID_;                                         //!< The network ID to identify a class through the network
@@ -298 +297 @@
     {
         public:
-            ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
-            void setName(const std::string& name);
+            static ClassIdentifier<T> *getIdentifier();
+            static ClassIdentifier<T> *getIdentifier(const std::string& name);
+            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
+            static bool isFirstCall();
 
             void updateConfigValues() const;
@@ -309 +310 @@
             void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
 
-            static ClassIdentifier<T> *getIdentifier();
-
         private:
-            ClassIdentifier();
+            ClassIdentifier() {}
             ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
             ~ClassIdentifier() {}                                       // don't delete
 
-            bool bSetName_;                                                                             //!< True if the name is set
             std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
             std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
@@ -327 +325 @@
 
     /**
-        @brief Constructor: Creates the ObjectList.
-    */
-    template <class T>
-    ClassIdentifier<T>::ClassIdentifier()
-    {
-        this->bSetName_ = false;
-    }
-
-    /**
         @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 name A string, containing exactly the name of the class
         @param bRootClass True if the class is either an Interface or the BaseObject itself
-        @return The ClassIdentifier itself
-    */
-    template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass)
-    {
-        this->setName(name);
-
+    */
+    template <class T>
+    void ClassIdentifier<T>::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 informations and initialize the Identifier
-            COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
+            COUT(4) << "*** ClassIdentifier: Register Class in " << this->getName() << "-Singleton -> Initialize Singleton." << std::endl;
             if (bRootClass)
-                this->initialize(NULL); // 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.
+                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);
         }
-
-        return this;
-    }
-
-    /**
-        @brief Creates the only instance of this class for the template class T and retrieves a unique Identifier for the given name.
+    }
+
+    /**
+        @brief Returns true if the function gets called the first time, false otherwise.
+        @return True if this function got called the first time.
+    */
+    template <class T>
+    bool ClassIdentifier<T>::isFirstCall()
+    {
+        static bool bFirstCall = true;
+
+        if (bFirstCall)
+        {
+            bFirstCall = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    /**
+        @brief Returns the only instance of this class.
         @return The unique Identifier
     */
@@ -369 +372 @@
     {
         // check if the static field has already been filled
-        if (ClassIdentifier<T>::classIdentifier_s == 0)
+        if (ClassIdentifier<T>::isFirstCall())
         {
             // Get the name of the class
@@ -375 +378 @@
 
             // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
-            ClassIdentifier<T> *proposal = new ClassIdentifier<T>();
+            ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
 
             // Get the entry from the map
-            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifier(name, proposal);
+            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
+
+            if (ClassIdentifier<T>::classIdentifier_s == proposal)
+            {
+                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
+            }
+            else
+            {
+                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
+            }
         }
 
@@ -386 +398 @@
 
     /**
-        @brief Sets the name of the class.
-        @param name The name
-    */
-    template <class T>
-    void ClassIdentifier<T>::setName(const std::string& name)
-    {
-        if (!this->bSetName_)
-        {
-            this->name_ = name;
-            this->bSetName_ = true;
-            Identifier::getIdentifierMapIntern()[name] = this;
-            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
-        }
+        @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>
+    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
+    {
+        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
+        identifier->setName(name);
+        return identifier;
     }
 
@@ -407 +416 @@
     void ClassIdentifier<T>::updateConfigValues() const
     {
-        for (Iterator<T> it = this->objects_->begin(); it; ++it)
+        for (Iterator<T> it = this->getObjects()->begin(); it; ++it)
             (*it)->setConfigValues();
     }

code/branches/core3/src/core/TclThreadManager.cc

@@ -58 +58 @@
     SetConsoleCommand(TclThreadManager, flush,   false).setArgumentCompleter(0, autocompletion::tclthreads());
 
-    TclThreadManager* instance_tclthreadmanager = &TclThreadManager::getInstance();
-
     TclThreadManager::TclThreadManager()
     {