Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9684 in orxonox.OLD for branches


Ignore:
Timestamp:
Aug 22, 2006, 1:34:31 AM (18 years ago)
Author:
bensch
Message:

orxonox/branches/new_class_id: slowly but surely reimplementing to the new groove… way to go

Location:
branches/new_class_id/src
Files:
2 deleted
31 edited

Legend:

Unmodified
Added
Removed

  • branches/new_class_id/src/lib/coord/p_node.cc

    r9656 r9684  
    1919
    2020#include "util/loading/load_param.h"
    21 #include "class_list.h"
    2221
    2322#include "netdefs.h"
    … …  
    3837  : BaseObject(), Synchronizeable()
    3938{
    40   this->setClassID(CL_PARENT_NODE, "PNode");
     39  this->registerObject(this, PNode::_objectList);
    4140
    4241  this->bRelCoorChanged = true;
    … …  
    541540void PNode::addChild (const std::string& childName)
    542541{
    543   PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
     542  PNode* childNode = PNode::objectList().getObject(childName);
    544543  //  PRINTF(0)("Adding the Child: %s to: %s\n", childName, this->getName());
    545544  //  assert( childNode != NULL );
    … …  
    625624void PNode::setParent (const std::string& parentName)
    626625{
    627   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
     626  PNode* parentNode = PNode::objectList().getObject(parentName);
    628627  if (parentNode != NULL)
    629628    parentNode->addChild(this);
    … …  
    681680void PNode::setParentSoft(const std::string& parentName, float bias)
    682681{
    683   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
     682  PNode* parentNode = PNode::objectList().getObject(parentName);
    684683  if (parentNode != NULL)
    685684    this->setParentSoft(parentNode, bias);
    … …  
    731730  {
    732731    PNode::nullParent = new PNode(NULL, PNODE_PARENT_MODE_DEFAULT | PNODE_REPARENT_TO_NULL);
    733     PNode::nullParent->setClassID(CL_NULL_PARENT, "NullParent");
     732    //PNode::nullParent->registerObject(, CL_NULL_PARENT);
    734733    PNode::nullParent->setName("NullParent");
    735734    PNode::nullParent->setSynchronized(true);

  • branches/new_class_id/src/lib/coord/p_node.h

    r9406 r9684  
    7474//! Patent Node is a Engine to calculate the position of an Object in respect to the position of its parent.
    7575class PNode : virtual public BaseObject, virtual public Synchronizeable {
    76  public:
     76  NewObjectListDeclaration(PNode);
     77
     78  public:
    7779  PNode (PNode* parent = PNode::getNullParent(), long nodeFlags = PNODE_PARENT_MODE_DEFAULT);
    7880  virtual ~PNode ();

  • branches/new_class_id/src/lib/graphics/importer/height_map.cc

    r8316 r9684  
    327327
    328328
     329NewObjectListDefinition(HeightMap);
    329330
    330331
    … …  
    413414void HeightMap::init(const std::string& heightMapName)
    414415{
    415   this->setClassID(CL_HEIGHT_MAP, "HeightMap");
     416  this->registerObject(this, HeightMap::_objectList);
    416417
    417418  this->shiftX = 0;

  • branches/new_class_id/src/lib/graphics/importer/height_map.h

    r7526 r9684  
    2929
    3030class SDL_Surface;
    31 class Vector;
    3231class Material;
    33 class PNode;
    3432class Texture;
    3533class HeightMap;
    … …  
    7068
    7169
     70
    7271//!< the height map representation itself
    7372class HeightMap : public VertexArrayModel
    7473{
     74  NewObjectListDeclaration(HeightMap);
    7575  friend class Tile;
    7676

  • branches/new_class_id/src/lib/graphics/importer/interactive_model.cc

    r9406 r9684  
    2222
    2323
     24NewObjectListDefinition(InteractiveModel);
     25
    2426/**
    2527 * standard constructor
    … …  
    2830InteractiveModel::InteractiveModel()
    2931{
    30   this->setClassID(CL_INTERACTIVE_MODEL, "InteractiveModel");
     32  this->registerObject(this, InteractiveModel::_objectList);
    3133}
    3234

  • branches/new_class_id/src/lib/graphics/importer/interactive_model.h

    r9003 r9684  
    3030class InteractiveModel : public Model
    3131{
     32  NewObjectListDeclaration(InteractiveModel);
    3233  public:
    3334    InteractiveModel();

  • branches/new_class_id/src/lib/graphics/importer/model.cc

    r9406 r9684  
    2020#include "glincl.h"
    2121
    22 
     22NewObjectListDefinition(Model);
    2323
    2424/**
    … …  
    2828Model::Model()
    2929{
    30   this->setClassID(CL_MODEL, "Model");
     30  this->registerObject(this, Model::_objectList);
    3131  this->pModelInfo.numVertices = 0;
    3232  this->pModelInfo.numTriangles = 0;

  • branches/new_class_id/src/lib/graphics/importer/model.h

    r8035 r9684  
    5454//! This class defines the basic components of a model
    5555class Model : virtual public BaseObject {
     56  NewObjectListDeclaration(Model);
    5657
    5758  public:

  • branches/new_class_id/src/lib/graphics/importer/objModel.cc

    r8369 r9684  
    2727#include "compiler.h"
    2828
     29NewObjectListDefinition(OBJModel);
    2930/**
    3031 * @brief Crates a 3D-Model, loads in a File and scales it.
    … …  
    3536  : StaticModel(fileName)
    3637{
    37   this->setClassID(CL_OBJ_MODEL, "OBJModel");
     38  this->registerObject(this, OBJModel::_objectList);
    3839
    3940  this->objPath = "./";

  • branches/new_class_id/src/lib/graphics/importer/objModel.h

    r8369 r9684  
    1212class OBJModel : public StaticModel
    1313{
    14  public:
     14  NewObjectListDeclaration(OBJModel);
     15  public:
    1516   OBJModel(const std::string& fileName, float scaling = 1.0);
    1617  virtual ~OBJModel();

  • branches/new_class_id/src/lib/graphics/importer/static_model.cc

    r9406 r9684  
    129129
    130130
     131
     132
    131133/////////////
    132134/// MODEL ///
    133135/////////////
     136NewObjectListDefinition(StaticModel);
     137
    134138/**
    135139 * @brief Creates a 3D-Model.
    … …  
    139143StaticModel::StaticModel(const std::string& modelName)
    140144{
    141   this->setClassID(CL_STATIC_MODEL, "StaticModel");
     145  this->registerObject(this, StaticModel::_objectList);
    142146  PRINTF(4)("new 3D-Model is being created\n");
    143147  this->setName(modelName);

  • branches/new_class_id/src/lib/graphics/importer/static_model.h

    r7221 r9684  
    9494class StaticModel : public Model
    9595{
    96  public:
     96  NewObjectListDeclaration(StaticModel);
     97  public:
    9798  StaticModel(const std::string& modelName = "");
    9899  virtual ~StaticModel();

  • branches/new_class_id/src/lib/graphics/importer/vertex_array_model.cc

    r9406 r9684  
    2424
    2525
     26NewObjectListDefinition(VertexArrayModel);
    2627
    2728/////////////
    … …  
    3536VertexArrayModel::VertexArrayModel()
    3637{
    37   this->setClassID(CL_MODEL, "VertexArrayModel");
     38  this->registerObject(this, VertexArrayModel::_objectList);
    3839
    3940  this->newStripe();
    … …  
    4950VertexArrayModel::VertexArrayModel(const Model& model)
    5051{
    51   this->setClassID(CL_MODEL, "VertexArrayModel");
     52  this->registerObject(this, VertexArrayModel::_objectList);
    5253
    5354  // importing the data to the new Model.

  • branches/new_class_id/src/lib/graphics/importer/vertex_array_model.h

    r6769 r9684  
    2727class VertexArrayModel : public Model
    2828{
    29  public:
     29  NewObjectListDeclaration(VertexArrayModel);
     30  public:
    3031  VertexArrayModel();
    3132  VertexArrayModel(const Model& model);

  • branches/new_class_id/src/lib/lang/Makefile.am

    r9677 r9684  
    99libORXlang_a_SOURCES = \
    1010                base_object.cc \
    11                 class_list.cc \
    1211                new_class_id.cc \
    1312                new_object_list.cc
    … …  
    1514noinst_HEADERS = \
    1615                base_object.h \
    17                 class_list.h \
    1816                new_class_id.h \
    1917                new_object_list.h

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

    r9406 r9684  
    2020
    2121#include "util/loading/load_param.h"
    22 #include "class_list.h"
    2322
    2423/**
    … …  
    2827BaseObject::BaseObject(const std::string& objectName)
    2928{
    30   this->classID = CL_BASE_OBJECT;
    3129  this->className = "BaseObject";
    3230
    3331  this->objectName = objectName;
    34   this->classList = NULL;
    3532  this->xmlElem = NULL;
    3633
    … …  
    4340BaseObject::~BaseObject ()
    4441{
    45   ClassList::removeFromClassList(this);
     42  /// Remove from the NewObjectLists
     43  ClassList::iterator it;
     44  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
     45  {
     46    (*it)._objectList->unregisterObject((*it)._iterator);
     47    delete (*it)._iterator;
     48  }
    4649
    4750  if (this->xmlElem != NULL)
    … …  
    6972
    7073/**
    71  * @brief sets the class identifiers
    72  * @param id a number for the class from class_id.h enumeration
    73  * @param className the class name
    74 */
    75 void BaseObject::setClassID(ClassID classID, const std::string& className)
    76 {
    77   //printf("%s(0x%.8X)->%s(0x%.8X)\n", this->className, this->classID, className, classID);
    78   assert (!(this->classID & classID & !CL_MASK_SUBSUPER_CLASS_IDA ));
    79 
    80   this->leafClassID = classID;
    81   this->classID |= (long)classID;
    82   this->className = className;
    83 
    84   this->classList = ClassList::addToClassList(this, classID, this->classID, className);
    85 }
    86 
    87 
    88 /**
    8974 * @brief set the name of the Object
    9075 * @param objectName The new name of the Object.
    … …  
    9782
    9883/**
    99  * @brief queries for the ClassID of the Leaf Class (the last made class of this type
    100  * @returns the ClassID of the Leaf Class (e.g. the ID of the Class)
    101  *
    102  * the returned ID can be used to generate new Objects of the same type through
    103  * Factory::fabricate(Object->getLeafClassID());
     84 * @brief Seeks in the Inheritance if it matches objectList.
     85 * @param objectList The ObjectList this should be a member of (by Pointer-comparison).
     86 * @return True if found, false if not.
    10487 */
    105 const ClassID& BaseObject::getLeafClassID() const
     88bool BaseObject::isA(const NewObjectListBase& objectList) const
    10689{
    107   return this->leafClassID;
     90  ClassList::const_iterator it;
     91  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
     92    if ((*it)._objectList == &objectList)
     93      return true;
     94  return false;
    10895}
    10996
    110 
     97/**
     98 * @brief Seeks in the Inheritance if it matches objectList.
     99 * @param classID The ClassID of the class this should be a member of.
     100 * @return True if found, false if not.
     101 */
     102bool BaseObject::isA(int classID) const
     103{
     104  ClassList::const_iterator it;
     105  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
     106    if (*(*it)._objectList == classID)
     107      return true;
     108  return false;
     109}
    111110
    112111/**
    113  * @brief checks if the class is a classID
    114  * @param classID the Identifier to check for
    115  * @returns true if it is, false otherwise
    116 */
    117 bool BaseObject::isA (ClassID classID) const
     112 * @brief Seeks in the Inheritance if it matches objectList.
     113 * @param className The ClassName of the class this should be a member of.
     114 * @return True if found, false if not.
     115 */
     116bool BaseObject::isA(const std::string& className) const
    118117{
    119   // if classID is a derivable object from a SUPERCLASS
    120   if (classID & CL_MASK_SUPER_CLASS)
    121   {
    122     if( likely(this->classID & classID))
     118  ClassList::const_iterator it;
     119  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
     120    if (*(*it)._objectList == className)
    123121      return true;
    124   }
    125   // if classID is a SubSuperClass, and
    126   else if (classID & CL_MASK_SUBSUPER_CLASS)
    127   {
    128     if (likely(((this->classID & CL_MASK_SUBSUPER_CLASS_IDA) == (classID & CL_MASK_SUBSUPER_CLASS_IDA)) &&
    129         this->classID & classID & CL_MASK_SUBSUPER_CLASS_IDB))
    130       return true;
    131   }
    132   // if classID is a LOWLEVEL-class
    133   else
    134   {
    135     if( likely((this->classID & CL_MASK_LOWLEVEL_CLASS) == classID))
    136       return true;
    137   }
    138122  return false;
    139123}
    140124
    141125
     126void BaseObject::listInheritance() const
     127{
     128  PRINT(0)("Listing inheritance diagram for ....: ");
     129  ClassList::const_iterator it;
     130  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
     131    PRINT(0)(" -> %s(id:%d)", (*it)._objectList->name().c_str(), (*it)._objectList->id());
     132  PRINT(0)("\n");
    142133
    143 /**
    144  * @brief checks if the class is a classID
    145  * @param classID the Identifier to check for
    146  * @returns true if it is, false otherwise
    147  */
    148 bool BaseObject::isA (const std::string& className) const
    149 {
    150   ClassID classID = ClassList::StringToID(className);
    151   if (classID != CL_NULL)
    152     return this->isA(classID);
    153   else
    154     return false;
    155134}
    156 
    157 
    158 /**
    159  * @brief compares the ObjectName with an external name
    160  * @param objectName: the name to check.
    161  * @returns true on match, false otherwise.
    162  */
    163 bool BaseObject::operator==(const std::string& objectName) const
    164 {
    165   return (this->objectName == objectName);
    166 }
    167 

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

    r9406 r9684  
    1414#define __BASE_OBJECT_H_
    1515
    16 #include "class_id.h"
     16#include "new_object_list.h"
    1717#include "sigslot/slot.h"
    1818
    … …  
    4141  inline TiXmlNode* getXmlElem() const { return this->xmlElem; };
    4242
    43   /** @returns the className of the corresponding Object */
    44   inline const std::string& getClassName() const { return this->className; }
     43  //  /** @returns the className of the corresponding Object */
     44  //inline const std::string& getClassName() const { return this->className; }
    4545  /** @returns the className of the corresponding Object as a C-compliant string (const char*) */
    4646  inline const char* getClassCName() const { return this->className.c_str(); };
    47   /** @returns the classID of the corresponding Object */
    48   inline int getClassID() const { return this->classID; };
    49   const ClassID& getLeafClassID() const;
     47  /** @returns the ClassName of the Topmost Object of the ClassStack */
     48  inline const std::string& getClassName() const { return _classes.front()._objectList->name(); }
    5049
    51   bool isA (ClassID classID) const;
    52   bool isA (const std::string& className) const;
     50  /** @returns the ID of the Topmost object of the ClassStack */
     51  inline int getLeafClassID() const { return _classes.front()._objectList->id(); }
     52
     53  bool isA(const NewObjectListBase& objectList) const;
     54  bool isA(int classID) const;
     55  bool isA(const std::string& className) const;
     56
     57  void listInheritance() const;
    5358
    5459  /** @param classID comparer for a ClassID @returns true on match, false otherwise */
    55   bool operator==(ClassID classID) const  { return this->isA(classID); };
    56   bool operator==(const std::string& objectName) const;
     60  bool operator==(int classID) const  { return this->isA(classID); };
     61  /** @param objectName: the name to check. * @returns true on match, false otherwise. */
     62  bool operator==(const std::string& objectName) const { return this->objectName == objectName;};
    5763
    5864protected:
    59   void setClassID(ClassID classID, const std::string& className);
     65  template<class T> void registerObject(T* object, NewObjectList<T>& list);
    6066
    6167protected:
    … …  
    6369
    6470private:
    65   std::string        className;        //!< the name of the class
    66   long               classID;          //!< this is the id from the class_id.h enumeration
    67   ClassID            leafClassID;      //!< The Leaf Class ID
    68 
    69   ClassList*         classList;        //!< Pointer to the ClassList this Object is inside of
    7071
    7172  TiXmlNode*         xmlElem;          //!< The XML Element with wich this Object was loaded(saved).
     73
     74  //////////////////////////////
     75  //// Type Definition Part ////
     76  //////////////////////////////
     77  //! A ClassEntry so we can store Classes inside of Objects
     78  struct ClassEntry
     79  {
     80    /** Simple Constuctor @param objectList the NewObjectList, @param iterator the (intrusive) Iterator inside of the ObjectList */
     81    inline ClassEntry (NewObjectListBase* objectList, NewObjectListBase::IteratorBase* iterator) : _objectList(objectList), _iterator(iterator) {}
     82    NewObjectListBase*                _objectList;  //!< A ObjectList this Object is part of
     83    NewObjectListBase::IteratorBase*  _iterator;    //!< An iterator pointing to the position of the Object inside of the List.
     84  };
     85  typedef std::list<ClassEntry>        ClassList;   //!< Type definition for the List.
     86
     87  std::string                         className;    //!< the name of the class
     88  ClassList                           _classes;     //!< All Classes this object is part of.
     89
    7290};
    7391
     92
     93/**
     94 * @brief Registeres an Object of Type T to objectList
     95 * @param object The Object to append to the objectList.
     96 * @param objectList The ObjectList to append the Object to.
     97 *
     98 * This function is essential to integrate objects into their designated ObjectList.
     99 * Remember if you do not want objects to be stored in Lists (less overhead),
     100 * do not attempt to call this function.
     101 */
     102template<class T>
     103inline void BaseObject::registerObject(T* object, NewObjectList<T>& objectList)
     104{
     105  this->_classes.push_front(ClassEntry(&objectList, objectList.registerObject(object)));
     106}
     107
    74108#endif /* __BASE_OBJECT_H_ */

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

    r9682 r9684  
    1616
    1717#define NewObjectListDeclaration(ClassName) \
    18    static NewObjectList<ClassName> objectList
     18  public: \
     19   static const NewObjectList<ClassName>& objectList() { return ClassName::_objectList; }; \
     20  private: \
     21   static NewObjectList<ClassName> _objectList
    1922
    2023#define NewObjectListDefinitionID(ClassName, ID) \
    21    NewObjectList<ClassName> ClassName::objectList(#ClassName, ID)
     24   NewObjectList<ClassName> ClassName::_objectList(#ClassName, ID)
    2225
    2326
    … …  
    157160T* NewObjectList<T>::getObject(const std::string& name) const
    158161{
    159   iterator it = std::find(this->_objects.begin(), this->_objects.end(), name);
    160   if (it != this->_objects.end())
    161     return *it;
    162   else
    163     return NULL;
     162  const_iterator it;
     163  for (it = this->_objects.begin(); it != this->_objects.end(); ++it)
     164    if ((*it)->getName() == name)
     165      return (*it);
     166  return NULL;
    164167}
    165168

  • branches/new_class_id/src/lib/util/executor/executor.cc

    r8894 r9684  
    1818#include "executor.h"
    1919
    20 ////////////////////////
    21 // SHELL COMMAND BASE //
    22 ////////////////////////
     20
     21NewObjectListDefinition(Executor);
     22
    2323/**
    2424 * @brief constructs and registers a new Command
    … …  
    3535                   const MultiType& param6)
    3636{
    37   this->setClassID(CL_EXECUTOR, "Executor");
     37  this->registerObject(this, Executor::_objectList);
    3838
    3939  // What Parameters have we got

  • branches/new_class_id/src/lib/util/executor/executor.h

    r8894 r9684  
    3838class Executor : public BaseObject
    3939{
     40  NewObjectListDeclaration(Executor);
    4041  public:
    4142    virtual ~Executor();

  • branches/new_class_id/src/lib/util/loading/dynamic_loader.cc

    r9406 r9684  
    2424
    2525
    26 
     26NewObjectListDefinition(DynamicLoader);
    2727
    2828/**
    … …  
    3131*/
    3232DynamicLoader::DynamicLoader (const std::string& libName)
    33     : Factory(NULL, CL_NULL)
     33    : Factory(NULL, 0)
    3434{
    35   this->setClassID(CL_DYNAMIC_LOADER, "DynamicLoader");
     35  this->registerObject(this, DynamicLoader::_objectList);
    3636
    3737  this->handle = NULL;

  • branches/new_class_id/src/lib/util/loading/dynamic_loader.h

    r7193 r9684  
    1919class DynamicLoader : public Factory
    2020{
     21  NewObjectListDeclaration(DynamicLoader);
    2122
    2223public:

  • branches/new_class_id/src/lib/util/loading/factory.cc

    r9675 r9684  
    1919//#include "shell_command.h"
    2020
    21 
     21NewObjectListDefinition(Factory);
    2222
    2323//SHELL_COMMAND(create, Factory, fabricate);
    … …  
    2828 * set everything to zero and define factoryName
    2929 */
    30 Factory::Factory (const std::string& factoryName, ClassID classID)
     30Factory::Factory (const std::string& factoryName, int classID)
    3131    : classID(classID), className(factoryName)
    3232{
    33   this->setClassID(CL_FACTORY, "Factory");
     33  this->registerObject(this, Factory::_objectList);
    3434  this->setName(factoryName);
    3535
    … …  
    7474 * @returns true on match, false otherwise
    7575 */
    76 bool Factory::operator==(ClassID classID) const
     76bool Factory::operator==(int classID) const
    7777{
    7878  return (this->classID == classID);
    … …  
    149149 * @returns a new Object of Type classID on match, NULL otherwise
    150150 */
    151 BaseObject* Factory::fabricate(ClassID classID)
     151BaseObject* Factory::fabricate(int classID)
    152152{
    153153  if (Factory::factoryList == NULL)

  • branches/new_class_id/src/lib/util/loading/factory.h

    r8148 r9684  
    3838
    3939//! The Factory is a loadable object handler
    40 class Factory : public BaseObject {
    41 
    42  public:
     40class Factory : public BaseObject
     41{
     42  NewObjectListDeclaration(Factory);
     43public:
    4344  virtual ~Factory ();
    4445
    … …  
    4647
    4748  static  BaseObject* fabricate(const std::string& className);
    48   static  BaseObject* fabricate(ClassID classID);
     49  static  BaseObject* fabricate(int classID);
    4950  static  BaseObject* fabricate(const TiXmlElement* root = NULL);
    5051
    5152
    52   bool operator==(ClassID classID) const;
     53  bool operator==(int classID) const;
    5354  bool operator==(const char* className) const;
    5455  bool operator==(const std::string& className) const;
    5556
    56   protected:
    57     Factory (const std::string& factoryName, ClassID classID);
    58     virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const = 0;
     57protected:
     58  Factory (const std::string& factoryName, int classID);
     59  virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const = 0;
    5960
    60   protected:
    61     const ClassID                 classID;              //!< The Class-Identifyer of the Factory.
    62     const std::string             className;            //!< The name of the Class.
    63     static std::list<Factory*>*   factoryList;          //!< List of Registered Factories
     61protected:
     62  const int                     classID;              //!< The Class-Identifyer of the Factory.
     63  const std::string             className;            //!< The name of the Class.
     64  static std::list<Factory*>*   factoryList;          //!< List of Registered Factories
    6465};
    6566
    … …  
    7071template<class T> class tFactory : public Factory
    7172{
    72  public:
    73  /**
    74   * @brief creates a new type Factory to enable the loading of T
    75   * @param factoryName the Name of the Factory to load.
    76   * @param classID the ID of the Class to be created.
    77   */
    78   tFactory (const char* factoryName, ClassID classID)
    79    : Factory(factoryName, classID)
     73public:
     74  /**
     75   * @brief creates a new type Factory to enable the loading of T
     76   * @param factoryName the Name of the Factory to load.
     77   * @param classID the ID of the Class to be created.
     78   */
     79  tFactory (const char* factoryName, int classID)
     80      : Factory(factoryName, classID)
    8081  {  }
    8182
    82   private:
    83    /**
    84     * @brief fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
    85     * @param root the TiXmlElement T should load parameters from.
    86     * @return the newly fabricated T.
    87     */
    88     virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const
    89     {
    90       return new T(root);
    91     }
     83private:
     84  /**
     85   * @brief fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
     86   * @param root the TiXmlElement T should load parameters from.
     87   * @return the newly fabricated T.
     88   */
     89  virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const
     90  {
     91    return new T(root);
     92  }
    9293};
    9394

  • branches/new_class_id/src/lib/util/loading/game_loader.cc

    r9110 r9684  
    2828#include "key_mapper.h"
    2929
     30NewObjectListDefinition(GameLoader);
    3031
    3132
    … …  
    4344GameLoader::GameLoader ()
    4445{
    45   this->setClassID(CL_GAME_LOADER, "GameLoader");
     46  this->registerObject(this, GameLoader::_objectList);
    4647  this->setName("GameLoader");
    4748  this->bRun = true;
    … …  
    5758    delete this->currentCampaign;
    5859  this->currentCampaign = NULL;
    59  
     60
    6061  GameLoader::singletonRef = NULL;
    6162}

  • branches/new_class_id/src/lib/util/loading/game_loader.h

    r7868 r9684  
    3838class GameLoader : public EventListener
    3939{
    40  public:
     40  NewObjectListDeclaration(GameLoader);
     41  public:
    4142  virtual ~GameLoader ();
    4243  /**  this class is a singleton class @returns an instance of itself  */

  • branches/new_class_id/src/lib/util/loading/resource_manager.cc

    r9406 r9684  
    5050#include <unistd.h>
    5151
    52 
     52NewObjectListDefinition(ResourceManager);
    5353
    5454/**
    … …  
    5757ResourceManager::ResourceManager ()
    5858{
    59   this->setClassID(CL_RESOURCE_MANAGER, "ResourceManager");
     59  this->registerObject(this, ResourceManager::_objectList);
    6060  this->setName("ResourceManager");
    6161

  • branches/new_class_id/src/lib/util/loading/resource_manager.h

    r8724 r9684  
    9494class ResourceManager : public BaseObject
    9595{
    96  public:
     96  NewObjectListDeclaration(ResourceManager);
     97public:
    9798  virtual ~ResourceManager();
    9899  /** @returns a Pointer to the only object of this Class */
    … …  
    101102  bool setDataDir(const std::string& dataDir);
    102103  /** @returns the Name of the data directory */
    103   inline const std::string& getDataDir() const { return this->dataDir; };
     104inline const std::string& getDataDir() const { return this->dataDir; };
    104105
    105106
    … …  
    139140  static ResourceType stringToResourceType(const std::string& resourceType);
    140141
    141  private:
     142private:
    142143  ResourceManager();
    143144  Resource* loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
    144145                         const MultiType& param0, const MultiType& param1, const MultiType& param2);
    145146
    146  private:
     147private:
    147148  static ResourceManager*    singletonRef;       //!< singleton Reference
    148149

  • branches/new_class_id/src/lib/util/preferences.cc

    r8362 r9684  
    2020#include "debug.h"
    2121
     22NewObjectListDefinition(Preferences);
    2223
    2324/**
    … …  
    2627Preferences::Preferences ()
    2728{
    28    this->setClassID(CL_PREFERENCES, "Preferences");
     29  this->registerObject(this, Preferences::_objectList);
    2930   this->setName("Preferences");
    3031   this->fileName = "";

  • branches/new_class_id/src/lib/util/preferences.h

    r8362 r9684  
    2929//! A default singleton class.
    3030class Preferences : public BaseObject {
    31 
     31  NewObjectListDeclaration(Preferences);
    3232 public:
    3333   virtual ~Preferences(void);

  • branches/new_class_id/src/world_entities/weapons/ammo_container.h

    r6671 r9684  
    2222  virtual ~AmmoContainer();
    2323
    24   bool operator=(ClassID projectileType) const { return (this->projectileType == projectileType); };
     24  bool operator=(int projectileType) const { return (this->projectileType == projectileType); };
    2525  ClassID getProjectileType() const { return this->projectileType; };
    2626
Note: See TracChangeset for help on using the changeset viewer.