Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 5982 in orxonox.OLD for trunk/src/util


Ignore:
Timestamp:
Dec 8, 2005, 12:22:53 AM (19 years ago)
Author:
bensch
Message:

orxonox/trunk: Factory-Redesign on the wish of manuel

Location:
trunk/src/util/loading
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/util/loading/factory.cc

    r5750 r5982  
    1313   co-programmer: Benjamin Grauer
    1414*/
    15 
     15#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOADING
    1616
    1717#include "factory.h"
    1818
    19 #include "shell_command.h"
    20 #include "game_loader.h"
     19//#include "shell_command.h"
     20
    2121using namespace std;
    2222
    23 SHELL_COMMAND(create, Factory, fabricate);
     23//SHELL_COMMAND(create, Factory, fabricate);
    2424
    2525
    … …  
    3939  this->setName(factoryName);
    4040
    41   this->next = NULL;
    4241  this->classID = classID;
     42  this->className = factoryName;
    4343
    44   Factory::registerFactory(this);
     44  if( Factory::factoryList == NULL)
     45    Factory::factoryList = new std::list<Factory*>;
     46
     47  Factory::factoryList->push_back(this);
    4548}
    4649
    4750/** a reference to the First Factory */
    48 Factory* Factory::first = NULL;
     51std::list<Factory*>* Factory::factoryList = NULL;
    4952
    5053/**
    5154 *  destructor
    52 
    53    clear the Q
    54 */
     55 *
     56 * clear the Q
     57 */
    5558Factory::~Factory ()
    5659{
    … …  
    5861  //  Factory* tmpDel = this->next;
    5962  //  this->next = NULL;
    60   if (this->next)
    61     delete this->next;
    6263}
    6364
     65void Factory::deleteFactories()
     66{
     67  if (Factory::factoryList != NULL)
     68  {
     69    while(!Factory::factoryList->empty())
     70    {
     71      delete Factory::factoryList->front();
     72      Factory::factoryList->pop_front();
     73    }
     74    delete Factory::factoryList;
     75    Factory::factoryList = NULL;
     76  }
     77}
     78
     79
    6480/**
    65  *  add a Factory to the Factory Queue
    66  * @param factory a Factory to be registered
    67 */
    68 void Factory::registerFactory( Factory* factory)
     81 * Compares the Factories Name against a given ClassName
     82 * @param className the Name of the Class to Query
     83 * @returns true on match, false otherwise.
     84 */
     85bool Factory::operator==(const char* className) const
    6986{
    70   assert( factory != NULL);
     87  return(className != NULL && !strcmp(className, this->className));
     88}
    7189
    72   PRINTF(5)("Registered factory for '%s'\n", factory->getName());
    7390
    74   if( Factory::first == NULL)
     91BaseObject* Factory::fabricate(const TiXmlElement* root)
     92{
     93  if (root == NULL || Factory::factoryList == NULL)
     94    return NULL;
     95
     96  std::list<Factory*>::const_iterator factory;
     97  for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
     98    if (*(*factory) == root->Value())
     99      break;
     100
     101  if (factory != Factory::factoryList->end())
    75102  {
    76     Factory::first = factory;
     103    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getName());
     104    return (*factory)->fabricateObject(root);
    77105  }
    78106  else
    79107  {
    80     Factory* tmpFac = Factory::first;
    81     while( tmpFac->next != NULL)
    82     {
    83       tmpFac = tmpFac->next;
    84     }
    85     tmpFac->setNext(factory);
     108    PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", root->Value());
     109    return NULL;
    86110  }
    87111}
    88112
    89 void Factory::fabricate(const char* className, const char* entityName)
     113BaseObject* Factory::fabricate(const char* className)
    90114{
    91   if (className == NULL)
    92     return;
    93   Factory* fac = Factory::first;
     115  if (className == NULL || Factory::factoryList == NULL)
     116    return NULL;
    94117
    95   while (fac != NULL)
     118  std::list<Factory*>::const_iterator factory;
     119  for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
     120    if (*(*factory) == className)
     121      break;
     122
     123  if (factory != Factory::factoryList->end())
    96124  {
    97     if (!strcmp(className, fac->getName()))
    98     {
    99       PRINTF(3)("Create a new Object of type %s\n", fac->getName());
    100       BaseObject* object = fac->fabricateDirect();
    101       if (object != NULL)
    102       {
    103         object->setName(entityName);
    104       }
    105       break;
    106     }
    107     fac = fac->next;
     125    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getName());
     126    return (*factory)->fabricateObject(NULL);
     127  }
     128  else
     129  {
     130    PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", className);
     131    return NULL;
    108132  }
    109133}
     134
     135
     136BaseObject* Factory::fabricate(ClassID classID)
     137{
     138  if (Factory::factoryList == NULL)
     139    return NULL;
     140
     141  std::list<Factory*>::const_iterator factory;
     142  for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
     143    if (*(*factory) == classID)
     144      break;
     145
     146  if (factory != Factory::factoryList->end())
     147  {
     148    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getName());
     149    return (*factory)->fabricateObject(NULL);
     150  }
     151  else
     152  {
     153    PRINTF(2)("Could not Fabricate an Object of ClassID '%h'\n", classID);
     154    return NULL;
     155  }
     156}

  • trunk/src/util/loading/factory.h

    r5944 r5982  
    2828#include "base_object.h"
    2929#include "debug.h"
     30#include <vector>
    3031
    3132/**
    … …  
    4041
    4142 public:
    42   Factory (const char* factoryName = NULL, ClassID classID = CL_NULL);
     43  Factory (const char* factoryName, ClassID classID);
    4344  virtual ~Factory ();
    4445
    45   void fabricate(const char* className, const char* entityName);
    46   virtual BaseObject* fabricate(ClassID classID) = NULL;
    47   virtual BaseObject* fabricate(const TiXmlElement* root) = NULL;
    48   virtual BaseObject* fabricateDirect() = NULL;
     46  static void deleteFactories();
    4947
    50   static void registerFactory( Factory* factory);
    51   /** @returns the first factory */
    52   static Factory* getFirst() { return Factory::first; };
     48  static  BaseObject* fabricate(const char* className);
     49  static  BaseObject* fabricate(ClassID classID);
     50  static  BaseObject* fabricate(const TiXmlElement* root = NULL);
     51
     52  bool operator==(ClassID classID) const { return (this->classID == classID); };
     53  bool operator==(const char* className) const;
    5354
    5455  protected:
    55     /** sets the Next factory in the list @param nextFactory the next factory */
    56     inline void setNext( Factory* nextFactory) { this->next = nextFactory; };
    57     /** @returns the next factory */
    58     Factory* getNext() const { return this->next; };
    59 
     56    virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const = 0;
    6057
    6158  protected:
    62     ClassID           classID;              //!< The CLass-Identifyer of the Factory.
    63 
    64   private:
    65     Factory*          next;                 //!< pointer to the next factory.
    66     static Factory*   first;                //!< A pointer to the first factory.
     59    ClassID                       classID;              //!< The Class-Identifyer of the Factory.
     60    const char*                   className;            //!< The name of the Class.
     61    static std::list<Factory*>*   factoryList;          //!< List of Registered Factories
    6762};
    6863
    … …  
    7368template<class T> class tFactory : public Factory
    7469{
    75   public:
    76     tFactory(const char* factoryName, ClassID classID);
    77     virtual ~tFactory();
     70 public:
     71  tFactory (const char* factoryName, ClassID classID)
     72   : Factory(factoryName, classID)
     73  {
     74  }
    7875
    7976  private:
    80     virtual BaseObject* fabricate(ClassID classID);
    81     virtual BaseObject* fabricate(const TiXmlElement* root);
    82     virtual BaseObject* fabricateDirect();
     77   /**
     78    * fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
     79    * @param root the TiXmlElement T should load parameters from.
     80    * @return the newly fabricated T.
     81    */
     82    virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const
     83    {
     84      return new T(root);
     85    }
    8386};
    84 
    85 /**
    86  *  construnts a factory with
    87  * @param factoryName the name of the factory
    88 */
    89 template<class T>
    90     tFactory<T>::tFactory(const char* factoryName, ClassID classID) : Factory(factoryName, classID)
    91 {
    92   PRINTF(4)("Class: %s loadable\n", this->getName());
    93 }
    94 
    95 /**
    96  * destructs the type-Factory
    97  */
    98 template<class T>
    99     tFactory<T>::~tFactory()
    100 {}
    101 
    102 /**
    103  * fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
    104  * @param root the TiXmlElement T should load parameters from.
    105  * @return the newly fabricated T, NULL otherwise.
    106  */
    107 template<class T>
    108     BaseObject* tFactory<T>::fabricate(const TiXmlElement* root)
    109 {
    110   if (root == NULL)
    111     return NULL;
    112 
    113   if(!strcmp(root->Value(), this->getName()))
    114     return new T ( root);
    115   else if( getNext() != NULL)
    116     return getNext()->fabricate( root);
    117   else
    118     return NULL;
    119 }
    120 
    121 
    122 /**
    123  * fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
    124  * @param classID the ClassID of T that should be created.
    125  * @return the newly fabricated T if fabricated NULL otherwise.
    126  */
    127 template<class T>
    128     BaseObject* tFactory<T>::fabricate(ClassID classID)
    129 {
    130   if(classID == this->classID)
    131     return this->fabricateDirect();
    132   else if( getNext() != NULL)
    133     return getNext()->fabricate( classID);
    134   else
    135     return NULL;
    136 }
    137 
    138 /**
    139  * directly fabricate an Entity of this factory.
    140  */
    141 template<class T>
    142     BaseObject* tFactory<T>::fabricateDirect()
    143 {
    144   return new T((const TiXmlElement*)NULL);
    145 }
    14687
    14788#endif /* _FACTORY_H */

  • trunk/src/util/loading/game_loader.cc

    r5819 r5982  
    331331    this->currentCampaign->previousLevel();
    332332}
    333 
    334 /**
    335  *  load a StoryEntity
    336  * @param element a XMLElement containing all the needed info
    337 */
    338 BaseObject* GameLoader::fabricate(const TiXmlElement* element)
    339 {
    340   assert( element != NULL);
    341 
    342   if( Factory::getFirst() == NULL)
    343     {
    344       PRINTF(1)("GameLoader does not know any factories, fabricate() failed\n");
    345       return NULL;
    346     }
    347 
    348   if( element->Value() != NULL)
    349     {
    350       PRINTF(4)("Attempting fabrication of a '%s'\n", element->Value());
    351       BaseObject* b = Factory::getFirst()->fabricate( element);
    352       if( b == NULL)
    353         PRINTF(2)("Failed to fabricate a '%s'\n", element->Value());
    354       else
    355         PRINTF(4)("Successfully fabricated a '%s'\n", element->Value());
    356       return b;
    357     }
    358 
    359   PRINTF(2)("Fabricate failed, TiElement did not contain a value\n");
    360 
    361   return NULL;
    362 }

  • trunk/src/util/loading/game_loader.h

    r5819 r5982  
    6060  ErrorMessage loadDebugCampaign(Uint32 campaignID);
    6161
    62   void registerFactory( Factory* factory );
    63   BaseObject* fabricate(const TiXmlElement* data);
    64 
    6562  void process(const Event &event);
    6663
Note: See TracChangeset for help on using the changeset viewer.