Changeset 5776 for code/branches/core5

Timestamp:

Sep 23, 2009, 11:47:13 PM (15 years ago)

Author:

landauf

Message:

moved SubclassIdentifier to a separate file

Location:

code/branches/core5/src

Files:

• libraries/core/CoreIncludes.h (modified) (1 diff)
• libraries/core/Identifier.h (modified) (3 diffs)
• libraries/core/SubclassIdentifier.h (added)
• orxonox/gametypes/Gametype.h (modified) (1 diff)
• orxonox/infos/PlayerInfo.h (modified) (1 diff)

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

@@ -45 +45 @@
 #include "util/Debug.h"
 #include "Identifier.h"
+#include "SubclassIdentifier.h"
 #include "Factory.h"
 #include "ClassFactory.h"

code/branches/core5/src/libraries/core/Identifier.h

@@ -29 +29 @@
 /**
     @file
-    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
+    @brief Definition of the Identifier class, definition and implementation of the ClassIdentifier class.
 
     The Identifier contains all needed information about the class it belongs to:
@@ -45 +45 @@
 
     Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
-
-    SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
-    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
 */
 
@@ -508 +505 @@
 #endif
     }
-
-
-    // ###############################
-    // ###   SubclassIdentifier    ###
-    // ###############################
-    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
-    /**
-        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 minimum type, a dynamic_cast is done, which makes it easier to create a new object.
-    */
-    template <class T>
-    class SubclassIdentifier
-    {
-        public:
-            /**
-                @brief Constructor: Automaticaly assigns the Identifier of the given class.
-            */
-            SubclassIdentifier()
-            {
-                this->identifier_ = ClassIdentifier<T>::getIdentifier();
-            }
-
-            /**
-                @brief Constructor: Assigns the given Identifier.
-                @param identifier The Identifier
-            */
-            SubclassIdentifier(Identifier* identifier)
-            {
-                this->operator=(identifier);
-            }
-
-            /**
-                @brief Copyconstructor: Assigns the identifier of the other SubclassIdentifier.
-                @param identifier The other SublcassIdentifier
-            */
-            template <class O>
-            SubclassIdentifier(const SubclassIdentifier<O>& identifier)
-            {
-                this->operator=(identifier.getIdentifier());
-            }
-
-            /**
-                @brief Overloading of the = operator: assigns the identifier and checks its type.
-                @param identifier The Identifier to assign
-                @return The SubclassIdentifier itself
-            */
-            const SubclassIdentifier<T>& operator=(Identifier* identifier)
-            {
-                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
-                {
-                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                    if (identifier)
-                    {
-                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
-                    }
-                    else
-                    {
-                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
-                    }
-                }
-                else
-                {
-                    this->identifier_ = identifier;
-                }
-                return *this;
-            }
-
-            /**
-                @brief Overloading of the = operator: assigns the identifier of the other SubclassIdentifier.
-                @param identifier The other SublcassIdentifier
-            */
-            template <class O>
-            const SubclassIdentifier<T>& operator=(const SubclassIdentifier<O>& identifier)
-            {
-                return this->operator=(identifier.getIdentifier());
-            }
-
-            /**
-                @brief Overloading of the * operator: returns the assigned identifier.
-            */
-            inline Identifier* operator*() const
-            {
-                return this->identifier_;
-            }
-
-            /**
-                @brief Overloading of the -> operator: returns the assigned identifier.
-            */
-            inline Identifier* operator->() const
-            {
-                return this->identifier_;
-            }
-
-            /**
-                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
-            */
-            inline operator Identifier*() const
-            {
-                return this->identifier_;
-            }
-
-            /**
-                @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
-            */
-            T* fabricate(BaseObject* creator) const
-            {
-                BaseObject* newObject = this->identifier_->fabricate(creator);
-
-                // Check if the creation was successful
-                if (newObject)
-                {
-                    return orxonox_cast<T*>(newObject);
-                }
-                else
-                {
-                    // Something went terribly wrong
-                    if (this->identifier_)
-                    {
-                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
-                    }
-                    else
-                    {
-                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
-                    }
-
-                    assert(false);
-                    return 0;
-                }
-            }
-
-            /** @brief Returns the assigned identifier. @return The identifier */
-            inline Identifier* getIdentifier() const
-                { return this->identifier_; }
-
-        private:
-            Identifier* identifier_;            //!< The assigned identifier
-    };
 }
 

code/branches/core5/src/orxonox/gametypes/Gametype.h

@@ -37 +37 @@
 
 #include "core/BaseObject.h"
-#include "core/Identifier.h"
+#include "core/SubclassIdentifier.h"
 #include "tools/interfaces/Tickable.h"
 #include "infos/GametypeInfo.h"

code/branches/core5/src/orxonox/infos/PlayerInfo.h

@@ -33 +33 @@
 
 #include "Info.h"
-#include "core/Identifier.h"
+#include "core/SubclassIdentifier.h"
 #include "controllers/Controller.h"