Changeset 496

Timestamp:

Dec 12, 2007, 10:37:30 PM (17 years ago)

Author:

landauf

Message:

added files from objecthierarchy, changed includes

Location:

code/branches/FICN/src

Files:

• loader/LevelLoader.cc (modified) (2 diffs)
• network/Client.cc (modified) (1 diff)
• network/Client.h (modified) (1 diff)
• network/ConnectionManager.cc (modified) (1 diff)
• network/ConnectionManager.h (modified) (1 diff)
• network/GameStateClient.h (modified) (1 diff)
• network/GameStateManager.h (modified) (1 diff)
• network/Synchronisable.h (modified) (1 diff)
• orxonox/core/CMakeLists.txt (modified) (1 diff)
• orxonox/core/ClassFactory.h (modified) (3 diffs)
• orxonox/core/Factory.cc (modified) (4 diffs)
• orxonox/core/Factory.h (modified) (4 diffs)
• orxonox/core/Identifier.cc (modified) (4 diffs)
• orxonox/core/Identifier.h (modified) (22 diffs)
• orxonox/core/IdentifierList.cc (modified) (1 diff)
• orxonox/core/Iterator.h (modified) (8 diffs)
• orxonox/core/MetaObjectList.h (modified) (5 diffs)
• orxonox/core/ObjectList.h (modified) (4 diffs)
• orxonox/core/OrxonoxClass.h (modified) (5 diffs)
• orxonox/main.cc (modified) (3 diffs)
• orxonox/objects/BaseObject.cc (modified) (3 diffs)
• orxonox/objects/BaseObject.h (modified) (2 diffs)
• orxonox/objects/CMakeLists.txt (modified) (1 diff)
• orxonox/objects/Test.h (modified) (1 diff)
• orxonox/objects/Tickable.h (modified) (1 diff)
• orxonox/objects/Timer.h (modified) (7 diffs)
• orxonox/objects/test3.cc (modified) (2 diffs)
• orxonox/objects/test3.h (modified) (1 diff)
• orxonox/orxonox.cc (modified) (3 diffs)

code/branches/FICN/src/loader/LevelLoader.cc

@@ -4 +4 @@
 #include "LevelLoader.h"
 #include "tinyxml/tinyxml.h"
-#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/CoreIncludes.h"
 #include "orxonox/core/Error.h"
 #include "orxonox/objects/BaseObject.h"
@@ -111 +111 @@
                                 {
                                         tElem = tNode->ToElement();
-                                        orxonox::BaseObject* obj = orxonox::ID(tElem->Value())->fabricate();
+                                        orxonox::BaseObject* obj = ID(tElem->Value())->fabricate();
                                         obj->loadParams(tElem);
                                 }                       

code/branches/FICN/src/network/Client.cc

