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

Timestamp:

Aug 31, 2006, 10:51:08 PM (18 years ago)

Author:

bensch

Message:

orxonox/branches/new_class_id: new_class ID working, adapdet many classes, and reinvented some of the ClassID stuff

Location:

branches/new_class_id/src/lib/lang

Files:

• base_object.h (modified) (1 diff)
• new_class_id.cc (modified) (1 diff)
• new_class_id.h (modified) (1 diff)
• new_object_list.cc (modified) (8 diffs)
• new_object_list.h (modified) (10 diffs)

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

@@ -44 +44 @@
   //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(); };
+  inline const char* getClassCName() const { return _classes.front()._objectList->name().c_str(); };
   /** @returns the ClassName of the Topmost Object of the ClassStack */
-  inline const std::string& getClassName() const { return _classes.front()._objectList->name(); }
+  inline const std::string& getClassName() const { return _classes.front()._objectList->name(); };
 
   inline const NewClassID& getClassID() const { return *_leafClassID; }

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

@@ -19 +19 @@
 #include "new_object_list.h"
 
+/**
+ * @brief a Default Constructor.
+ * this Always points to the ID of the NullClass.
+ */
 NewClassID::NewClassID()
 {
-  *this = NullClass::classID();
+  NullClass::acquireID(this->_id, this->_name);
 };
 
-NewClassID::NewClassID(const NewObjectListBase* objList)
+/**
+ * @brief Acquiring the ID of a objectList.
+ * @param objList The NewObjectList to acquire the ID from.
+ */
+NewClassID::NewClassID(const NewObjectListBase* const objList)
 {
-
-  objList->acquireID(_id, _name);
-
+  objList->acquireID(this->_id, this->_name);
 }
 
 
 NewClassID NullClass::_classID;
+
+int NullClass::_nullID;
+const std::string NullClass::_nullName = std::string("NullClass");

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

@@ -12 +12 @@
 class NewObjectListBase;
 
-//! A class to dynamically allocate ClassID's and support a isA operator
+//! A class to dynamically allocate ClassID's and to support a isA operator
+/**
+ * A NewClassID can only be aquired over a NewObjectList,
+ * thus enabling the developer to have permanent access to the correct ID and ClassName
+ *
+ * The Idea behind this concept is, that storing a NewClassID that changes its internal state
+ * all NewClassID's will be updated correctly.
+ *
+ * Since the Existance of any NewObjectList is a requirement during the working process all
+ * ID's should reference a valid ID and ClassName
+ */
 class NewClassID
 {
 public:
   NewClassID();
-  NewClassID(const NewObjectListBase* id);
-  // the copy constructor is also defined.
+  NewClassID(const NewObjectListBase* const id);
+  /// the copy constructor is also defined implicitely.
+
+  /** @returns A constant reference to the ID. */
   const int& id() const { return *_id; };
+  /** @returns A constant reference to the Name. */
   const std::string& name() const { return *_name; };
 
+  /** @param id the id to compare @returns true on match (match is same ID) @brief compares two id's */
   bool operator==(const NewClassID& id) const { return *_id == *id._id /* || _name == id._name */; };
+  /** @param id the id to compare @returns true on match (match is same ID) @brief compares two id's */
   bool operator==(int id) const { return *_id == id; };
+  /** @param name the id to compare @returns true on match (match is same Name) @brief compares an ID with a ClassName */
   bool operator==(const std::string& name) const { return *_name == name; };
+  /** @param id the id to compare @returns false on match (match is same ID) @brief compares two id's */
   bool operator!=(const NewClassID& id) const { return *_id != *id._id /* && _name != id._name*/;  };
+  /** @param id the id to compare @returns false on match (match is same ID) @brief compares two id's */
   bool operator!=(int id) const { return *_id != id; };
+  /** @param name the id to compare @returns false on match (match is same Name) @brief compares an ID with a ClassName */
   bool operator!=(const std::string& name) const { return *_name != name; };
 
 private:
-  const int*                _id;
-  const std::string*        _name;
+  const int*                _id;           //!< A pointer to the ID of the ClassID.
+  const std::string*        _name;         //!< A pointer to the Name of the ClassID.
 };
 
