Changeset 4938 in orxonox.OLD for orxonox/trunk/src/util/object_manager.h

Timestamp:

Jul 22, 2005, 11:57:38 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: doxygen tags.

File:

• orxonox/trunk/src/util/object_manager.h (modified) (8 diffs)

orxonox/trunk/src/util/object_manager.h

@@ -1 +1 @@
 /*!
-    \file object_manager.h
-  *  this manager will ceep track of the objects  in the world
-
-    This is specially designed to:
-    - Give an interface to the world data
-    - separate the world data from the world build,update,draw process
-    - recycle deleted objects: specific for Projectils since there is a lot of world entity creation/deletion (and this needs a lot of time)
-    - control the garbage collector
-
-    TO ADD SUPPORT FOR A CLASS do the following steps:
-    1. include the hader file : #include "class_id.h"
-    2. add the class to the type enum classID {}; in class_id.h
-    3. define a function void mCache( ClassName ) in class ObjectManager
-
+ * @file object_manager.h
+ * The ObjectManager (FastFactory) is designed, to automatically generate and remove
+ * (without to much overhead) many instances of different classes.
+ *
+ * It is especially usefull for objects, that come only for a short time into existence,
+ * and get killed after a small amount of time (like shots).
+ *
+ * The Creation of an Object is usually done in the Weapon Class, where one subscribes
+ * a Projectile with:
+ * this->bulletFactory = tFastFactory<TestBullet>::getFastFactory(CL_TEST_BULLET, "TestBullet");
+ * (this might change over time).
+ * Then you can at loading time initialize an amount of the class with something like:
+ * this->bulletFactory->prepare(100); // creates 100 entities of TestBullet (dead ones)
+ * afterwards one can just retrieve an Object form the Class with
+ * this->bulletFactory->resurrect();  // this returns a BaseObject an Object of the class.
 */
 
@@ -21 +22 @@
 
 #include "base_object.h"
-#include "class_id.h"
 
+
+// FORWARD DECLARATION //
+class GarbageCollector;
 template<class T> class tList;
-class GarbageCollector;
-
 
 /**
@@ -36 +37 @@
 struct FastObjectMember
 {
-  BaseObject*               objectPointer;
+  BaseObject*          objectPointer;      //!< Pointer to the Object Stored in this Class (if it is the DeadList, else it is bork)
 
-  FastObjectMember*         next;
+  FastObjectMember*    next;               //!< the next stored FastObjectMember. (or NULL if this is the last one stored in either the deadList or the unusedContainers)
 };
 
 //! The FastFactory is a fast loadable object creator, and Dynamic List of dead object handler.
 /**
+ * The ObjectManager (FastFactory) is designed, to automatically generate and remove
+ * (without to much overhead) many instances of different classes.
+ *
  * FastFactory is needed to glue all the tFastFactory<T>'s together.
- * Furthermore one can retrieve the corresponding tFastFactory over
- * tFastFactory<T>* = FastFacroty::getFastFactory(ID);
+ * It is also the general class that implements the necessary functions
+ * to generate, resurrect kill and stuff...
  */
 class FastFactory : public BaseObject {
@@ -53 +57 @@
 
     // functions to push and pop elements of this class
-    BaseObject* resurect(ClassID classID);
-    void kill(ClassID classID, BaseObject* object);
+    BaseObject* resurrect();
+    static BaseObject* resurrect(ClassID classID);
+    void kill(BaseObject* object);
+    static void kill(BaseObject* object, ClassID classID);
 
-    virtual void fabricate() = NULL;
     void prepare(unsigned int count);
     // retrival functions for fast Ineraction
@@ -76 +81 @@
 
 //    virtual BaseObject* fabricate(ClassID classID) = NULL;
-
+    virtual void fabricate() = NULL;
     static FastFactory* searchFastFactory(ClassID classID, const char* fastFactoryName = NULL);
 
@@ -104 +109 @@
     static tFastFactory<T>* getFastFactory(ClassID classID, const char* fastFactoryName = NULL);
 
-    T* resurect();
   private:
     tFastFactory(ClassID classID, const char* fastFactoryName);
 
     virtual void fabricate();
-
-  private:
 };
 
@@ -149 +151 @@
 }
 
-template<class T>
-    T* tFastFactory<T>::resurect()
-{
-  PRINTF(4)("Resurecting Object of type %s\n", this->getName());
-  if (unlikely(this->deadList == NULL))
-  {
-    PRINTF(2)("The deadList of Class %s is empty, this may be either because it has not been filled yet, or the cache is to small.\n" \
-        "Fabricating a new %s", this->getName(), this->getName());
-    this->fabricate();
-    return resurect();
-  }
-  else
-  {
-    FastObjectMember* tmpC = deadList;
-    this->deadList = this->deadList->next;
 
-    tmpC->next = this->unusedContainers;
-    this->unusedContainers = tmpC;
 
-    return dynamic_cast<T*>(tmpC->objectPointer);
-  }
-}
+
+
+
+
+
 
 ////////////////////
@@ -186 +173 @@
   void registerClass(ClassID classID);
 
-  BaseObject* resurect();
+  BaseObject* resurrect();
   void kill(BaseObject* object);