Changeset 9673 in orxonox.OLD

Timestamp:

Aug 21, 2006, 6:22:53 PM (18 years ago)

Author:

bensch

Message:

ClassList seems to work as it should.

Location:

trunk/src/lib/lang

Files:

• new_class_id.cc (modified) (1 diff)
• new_class_id.h (modified) (2 diffs)
• new_object_list.h (modified) (2 diffs)
• test_object_list.cc (modified) (4 diffs)

trunk/src/lib/lang/new_class_id.cc

@@ -35 +35 @@
 {
   //  assert(_objectList != NULL);
-  std::list<NewObjectListBase::ClassEntry>::iterator it;
+  ClassList::iterator it;
   for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
     (*it)._objectList->unregisterObject((*it)._iterator);

trunk/src/lib/lang/new_class_id.h

@@ -8 +8 @@
 #define _NEW_CLASS_ID_H
 
-#include "type_info.h"
+#include "new_object_list.h"
+
 #include <string>
 #include <list>
-#include "new_object_list.h"
 
 
@@ -23 +23 @@
   ~NewClassID();
 
+
   template<class T> void registerObject(T* object, NewObjectList<T>& list);
+  bool isA(const NewObjectListBase& objectList) const;
+  bool isA(int id) const;
+  bool isA(const std::string& className) const;
 
 private:
-  std::list<NewObjectListBase::ClassEntry>       _classes;
+
+  //////////////////////////////
+  //// Type Definition Part ////
+  //////////////////////////////
+  //! A ClassEntry so we can store Classes inside of Objects
+  struct ClassEntry{
+    /** Simple Constuctor @param objectList the NewObjectList, @param iterator the (intrusive) Iterator inside of the ObjectList */
+    inline ClassEntry (NewObjectListBase* objectList, NewObjectListBase::IteratorBase* iterator) : _objectList(objectList), _iterator(iterator) {}
+    NewObjectListBase*                _objectList;  //!< A ObjectList this Object is part of
+    NewObjectListBase::IteratorBase*  _iterator;    //!< An iterator pointing to the position of the Object inside of the List.
+  };
+  typedef std::list<ClassEntry>        ClassList;   //!< Type definition for the List.
+  ClassList                           _classes;     //!< All Classes this object is part of.
 };
 
 
+/**
+ * @brief Registeres an Object of Type T to objectList
+ * @param object The Object to append to the objectList.
+ * @param objectList The ObjectList to append the Object to.
+ *
+ * This function is essential to integrate objects into their designated ObjectList.
+ * Remember if you do not want objects to be stored in Lists (less overhead),
+ * do not attempt to call this function.
+ */
 template<class T>
     inline void NewClassID::registerObject(T* object, NewObjectList<T>& objectList)
 {
-  this->_classes.push_back(NewObjectListBase::ClassEntry(&objectList, objectList.registerObject(object)));
-
-  /*  this->_objectList = &objectList;
-  _iterators.push_back(objectList.registerObject(object, this->_objectList));*/
+  this->_classes.push_back(ClassEntry(&objectList, objectList.registerObject(object)));
 }
 

trunk/src/lib/lang/new_object_list.h

@@ -21 +21 @@
    NewObjectList<ClassName> ClassName::objectList(#ClassName)
 
+
+//! The superclass that all NewObjectLists follow.
+/**
+ * @see template<class T> NewObjectList<T>
+ */
 class NewObjectListBase
 {
 public:
+  //! An iterator Base-Class, for iterator-casting and storing.
   class IteratorBase { };
-  struct ClassEntry{
-    inline ClassEntry (NewObjectListBase* objectList, NewObjectListBase::IteratorBase* iterator) : _objectList(objectList), _iterator(iterator) {}
-    NewObjectListBase*                _objectList;
-    NewObjectListBase::IteratorBase*  _iterator;
-  };
 
 public:
@@ -83 +84 @@
 //! Defines a ObjectsList handler for objects of type T.
 /**
+ * To define a Class with a ObjectList, you have to:
+ *  1. Include 'NewObjectListDeclaration(T);' in its Declaration (at the beginning)
+ *  2. Include 'NewObjectListDefinition(T);' in some Definition file (cc-file)
+ *  3. In the constructor add 'registerObject(this, objectList);'
+ *
  * @note The Class must define the compare with const std::string& operator for this to work.
  */

trunk/src/lib/lang/test_object_list.cc

@@ -5 +5 @@
 class BaseObject
 {
-  public:
-    void setName(const std::string& name) { this->_objectName = name; };
+public:
+  void setName(const std::string& name) { this->_objectName = name; };
   const std::string& name() const { return _objectName; };
   bool operator==(const std::string& name) const { return _objectName == name; };
@@ -16 +16 @@
   BaseObject(const std::string& objectName = "") : _objectName(objectName) { this->registerObject(this, objectList); };
   template<class T>
-      inline void registerObject(T* object, NewObjectList<T>& objectList) { _id.registerObject(object, objectList); };
-  private:
+  inline void registerObject(T* object, NewObjectList<T>& objectList) { _id.registerObject(object, objectList); };
+private:
   NewClassID    _id;
   std::string   _objectName;
@@ -41 +41 @@
 {
   this->registerObject(this, Test::objectList);
-  std::cout << "Test()\n";
+ // std::cout << "Test()\n";
 };
 Test::~Test()
-{ std::cout << "~Test()\n"; }
+{
+//  std::cout << "~Test()\n";
+}
 
 class Bone : public BaseObject
 {
 public:
-  Bone() {
+  Bone()
+  {
     this->registerObject(this, Bone::objectList);
-    std::cout << "Bone()\n"; };
-  ~Bone() { std::cout << "~Bone()\n"; };
+    //std::cout << "Bone()\n";
+  };
+  ~Bone() {
+  //  std::cout << "~Bone()\n";
+  };
   NewObjectListDeclaration(Bone);
 };
@@ -59 +65 @@
 int main()
 {
-  Test* test = new Test();
-  test->setName("Test-object");
-
-  Test::objectList.debug();
 
 
-  Test::objectList.debug();
+
+  Test* test = new Test[1000000];
+  //test->setName("Test-object");
+
+//  Test::objectList.debug();
+/*
   Bone* bone = new Bone();
-  bone->setName("Bone-object");
+  bone->setName("Bone-object");*/
 
-  std::cout << "Here is debug of all Classes\n";
-  BaseObject::objectList.debug();
-  delete bone;
-  delete test;
-
+  //std::cout << "Here is debug of all Classes\n";
+  //BaseObject::objectList.debug();
+//   delete bone;
+  delete []test;
 }