Changeset 9671 in orxonox.OLD

Timestamp:

Aug 21, 2006, 4:14:57 PM (18 years ago)

Author:

bensch

Message:

trunk: just realized, that polimorphism again is the evil part of classes.
Classes, that derive say from PNode and Element2D force that Element2D is registered after PNode, which means, that Element2D is interpretet as being derived from PNode in my implmentational idea…
hmm… now go for some new approach, this cannot and will not be the end of this…

Location:

trunk/src/lib/lang

Files:

• new_class_id.cc (modified) (1 diff)
• new_class_id.h (modified) (1 diff)
• new_object_list.cc (modified) (3 diffs)
• new_object_list.h (modified) (9 diffs)
• test_object_list.cc (modified) (3 diffs)

trunk/src/lib/lang/new_class_id.cc

@@ -36 +36 @@
 {
   assert(_objectList != NULL);
-
-
-  //  _objectList->unregister(this);
+  _objectList->unregisterObject(this->_iterators);
 }
 

trunk/src/lib/lang/new_class_id.h

@@ -26 +26 @@
 
 private:
-  NewObjectListBase*            _objectList;
+  NewObjectListBase*                           _objectList;
   std::list<NewObjectListBase::IteratorBase*>  _iterators; //!< Iterators to the class-list's positions.
 };
 
 
-template<class T> void NewClassID::registerObject(T* object, NewObjectList<T>& objectList)
+template<class T>
+    inline void NewClassID::registerObject(T* object, NewObjectList<T>& objectList)
 {
   this->_objectList = &objectList;
-  _iterators.push_back(objectList.registerObject(object));
+  _iterators.push_back(objectList.registerObject(object, this->_objectList));
 }
 

trunk/src/lib/lang/new_object_list.cc

