Changeset 9637 for code

Timestamp:

Aug 11, 2013, 4:23:41 PM (11 years ago)

Author:

landauf

Message:

removed constructor arguments from ClassFactories. use the helper-function registerClass() to add the factory to the corresponding identifier

Location:

code/branches/core6

Files:

• src/libraries/core/CoreIncludes.h (modified) (4 diffs)
• src/libraries/core/object/ClassFactory.h (modified) (4 diffs)
• test/core/class/IdentifierExternalClassHierarchyTest.cc (modified) (1 diff, 1 prop)
• test/core/class/IdentifierSimpleClassHierarchyTest.cc (modified) (1 diff, 1 prop)
• test/core/object/ClassFactoryTest.cc (modified) (1 diff)

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

@@ -117 +117 @@
 */
 #define CreateFactory(ClassName) \
-    RegisterFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(#ClassName, true))
+    RegisterFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), true)
 
 /**
@@ -124 +124 @@
 */
 #define CreateUnloadableFactory(ClassName) \
-    RegisterFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(#ClassName, false))
+    RegisterFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), false)
 
 /**
@@ -130 +130 @@
     @param ClassName The name of the class
 */
-#define RegisterFactory(ClassName, FactoryInstance) \
-    Factory* _##ClassName##Factory = FactoryInstance
+#define RegisterFactory(ClassName, FactoryInstance, bLoadable) \
+    Identifier* _##ClassName##Identifier = orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)
 
 /**
@@ -143 +143 @@
 namespace orxonox
 {
+    /**
+     * @brief Overload of registerClass() which determines T implicitly by the template argument of the ClassFactory.
+     */
+    template <class T>
+    inline Identifier* registerClass(const std::string& name, ClassFactory<T>* factory, bool bLoadable = true)
+    {
+        return registerClass<T>(name, static_cast<Factory*>(factory), bLoadable);
+    }
+
+    /**
+     * @brief Registers a class in the framework.
+     * @param name The name of the class
+     * @param factory The factory which is able to create new instances of this class
+     * @param bLoadable Whether the class is allowed to be loaded through XML
+     */
+    template <class T>
+    inline Identifier* registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
+    {
+        orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
+        Identifier* identifier = ClassIdentifier<T>::getIdentifier(name);
+        identifier->setFactory(factory);
+        identifier->setLoadable(bLoadable);
+        return identifier;
+    }
+
     /**
         @brief Returns the Identifier with a given name.

code/branches/core6/src/libraries/core/object/ClassFactory.h

@@ -43 +43 @@
 
 #include "util/Output.h"
-#include "core/class/Identifier.h"
 
 namespace orxonox
@@ -54 +53 @@
     {
         public:
-            virtual ~Factory() {};
+            virtual ~Factory() {}
             virtual Identifiable* fabricate(Context* context) = 0;
     };
@@ -61 +60 @@
     // ###      ClassFactory       ###
     // ###############################
-    /// The ClassFactory is able to create new objects of a specific class that require no constructor arguments.
+    /// The ClassFactory is the base-class of all class-spezific factories
     template <class T>
     class ClassFactory : public Factory
     {
+    };
+
+    // ###############################
+    // ###   ClassFactoryNoArgs    ###
+    // ###############################
+    /// The ClassFactoryNoArgs is able to create new objects of a specific class that require no constructor arguments.
+    template <class T>
+    class ClassFactoryNoArgs : public ClassFactory<T>
+    {
         public:
-            /**
-                @brief Constructor: Adds the ClassFactory to the Identifier of the same type.
-                @param name The name of the class
-                @param bLoadable True if the class can be loaded through XML
-            */
-            ClassFactory(const std::string& name, bool bLoadable = true)
-            {
-                orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
-                ClassIdentifier<T>::getIdentifier(name)->setFactory(this);
-                ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
-            }
-
             /**
                 @brief Creates and returns a new object of class T.
@@ -93 +89 @@
     /// The ClassFactoryWithContext is able to create new objects of a specific class that require a context as constructor argument
     template <class T>
-    class ClassFactoryWithContext : public Factory
+    class ClassFactoryWithContext : public ClassFactory<T>
     {
         public:
-            /**
-                @brief Constructor: Adds the ClassFactory to the Identifier of the same type.
-                @param name The name of the class
-                @param bLoadable True if the class can be loaded through XML
-            */
-            ClassFactoryWithContext(const std::string& name, bool bLoadable = true)
-            {
-                orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
-                ClassIdentifier<T>::getIdentifier(name)->setFactory(this);
-                ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
-            }
-
             /**
                 @brief Creates and returns a new object of class T.

code/branches/core6/test/core/class/IdentifierExternalClassHierarchyTest.cc

@@ -22 +22 @@
                 virtual void SetUp()
                 {
-                    new ClassFactory<Interface>("Interface");
-                    new ClassFactory<BaseClass>("BaseClass");
-                    new ClassFactory<RealClass>("RealClass");
+                    registerClass("Interface", new ClassFactoryNoArgs<Interface>());
+                    registerClass("BaseClass", new ClassFactoryNoArgs<BaseClass>());
+                    registerClass("RealClass", new ClassFactoryNoArgs<RealClass>());
                     IdentifierManager::createClassHierarchy();
                 }

code/branches/core6/test/core/class/IdentifierSimpleClassHierarchyTest.cc

@@ -24 +24 @@
                 virtual void SetUp()
                 {
-                    new ClassFactory<Interface>("Interface");
-                    new ClassFactory<BaseClass>("BaseClass");
-                    new ClassFactory<RealClass>("RealClass");
+                    registerClass("Interface", new ClassFactoryNoArgs<Interface>());
+                    registerClass("BaseClass", new ClassFactoryNoArgs<BaseClass>());
+                    registerClass("RealClass", new ClassFactoryNoArgs<RealClass>());
                     IdentifierManager::createClassHierarchy();
                 }

code/branches/core6/test/core/object/ClassFactoryTest.cc

@@ -7 +7 @@
     TEST(ClassFactoryTest, CanFabricateObject)
     {
-        Factory* factory = new ClassFactoryWithContext<BaseObject>("BaseObject");
+        Factory* factory = new ClassFactoryWithContext<BaseObject>();
         Identifiable* object = factory->fabricate(NULL);
         ASSERT_TRUE(object != NULL);