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

/*!
 * @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
   */
  class IteratorBase { };

public:
  inline const NewClassID& identity() const { return _identity; };
  inline int id() const { return _identity.id(); };
  inline const std::string& name() const { return _identity.name(); };
  bool operator==(int id) const { return _identity == id; };
  bool operator==(const NewClassID& id) const { return _identity == id; };
  bool operator==(const std::string& name) const { return _identity == name; };

  virtual void debug() const = 0;

  static unsigned int                   classCount();
  static const std::string&             IDToString(int classID);
  static int                            StringToID(const std::string& className);

  static const std::list<std::string>&  getClassNames();

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

public:
  class base_iterator
  {
  public:
    /// @NOTE Do not use this class. For internal handling.
    class __base_iterator_base
    {
    public:
      virtual void operator++(int) = 0;
      virtual void operator++() = 0;
      virtual void operator--(int) = 0;
      virtual void operator--() = 0;
      virtual BaseObject* operator*() = 0;
      virtual __base_iterator_base& operator=(const base_iterator& iterator) = 0;
      virtual bool operator==(const __base_iterator_base& iterator) const = 0;
      virtual bool operator!=(const __base_iterator_base& iterator) const = 0;
      virtual __base_iterator_base* clone() const;
    };

  public:
    base_iterator(__base_iterator_base& it) { _it = it.clone(); };
    ~base_iterator() { delete _it; }
    void operator++() { (*_it)++; };
    void operator++(int) { ++(*_it); };
    void operator--() { (*_it)--; };
    void operator--(int) { --(*_it); };
    BaseObject* operator*() { return *(*_it); };
    base_iterator& operator=(const base_iterator& iterator);
    bool operator==(const base_iterator& iter) const { return *this->_it == *iter._it; };
    bool operator!=(const base_iterator& iter) const { return *this->_it != *iter._it; };

  private:
    __base_iterator_base*    _it;
  };

  virtual base_iterator base_begin() const = 0;
  virtual base_iterator base_end() const = 0;


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

  NewClassID                    _identity;          //!< The Identity of the Class (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.
/**
 * 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.
 */
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;

  virtual base_iterator base_begin() const { return base_iterator(__base_iterator(this->_objects.begin())); };
  virtual base_iterator base_end() const { return base_iterator(__base_iterator(this->_objects.end())); };


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

  T*                      getObject(const std::string& name) const;
  inline const list&      objects() const { return _objects; };

  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);
  void unregisterObject(IteratorBase* iterator);

  virtual void debug() const;

protected:
class __base_iterator : public base_iterator::__base_iterator_base
  {
  public:
    __base_iterator(const const_iterator& iter);
    void operator++(int) { ++_iter; };
    void operator++()  { _iter++; };
    void operator--(int) { --_iter; };
    void operator--()  { _iter--; };
    BaseObject* operator*() { return *iter; };
    base_iterator::__base_iterator_base& operator=(const base_iterator& iterator) { _iter = iterator._iter; return *this; };
    bool operator==(const __base_iterator_base& iterator) const { return _iter == iterator._iter; };
    bool operator!=(const __base_iterator_base& iterator) const { return _iter != iterator._iter; };
  private:
    iterator _iter;
  };

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

private:
  list                _objects;
};





/////////////////////////
//// 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 still Object in the ObjectList of " << this->name() << "(id:" << this->id() << ")\n";
    this->debug();
  }
}

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

template <class T>
NewObjectListBase::IteratorBase* NewObjectList<T>::registerObject(T* object)
{
  this->_objects.push_front(object);
  return new Iterator(this->_objects.begin());
}

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


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