Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/lang/object_list.h @ 10166

Last change on this file since 10166 was 10114, checked in by patrick, 18 years ago

merged network back to trunk

File size: 14.1 KB
Line 
1/*!
2 * @file object_list.h
3 * @brief Definition of a dynamically allocating ClassID
4 *
5 */
6
7#ifndef _OBJECT_LIST_H
8#define _OBJECT_LIST_H
9
10#include "class_id.h"
11#include <map>
12#include <list>
13#include <string>
14
15#include <cassert>
16#include <iostream>
17
18/**
19 * @brief Use this macro to easily declare a Class to store its own ObjectListDeclaration
20 * @param ClassName the Name of the Class.
21 * @note: Using this inside of a Class means, that you loose the member: _objectList, while defining
22 * two new functions objectList() and classID().
23 */
24#define ObjectListDeclaration(ClassName) \
25  public: \
26   static inline const ObjectList<ClassName>& objectList() { return ClassName::_objectList; }; \
27   static inline const ClassID& staticClassID() { return ClassName::_objectList.identity(); }; \
28  private: \
29   static ObjectList<ClassName> _objectList
30
31/**
32 * @brief Use this macro to easily define a Class to store its own ObjectListDefinition
33 * @param ClassName: the Name of the Class.
34 */
35#define ObjectListDefinition(ClassName) \
36    ObjectList<ClassName> ClassName::_objectList(#ClassName)
37
38class BaseObject;
39//! The superclass that all ObjectLists follow.
40/**
41 * @see template<class T> ObjectList<T>
42 */
43class ObjectListBase
44{
45public:
46  /** @brief A Typedefinition for the Base-List that can be retrieved with getBaseObjectList(base_list*) */
47  typedef std::list<BaseObject*>        base_list;
48  /** @brief An iterator for the base_list */
49  typedef base_list::iterator           base_iterator;
50  //! A fast iterator Base-Class, for iterator-casting and storing.
51  /** @note This Iterator is explicitely used only for storage purposes in the BaseObject */
52  class IteratorBase { };
53
54public:
55  /** @returns The Identity of the Class stored within. */
56  inline const ClassID&                 identity() const { return _identity; }
57  /** @returns the ID of the Identity of the ObjectList */
58  inline int                            id() const { return _id; };
59  /** @returns The Name of the Class stored in this ObjectList */
60  inline const std::string&             name() const { return _name; };
61  /** @param id The id to compare @returns true on match, false otherwise */
62  inline bool                           operator==(int id) const { return _id == id; };
63  /** @param id The id to compare @returns true on match, false otherwise */
64  inline bool                           operator==(const ClassID& id) const { return id == _id; };
65  /** @param name The name to compare @returns true on match, false otherwise */
66  inline bool                           operator==(const std::string& name) const { return _name == name; };
67  /** @param id The id to acquire @param name the Name to acquire @brief stores a Name and an ID in a pointer. */
68  inline void                           acquireID(const int*& id, const std::string*& name) const { id = &_id; name = &_name; };
69  /** @brief fills a list of Objects into a BaseObject*-List. @param list the list to fill */
70  virtual void                          getBaseObjectList(base_list* list) const = 0;
71
72  static const ClassID&                 retrieveIdentity(int id);
73  static const ClassID&                 retrieveIdentity(const std::string& name);
74
75  static const ObjectListBase* const    getObjectList(int classID);
76  static const ObjectListBase* const    getObjectList(const std::string& className);
77  static const ObjectListBase* const    getObjectList(const ClassID& classID);
78
79  static BaseObject*                    getBaseObject(int classID, const std::string& objectName);
80  static BaseObject*                    getBaseObject(const std::string& className, const std::string& objectName);
81  static BaseObject*                    getBaseObject(const ClassID& classID, const std::string& objectName);
82
83  /** @returns an Object with Name name out of this List @param name the name of the Object. */
84  virtual BaseObject*                   getBaseObject(const std::string& name) const = 0;
85
86  static const std::list<std::string>&  getClassNames();
87
88
89  static unsigned int                   classCount();
90  void                                  debug(unsigned int level) const;
91  static void                           debugAll(unsigned int level);
92
93  static const std::string&             IDToString(int classID);
94  static int                            StringToID(const std::string& className);
95
96  //! Only used to unsubscribe a BaseObject. (just try to make a valid iterator, stupid :))
97  virtual void                          unregisterObject(IteratorBase* _iterators) = 0;
98  //! Only for debug purposes
99  virtual bool                          checkIteratorInList(IteratorBase* _iterator) const = 0;
100  virtual bool                          checkObjectInList(BaseObject* obj) const = 0;
101
102protected:
103  ObjectListBase(const std::string& className);
104  virtual ~ObjectListBase();
105
106private:
107  /** @brief hidden copy constructor. */
108  ObjectListBase(const ObjectListBase&) {};
109
110  static bool                         classIDExists(int id);
111  static bool                         classNameExists(const std::string& className);
112
113
114protected:
115  typedef std::map<int, ObjectListBase*>         IDMap;   //!< The Generic Map.
116  typedef std::map<std::string, ObjectListBase*> NameMap; //!< The Generic Map.
117
118private:
119  int                           _id;                //!< The Unique ID of the Class.
120  const std::string             _name;              //!< The Name of the Class.
121  ClassID                       _identity;          //!< The Identity of the Class. (equal to _id and _name)
122
123private:
124  static IDMap*                 _classesByID;       //!< A Map of all the classes in existance.
125  static NameMap*               _classesByName;     //!< A Map of all the classes in existance.
126  static std::list<std::string> _classNames;        //!< A list of all the registered ClassNames.
127
128public:
129  static void replaceIDMap( const std::map<std::string, int>& str2id );
130  static std::map<std::string, int>* createStrToId();
131};
132
133
134/////////////////////////
135//// TEMPLATISATION /////
136/////////////////////////
137//! Defines a ObjectList handler for objects of type T.
138/**
139 * The ObjectList is a generic way to store every object created from a Class 'T'
140 *  in a List. The list can be retrieved, and used constantly over iterators,
141 *  as with normal std::list.
142 *
143 * Furthermore the linkage over the single Lists is given over the Superclass ObjectListBase.
144 *
145 * The approach of ObjectList is an intrusive one, meaning, that each Class that wants to
146 * support it must implement a Declaration and a Definition for the ObjectList, as mentioned
147 * in the next statement:
148 *
149 * To define a Class with a ObjectList, you have to:
150 *  1. Include 'ObjectListDeclaration(T);' in its Declaration (at the beginning)
151 *  2. Include 'ObjectListDefinition(T);' in some Definition file (cc-file)
152 *  3. In the constructor add 'registerObject(this, objectList);'
153 *
154 * @note The Class must define the compare with const std::string& operator for this to work.
155 *  The operator==(const std::string& name) should compare the object's name with name.
156 *
157 *
158 *
159 * Limitations:
160 *  ObjectList cannot be used with other Factory style Classes, if the class is also a BaseObject,
161 *   and not loaded before the ObjectList.
162 *
163 * example: Iterating: Iteration is made easy, and fast as follows:
164 *   for (ObjectList<PlayerStats>::const_iterator it = PlayerStats::objectList().begin();
165 *      it != PlayerStats::objectList().end();
166 *     ++it)
167 *   {
168 *    (*it)->dosomething
169 *   }
170 *
171 * example: Find an Object:
172 * Playable* playable = Playable::objectList("orxonox-super-rocket-fighter"); // searches an Object By its name.
173 *
174 */
175template<class T>
176class ObjectList : public ObjectListBase
177{
178public:
179  typedef std::list<T*>                  list;             //!< The list of Type T* (used for Objects in this ObjectList)
180  typedef typename list::iterator        iterator;         //!< The iterator for the List of type T (use with ObjectList<Type>::iterator)
181  typedef typename list::const_iterator  const_iterator;   //!< A constant iterator for the List of type T (use with ObjectList<Type>::const_iterator)
182
183
184  //! An iterator to store Objects in the BaseObject, and remove Objects fast.
185class Iterator : public ObjectListBase::IteratorBase
186  {
187  public:
188    /** @brief creates an Iterator fast. @param it the Iterator. */
189    inline Iterator(iterator it) { _it = it; }
190    /** @returns the Iterator */
191    inline iterator& it() { return _it; }
192  private:
193    typename ObjectList::iterator _it;  //!< Stored Iterator
194  };
195
196public:
197  ObjectList(const std::string& name);
198  ~ObjectList();
199
200  virtual BaseObject*                getBaseObject(const std::string& name) const;
201  T*                                 getObject(const std::string& name) const;
202  /** @returns A constant list of Objects of this Class. */
203  inline const list&                 objects() const { return _objects; };
204  bool                               exists(const T* const object) const;
205
206  /** @returns an Iterator to the beginning of the List. */
207  inline iterator                    begin() { return _objects.begin(); };
208  /** @returns a constant Iterator to the beginning of the List. */
209  inline const_iterator              begin() const { return _objects.begin(); };
210  /** @returns an Iterator to the end of the List. */
211  inline iterator                    end() { return _objects.end(); };
212  /** @returns a constant Iterator to the beginning of the List. */
213  inline const_iterator              end() const { return _objects.end(); };
214
215  /** @returns true if the List is empty. */
216  inline bool                        empty() const { return _objects.empty(); };
217  /** @returns the size of the List */
218  inline int                         size() const { return _objects.size(); };
219  /** @returns the frontmost Element of the list (normaly the last added Object). */
220  inline T*                          front() const { return _objects.front(); };
221  /** @returns the last added Object */
222  inline T*                          back() const { return _objects.back(); };
223
224
225  ObjectListBase::IteratorBase*      registerObject(T* object);
226  virtual void                       unregisterObject(IteratorBase* iterator);
227  bool                               checkIteratorInList(IteratorBase* iterator) const;
228  bool                               checkObjectInList(BaseObject* obj) const;
229protected:
230  virtual void                       getBaseObjectList(ObjectListBase::base_list* list) const;
231
232
233private:
234  //! the copy constructor will be hidden.
235  ObjectList(const ObjectList& definer) {};
236
237private:
238  list                _objects;     //!< The List of stored Objects of Type T.
239};
240
241
242
243
244
245/////////////////////////
246//// IMPLEMENTATION /////
247/////////////////////////
248/**
249 * @brief creates a new ObjectList
250 * @param name The name of the Class.
251 * @param id The ID of the class if desired, or -1 if an id should be assigned automatically.
252 */
253template <class T>
254ObjectList<T>::ObjectList(const std::string& name)
255    : ObjectListBase(name)
256{}
257
258/**
259 * @brief deletes the ObjectList.
260 */
261template <class T>
262ObjectList<T>::~ObjectList()
263{
264  if (!_objects.empty())
265  {
266    // std::cout << "There are " << this->size() << " objects from class " << this->name() << "(id:" << this->id() << ") in existance\n";
267  }
268}
269
270/**
271 * @brief Retrieves a BaseObject matching the Name name in this List.
272 * @param name the Name of the Object.
273 * @returns a BaseObject pointing to the object if found, NULL otherwise.
274 */
275template <class T>
276BaseObject* ObjectList<T>::getBaseObject(const std::string& name) const
277{
278  return this->getObject(name);
279}
280
281
282
283/**
284 * @brief Retrieves an Object of type T matching the Name name in this List.
285 * @param name the Name of the Object.
286 * @returns an Object of type T pointing to the object if found, NULL otherwise.
287 */
288template <class T>
289T* ObjectList<T>::getObject(const std::string& name) const
290{
291  const_iterator it;
292  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
293    if ((*it)->getName() == name)
294      return (*it);
295  return NULL;
296}
297
298/**
299 * @brief checks if Object object exists in this ClassList.
300 * @param object the Object to check for
301 * @returns True if the object is found within the List, false otherwise
302 */
303template <class T>
304bool ObjectList<T>::exists(const T* const object) const
305{
306  return (std::find(_objects.begin(), _objects.end(), object) != _objects.end());
307}
308
309
310/**
311 * @brief retrieves a List of BaseObjects
312 * @param list the list to push the ObjectList into.
313 */
314template <class T>
315void ObjectList<T>::getBaseObjectList(ObjectListBase::base_list* list) const
316{
317  assert (list != NULL);
318  const_iterator it;
319  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
320    list->push_back(*it);
321}
322
323
324/**
325 * @brief registers an Object to the ObjectList.
326 * @param object The Object to register.
327 * @returns a pointer to the iterator inside of the list.
328 */
329template <class T>
330ObjectListBase::IteratorBase* ObjectList<T>::registerObject(T* object)
331{
332  this->_objects.push_back(object);
333  return new Iterator(--this->_objects.end());
334}
335
336/**
337 * @brief removes an Object from the ClassList.
338 * @param iterator the Position at which to remove the Object.
339 */
340template <class T>
341void ObjectList<T>::unregisterObject(IteratorBase* iterator)
342{
343  this->_objects.erase(static_cast<Iterator*>(iterator)->it());
344  //_objects.erase(std::find(_objects.begin(), _objects.end(), object));
345}
346
347template <class T>
348bool ObjectList<T>::checkIteratorInList(IteratorBase* iterator) const
349{
350  const_iterator it;
351  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
352    if (static_cast<Iterator*>(iterator)->it() == it)
353      return true;
354  printf("ObjectList:: checkIteratorInList:: ITERATOR NOT IN THE LIST '%s' (UN-SYNC SHOULD NOT HAPPEN!!)\n", this->name().c_str());
355  return false;
356}
357
358template <class T>
359bool ObjectList<T>::checkObjectInList(BaseObject* obj) const
360{
361  T* object = dynamic_cast<T*>(obj);
362  if (object != NULL)
363  {
364    printf("EXTREME BUG: Object does not exist anymore!! (or a bug in ObjectList)\n");
365    return false;;
366  }
367
368  const_iterator it;
369  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
370  {
371    if (*it == object)
372      return true;
373  }
374  printf("ObjectList:: checkObjectInList:: OBJECT NOT IN THE LIST '%s' (UN-SYNC SHOULD NOT HAPPEN!!)\n", this->name().c_str());
375  return false;
376}
377
378
379#endif /* _OBJECT_LIST_H */
Note: See TracBrowser for help on using the repository browser.