Changeset 698 for code/branches/FICN

Timestamp:

Dec 27, 2007, 5:49:03 AM (17 years ago)

Author:

landauf

Message:

hopefully replaced all static pre-main variables with more secure wrapper functions. and now i'll sleep.

Location:

code/branches/FICN/src/orxonox/core

Files:

• ConfigValueContainer.cc (modified) (12 diffs)
• ConfigValueContainer.h (modified) (2 diffs)
• Factory.cc (modified) (1 diff)
• Identifier.cc (modified) (2 diffs)
• Identifier.h (modified) (4 diffs)
• ObjectList.h (modified) (3 diffs)

code/branches/FICN/src/orxonox/core/ConfigValueContainer.cc

@@ -36 +36 @@
 namespace orxonox
 {
-    std::list<std::string>* ConfigValueContainer::configFileLines_s = 0; // Set the static member variable configFileLines_s to zero
-    bool ConfigValueContainer::readConfigFile_s = false;                 // Set the static member variable readConfigFile_s to false
-
     /**
         @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
@@ -438 +435 @@
     {
         // Read the file if needed
-        if (!ConfigValueContainer::readConfigFile_s)
+        if (!ConfigValueContainer::finishedReadingConfigFile())
             ConfigValueContainer::readConfigFile(CONFIGFILEPATH);
 
@@ -450 +447 @@
         bool success = false;
         std::list<std::string>::iterator it1;
-        for(it1 = ConfigValueContainer::configFileLines_s->begin(); it1 != ConfigValueContainer::configFileLines_s->end(); ++it1)
+        for(it1 = ConfigValueContainer::getConfigFileLines().begin(); it1 != ConfigValueContainer::getConfigFileLines().end(); ++it1)
         {
             // Don't try to parse comments
@@ -464 +461 @@
                 // Iterate through all lines in the section
                 std::list<std::string>::iterator it2;
-                for(it2 = ++it1; it2 != ConfigValueContainer::configFileLines_s->end(); ++it2)
+                for(it2 = ++it1; it2 != ConfigValueContainer::getConfigFileLines().end(); ++it2)
                 {
                     // Don't try to parse comments
@@ -495 +492 @@
                     {
                         // The next section startet, so our line isn't yet in the file - now we add it and safe the file
-                        this->configFileLine_ = this->configFileLines_s->insert(positionToPutNewLineAt, this->varname_ + "=" + this->defvalueString_);
+                        this->configFileLine_ = this->getConfigFileLines().insert(positionToPutNewLineAt, this->varname_ + "=" + this->defvalueString_);
                         ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
                         success = true;
@@ -515 +512 @@
                 {
                     // Looks like we found the right section, but the file ended without containing our variable - so we add it and safe the file
-                    this->configFileLine_ = this->configFileLines_s->insert(positionToPutNewLineAt, this->varname_ + "=" + this->defvalueString_);
+                    this->configFileLine_ = this->getConfigFileLines().insert(positionToPutNewLineAt, this->varname_ + "=" + this->defvalueString_);
                     ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
                     success = true;
@@ -527 +524 @@
         {
             // We obviously didn't found the right section, so we'll create it
-            this->configFileLines_s->push_back("[" + this->classname_ + "]");                   // Create the section
-            this->configFileLines_s->push_back(this->varname_ + "=" + this->defvalueString_);   // Create the line
-            this->configFileLine_ = --this->configFileLines_s->end();                           // Set the pointer to the last element
+            this->getConfigFileLines().push_back("[" + this->classname_ + "]");                   // Create the section
+            this->getConfigFileLines().push_back(this->varname_ + "=" + this->defvalueString_);   // Create the line
+            this->configFileLine_ = --this->getConfigFileLines().end();                           // Set the pointer to the last element
             success = true;
-            this->configFileLines_s->push_back("");                                             // Add an empty line - this is needed for the algorithm in the searchConfigFileLine-function
+            this->getConfigFileLines().push_back("");                                             // Add an empty line - this is needed for the algorithm in the searchConfigFileLine-function
             ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);                              // Save the changed config-file
         }
@@ -601 +598 @@
 
     /**
+        @returns a list, containing all entrys in the config-file.
+    */
+    std::list<std::string>& ConfigValueContainer::getConfigFileLines()
+    {
+        // This is done to avoid problems while executing this code before main()
+        static std::list<std::string> configFileLinesStaticReference = std::list<std::string>();
+        return configFileLinesStaticReference;
+    }
+
+    /**
+        @brief Returns true if the ConfigFile is read and stored into the ConfigFile-lines-list.
+        @param finished This is used to change the state
+        @return True if the ConfigFile is read and stored into the ConfigFile-lines-list
+    */
+    bool ConfigValueContainer::finishedReadingConfigFile(bool finished)
+    {
+        // This is done to avoid problems while executing this code before main()
+        static bool finishedReadingConfigFileStaticVariable = false;
+
+        if (finished)
+            finishedReadingConfigFileStaticVariable = true;
+
+        return finishedReadingConfigFileStaticVariable;
+    }
+
+    /**
         @brief Reads the config-file and stores the lines in a list.
         @param filename The name of the config-file
@@ -606 +629 @@
     void ConfigValueContainer::readConfigFile(const std::string& filename)
     {
-        ConfigValueContainer::readConfigFile_s = true;
-
-        // Create the list if needed
-        if (!ConfigValueContainer::configFileLines_s)
-            ConfigValueContainer::configFileLines_s = new std::list<std::string>;
+        ConfigValueContainer::finishedReadingConfigFile(true);
 
         // This creates the file if it's not existing
@@ -627 +646 @@
         {
             file.getline(line, 1024);
-            ConfigValueContainer::configFileLines_s->push_back(line);
+            ConfigValueContainer::getConfigFileLines().push_back(line);
 //            std::cout << "### ->" << line << "<- : empty: " << isEmpty(line) << " comment: " << isComment(line) << std::endl;
         }
 
         // The last line is useless
-        ConfigValueContainer::configFileLines_s->pop_back();
+        ConfigValueContainer::getConfigFileLines().pop_back();
 
         // Add an empty line to the end of the file if needed
         // this is needed for the algorithm in the searchConfigFileLine-function
-        if ((ConfigValueContainer::configFileLines_s->size() > 0) && !isEmpty(*ConfigValueContainer::configFileLines_s->rbegin()))
+        if ((ConfigValueContainer::getConfigFileLines().size() > 0) && !isEmpty(*ConfigValueContainer::getConfigFileLines().rbegin()))
         {
 //            std::cout << "### newline added" << std::endl;
-            ConfigValueContainer::configFileLines_s->push_back("");
+            ConfigValueContainer::getConfigFileLines().push_back("");
         }
 
@@ -652 +671 @@
     {
         // Make sure we stored the config-file in the list
-        if (!ConfigValueContainer::readConfigFile_s)
+        if (!ConfigValueContainer::finishedReadingConfigFile())
             ConfigValueContainer::readConfigFile(filename);
 
@@ -661 +680 @@
         // Iterate through the list an write the lines into the file
         std::list<std::string>::iterator it;
-        for(it = ConfigValueContainer::configFileLines_s->begin(); it != ConfigValueContainer::configFileLines_s->end(); ++it)
+        for(it = ConfigValueContainer::getConfigFileLines().begin(); it != ConfigValueContainer::getConfigFileLines().end(); ++it)
         {
             file << (*it) << std::endl;

code/branches/FICN/src/orxonox/core/ConfigValueContainer.h

@@ -86 +86 @@
             ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::ColourValue defvalue);
 
+            static std::list<std::string>& getConfigFileLines();
+            static bool finishedReadingConfigFile(bool finished = false);
             void setConfigFileEntyToDefault();
             void searchConfigFileLine();
@@ -143 +145 @@
 
             std::list<std::string>::iterator configFileLine_;   //!< An iterator, pointing to the entry of the variable in the config-file
-            static std::list<std::string>* configFileLines_s;   //!< A list, containing all entrys in the config-file
-            static bool readConfigFile_s;                       //!< True if the config-file is read and stored in the list
 
             enum VariableType

code/branches/FICN/src/orxonox/core/Factory.cc

@@ -104 +104 @@
     Factory* Factory::getFactoryPointer()
     {
-      static Factory theOneAndOnlyInstance = Factory();
-      return &theOneAndOnlyInstance;
+      static Factory theOneAndOnlyFactoryInstance = Factory();
+      return &theOneAndOnlyFactoryInstance;
     }
 }

code/branches/FICN/src/orxonox/core/Identifier.cc

@@ -38 +38 @@
     // ###       Identifier        ###
     // ###############################
-    int Identifier::hierarchyCreatingCounter_s = 0; // Set the static member variable hierarchyCreatingCounter_s to zero
-    unsigned int Identifier::classIDcounter_s = 0;  // Set the static member variable classIDcounter_s to zero
+    int Identifier::hierarchyCreatingCounter_s = 0; // Set the static member variable hierarchyCreatingCounter_s to zero (this static member variable is ok: it's used in main(), not before)
 
     /**
@@ -50 +49 @@
 
         this->children_ = new IdentifierList;
-        this->classID_ = Identifier::classIDcounter_s++;
+
+        // Use a static variable because the classID gets created before main() and that's why we should avoid static member variables
+        static unsigned int classIDcounter_s = 0;
+        this->classID_ = classIDcounter_s++;
     }
 

code/branches/FICN/src/orxonox/core/Identifier.h

@@ -137 +137 @@
                 { this->configValues_[varname] = container; }
 
-            std::map<std::string, Identifier*>& getIdentifierMap();
+            static std::map<std::string, Identifier*>& getIdentifierMap();
 
         private:
@@ -171 +171 @@
             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)
-            static unsigned int classIDcounter_s;                       //!< The number of existing Identifiers
             unsigned int classID_;                                      //!< The network ID to identify a class through the network
             std::map<std::string, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
@@ -197 +196 @@
         private:
             ClassIdentifier();
-            ClassIdentifier(const ClassIdentifier<T>& identifier) {} // don't copy
-            ~ClassIdentifier();
+            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
+            ~ClassIdentifier() {}                                       // don't delete
 
             ObjectList<T>* objects_;    //!< The ObjectList, containing all objects of type T
@@ -211 +210 @@
     ClassIdentifier<T>::ClassIdentifier()
     {
-        this->objects_ = new ObjectList<T>;
+        this->objects_ = ObjectList<T>::getList();
         this->bSetName_ = false;
-    }
-
-    /**
-        @brief Destructor: Deletes the ObjectList, sets the singleton-pointer to zero.
-    */
-    template <class T>
-    ClassIdentifier<T>::~ClassIdentifier()
-    {
-        delete this->objects_;
     }
 

code/branches/FICN/src/orxonox/core/ObjectList.h

@@ -82 +82 @@
     {
         public:
+            static ObjectList<T>* getList();
+
+            ObjectListElement<T>* add(T* object);
+//            void remove(OrxonoxClass* object, bool bIterateForwards = true);
+
+            /** @returns the first element in the list */
+            inline static Iterator<T> start()
+                { return Iterator<T>(getList()->first_); }
+
+            /** @returns the last element in the list */
+            inline static Iterator<T> end()
+                { return Iterator<T>(getList()->last_); }
+
+            ObjectListElement<T>* first_;       //!< The first element in the list
+            ObjectListElement<T>* last_;        //!< The last element in the list
+
+        private:
             ObjectList();
             ~ObjectList();
-            ObjectListElement<T>* add(T* object);
-//            void remove(OrxonoxClass* object, bool bIterateForwards = true);
-
-            /** @returns the first element in the list */
-            inline static Iterator<T> start()
-                { return Iterator<T>(pointer_s->first_); }
-
-            /** @returns the last element in the list */
-            inline static Iterator<T> end()
-                { return Iterator<T>(pointer_s->last_); }
-
-            ObjectListElement<T>* first_;       //!< The first element in the list
-            ObjectListElement<T>* last_;        //!< The last element in the list
-
-        private:
-            static ObjectList<T>* pointer_s;    //!< A static pointer to the last created list (different for all T)
     };
-
-    template <class T>
-    ObjectList<T>* ObjectList<T>::pointer_s = 0; // Set the static member variable pointer_s to zero
 
     /**
@@ -113 +111 @@
         this->first_ = 0;
         this->last_ = 0;
-
-        // ObjectLists are only created by Identifiers and therefore only one ObjectList of each T will exist.
-        // Thats why pointer_s is in fact a pointer to the only ObjectList for a type, which makes it almost a singleton.
-        this->pointer_s = this;
     }
 
@@ -132 +126 @@
             this->first_ = temp;
         }
+    }
+
+    /**
+        @returns a pointer to the only existing instance for the given class T.
+    */
+    template <class T>
+    ObjectList<T>* ObjectList<T>::getList()
+    {
+        static ObjectList<T> theOnlyObjectListObjectForClassT = ObjectList<T>();
+        return &theOnlyObjectListObjectForClassT;
     }