@@ -170 +170 @@
   void Client::processClassid(classid *clid){
     orxonox::Identifier *id;
-    id=orxonox::ID(std::string(clid->message));
+    id=ID(std::string(clid->message));
     if(id!=NULL)
       id->setNetworkID(clid->clid);

code/branches/FICN/src/network/Client.h

@@ -19 +19 @@
 #include "PacketManager.h"
 #include "GameStateClient.h"
-#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/CoreIncludes.h"
 //#include "NetworkFrameListener.h"
 

code/branches/FICN/src/network/ConnectionManager.cc

@@ -224 +224 @@
     orxonox::Identifier *id;
     while(!abort){
-      id = orxonox::ID(i);
+      id = ID(i);
       if(id == NULL)
         abort=true;

code/branches/FICN/src/network/ConnectionManager.h

@@ -24 +24 @@
 #include "PacketBuffer.h"
 #include "PacketManager.h"
-#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/CoreIncludes.h"
 
 namespace std{

code/branches/FICN/src/network/GameStateClient.h

@@ -15 +15 @@
 #include "zlib.h"
 #include "Synchronisable.h"
-#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/CoreIncludes.h"
 #include "GameStateManager.h"
 

code/branches/FICN/src/network/GameStateManager.h

@@ -19 +19 @@
 #include "ClientInformation.h"
 #include "Synchronisable.h"
-#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/CoreIncludes.h"
 #include "orxonox/core/Iterator.h"
 #include "PacketTypes.h"

code/branches/FICN/src/network/Synchronisable.h

@@ -16 +16 @@
 #include <iostream>
 
-#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/CoreIncludes.h"
 #include "orxonox/core/OrxonoxClass.h"
 

code/branches/FICN/src/orxonox/core/CMakeLists.txt

@@ -7 +7 @@
   MetaObjectList.cc
   OrxonoxClass.cc
+  ConfigValueContainer.cc
   Error.cc
+  SignalHandler.cc
 )
 

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

@@ -1 +1 @@
 /*!
     @file ClassFactory.h
-    @brief Definition of the ClassFactory class
+    @brief Definition and implementation of the ClassFactory class
 
     The ClassFactory is able to create new objects of a specific class.
@@ -21 +21 @@
     {
         public:
-            static bool create();
+            static bool create(const std::string& name);
             BaseObject* fabricate();
 
@@ -33 +33 @@
 
     /**
-        @brief Adds the ClassFactory to the Identifier of the same type and creates a new object to retrieve the parents.
-        @return True, because the compiler only allows assignments before main()
+        @brief Adds the ClassFactory to the Identifier of the same type and the Identifier to the Factory.
+        @return Always true (this is needed because the compiler only allows assignments before main())
     */
     template <class T>
-    bool ClassFactory<T>::create()
+    bool ClassFactory<T>::create(const std::string& name)
     {
-        // Add the ClassFactory to the Classidentifier of type T
         ClassIdentifier<T>::getIdentifier()->addFactory(new ClassFactory<T>);
-
-        // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
-        ClassIdentifier<T>::getIdentifier()->startCreatingHierarchy();
-#if HIERARCHY_VERBOSE
-        std::cout << "*** Create Factory -> Create Class\n";
-#endif
-        BaseObject* temp = ClassIdentifier<T>::getIdentifier()->fabricate();
-        delete temp;
-        ClassIdentifier<T>::getIdentifier()->stopCreatingHierarchy();
+        Factory::add(name, ClassIdentifier<T>::getIdentifier());
 
         return true;

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

@@ -6 +6 @@
 #include "Factory.h"
 #include "Identifier.h"
+#include "Debug.h"
+#include "../objects/BaseObject.h"
 
 namespace orxonox
@@ -24 +26 @@
 
     /**
-        @returns the Identifier with a given networkID.
-        @param id The networkID of the wanted Identifier
+        @returns the Identifier with a given network ID.
+        @param id The network ID of the wanted Identifier
     */
     Identifier* Factory::getIdentifier(const unsigned int id)
@@ -50 +52 @@
 
     /**
-        @brief Removes the entry with the old networkID and adds a new one.
+        @brief Removes the entry with the old network ID and adds a new one.
         @param identifier The identifier to change
         @param oldID The old networkID
@@ -60 +62 @@
         pointer_s->identifierNetworkIDMap_[newID] = identifier;
     }
+
+    /**
+        @brief Creates the class-hierarchy by creating and destroying one object of each type.
+    */
+    void Factory::createClassHierarchy()
+    {
+        if (!pointer_s)
+            pointer_s = new Factory;
+
+        COUT(4) << "*** Factory -> Create class-hierarchy\n";
+        std::map<std::string, Identifier*>::iterator it;
+        it = pointer_s->identifierStringMap_.begin();
+        (*pointer_s->identifierStringMap_.begin()).second->startCreatingHierarchy();
+        for (it = pointer_s->identifierStringMap_.begin(); it != pointer_s->identifierStringMap_.end(); ++it)
+        {
+            // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
+            BaseObject* temp = (*it).second->fabricate();
+            delete temp;
+        }
+        (*pointer_s->identifierStringMap_.begin()).second->stopCreatingHierarchy();
+        COUT(4) << "*** Factory -> Finished class-hierarchy creation\n";
+    }
 }

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

@@ -3 +3 @@
     @brief Definition of the Factory and the BaseFactory class.
 
-    The Factory is a singleton, containing two maps to map either the name or the networkID
+    The Factory is a singleton, containing two maps to map either the name or the network ID
     of a class with the corresponding Identifier.
 
@@ -28 +28 @@
     // ###         Factory         ###
     // ###############################
-    //! The Factory is used to map name or networkID of a class with its Identifier.
+    //! The Factory is used to map the name or the network ID of a class with its Identifier.
     class Factory
     {
@@ -36 +36 @@
             static void add(const std::string& name, Identifier* identifier);
             static void changeNetworkID(Identifier* identifier, const unsigned int oldID, const unsigned int newID);
+            static void createClassHierarchy();
 
         private:
@@ -43 +44 @@
 
             static Factory* pointer_s;                                          //!< The pointer to the singleton
-            std::map<std::string, Identifier*> identifierStringMap_;            //!< The map mapping string with Identifier
-            std::map<unsigned int, Identifier*> identifierNetworkIDMap_;        //!< The map mapping networkID with Identifier
+            std::map<std::string, Identifier*> identifierStringMap_;            //!< The map, mapping the name with the Identifier
+            std::map<unsigned int, Identifier*> identifierNetworkIDMap_;        //!< The map, mapping the network ID with the Identifier
     };
 

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

@@ -12 +12 @@
     // ###############################
     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
+    unsigned int Identifier::classIDcounter_s = 0;  // Set the static member variable classIDcounter_s to zero
 
     /**
@@ -41 +41 @@
     void Identifier::initialize(const IdentifierList* parents)
     {
-#if HIERARCHY_VERBOSE
-        std::cout << "*** Initialize " << this->name_ << "-Singleton.\n";
-#endif
+        COUT(4) << "*** Initialize " << this->name_ << "-Singleton.\n";
         this->bCreatedOneObject_ = true;
 
@@ -72 +70 @@
         {
             // Abstract classes don't have a factory and therefore can't create new objects
-            std::cout << "Error: Cannot create an object of type '" << this->name_ << "'. Class is abstract.\n";
-            std::cout << "Aborting...";
+            COUT(1) << "Error: Cannot create an object of type '" << this->name_ << "'. Class is abstract.\n";
+            COUT(1) << "Aborting...";
             abort();
         }
@@ -79 +77 @@
 
     /**
-        @brief Sets the networkID to a new value and changes the entry in the Factory.
-        @param id The new networkID
+        @brief Sets the network ID to a new value and changes the entry in the Factory.
+        @param id The new network ID
     */
     void Identifier::setNetworkID(unsigned int id)

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

@@ -1 +1 @@
 /*!
     @file Identifier.h
-    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes.
+    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
 
     The Identifier contains all needed informations about the class it belongs to:
@@ -7 +7 @@
      - a list with all objects
      - parents and childs
-     - the factory, if available
+     - the factory (if available)
      - the networkID that can be synchronised with the server
+     - all configurable variables (if available)
 
     Every object has a pointer to the Identifier of its class. This allows the use isA(...),
@@ -18 +19 @@
 
     SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
-    You can only assign Identifiers of the given class or a derivative to a SubclassIdentifier.
+    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
 */
 
@@ -25 +26 @@
 
 #include <iostream>
+#include <map>
 
 #include "IdentifierList.h"
 #include "ObjectList.h"
 #include "Factory.h"
-
-#define HIERARCHY_VERBOSE false
-
+#include "ConfigValueContainer.h"
+#include "Debug.h"
 
 namespace orxonox
@@ -46 +47 @@
          - a list with all objects
          - parents and childs
-         - the factory, if available
+         - the factory (if available)
          - the networkID that can be synchronised with the server
+         - all configurable variables (if available)
 
         Every object has a pointer to the Identifier of its class. This allows the use isA(...),
@@ -62 +64 @@
         friend class SubclassIdentifier; // Forward declaration
 
-        template <class T>
-        friend class ClassFactory; // Forward declaration
+        friend class Factory; // Forward declaration
 
         public:
@@ -85 +86 @@
             inline IdentifierList& getChildren() const { return *this->children_; }
 
-            /** @returns true, if a branch of the class-hierarchy is getting created, causing all new objects to store their parents. */
+            /** @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 NetworkID to identify a class through the network. */
+            /** @returns the network ID to identify a class through the network. */
             inline const unsigned int getNetworkID() const { return this->classID_; }
 
+            /** @brief Sets the network ID to a new value. @param id The new value */
             void setNetworkID(unsigned int id);
+
+            /** @returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable */
+            inline ConfigValueContainer* getConfigValueContainer(const std::string& varname)
+                { return this->configValues_[varname]; }
+
+            /** @brief Sets the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variablee @param container The container */
+            inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
+                { this->configValues_[varname] = container; }
 
         private:
@@ -105 +115 @@
             {
                 hierarchyCreatingCounter_s++;
-#if HIERARCHY_VERBOSE
-                std::cout << "*** Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n";
-#endif
+                COUT(4) << "*** Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n";
             }
 
@@ -116 +124 @@
             {
                 hierarchyCreatingCounter_s--;
-#if HIERARCHY_VERBOSE
-                std::cout << "*** Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n";
-#endif
-            }
-
-            IdentifierList parents_;                    //!< The Parents of the class the Identifier belongs to
-            IdentifierList* children_;                  //!< The Children of the class the Identifier belongs to
-
-            std::string name_;                          //!< The name of the class the Identifier belongs to
-
-            BaseFactory* factory_;                      //!< The Factory, able to create new objects of the given class
-            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 unique Identifiers
-            unsigned int classID_;                      //!< The networkID to identify a class through the network
+                COUT(4) << "*** Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n";
+            }
+
+            IdentifierList parents_;                                    //!< The Parents of the class the Identifier belongs to
+            IdentifierList* children_;                                  //!< The Children of the class the Identifier belongs to
+
+            std::string name_;                                          //!< The name of the class the Identifier belongs to
+
+            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)
+            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
     };
 
