Changeset 4301 in orxonox.OLD for orxonox/branches/physics/src/util

Timestamp:

May 26, 2005, 3:20:55 PM (20 years ago)

Author:

bensch

Message:

orxonox/branches/physics: merged the trunk back to the physics-branche
merged with command:
svn merge -4 4283:HEAD ../../trunk/ .
no conflicts

Location:

orxonox/branches/physics/src/util

Files:

• garbage_collector.cc (modified) (2 diffs)
• loading/load_param.cc (modified) (3 diffs)
• loading/load_param.h (modified) (6 diffs)
• object_manager.cc (modified) (5 diffs)
• object_manager.h (modified) (3 diffs)

orxonox/branches/physics/src/util/garbage_collector.cc

@@ -25 +25 @@
 
 #include "list.h"
+#include "object_manager.h"
 
 using namespace std;
@@ -137 +138 @@
           entity->remove();
           /* then finaly delete reference */
-          delete entity;
+          //delete entity;
+          ObjectManager::getInstance()->addToDeadList(CL_TEST_BULLET, entity);
+          ObjectManager::getInstance()->debug();
         }
       entity = iterator->nextElement();

orxonox/branches/physics/src/util/loading/load_param.cc

@@ -10 +10 @@
 
    ### File Specific:
-   main-programmer: Christian Meyer
+   main-programmer: Benjamin Grauer
    co-programmer: ...
 */
@@ -27 +27 @@
    \param ... the parameter information
 */
-BaseLoadParam::BaseLoadParam(BaseObject* object, const char* paramName, int paramCount, ...)
-{
+BaseLoadParam::BaseLoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName, int paramCount, ...)
+{
+  this->loadString = grabParameter(root, paramName);
+
   this->paramDesc = NULL;
   if (LoadClassDescription::parametersDescription)
@@ -47 +49 @@
           strcpy(this->paramDesc->types[i], tmpTypeName);
         }
-      va_end(types);  
+      va_end(types);
 
       int argCount = 0;

orxonox/branches/physics/src/util/loading/load_param.h

@@ -65 +65 @@
 #define LoadParam1(type1) \
  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE)) \