@@ -24 +24 @@
 {
   if (NewObjectListBase::_classes == NULL)
-    NewObjectListBase::_classes = new cList;
+    NewObjectListBase::_classes = new cSet;
+
+
   assert(!NewObjectListBase::classNameExists(className) && "Classes should not be included once, and no two classes should have the same name (key value)");
 
@@ -37 +39 @@
 
 int NewObjectListBase::_idCounter = 0;
-NewObjectListBase::cList* NewObjectListBase::_classes = NULL;
+NewObjectListBase::cSet* NewObjectListBase::_classes = NULL;
 
 
@@ -48 +50 @@
 bool NewObjectListBase::classNameExists(const std::string& name)
 {
-  cList::iterator it;
+  cSet::iterator it;
   for (it = NewObjectListBase::_classes->begin(); it != NewObjectListBase::_classes->end(); it++)
     if(*it != NULL && (*it)->name() != name)

trunk/src/lib/lang/new_object_list.h

@@ -11 +11 @@
 #include <set>
 #include <list>
+#include <vector>
 #include <string>
 
@@ -33 +34 @@
 
   /// Comparing operators.
-  bool compareName(const NewObjectListBase& more) { return this->_name < more.name(); };
-  bool compareID(const NewObjectListBase& more) { return this->_id < more.id(); };
+  bool compareName(const NewObjectListBase& more) const { return this->_name < more.name(); };
+  bool compareID(const NewObjectListBase& more) const { return this->_id < more.id(); };
+
+  virtual void debug() const = 0;
 
   static unsigned int                   classCount() { return _idCounter; };
@@ -42 +45 @@
   static const std::list<std::string>&  getClassNames();
 
+  virtual void unregisterObject(std::list<NewObjectListBase::IteratorBase*> _iterators) = 0;
+
 protected:
-
   NewObjectListBase(const std::string& className);
-  ~NewObjectListBase();
+  virtual ~NewObjectListBase();
 
 private:
@@ -52 +56 @@
   static bool classNameExists(const std::string& className);
 
+protected:
+  typedef std::set<NewObjectListBase*>     cSet;    //!< The Generic Set.
+  typedef std::vector<NewObjectListBase*>  cVector; //!< The
+
+  int                           _id;                //!< The ID of the class.
+  std::string                   _name;              //!< The Name of the Class.
+
+  cVector                       _typeOfList;        //!< A List of all classes this class is derived of, and the class itself, ordered by age of addition.
+  cSet                          _typeOfSet;         //!< A Set of all classes this is derived from and the class itself (for isA).
 private:
-  int                           _id;
-  std::string                   _name;
 
-private:
-  typedef std::set<NewObjectListBase*>  cList;
-
-  static int                           _idCounter;      //!< A counter, that gives all classes a Unique ClassID. Access to this Variable is to be Thread-Safe.
-  static cList*                        _classes;        //!< A Set of all the classes in existance.
-  static std::list<std::string>        _classNames;     //!< A list of all the registered ClassNames.
+  static int                    _idCounter;         //!< A counter, that gives all classes a Unique ClassID. Access to this Variable is to be Thread-Safe.
+  static cSet*                  _classes;           //!< A Set of all the classes in existance.
+  static std::list<std::string> _classNames;        //!< A list of all the registered ClassNames.
 };
 
@@ -76 +84 @@
 {
 public:
-  typedef std::list<T*>               list;
-  typedef typename list::iterator     iterator;
+  typedef std::list<T*>                  list;
+  typedef typename list::iterator        iterator;
+  typedef typename list::const_iterator  const_iterator;
 
 class Iterator : public NewObjectListBase::IteratorBase
@@ -93 +102 @@
   inline const list&      objects() const { return _objects; };
 
-  NewObjectListBase::IteratorBase* registerObject(T* object);
+  NewObjectListBase::IteratorBase* registerObject(T* object, NewObjectListBase* objectList);
   void unregisterObject(const IteratorBase& iterator);
+  virtual void unregisterObject(std::list<NewObjectListBase::IteratorBase*> _iterators) = 0;
+
+  virtual void debug() const;
 
 private:
@@ -119 +131 @@
 NewObjectList<T>::~NewObjectList()
 {
- // assert(_objects.empty());
+  // assert(_objects.empty());
 }
 
@@ -133 +145 @@
 
 template <class T>
-NewObjectListBase::IteratorBase* NewObjectList<T>::registerObject(T* object)
+    NewObjectListBase::IteratorBase* NewObjectList<T>::registerObject(T* object, NewObjectListBase* objectList)
 {
+  if(this->_typeOfList.empty())
+  {
+    this->_typeOfList.push_back(objectList);
+  }
+
   this->_objects.push_front(object);
   return new Iterator(this->_objects.begin());
@@ -146 +163 @@
 }
 
+#include <iostream>
+
+template <class T>
+void NewObjectList<T>::debug() const
+{
+  const_iterator it;
+  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
+  {
+    std::cout << (*it)->name() << std::endl;
+  }
+}
 
 #endif /* _NEW_OBJECT_LIST_H */

trunk/src/lib/lang/test_object_list.cc

@@ -3 +3 @@
 #include <iostream>
 
-class Test
+class BaseObject
+{
+  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; };
+
+protected:
+  template<class T>
+      inline void registerObject(T* object, NewObjectList<T>& objectList) { _id.registerObject(object, objectList); };
+  private:
+  NewClassID    _id;
+  std::string   _objectName;
+
+};
+
+class Test : public BaseObject
 {
 public:
@@ -16 +32 @@
 
 Test::Test()
-{  std::cout << "Test()\n"; };
+{
+  this->registerObject(this, Test::objectList);
+  std::cout << "Test()\n";
+};
 Test::~Test()
 { std::cout << "~Test()\n"; }
 
-class Bone
+class Bone : public BaseObject
 {
 public:
-  Bone() { std::cout << "Bone()\n"; };
+  Bone() {
+    this->registerObject(this, Bone::objectList);
+    std::cout << "Bone()\n"; };
   ~Bone() { std::cout << "~Bone()\n"; };
   NewObjectListDeclaration(Bone);
@@ -32 +53 @@
 {
   Test* test = new Test();
+  test->setName("Testing");
 
-  NewClassID id;
-  id.registerObject(test, Test::objectList);
+  Test::objectList.debug();
 
   delete test;
+
+  Test::objectList.debug();
   Bone* bone = new Bone();
   delete bone;
+
+
 
   std::cout << NewObjectListBase::classCount() << std::endl;