source: orxonox.OLD/branches/new_class_id/src/lib/lang/new_object_list.h @ 9709

/*!
 * @file new_object_list.h
 * @brief Definition of a dynamically allocating ClassID
 *
 */

#ifndef _NEW_OBJECT_LIST_H
#define _NEW_OBJECT_LIST_H

#include "new_class_id.h"
#include <map>
#include <list>
#include <string>
#include <iostream>

/**
 * @brief Use this macro to easily declare a Class to store its own ObjectListDeclaration
 * @param ClassName the Name of the Class.
 * @note: Using this inside of a Class means, that you loose the member: _objectList, while defining
 * two new functions objectList() and classID().
 */
#define NewObjectListDeclaration(ClassName) \
  public: \
   static inline const NewObjectList<ClassName>& objectList() { return ClassName::_objectList; }; \
   static inline const NewClassID& classID() { return ClassName::_objectList.identity(); }; \
  private: \
   static NewObjectList<ClassName> _objectList

#define NewObjectListDefinitionID(ClassName, ID) \
   NewObjectList<ClassName> ClassName::_objectList(#ClassName, ID)


#define NewObjectListDefinition(ClassName) \
    NewObjectListDefinitionID(ClassName, -1)

class BaseObject;
//! The superclass that all NewObjectLists follow.
/**
 * @see template<class T> NewObjectList<T>
 */
class NewObjectListBase
{
public:
  //! A fast iterator Base-Class, for iterator-casting and storing.
  /**
   * @note This Iterator is explicitely used only for storage purposes in the BaseObject
   */
  class IteratorBase { };

  /** @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; }
  /** @returns the ID of the Identity of the ObjectList */
  inline int                            id() const { return _id; };
  /** @returns The Name of the Class stored in this ObjectList */
  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; };
  /** @param id The id to compare @returns true on match, false otherwise */
  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; };
  /** @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; };
  /** @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);

  static const NewObjectListBase* const getObjectList(int classID);
  static const NewObjectListBase* const getObjectList(const std::string& className);
  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);

  /** @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;

  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);

  //! Only uset to unsubscribe a BaseObject.
  virtual void                          unregisterObject(IteratorBase* _iterators) = 0;

protected:
  NewObjectListBase(const std::string& className, int id = -1);
  virtual ~NewObjectListBase();

private:
  NewObjectListBase(const NewObjectListBase&);

  static bool                         classIDExists(int id);
  static bool                         classNameExists(const std::string& className);


protected:
  typedef std::map<int, NewObjectListBase*>         classIDMap;   //!< The Generic Map.
  typedef std::map<std::string, NewObjectListBase*> classNameMap; //!< The Generic Map.

private:
  int                           _id;
  const std::string             _name;              //!< The Name of the Class.
  NewClassID                    _identity;          //!< The Identity of the Class. (equal to _id and _name)

private:
  static classIDMap*            _classesByID;       //!< A Map of all the classes in existance.
  static classNameMap*          _classesByName;     //!< A Map of all the classes in existance.
  static std::list<std::string> _classNames;        //!< A list of all the registered ClassNames.
};


/////////////////////////
//// TEMPLATISATION /////
/////////////////////////
//! 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)
 *  2. Include 'NewObjectListDefinition(T);' in some Definition file (cc-file)
 *  3. In the constructor add 'registerObject(this, objectList);'
 *
 * @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>
class NewObjectList : public NewObjectListBase
{
public:
  typedef std::list<T*>                  list;
  typedef typename list::iterator        iterator;
  typedef typename list::const_iterator  const_iterator;


class Iterator : public NewObjectListBase::IteratorBase
  {
  public:
    Iterator(iterator it) { _it = it; }
    inline iterator& it() { return _it; }
    typename NewObjectList::iterator _it;
  };

public:
  NewObjectList(const std::string& name, int id = -1);
  ~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;

  /** @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;


private:
  //! the copy constructor will be hidden.
  NewObjectList(const NewObjectList& definer) {};

private:
  list                _objects;     //!< The List of stored Objects of Type T.
};





/////////////////////////
//// IMPLEMENTATION /////
/////////////////////////
/**
 * @brief creates a new NewObjectList
 * @param name The name of the Class.
 * @param id The ID of the class if desired, or -1 if an id should be assigned automatically.
 */
template <class T>
NewObjectList<T>::NewObjectList(const std::string& name, int id)
    : NewObjectListBase(name, id)
{}

/**
 * @brief deletes the NewObjectList.
 */
template <class T>
NewObjectList<T>::~NewObjectList()
{
  if (!_objects.empty())
  {
    // std::cout << "There are " << this->size() << " objects from class " << this->name() << "(id:" << this->id() << ") in existance\n";
  }
}

/**
 * @brief Retrieves a BaseObject matching the Name name in this List.
 * @param name the Name of the Object.
 * @returns a BaseObject pointing to the object if found, NULL otherwise.
 */
template <class T>
BaseObject* NewObjectList<T>::getBaseObject(const std::string& name) const
{
  return this->getObject(name);
}



/**
 * @brief Retrieves an Object of type T matching the Name name in this List.
 * @param name the Name of the Object.
 * @returns an Object of type T pointing to the object if found, NULL otherwise.
 */
template <class T>
T* NewObjectList<T>::getObject(const std::string& name) const
{
  const_iterator it;
  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
    if ((*it)->getName() == name)
      return (*it);
  return NULL;
}

/**
 * @brief checks if Object object exists in this ClassList.
 * @param object the Object to check for
 * @returns True if the object is found within the List, false otherwise
 */
template <class T>
    bool NewObjectList<T>::exists(const T* const object) const
{
  return (std::find(_objects.begin(), _objects.end(), object) != _objects.end());
}


/**
 * @brief retrieves a List of BaseObjects
 * @param list the list to push the ObjectList into.
 */
template <class T>
void NewObjectList<T>::getBaseObjectList(NewObjectListBase::base_list* list) const
{
  assert (list != NULL);
  const_iterator it;
  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
    list->push_back(*it);
}


/**
 * @brief registers an Object to the NewObjectList.
 * @param T object the Object to register.
 * @returns a pointer to the iterator inside of the list.
 */
template <class T>
NewObjectListBase::IteratorBase* NewObjectList<T>::registerObject(T* object)
{
  this->_objects.push_back(object);
  return new Iterator(--this->_objects.end());
}

/**
 * @brief removes an Object from the ClassList.
 * @param iterator the Position at which to remove the Object.
 */
template <class T>
void NewObjectList<T>::unregisterObject(IteratorBase* iterator)
{
  this->_objects.erase(static_cast<Iterator*>(iterator)->it());
  //_objects.erase(std::find(_objects.begin(), _objects.end(), object));
}

#endif /* _NEW_OBJECT_LIST_H */