Changeset 9638 for code/branches/core6/src/libraries

Timestamp:

Aug 11, 2013, 5:52:29 PM (11 years ago)

Author:

landauf

Message:

renamed CreateFactory() as RegisterClass() to be more consistent with the corresponding RegisterObject() macro

Location:

code/branches/core6/src/libraries

Files:

• core/BaseObject.cc (modified) (1 diff)
• core/CoreIncludes.h (modified) (6 diffs)
• core/Namespace.cc (modified) (1 diff)
• core/Template.cc (modified) (1 diff)
• tools/ResourceCollection.cc (modified) (1 diff)
• tools/ResourceLocation.cc (modified) (1 diff)

code/branches/core6/src/libraries/core/BaseObject.cc

@@ -50 +50 @@
 namespace orxonox
 {
-    CreateFactory(BaseObject);
+    RegisterClass(BaseObject);
 
     /**

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

@@ -28 +28 @@
 
 /**
-    @defgroup Factory RegisterObject() and CreateFactory()
+    @defgroup Factory RegisterObject() and RegisterClass()
     @ingroup Object
 */
@@ -35 +35 @@
     @file
     @ingroup Object Factory Class Identifier
-    @brief Defines several very important macros used to register objects, create factories, and to work with identifiers.
+    @brief Defines several very important macros used to register objects, register classes, and to work with identifiers.
 
     Every class needs the @c RegisterObject(class) macro in its constructor. If the class is an interface
     or the @c BaseObject itself, it needs the macro @c RegisterRootObject(class) instead.
 
-    To allow the object being created through the factory, use the @c CreateFactory(class) macro outside
-    of the class implementation, so it gets executed statically before @c main(). This will at the same time
-    register @a class in the class-hierarchy. If you don't want @a class to be loadable, but still
-    register it, call @c CreateUnloadableFactory(class).
+    To register @a class in the class-hierarchy, use the @c RegisterClass(class) macro outside of the class implementation,
+    so it gets executed statically before @c main(). If you don't want @a class to be loadable, but still register it, call
+    @c RegisterUnloadableClass(class).
 
     Example:
     @code
-    // Create the factory for MyClass
-    CreateFactory(MyClass);
+    // register MyClass
+    RegisterClass(MyClass);
 
     // Constructor:
@@ -83 +82 @@
 #include "object/ObjectList.h"
 
+// resolve macro conflict on windows
+#if defined(ORXONOX_PLATFORM_WINDOWS)
+#   include <windows.h>
+#   undef RegisterClass
+#endif
+
 
 /**
@@ -96 +101 @@
 
 /**
-    @brief Registers a newly created object in the core. Has to be called at the beginning of the constructor of @a ClassName.
+    @brief Registers a newly created object in the framework. Has to be called at the beginning of the constructor of @a ClassName.
     @param ClassName The name of the class
 */
@@ -103 +108 @@
 
 /**
-    @brief Registers a newly created object in the core. Has to be called at the beginning of the constructor of @a ClassName.
+    @brief Registers a newly created object in the framework. Has to be called at the beginning of the constructor of @a ClassName.
     @param ClassName The name of the class
 
@@ -113 +118 @@
 
 /**
-    @brief Creates and registers the Factory.
-    @param ClassName The name of the class
-*/
-#define CreateFactory(ClassName) \
-    RegisterFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), true)
-
-/**
-    @brief Creates and registers the Factory for classes which should not be loaded through XML.
-    @param ClassName The name of the class
-*/
-#define CreateUnloadableFactory(ClassName) \
-    RegisterFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), false)
-
-/**
-    @brief Registers a given Factory.
-    @param ClassName The name of the class
-*/
-#define RegisterFactory(ClassName, FactoryInstance, bLoadable) \
+    @brief Registers the class in the framework.
+    @param ClassName The name of the class
+*/
+#define RegisterClass(ClassName) \
+    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), true)
+
+/**
+    @brief Registers the class in the framework (for classes which should not be loaded through XML).
+    @param ClassName The name of the class
+*/
+#define RegisterUnloadableClass(ClassName) \
+    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), false)
+
+/**
+    @brief Registers the class in the framework with a given Factory.
+    @param ClassName The name of the class
+*/
+#define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
     Identifier* _##ClassName##Identifier = orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)
 

code/branches/core6/src/libraries/core/Namespace.cc

@@ -38 +38 @@
 namespace orxonox
 {
-    CreateFactory(Namespace);
+    RegisterClass(Namespace);
 
     Namespace::Namespace(Context* context) : BaseObject(context), Context(context),

code/branches/core6/src/libraries/core/Template.cc

@@ -38 +38 @@
 namespace orxonox
 {
-    CreateFactory(Template);
+    RegisterClass(Template);
 
     Template::Template(Context* context) : BaseObject(context)

code/branches/core6/src/libraries/tools/ResourceCollection.cc

@@ -37 +37 @@
 namespace orxonox
 {
-    CreateFactory(ResourceCollection);
+    RegisterClass(ResourceCollection);
 
     ResourceCollection::ResourceCollection(Context* context)

code/branches/core6/src/libraries/tools/ResourceLocation.cc

@@ -41 +41 @@
 namespace orxonox
 {
-    CreateFactory(ResourceLocation);
+    RegisterClass(ResourceLocation);
 
     ResourceLocation::ResourceLocation(Context* context)