Changeset 9684 in orxonox.OLD for branches/new_class_id/src/lib/lang

Timestamp:

Aug 22, 2006, 1:34:31 AM (19 years ago)

Author:

bensch

Message:

orxonox/branches/new_class_id: slowly but surely reimplementing to the new groove… way to go

Location:

branches/new_class_id/src/lib/lang

Files:

• Makefile.am (modified) (2 diffs)
• base_object.cc (modified) (5 diffs)
• base_object.h (modified) (3 diffs)
• class_list.cc (deleted)
• class_list.h (deleted)
• new_object_list.h (modified) (2 diffs)

branches/new_class_id/src/lib/lang/Makefile.am

@@ -9 +9 @@
 libORXlang_a_SOURCES = \
                 base_object.cc \
-                class_list.cc \
                 new_class_id.cc \
                 new_object_list.cc
@@ -15 +14 @@
 noinst_HEADERS = \
                 base_object.h \
-                class_list.h \
                 new_class_id.h \
                 new_object_list.h

branches/new_class_id/src/lib/lang/base_object.cc

@@ -20 +20 @@
 
 #include "util/loading/load_param.h"
-#include "class_list.h"
 
 /**
@@ -28 +27 @@
 BaseObject::BaseObject(const std::string& objectName)
 {
-  this->classID = CL_BASE_OBJECT;
   this->className = "BaseObject";
 
   this->objectName = objectName;
-  this->classList = NULL;
   this->xmlElem = NULL;
 
@@ -43 +40 @@
 BaseObject::~BaseObject ()
 {
-  ClassList::removeFromClassList(this);
+  /// Remove from the NewObjectLists
+  ClassList::iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+  {
+    (*it)._objectList->unregisterObject((*it)._iterator);
+    delete (*it)._iterator;
+  }
 
   if (this->xmlElem != NULL)
@@ -69 +72 @@
 
 /**
- * @brief sets the class identifiers
- * @param id a number for the class from class_id.h enumeration
- * @param className the class name
-*/
-void BaseObject::setClassID(ClassID classID, const std::string& className)
-{
-  //printf("%s(0x%.8X)->%s(0x%.8X)\n", this->className, this->classID, className, classID);
-  assert (!(this->classID & classID & !CL_MASK_SUBSUPER_CLASS_IDA ));
-
-  this->leafClassID = classID;
-  this->classID |= (long)classID;
-  this->className = className;
-
-  this->classList = ClassList::addToClassList(this, classID, this->classID, className);
-}
-
-
-/**
  * @brief set the name of the Object
  * @param objectName The new name of the Object.
@@ -97 +82 @@
 
 /**
- * @brief queries for the ClassID of the Leaf Class (the last made class of this type
- * @returns the ClassID of the Leaf Class (e.g. the ID of the Class)
- *
- * the returned ID can be used to generate new Objects of the same type through
- * Factory::fabricate(Object->getLeafClassID());
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param objectList The ObjectList this should be a member of (by Pointer-comparison).
+ * @return True if found, false if not.
  */
-const ClassID& BaseObject::getLeafClassID() const
+bool BaseObject::isA(const NewObjectListBase& objectList) const
 {
-  return this->leafClassID;
+  ClassList::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if ((*it)._objectList == &objectList)
+      return true;
+  return false;
 }
 
-
+/**
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param classID The ClassID of the class this should be a member of.
+ * @return True if found, false if not.
+ */
+bool BaseObject::isA(int classID) const
+{
+  ClassList::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if (*(*it)._objectList == classID)
+      return true;
+  return false;
+}
 
 /**
- * @brief checks if the class is a classID
- * @param classID the Identifier to check for
- * @returns true if it is, false otherwise
-*/
-bool BaseObject::isA (ClassID classID) const
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param className The ClassName of the class this should be a member of.
+ * @return True if found, false if not.
+ */
+bool BaseObject::isA(const std::string& className) const
 {
-  // if classID is a derivable object from a SUPERCLASS
-  if (classID & CL_MASK_SUPER_CLASS)
-  {
-    if( likely(this->classID & classID))
+  ClassList::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if (*(*it)._objectList == className)
       return true;
-  }
-  // if classID is a SubSuperClass, and
-  else if (classID & CL_MASK_SUBSUPER_CLASS)
-  {
-    if (likely(((this->classID & CL_MASK_SUBSUPER_CLASS_IDA) == (classID & CL_MASK_SUBSUPER_CLASS_IDA)) &&
-        this->classID & classID & CL_MASK_SUBSUPER_CLASS_IDB))
-      return true;
-  }
-  // if classID is a LOWLEVEL-class
-  else
-  {
-    if( likely((this->classID & CL_MASK_LOWLEVEL_CLASS) == classID))
-      return true;
-  }
   return false;
 }
 
 