-  : BaseLoadParam(pt2Object, paramName, 1, type1##_NAME) \
-    { \
-      const char* loadString = grabParameter(root, paramName); \
+   : BaseLoadParam(root, pt2Object, paramName, 1, type1##_NAME)         \
+    { \
       if (loadString != NULL && root != NULL) \
         (*pt2Object.*function)(type1##_FUNC(loadString)); \
@@ -78 +77 @@
 #define LoadParam2(type1, type2) \
  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE)) \
-  : BaseLoadParam(pt2Object, paramName, 2, type1##_NAME, type2##_NAME) \
-    { \
-      const char* loadString = grabParameter(root, paramName); \
+   : BaseLoadParam(root, pt2Object, paramName, 2, type1##_NAME, type2##_NAME) \
+    { \
       if (loadString != NULL && root != NULL) \
         { \
@@ -98 +96 @@
 #define LoadParam3(type1, type2, type3) \
  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE))\
-  : BaseLoadParam(pt2Object, paramName, 3, type1##_NAME, type2##_NAME, type3##_NAME) \
-    { \
-      const char* loadString = grabParameter(root, paramName); \
+   : BaseLoadParam(root, pt2Object, paramName, 3, type1##_NAME, type2##_NAME, type3##_NAME) \
+    { \
       if (loadString != NULL && root != NULL) \
         { \
@@ -118 +115 @@
 #define LoadParam4(type1, type2, type3, type4) \
  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE)) \
-  : BaseLoadParam(pt2Object, paramName, 4, type1##_NAME, type2##_NAME, type3##_NAME, type2##_NAME, type4##_NAME) \
-    { \
-      const char* loadString = grabParameter(root, paramName); \
+   : BaseLoadParam(root, pt2Object, paramName, 4, type1##_NAME, type2##_NAME, type3##_NAME, type2##_NAME, type4##_NAME) \
+    { \
       if (loadString != NULL && root != NULL) \
         { \
@@ -138 +134 @@
 #define LoadParam5(type1, type2, type3, type4, type5) \
  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE, type5##_TYPE)) \
-  : BaseLoadParam(pt2Object, paramName, 5, type1##_NAME, type2##_NAME, type3##_NAME, type2##_NAME, type4##_NAME, type5##_NAME) \
-    { \
-      const char* loadString = grabParameter(root, paramName); \
+   : BaseLoadParam(root, pt2Object, paramName, 5, type1##_NAME, type2##_NAME, type3##_NAME, type2##_NAME, type4##_NAME, type5##_NAME) \
+    { \
       if (loadString != NULL && root != NULL) \
         { \
@@ -202 +197 @@
 
  protected:
-  BaseLoadParam(BaseObject* object, const char* paramName, int paramCount, ...);
+  BaseLoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName, int paramCount, ...);
 
  protected:
   LoadClassDescription* classDesc;               //!< The LoadClassDescription of this LoadParameter
   LoadParamDescription* paramDesc;               //!< The LoadParameterDescription of this LoadParameter
+  const char* loadString;                        //!< The string loaded by this LoadParam
 };
 

orxonox/branches/physics/src/util/object_manager.cc

@@ -11 +11 @@
    ### File Specific:
    main-programmer: Patrick Boenzli
-   co-programmer: ...
 */
 
@@ -17 +16 @@
 
 #include "object_manager.h"
+#include "garbage_collector.h"
+#include "list.h"
+
 
 using namespace std;
@@ -26 +28 @@
 ObjectManager::ObjectManager () 
 {
-   this->setClassName ("ObjectManager");
+  this->setClassName ("ObjectManager");
+  
+  //this->managedObjectList = new BaseObject*[CL_NUMBER];
+  this->managedObjectList = new tList<BaseObject>*[CL_NUMBER];
 
+  this->garbageCollector = GarbageCollector::getInstance();
 }
 
@@ -45 +51 @@
 }
 
+
 /**
    \brief standard deconstructor
@@ -52 +59 @@
 {
   ObjectManager::singletonRef = NULL;
+}
 
+
+void ObjectManager::cache(classList index, int number, const BaseObject &copyObject)
+{
+  //this->managedObjectList[index] = new BaseObject[number];
+  this->managedObjectList[index] = new tList<BaseObject>();
+  for(int i = 0; i < number; ++i)
+    {
+      this->managedObjectList[index]->add(new BaseObject(copyObject));
+    }
 }
+
+
+void ObjectManager::addToDeadList(classList index, BaseObject* object)
+{
+  if( likely(this->managedObjectList[index] != NULL))
+    this->managedObjectList[index]->add(object);
+  else
+    PRINTF(0)(" Error: unable to add object to the list nr. %i: no list initialized - ignoring\n", index);
+}
+
+
+BaseObject* ObjectManager::getFromDeadList(classList index, int number)
+{
+  if( likely(this->managedObjectList[index] != NULL))
+    {
+      BaseObject* obj = this->managedObjectList[index]->firstElement();
+      this->managedObjectList[index]->remove(obj);
+      return obj;
+    }
+  else
+    PRINTF(0)(" Error: unable to get object from the list nr. %i: no elements initialized - ignoring\n", index);
+}
+
+
+void ObjectManager::debug()
+{
+  PRINT(0)("\n==========================| ObjectManager::debug() |===\n");
+  PRINT(0)("=  Number of registerable classes: %i\n", CL_NUMBER );  
+  PRINT(0)("=  Currently cached objects: \n");
+  for(int i = 0; i < CL_NUMBER; ++i)
+    {
+      if(this->managedObjectList[i] != NULL)
+        PRINT(0)("=   o Class Nr. %i has cached %i object(s)\n", i, this->managedObjectList[i]->getSize());
+      else
+        PRINT(0)("=   o Class Nr. %i has cached 0 object(s)\n", i);
+    }
+  PRINT(0)("=======================================================\n");
+}

orxonox/branches/physics/src/util/object_manager.h

@@ -18 +18 @@
 #define OM_
 
+#include "class_list.h"
+
+
 class WorldEntity;
+class GarbageCollector;
 
 
 template<class T> class tList; 
+template<class T> class ManagedObject;
 
 //! the object manager itself
@@ -29 +34 @@
   static ObjectManager* getInstance(void);
   virtual ~ObjectManager(void);
+  
+  void cache(classList index, int number, const BaseObject &copyObject);
+  void addToDeadList(classList index, BaseObject* object);
+  BaseObject* getFromDeadList(classList index, int number = 1);
 
-  void preLoad();
+  void debug();
 
  private:
@@ -36 +45 @@
   static ObjectManager* singletonRef;
 
-  tList<WorldEntity>* projectileBuffer;            //!< a list of projectiles that is generated at the beginning to make orx faster
+  //BaseObject** managedObjectList;
+  tList<BaseObject>** managedObjectList;
+  GarbageCollector* garbageCollector;
+};
 
 
-};
 
 #endif /* _OBJECT_MANAGER_H */