+//! A NullClass. This is the Null of the ClassID.
+/**
+ * implemented as a Class id can be used to reference NullObjects.
+ */
 class NullClass
 {
 public:
-  static NewClassID classID() { return NullClass::_classID; }
+  /** @returns the NullClass' ID. */
+  static const NewClassID& classID() { return NullClass::_classID; }
+  /** @param id the ID to acquire @param name the name to acquire @brief acquires the ID of this Class */
+  static void acquireID(const int*& id, const std::string*& name) { id = &_nullID; name = &_nullName; };
+
 private:
-  NullClass();
+  NullClass() {}; //!< The Default Constructor is hidden from the User.
+
 private:
-  static NewClassID _classID;
+  static NewClassID         _classID;      //!< The NullClass' ID
+  static const std::string  _nullName;     //!< The NullClass' Name ("NullClass")
+  static int                _nullID;       //!< The NullClass' ID
 };
 

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

@@ -20 +20 @@
 
 
+#include <stdio.h>
+
 /**
  * @brief Constructor, that creates an ObjectList while checking (development mode) for uniqueness of all Keys (names and ID's)
@@ -27 +29 @@
  */
 NewObjectListBase::NewObjectListBase(const std::string& className, int id)
-  : _name(className)
-{
+    : _name(className)
+{
+  printf("NewObjectList, Registered %s::%d\n", className.c_str(), id);
   if (NewObjectListBase::_classesByID == NULL)
   {
@@ -47 +50 @@
   _id = id;
   /// Some Output, that will fall out later
-  //std::cout << "register new ObjectList " << className << " ID: " << this->_id << std::endl;
+  std::cout << "register new ObjectList " << className << " ID: " << this->_id << std::endl;
 
   this->_identity = NewClassID(this);
@@ -98 +101 @@
  * @return true if such a class already exists.
  */
+bool NewObjectListBase::classIDExists(int id)
+{
+  return (NewObjectListBase::_classesByID->find(id) != NewObjectListBase::_classesByID->end());
+}
+
+/**
+ * @brief Checks if a Class with name already exists.
+ * @param name The Name of the Class to check.
+ * @return true if such a class already exists.
+ */
 bool NewObjectListBase::classNameExists(const std::string& name)
 {
@@ -108 +121 @@
  * @returns the ClassID if found and NullClass' identity if not.
  */
-const NewClassID& NewObejctListBase::retrieveIdentity(int id)
+const NewClassID& NewObjectListBase::retrieveIdentity(int id)
 {
   const NewObjectListBase* const base = NewObjectListBase::getObjectList(id);
@@ -117 +130 @@
     return NullClass::classID();
 }
+
 
 /**
@@ -130 +144 @@
     return base->_identity;
   else
-    return NullObject::classID();
-}
-
-
-/**
- * @brief Checks if a Class with name already exists.
- * @param name The Name of the Class to check.
- * @return true if such a class already exists.
- */
-bool NewObjectListBase::classIDExists(int id)
-{
-  return (NewObjectListBase::_classesByID->find(id) != NewObjectListBase::_classesByID->end());
+    return NullClass::classID();
 }
 
@@ -230 +233 @@
 }
 
+#include "base_object.h"
+
+/**
+ * @brief Prints out some debugging information about a given List.
+ */
+void NewObjectListBase::debug(unsigned int level) const
+{
+  base_list list;
+  this->getBaseObjectList(&list);
+
+  if (level > 1 || !list.empty())
+    printf(" ObjectList of class %s(id:%d) contains %d objects\n", this->name().c_str(), this->id(), list.size());
+
+  if (level >= 2)
+  {
+    printf("  - listing Instances: \n");
+    for (base_iterator it = list.begin();
+         it != list.end();
+         ++it)
+    {
+      printf("   + %s::%s\n", (*it)->getClassCName(), (*it)->getCName());
+    }
+  }
+}
+
+
+void NewObjectListBase::debugAll(unsigned int level)
+{
+  printf("Listing all %d ObjectLists \n", NewObjectListBase::_classesByID->size());
+
+  for (classNameMap::const_iterator it = NewObjectListBase::_classesByName->begin();
+       it != NewObjectListBase::_classesByName->end();
+       ++it)
+  {
+    (*it).second->debug(level);
+
+  }
+
+}
+
+
 
 /**

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

@@ -48 +48 @@
   class IteratorBase { };
 
-  typedef std::list<BaseObject*>            base_list;
-  typedef base_list::iterator               base_iterator;
+  /** @brief A Typedefinition for the Base-List that can be retrieved with getBaseObjectList(base_list*) */
+  typedef std::list<BaseObject*>        base_list;
+  /** @brief An iterator for the base_list */
+  typedef base_list::iterator           base_iterator;
 
 public:
   /** @returns The Identity of the Class stored within. */
-  inline const NewClassID& identity() const { return _identity; }
+  inline const NewClassID&              identity() const { return _identity; }
   /** @returns the ID of the Identity of the ObjectList */
-  inline int id() const { return _id; };
+  inline int                            id() const { return _id; };
   /** @returns The Name of the Class stored in this ObjectList */
-  inline const std::string& name() const { return _name; };
+  inline const std::string&             name() const { return _name; };
   /** @param id The id to compare @returns true on match, false otherwise */
-  inline bool operator==(int id) const { return _id == id; };
+  inline bool                           operator==(int id) const { return _id == id; };
   /** @param id The id to compare @returns true on match, false otherwise */
-  inline bool operator==(const NewClassID& id) const { return id == _id; };
+  inline bool                           operator==(const NewClassID& id) const { return id == _id; };
   /** @param name The name to compare @returns true on match, false otherwise */
-  inline bool operator==(const std::string& name) const { return _name == name; };
+  inline bool                           operator==(const std::string& name) const { return _name == name; };
   /** @param id The id to check @returns true on match, false otherwise */
-  inline void acquireID(const int*& id, const std::string*& name) const { id = &_id; name = &_name; };
+  inline void                           acquireID(const int*& id, const std::string*& name) const { id = &_id; name = &_name; };
   /** @brief fills a list of Objects into a BaseObject*-List. @param list the list to fill */
-  virtual void getBaseObjectList(base_list* list) const = 0;
-
-  static const NewClassID& retrieveIdentity(int id);
-  static const NewClassID& retrieveIdentity(const std::string& name);
+  virtual void                          getBaseObjectList(base_list* list) const = 0;
+
+  static const NewClassID&              retrieveIdentity(int id);
+  static const NewClassID&              retrieveIdentity(const std::string& name);
 
   static const NewObjectListBase* const getObjectList(int classID);
@@ -76 +78 @@
   static const NewObjectListBase* const getObjectList(const NewClassID& classID);
 
-  static BaseObject* getBaseObject(int classID, const std::string& objectName);
-  static BaseObject* getBaseObject(const std::string& className, const std::string& objectName);
-  static BaseObject* getBaseObject(const NewClassID& classID, const std::string& objectName);
+  static BaseObject*                    getBaseObject(int classID, const std::string& objectName);
+  static BaseObject*                    getBaseObject(const std::string& className, const std::string& objectName);
+  static BaseObject*                    getBaseObject(const NewClassID& classID, const std::string& objectName);
 
   /** @returns an Object with Name name out of this List @param name the name of the Object. */
-  virtual BaseObject* getBaseObject(const std::string& name) const = 0;
+  virtual BaseObject*                   getBaseObject(const std::string& name) const = 0;
 
   static const std::list<std::string>&  getClassNames();
 
+
   static unsigned int                   classCount();
+  void                                  debug(unsigned int level) const;
+  static void                           debugAll(unsigned int level);
+
   static const std::string&             IDToString(int classID);
   static int                            StringToID(const std::string& className);
 
-  virtual void debug() const = 0;
-
   //! Only uset to unsubscribe a BaseObject.
-  virtual void unregisterObject(IteratorBase* _iterators) = 0;
+  virtual void                          unregisterObject(IteratorBase* _iterators) = 0;
 
 protected:
@@ -101 +105 @@
   NewObjectListBase(const NewObjectListBase&);
 
-  static bool classIDExists(int id);
-  static bool classNameExists(const std::string& className);
+  static bool                         classIDExists(int id);
+  static bool                         classNameExists(const std::string& className);
 
 
@@ -126 +130 @@
 //! Defines a ObjectsList handler for objects of type T.
 /**
+ * The ObjectList is a generic way to store every object created from a Class 'T'
+ *  into a List. The list can be retrieved, and used constantly over iterators,
+ *  as with normal std::list.
+ *
+ * Furthermore the linkage over the single Lists is given over the Superclass NewObjectListBase.
+ *
+ *
+ *
+ *
  * To define a Class with a ObjectList, you have to:
  *  1. Include 'NewObjectListDeclaration(T);' in its Declaration (at the beginning)
@@ -132 +145 @@
  *
  * @note The Class must define the compare with const std::string& operator for this to work.
+ *
+ *
+ *
+ * Limitations:
+ *  ObjectList cannot be used with other Factory style Classes, if the class is also a BaseObject,
+ *   and not loaded before the ObjectList.
+ *
+ * @example Iterating: Iteration is made easy, and fast as follows:
+ *   for (NewObjectList<PlayerStats>::const_iterator it = PlayerStats::objectList().begin();
+ *      it != PlayerStats::objectList().end();
+ *     ++it)
+ *   {
+ *    (*it)->dosomething
+ *   }
+ *
+ * @example Find an Object:
+ * Playable* playable = Playable::objectList("orxonox-super-rocket-fighter"); // searches an Object By its name.
+ *
  */
 template<class T>
@@ -154 +185 @@
   ~NewObjectList();
 
-  virtual BaseObject*     getBaseObject(const std::string& name) const;
-  T*                      getObject(const std::string& name) const;
-  inline const list&      objects() const { return _objects; };
-  bool exists(const T* const object) const;
-
-  inline iterator begin() { return _objects.begin(); };
-  inline const_iterator begin() const { return _objects.begin(); };
-  inline iterator  end() { return _objects.end(); };
-  inline const_iterator  end() const { return _objects.end(); };
-
-  inline bool empty() const { return _objects.empty(); };
-  inline int size() const { return _objects.size(); };
-  inline T* front() const { return _objects.front(); };
-  inline T* back() const { return _objects.back(); };
-
-
-  NewObjectListBase::IteratorBase* registerObject(T* object);
-  virtual void unregisterObject(IteratorBase* iterator);
-
-  virtual void debug() const;
+  virtual BaseObject*                getBaseObject(const std::string& name) const;
+  T*                                 getObject(const std::string& name) const;
+  inline const list&                 objects() const { return _objects; };
+  bool                               exists(const T* const object) const;
+
+  /** @returns an Iterator to the beginning of the List. */
+  inline iterator                    begin() { return _objects.begin(); };
+  /** @returns a constant Iterator to the beginning of the List. */
+  inline const_iterator              begin() const { return _objects.begin(); };
+  /** @returns an Iterator to the end of the List. */
+  inline iterator                    end() { return _objects.end(); };
+  /** @returns a constant Iterator to the beginning of the List. */
+  inline const_iterator              end() const { return _objects.end(); };
+
+  /** @returns true if the List is empty. */
+  inline bool                        empty() const { return _objects.empty(); };
+  /** @returns the size of the List */
+  inline int                         size() const { return _objects.size(); };
+  /** @returns the frontmost Element of the list (normaly the last added Object). */
+  inline T*                          front() const { return _objects.front(); };
+  /** @returns the last added Object */
+  inline T*                          back() const { return _objects.back(); };
+
+
+  NewObjectListBase::IteratorBase*   registerObject(T* object);
+  virtual void                       unregisterObject(IteratorBase* iterator);
 
 protected:
-  virtual void getBaseObjectList(NewObjectListBase::base_list* list) const;
+  virtual void                       getBaseObjectList(NewObjectListBase::base_list* list) const;
 
 
@@ -184 +221 @@
 
 private:
-  list                _objects;
+  list                _objects;     //!< The List of stored Objects of Type T.
 };
 
@@ -212 +249 @@
   if (!_objects.empty())
   {
-    std::cout << "There are still Object in the ObjectList of " << this->name() << "(id:" << this->id() << ")\n";
-    this->debug();
+    // std::cout << "There are " << this->size() << " objects from class " << this->name() << "(id:" << this->id() << ") in existance\n";
   }
 }
@@ -279 +315 @@
 NewObjectListBase::IteratorBase* NewObjectList<T>::registerObject(T* object)
 {
-  this->_objects.push_front(object);
-  return new Iterator(this->_objects.begin());
+  this->_objects.push_back(object);
+  return new Iterator(--this->_objects.end());
 }
 
@@ -294 +330 @@
 }
 
-/**
- * @brief print out some debug information
- * @note this function will most probably vanish from here and be completely moved to the base class.
- */
-template <class T>
-void NewObjectList<T>::debug() const
-{
-  const_iterator it;
-  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
-  {
-    std::cout << (*it)->getName() << std::endl;
-  }
-}
-
 #endif /* _NEW_OBJECT_LIST_H */