+void BaseObject::listInheritance() const
+{
+  PRINT(0)("Listing inheritance diagram for ....: ");
+  ClassList::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    PRINT(0)(" -> %s(id:%d)", (*it)._objectList->name().c_str(), (*it)._objectList->id());
+  PRINT(0)("\n");
 
-/**
- * @brief checks if the class is a classID
- * @param classID the Identifier to check for
- * @returns true if it is, false otherwise
- */
-bool BaseObject::isA (const std::string& className) const
-{
-  ClassID classID = ClassList::StringToID(className);
-  if (classID != CL_NULL)
-    return this->isA(classID);
-  else
-    return false;
 }
-
-
-/**
- * @brief compares the ObjectName with an external name
- * @param objectName: the name to check.
- * @returns true on match, false otherwise.
- */
-bool BaseObject::operator==(const std::string& objectName) const
-{
-  return (this->objectName == objectName);
-}
-

branches/new_class_id/src/lib/lang/base_object.h

@@ -14 +14 @@
 #define __BASE_OBJECT_H_
 
-#include "class_id.h"
+#include "new_object_list.h"
 #include "sigslot/slot.h"
 
@@ -41 +41 @@
   inline TiXmlNode* getXmlElem() const { return this->xmlElem; };
 
-  /** @returns the className of the corresponding Object */
-  inline const std::string& getClassName() const { return this->className; }
+  //  /** @returns the className of the corresponding Object */
+  //inline const std::string& getClassName() const { return this->className; }
   /** @returns the className of the corresponding Object as a C-compliant string (const char*) */
   inline const char* getClassCName() const { return this->className.c_str(); };
-  /** @returns the classID of the corresponding Object */
-  inline int getClassID() const { return this->classID; };
-  const ClassID& getLeafClassID() const;
+  /** @returns the ClassName of the Topmost Object of the ClassStack */
+  inline const std::string& getClassName() const { return _classes.front()._objectList->name(); }
 
-  bool isA (ClassID classID) const;
-  bool isA (const std::string& className) const;
+  /** @returns the ID of the Topmost object of the ClassStack */
+  inline int getLeafClassID() const { return _classes.front()._objectList->id(); }
+
+  bool isA(const NewObjectListBase& objectList) const;
+  bool isA(int classID) const;
+  bool isA(const std::string& className) const;
+
+  void listInheritance() const;
 
   /** @param classID comparer for a ClassID @returns true on match, false otherwise */
-  bool operator==(ClassID classID) const  { return this->isA(classID); };
-  bool operator==(const std::string& objectName) const;
+  bool operator==(int classID) const  { return this->isA(classID); };
+  /** @param objectName: the name to check. * @returns true on match, false otherwise. */
+  bool operator==(const std::string& objectName) const { return this->objectName == objectName;};
 
 protected:
-  void setClassID(ClassID classID, const std::string& className);
+  template<class T> void registerObject(T* object, NewObjectList<T>& list);
 
 protected:
@@ -63 +69 @@
 
 private:
-  std::string        className;        //!< the name of the class
-  long               classID;          //!< this is the id from the class_id.h enumeration
-  ClassID            leafClassID;      //!< The Leaf Class ID
-
-  ClassList*         classList;        //!< Pointer to the ClassList this Object is inside of
 
   TiXmlNode*         xmlElem;          //!< The XML Element with wich this Object was loaded(saved).
+
+  //////////////////////////////
+  //// 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.
+
+  std::string                         className;    //!< the name of the class
+  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 BaseObject::registerObject(T* object, NewObjectList<T>& objectList)
+{
+  this->_classes.push_front(ClassEntry(&objectList, objectList.registerObject(object)));
+}
+
 #endif /* __BASE_OBJECT_H_ */

branches/new_class_id/src/lib/lang/new_object_list.h

@@ -16 +16 @@
 
 #define NewObjectListDeclaration(ClassName) \
-   static NewObjectList<ClassName> objectList
+  public: \
+   static const NewObjectList<ClassName>& objectList() { return ClassName::_objectList; }; \
+  private: \
+   static NewObjectList<ClassName> _objectList
 
 #define NewObjectListDefinitionID(ClassName, ID) \
-   NewObjectList<ClassName> ClassName::objectList(#ClassName, ID)
+   NewObjectList<ClassName> ClassName::_objectList(#ClassName, ID)
 
 
@@ -157 +160 @@
 T* NewObjectList<T>::getObject(const std::string& name) const
 {
-  iterator it = std::find(this->_objects.begin(), this->_objects.end(), name);
-  if (it != this->_objects.end())
-    return *it;
-  else
-    return NULL;
+  const_iterator it;
+  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
+    if ((*it)->getName() == name)
+      return (*it);
+  return NULL;
 }