@@ -164 +171 @@
 
     /**
-        @brief Constructor: Create the ObjectList.
+        @brief Constructor: Creates the ObjectList.
     */
     template <class T>
@@ -173 +180 @@
 
     /**
-        @brief Destructor: Delete the ObjectList, set the singleton-pointer to zero.
+        @brief Destructor: Deletes the ObjectList, sets the singleton-pointer to zero.
     */
     template <class T>
@@ -186 +193 @@
         @param parents An IdentifierList, 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 BaseObject itself
+        @param bRootClass True if the class is either an Interface or the BaseObject itself
         @return The ClassIdentifier itself
     */
@@ -192 +199 @@
     ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass)
     {
-#if HIERARCHY_VERBOSE
-        std::cout << "*** Register Class in " << name << "-Singleton.\n";
-#endif
+        COUT(4) << "*** Register Class in " << name << "-Singleton.\n";
 
         // It's a singleton, so maybe we have to create it first
         if (!pointer_s)
         {
-#if HIERARCHY_VERBOSE
-            std::cout << "*** Register Class in " << name << "-Singleton -> Create Singleton.\n";
-#endif
+            COUT(4) << "*** Register Class in " << name << "-Singleton -> Create Singleton.\n";
             pointer_s = new ClassIdentifier();
         }
@@ -210 +213 @@
             // If no: We have to store the informations and initialize the Identifier
 
-#if HIERARCHY_VERBOSE
-            std::cout << "*** Register Class in " << name << "-Singleton -> Initialize Singleton.\n";
-#endif
+            COUT(4) << "*** Register Class in " << name << "-Singleton -> Initialize Singleton.\n";
             pointer_s->name_ = name;
-            Factory::add(name, pointer_s); // Add the Identifier to the Factory
+//            Factory::add(name, pointer_s); // Add the Identifier to the Factory
 
             if (bRootClass)
@@ -226 +227 @@
 
     /**
-        @returns the Identifier itself
+        @returns the Identifier itself.
     */
     template <class T>
@@ -233 +234 @@
         if (!pointer_s)
         {
-#if HIERARCHY_VERBOSE
-            std::cout << "*** Create Singleton.\n";
-#endif
+            COUT(4) << "*** Create Singleton.\n";
             pointer_s = new ClassIdentifier();
         }
@@ -249 +248 @@
     void ClassIdentifier<T>::addObject(T* object)
     {
-#if HIERARCHY_VERBOSE
-        std::cout << "*** Added object to " << ClassIdentifier<T>::getIdentifier()->getName() << "-list.\n";
-#endif
+        COUT(4) << "*** Added object to " << ClassIdentifier<T>::getIdentifier()->getName() << "-list.\n";
         object->getMetaList().add(ClassIdentifier<T>::getIdentifier()->objects_, ClassIdentifier<T>::getIdentifier()->objects_->add(object));
     }
@@ -261 +258 @@
     //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
     /**
-        You can only assign Identifiers that belong to a class of at least B (or derived) to a SubclassIdentifier<T>.
+        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
         If you assign something else, the program aborts.
         Because we know the minimal type, a dynamic_cast is done, which makes it easier to create a new object.
@@ -286 +283 @@
                 if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
                 {
-                    std::cout << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!\n";
-                    std::cout << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden.\n";
-                    std::cout << "Aborting...\n";
+                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!\n";
+                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden.\n";
+                    COUT(1) << "Aborting...\n";
                     abort();
                 }
@@ -314 +311 @@
 
             /**
-                @brief Creates a new object of the type of the assigned identifier and dynamic_casts it to the minimal type given by the SubclassIdentifier.
+                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
                 @return The new object
             */
@@ -321 +318 @@
                 BaseObject* newObject = this->identifier_->fabricate();
 
-                // Check if the creation worked
+                // Check if the creation was successful
                 if (newObject)
                 {
@@ -332 +329 @@
                     if (this->identifier_)
                     {
-                        std::cout << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!\n";
-                        std::cout << "Error: Couldn't fabricate a new Object.\n";
-                        std::cout << "Aborting...\n";
+                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!\n";
+                        COUT(1) << "Error: Couldn't fabricate a new Object.\n";
+                        COUT(1) << "Aborting...\n";
                     }
                     else
                     {
-                        std::cout << "Error: Couldn't fabricate a new Object - Identifier is undefined.\n";
-                        std::cout << "Aborting...\n";
+                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined.\n";
+                        COUT(1) << "Aborting...\n";
                     }
 

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

@@ -101 +101 @@
 
     /**
-        @returns a string, containing the names of all Identifiers in the list.
+        @returns a string, containing a list of the names of all Identifiers in the list.
     */
     std::string IdentifierList::toString() const

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

@@ -1 +1 @@
 /*!
     @file Iterator.h
-    @brief Definition of the Iterator class.
+    @brief Definition and implementation of the Iterator class.
 
     The Iterator of a given class allows to iterate through an ObjectList, containing all objects of that type.
-    This is the only way to access the objects in an ObjectList.
+    This is the only way to access the objects stored in an ObjectList.
 
     Usage:
@@ -13 +13 @@
     }
 
-    Warning: Don't delete an object directly through the iterator.
+    Warning: Don't delete objects directly through the iterator.
 */
 
 #ifndef _Iterator_H__
 #define _Iterator_H__
+
+#include "Debug.h"
 
 namespace orxonox
@@ -27 +29 @@
         public:
             /**
-                @brief Constructor: Sets the element whereon the iterator points to zero.
+                @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
             Iterator()
@@ -35 +37 @@
 
             /**
-                @brief Constructor: Sets the element whereon the iterator points to a given element.
+                @brief Constructor: Sets the element, whereon the iterator points, to a given element.
                 @param element The element to start with
             */
@@ -44 +46 @@
 
             /**
-                @brief Overloading of the ++it operator: Iterator iterates to the next object in the list.
+                @brief Overloading of the ++it operator: Iterator points to the next object in the list.
                 @return The Iterator itself
             */
@@ -54 +56 @@
 
             /**
-                @brief Overloading of the --it operator: Iterator iterates to the previous object in the list.
+                @brief Overloading of the --it operator: Iterator points to the previous object in the list.
                 @return The Iterator itself
             */
@@ -98 +100 @@
             bool operator!=(int compare)
             {
-                // Comparing with something except zero makes no sense
+                // Comparing with anything except zero makes no sense
                 if (compare != 0)
-                    std::cout << "Warning: Comparing the " << ClassIdentifier<T>::getIdentifier()->getName() << "-List-Iterator with " << compare << " has no effect. Only comparison with 0 works.\n";
+                    COUT(2) << "Warning: Comparing the " << ClassIdentifier<T>::getIdentifier()->getName() << "-List-Iterator with " << compare << " has no effect. Only comparison with 0 works.\n";
 
                 return (this->element_ != 0);
@@ -106 +108 @@
 
         private:
-            ObjectListElement<T>* element_;     //!< The element the Iterator points to
+            ObjectListElement<T>* element_;     //!< The element the Iterator points at
     };
 }

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

@@ -4 +4 @@
 
     The MetaObjectList is a single-linked list, containing all list-elements and their
-    lists wherein the object that owns the MetaObjectList is registered.
-    This allows much faster deleting of objects.
+    lists wherein the object, owning the MetaObjectList, is registered.
+    This allows much faster deletion of objects because no iteration is needed.
 */
 
@@ -13 +13 @@
 #include "ObjectList.h"
 #include "Identifier.h"
+#include "Debug.h"
 
 namespace orxonox
@@ -20 +21 @@
     {
         public:
-            /** @brief Defaultdestructor */
+            /** @brief Default destructor */
             virtual ~BaseMetaObjectListElement() {};
 
@@ -69 +70 @@
 
 
-#if HIERARCHY_VERBOSE
-        std::cout << "*** Removing Object from " << ClassIdentifier<T>::getIdentifier()->getName() << "-list.\n";
-#endif
+        COUT(4) << "*** Removing Object from " << ClassIdentifier<T>::getIdentifier()->getName() << "-list.\n";
         delete this->element_;
     }
@@ -83 +82 @@
         The MetaObjectList is a single-linked list, containing all list-elements and their
         lists wherein the object that owns the MetaObjectList is registered.
-        This allows much faster deleting of objects.
+        This allows much faster deletion of objects because no iteration is needed.
     */
     class MetaObjectList

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

@@ -1 +1 @@
 /*!
     @file ObjectList.h
-    @brief Definition of the ObjectList class.
-
-    The ObjectList is a double-linked list, used by Identifiers to store all objects of a specific class in it.
-    Created objects are added through the RegisterObject-macro in its constructor.
+    @brief Definition and implementation of the ObjectList class.
+
+    The ObjectList is a double-linked list, used by Identifiers to store all objects of a given class.
+    Newly created objects are added through the RegisterObject-macro in its constructor.
     Use Iterator<class> to iterate through all objects of the class.
 */
@@ -32 +32 @@
     /**
         @brief Constructor: Creates the list-element with an object.
-        @param Object The object to store
+        @param object The object to store
     */
     template <class T>
@@ -49 +49 @@
     class Iterator; // Forward declaration
 
-    //! The ObjectList contains all objects of a specific class.
-    /**
-        The ObjectList is used by Identifiers to store all objects of a specific class in it.
+    //! The ObjectList contains all objects of a given class.
+    /**
+        The ObjectList is used by Identifiers to store all objects of a given class.
         Use Iterator<class> to iterate through all objects in the list.
     */
@@ -82 +82 @@
 
     /**
-        @brief Constructor: Sets first_ and last_ to zero and the static member variable pointer_s to _this_
+        @brief Constructor: Sets default values.
     */
     template <class T>

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

@@ -3 +3 @@
     @brief Definition of the OrxonoxClass Class.
 
-    All objects and interfaces of the game-logic are derived from OrxonoxClass.
-    It stores the Identifier and the MetaObjectList and has all needed functions to create the class-hierarchy.
+    All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.
+    It stores the Identifier and the MetaObjectList and has all needed functions to create and use the class-hierarchy.
 */
 
@@ -15 +15 @@
 #include "MetaObjectList.h"
 
-#include "../../tinyxml/tinyxml.h"
-
-
 namespace orxonox
 {
-    //! The class all objects and interfaces of the game-logic are derived from.
+    //! The class all objects and interfaces of the game-logic (not the engine) are derived from.
     /**
-        BaseObject and Interaces are derived with 'virtual public OrxonoxClass' from OrxonoxClass.
+        The BaseObject and Interaces are derived with 'virtual public OrxonoxClass' from OrxonoxClass.
         OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the MetaObjectList.
     */
@@ -30 +27 @@
             OrxonoxClass();
             virtual ~OrxonoxClass();
+
+            void setConfigValues() {};
 
             /** @returns the Identifier of the object */
@@ -46 +45 @@
             inline MetaObjectList& getMetaList() { return this->metaList_; }
 
+
+            /** @returns true if the objects class is of the given type or a derivative. */
             inline bool isA(const Identifier* identifier)
                 { return this->getIdentifier()->isA(identifier); }
+            /** @returns true if the objects class is exactly of the given type. */
             inline bool isDirectlyA(const Identifier* identifier)
                 { return this->getIdentifier()->isDirectlyA(identifier); }
+            /** @returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const Identifier* identifier)
                 { return this->getIdentifier()->isChildOf(identifier); }
+            /** @returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const Identifier* identifier)
                 { return this->getIdentifier()->isParentOf(identifier); }
 
+
+            /** @returns true if the objects class is of the given type or a derivative. */
             inline bool isA(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isA(identifier->getIdentifier()); }
+            /** @returns true if the objects class is exactly of the given type. */
             inline bool isDirectlyA(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
+            /** @returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
+            /** @returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
 
+
+            /** @returns true if the objects class is of the given type or a derivative. */
             inline bool isA(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isA(identifier.getIdentifier()); }
+            /** @returns true if the objects class is exactly of the given type. */
             inline bool isDirectlyA(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
+            /** @returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
+            /** @returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
 
+
+            /** @returns true if the objects class is of the given type or a derivative. */
             inline bool isA(const OrxonoxClass* object)
                 { return this->getIdentifier()->isA(object->getIdentifier()); }
+            /** @returns true if the objects class is exactly of the given type. */
             inline bool isDirectlyA(const OrxonoxClass* object)
                 { return this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
+            /** @returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const OrxonoxClass* object)
                 { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
+            /** @returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const OrxonoxClass* object)
                 { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
 
 
-            inline void setName(const std::string& name) { this->name_ = name; }
+            /** @brief Sets the name of the object. @param name The name */
+            inline virtual void setName(const std::string& name) { this->name_ = name; }
+
+            /** @returns the name of the object. */
             inline const std::string& getName() const { return this->name_; }
 
-            inline void setActive(bool bActive) { this->bActive_ = bActive; }
+            /** @brief Sets the state of the objects activity. @param bActive True = active */
+            inline virtual void setActive(bool bActive) { this->bActive_ = bActive; }
+
+            /** @returns the state of the objects activity. */
             inline const bool isActive() const { return this->bActive_; }
 
-            inline void setVisible(bool bVisible) { this->bVisible_ = bVisible; }
+            /** @brief Sets the state of the objects visibility. @param bVisible True = visible */
+            inline virtual void setVisible(bool bVisible) { this->bVisible_ = bVisible; }
+
+            /** @returns the state of the objects visibility. */
             inline const bool isVisible() const { return this->bVisible_; }
-
 
         private:
@@ -98 +125 @@
             MetaObjectList metaList_;       //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
 
-            std::string name_;
-            bool bActive_;
-            bool bVisible_;
+            std::string name_;              //!< The name of the object
+            bool bActive_;                  //!< True = the object is active
+            bool bVisible_;                 //!< True = the object is visible
     };
 }

code/branches/FICN/src/orxonox/main.cc

@@ -35 +35 @@
 
 
+#include "core/SignalHandler.h"
 #include "orxonox.h"
 
@@ -66 +67 @@
 #endif
 
-#if OGRE_PLATFORM == PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WIN32
-#define WIN32_LEAN_AND_MEAN
-#include "windows.h"
-
-             INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
-#else
-
-             int main(int argc, char **argv)
-#endif
+int main(int argc, char **argv)
 {
   try
   {
+    SignalHandler::getInstance()->doCatch(argv[0], "orxonox.log");
     Orxonox* orx = Orxonox::getSingleton();
 #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
@@ -90 +84 @@
   catch(Ogre::Exception& e)
   {
-#if OGRE_PLATFORM == PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WIN32
-    MessageBoxA(NULL, e.getFullDescription().c_str(), "An exception has occurred!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
-#else
     fprintf(stderr, "An exception has occurred: %s\n",
             e.getFullDescription().c_str());
     return 1;
-#endif
   }
 

code/branches/FICN/src/orxonox/objects/BaseObject.cc

@@ +1 @@
+/*!
+    @file BaseObject.cc
+    @brief Implementation of the BaseObject class.
+*/
+
 #include "BaseObject.h"
 
@@ -5 +10 @@
     CreateFactory(BaseObject);
 
+    /**
+        @brief Constructor: Registers the object in the BaseObject-list.
+    */
     BaseObject::BaseObject()
     {
@@ -10 +18 @@
     }
 
+    /**
+        @brief Destructor
+    */
     BaseObject::~BaseObject()
     {
     }
-    
 }

code/branches/FICN/src/orxonox/objects/BaseObject.h

@@ +1 @@
+/*!
+    @file BaseObject.h
+    @brief Definition of the BaseObject class.
+
+    The BaseObject is the parent of all classes representing an instance in the game.
+*/
+
 #ifndef _BaseObject_H__
 #define _BaseObject_H__
 
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
+#include "tinyxml/tinyxml.h"
 
 namespace orxonox
 {
+    //! The BaseObject is the parent of all classes representing an instance in the game.
     class BaseObject : virtual public OrxonoxClass
     {
@@ -11 +20 @@
             BaseObject();
             virtual ~BaseObject();
-                        virtual void loadParams(TiXmlElement* xmlElem) {}
-            
+            virtual void loadParams(TiXmlElement* xmlElem) {}
     };
 }

code/branches/FICN/src/orxonox/objects/CMakeLists.txt

@@ -3 +3 @@
 SET( OBJECTS_SRC_FILES
   BaseObject.cc
+  WorldEntity.cc
   test1.cc
   test2.cc

code/branches/FICN/src/orxonox/objects/Test.h

@@ -3 +3 @@
 
 #include "BaseObject.h"
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
 
 namespace orxonox

code/branches/FICN/src/orxonox/objects/Tickable.h

@@ +1 @@
+/*!
+    @file Tickable.h
+    @brief Definition of the Tickable interface.
+
+    The Tickable interface provides a tick(dt) function, that gets called every frame.
+    float dt is the time since the last frame.
+
+    Attention:
+    Classes derived from a Tickable that want to have a tick(dt) function on their part, MUST call the
+    parent::tick(dt) function explicit in their implementation of tick(dt) because it's a virtual function.
+*/
+
 #ifndef _Tickable_H__
 #define _Tickable_H__
 
-#include <OgreFrameListener.h>
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
+#include "OgreFrameListener.h"
 
 namespace orxonox
 {
-    class TickFrameListener;
+    class TickFrameListener; // Forward declaration
 
+    //! The Tickable interface provides a tick(dt) function, that gets called every frame.
     class Tickable : virtual public OrxonoxClass
     {
         public:
+            /**
+                @brief Gets called every frame.
+                @param dt The time since the last frame
+            */
             virtual void tick(float dt) = 0;
 
         protected:
+            /**
+                @brief Constructor: Registers the object in the Tickable-list
+            */
             Tickable() { RegisterRootObject(Tickable); }
     };
 
+    //! The TickFrameListener calls the tick(dt) function of all Tickables every frame.
     class TickFrameListener : public Ogre::FrameListener
     {
         private:
+            /** @brief Gets called before a frame gets rendered. */
             bool frameStarted(const Ogre::FrameEvent &evt)
             {
+                // Iterate through all Tickables and call their tick(dt) function
                 for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
                     it->tick(evt.timeSinceLastFrame);

code/branches/FICN/src/orxonox/objects/Timer.h

@@ +1 @@
+/*!
+    @file Timer.h
+    @brief Definition and Implementation of the Timer class.
+
+    The Timer is a callback-object, calling a given function after a given time-interval.
+
+    Usage:
+    header.h:
+        class ClassName
+        {
+            public:
+                ClassName();
+                void functionName();
+                Timer myTimer;
+        };
+
+    source.cc:
+        ClassName::ClassName()
+        {
+            myTimer.setTimer(interval_in_seconds, bLoop, this, &ClassName::functionName);
+        }
+
+        void ClassName::functionName()
+        {
+            whateveryouwant();
+            something(else);
+        }
+*/
+
 #ifndef _Timer_H__
 #define _Timer_H__
 
-#include <OgreFrameListener.h>
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
+#include "OgreFrameListener.h"
 
 namespace orxonox
 {
+    //! TimerBase is the parent of the Timer class.
     class TimerBase : public OrxonoxClass
     {
@@ -12 +42 @@
 
         public:
+            /** @brief Constructor: Sets the default-values. */
             TimerBase()
             {
@@ -25 +56 @@
             virtual void run() const = 0;
 
+            /** @brief Starts the Timer: Function-call after 'interval' seconds. */
             inline void startTimer() { this->bActive_ = true; this->time_ = this->interval_; }
+            /** @brief Stops the Timer. */
             inline void stopTimer() { this->bActive_ = false; this->time_ = this->interval_; }
+            /** @brief Pauses the Timer - it will continue with the actual state if you unpause it. */
             inline void pauseTimer() { this->bActive_ = false; }
+            /** @brief Unpauses the Timer - continues with the given state. */
             inline void unpauseTimer() { this->bActive_ = true; }
+            /** @returns true if the Timer is active (= not stoped, not paused). */
             inline bool isActive() const { return this->bActive_; }
 
         protected:
-            float interval_;
-            bool bLoop_;
-            bool bActive_;
+            float interval_;    //!< The time-interval in seconds
+            bool bLoop_;        //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;      //!< If true, the Timer ticks and calls the function if the time's up
 
-            float time_;
+            float time_;        //!< Internal variable, counting the time till the next function-call
     };
 
+    //! The Timer is a callback-object, calling a given function after a given time-interval.
     template <class T = BaseObject>
     class Timer : public TimerBase
     {
         public:
+            /** @brief Constructor: Sets the default-values. */
             Timer()
             {
@@ -49 +87 @@
             }
 
+            /**
+                @brief Constructor: Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param timerFunction A function pointer to the function to call
+            */
             Timer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
             {
@@ -54 +99 @@
             }
 
+            /**
+                @brief Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param timerFunction A function pointer to the function to call
+            */
             void setTimer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
             {
@@ -65 +117 @@
             }
 
+            /** @brief Calls the given function of the given object. */
             void run() const
             {
@@ -75 +128 @@
     };
 
+    //! The TimerFrameListener manages all Timers in the game.
     class TimerFrameListener : public Ogre::FrameListener
     {
         private:
+            /** @brief Gets called before a frame gets rendered. */
             bool frameStarted(const Ogre::FrameEvent &evt)
             {
+                // Iterate through all Timers
                 for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; ++it)
                 {
                     if (it->isActive())
                     {
+                        // If active: Decrease the timer by the duration of the last frame
                         it->time_ -= evt.timeSinceLastFrame;
 
                         if (it->time_ <= 0)
                         {
+                            // It's time to call the function
                             if (it->bLoop_)
-                                it->time_ += it->interval_;
+                                it->time_ += it->interval_; // Q: Why '+=' and not '='? A: Think about it. It's more accurate like that. Seriously.
                             else
-                                it->stopTimer();
+                                it->stopTimer(); // Stop the timer if we don't want to loop
 
                             it->run();

code/branches/FICN/src/orxonox/objects/test3.cc

@@ -10 +10 @@
     {
         RegisterObject(Test3);
+
+        this->setConfigValues();
+    }
+
+    void Test3::setConfigValues()
+    {
+        SetConfigValue(value_int_, -100);
+        SetConfigValue(value_double_, 10.555678);
+        SetConfigValue(value_bool_, true);
+        SetConfigValue(value_string_, "Dies ist ein Test");
+        SetConfigValue(value_vector2_, Vector2(101, 202));
+        SetConfigValue(value_vector3_, Vector3(13, 26, 39));
+        SetConfigValue(value_colourvalue_, ColourValue(1.0, 0.5, 0.25, 0.887));
     }
 
@@ -15 +28 @@
     {
     }
+
+        #include <fstream>
+    void Test3::configOutput()
+    {
+        std::cout << this->value_int_ << std::endl;
+        std::cout << this->value_double_ << std::endl;
+        std::cout << this->value_bool_ << std::endl;
+        std::cout << this->value_string_ << std::endl;
+        std::cout << this->value_vector2_ << std::endl;
+        std::cout << this->value_vector3_ << std::endl;
+        std::cout << this->value_colourvalue_ << std::endl;
+    }
+
         #define testandcout(code) \
           std::cout << #code << " " << code << "\n"

code/branches/FICN/src/orxonox/objects/test3.h

@@ -15 +15 @@
             virtual ~Test3();
 
+            void setConfigValues();
+
             void usefullClassesIsATest(Test1* test1);
             void usefullClassesIsATest(Test2* test2);
+
+            void configOutput();
+
+        private:
+            int                 value_int_;
+            double              value_double_;
+            bool                value_bool_;
+            std::string         value_string_;
+            Vector2             value_vector2_;
+            Vector3             value_vector3_;
+            ColourValue         value_colourvalue_;
     };
 }

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

@@ -51 +51 @@
 #include <string>
 #include <iostream>
+
+#include "objects/Tickable.h"
+#include "objects/Timer.h"
+#include "core/Factory.h"
 
 #include "../xml/xmlParser.h"
@@ -255 +259 @@
     setupInputSystem();
     createFrameListener();
+    Factory::createClassHierarchy();
     startRenderLoop();
   }
@@ -416 +421 @@
   void Orxonox::createFrameListener()
   {
+    TickFrameListener* TickFL = new TickFrameListener();
+    ogre_->getRoot()->addFrameListener(TickFL);
+
+    TimerFrameListener* TimerFL = new TimerFrameListener();
+    ogre_->getRoot()->addFrameListener(TimerFL);
+
     frameListener_ = new OrxListener(keyboard_, mouse_, auMan_);
     ogre_->getRoot()->addFrameListener(frameListener_);