Changeset 9663 in orxonox.OLD for trunk/src/lib

Timestamp:

Aug 20, 2006, 3:07:59 PM (18 years ago)

Author:

bensch

Message:

more work on classID's

Location:

trunk/src/lib/lang

Files:

• new_class_id.h (modified) (2 diffs)
• new_object_list.cc (modified) (2 diffs)
• new_object_list.h (modified) (5 diffs)

trunk/src/lib/lang/new_class_id.h

@@ -12 +12 @@
 #include <string>
 
+#include "new_object_list.h"
+
 //! A class to dynamically allocate ClassID's and support a isA operator
 class NewClassID
@@ -18 +20 @@
   NewClassID();
   ~NewClassID();
+
+  void registerObject(NewObjectListBase* object);
 
 private:

trunk/src/lib/lang/new_object_list.cc

@@ -25 +25 @@
   if (NewObjectListBase::_classes == NULL)
     NewObjectListBase::_classes = new cList;
-  assert(!NewObjectListBase::exists(className) && "Classes should not be included once, and no two classes should have the same name (key value)");
+  assert(!NewObjectListBase::classNameExists(className) && "Classes should not be included once, and no two classes should have the same name (key value)");
 
+  this->_id = NewObjectListBase::_idCounter++;
 
 
@@ -46 +47 @@
  * @return true if such a class already exists.
  */
-bool NewObjectListBase::exists(const std::string& name)
+bool NewObjectListBase::classNameExists(const std::string& name)
 {
   cList::iterator it;

trunk/src/lib/lang/new_object_list.h

@@ -10 +10 @@
 #include "type_info.h"
 #include <set>
+#include <list>
 #include <string>
 
-#define DeclareClass(ClassName) \
-   NewObjectList ClassID_##ClassName(ClassName)
 
-#define DeclareInClass(ClassName) \
-   NewObjectList objectList(ClassName)
+#define NewObjectListDeclaration(ClassName) \
+   static NewObjectList<ClassName> objectList
+
+#define NewObjectListDefinition(ClassName) \
+   NewObjectList<ClassName> ClassName::objectList(#ClassName)
 
 class NewObjectListBase
@@ -23 +25 @@
   int id() const { return _id; };
   const std::string& name() const { return _name; };
+  bool operator==(int id) const { return _id == id; };
+  bool operator==(const std::string& name) const { return _name == name; };
 
-  static int classCount() { return _idCounter; };
 
+  /// Comparing operators.
   bool compareName(const NewObjectListBase& more) { return this->_name < more.name(); };
   bool compareID(const NewObjectListBase& more) { return this->_id < more.id(); };
+
+
+  static unsigned int                   classCount() { return _idCounter; };
+  static const std::string&             IDToString(int classID);
+  static int                            StringToID(const std::string& className);
+
+  static const std::list<std::string>&  getClassNames();
 
 protected:
   NewObjectListBase(const std::string& className);
   ~NewObjectListBase();
+
 private:
   NewObjectListBase(const NewObjectListBase&);
 
-  static bool exists(const std::string& className);
+  static bool classNameExists(const std::string& className);
 
 private:
@@ -46 +58 @@
   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.
 };
 
@@ -52 +65 @@
 //// TEMPLATISATION /////
 /////////////////////////
+//! Defines a ObjectsList handler for objects of type T.
+/**
+ * @note The Class must define the compare with const std::string& operator for this to work.
+ */
 template<class T> class NewObjectList : public NewObjectListBase
 {
+public:
+  typedef std::list<T*>               list;
+  typedef typename list::iterator     iterator;
+
+
 public:
   NewObjectList(const std::string& name);
   ~NewObjectList();
 
+  T*                      getObject(const std::string& name) const;
+  inline const list&      objects() const { return _objects; };
+
+
 private:
   //! the copy constructor will be hidden.
   NewObjectList(const NewObjectList& definer) {};
+
+  list                _objects;
 };
 
@@ -70 +98 @@
 template <class T>
 NewObjectList<T>::~NewObjectList()
-{}
+{
+  assert(_objects.empty());
+}
 
+template <class T>
+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;
+}
 
 #endif /* _NEW_OBJECT_LIST_H */