Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 19, 2007, 10:10:11 PM (17 years ago)
Author:
landauf
Message:
  • removed the "ClassHierarchy" manager-class and put its sole feature (bIsCreatingClassHierarchy_) directly into the Identifier.
  • added a dynamic_cast from OrxonoxClass to BaseObject to the Factory. OrxonoxClass is needed because several classes use Interfaces, but all classes are derived at least from BaseObject, so the cast will work.
Location:
code/branches/objecthierarchie/src
Files:
2 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • code/branches/objecthierarchie/src/BaseObject.h

    r197 r219  
    6464                { this->getIdentifier()->isDirectParentOf(object->getIdentifier); }
    6565*/
    66 
    6766    };
    6867}
  • code/branches/objecthierarchie/src/CMakeLists.txt

    r218 r219  
    22
    33# create a few variables to simplify life
    4 SET(SRC_FILES orxonox.cc IdentifierList.cc ObjectList.cc Identifier.cc Factory.cc ClassHierarchy.cc OrxonoxClass.cc BaseObject.cc test1.cc test2.cc test3.cc)
    5 SET(INC_FILES IdentifierIncludes.h ClassHierarchy.h Identifier.h Factory.h IdentifierList.h ObjectList.h OrxonoxClass.h BaseObject.h Test.h test1.h test2.h test3.h)
     4SET(SRC_FILES orxonox.cc IdentifierList.cc ObjectList.cc Identifier.cc Factory.cc OrxonoxClass.cc BaseObject.cc test1.cc test2.cc test3.cc)
     5SET(INC_FILES IdentifierIncludes.h Identifier.h Factory.h IdentifierList.h ObjectList.h OrxonoxClass.h BaseObject.h Test.h test1.h test2.h test3.h)
    66
    77#Creates an executable
  • code/branches/objecthierarchie/src/Factory.cc

    r218 r219  
    11#include "Factory.h"
    22#include "Identifier.h"
     3#include "BaseObject.h"
    34
    45namespace orxonox
    56{
    6     ClassFactory* ClassFactory::pointer_ = NULL;
     7    ClassFactory* ClassFactory::pointer_s = NULL;
    78
    8     OrxonoxClass* ClassFactory::fabricate(const std::string& name)
     9    BaseObject* ClassFactory::fabricate(const std::string& name)
    910    {
    10         if (!pointer_)
    11             pointer_ = new ClassFactory;
     11        if (!pointer_s)
     12            pointer_s = new ClassFactory;
    1213
    13         return pointer_->identifierMap_[name]->fabricate();
     14        return pointer_s->identifierMap_[name]->fabricate();
    1415    }
    1516
    1617    void ClassFactory::add(const std::string& name, Identifier* identifier)
    1718    {
    18         if (!pointer_)
    19             pointer_ = new ClassFactory;
     19        if (!pointer_s)
     20            pointer_s = new ClassFactory;
    2021
    21         pointer_->identifierMap_[name] = identifier;
     22        pointer_s->identifierMap_[name] = identifier;
    2223    }
    2324}
  • code/branches/objecthierarchie/src/Factory.h

    r218 r219  
    88{
    99    class Identifier;
    10     class OrxonoxClass;
     10    class BaseObject;
    1111
    1212    class ClassFactory
    1313    {
    1414        public:
    15             static OrxonoxClass* fabricate(const std::string& name);
     15            static BaseObject* fabricate(const std::string& name);
    1616            static void add(const std::string& name, Identifier* identifier);
    1717
     
    2121            ~ClassFactory() {}
    2222
    23             static ClassFactory* pointer_;
     23            static ClassFactory* pointer_s;
    2424            std::map<std::string, Identifier*> identifierMap_;
    2525    };
  • code/branches/objecthierarchie/src/Identifier.cc

    r197 r219  
    66    // ###       Identifier        ###
    77    // ###############################
     8    int Identifier::hierarchyCreatingCounter_s = 0;
     9
    810    Identifier::Identifier()
    911    {
    1012        this->bCreatedOneObject_ = false;
    11         this->directParents_ = new IdentifierList();
    12         this->allParents_ = new IdentifierList();
    13         this->directChildren_ = new IdentifierList();
    14         this->allChildren_ = new IdentifierList();
    15         this->objects_ = new ObjectList();
     13//        this->directParents_ = new IdentifierList();
     14//        this->allParents_ = new IdentifierList();
     15//        this->directChildren_ = new IdentifierList();
     16//        this->allChildren_ = new IdentifierList();
     17//        this->objects_ = new ObjectList();
    1618    }
    1719
    1820    Identifier::~Identifier()
    1921    {
    20         delete this->directParents_;
    21         delete this->allParents_;
    22         delete this->directChildren_;
    23         delete this->allChildren_;
    24         delete this->objects_;
     22//        delete this->directParents_;
     23//        delete this->allParents_;
     24//        delete this->directChildren_;
     25//        delete this->allChildren_;
     26//        delete this->objects_;
    2527        delete &this->name_;
    2628    }
     
    4042            while (temp1)
    4143            {
    42                 temp2 = temp1->identifier_->directParents_->first_;
     44                temp2 = temp1->identifier_->directParents_.first_;
    4345                while (temp2)
    4446                {
     
    6264                if (temp1->bDirect_)
    6365                {
    64                     this->directParents_->add(temp1->identifier_);
    65                     temp1->identifier_->directChildren_->add(this);
     66                    this->directParents_.add(temp1->identifier_);
     67                    temp1->identifier_->directChildren_.add(this);
    6668                }
    6769
    68                 this->allParents_->add(temp1->identifier_);
    69                 temp1->identifier_->allChildren_->add(this);
     70                this->allParents_.add(temp1->identifier_);
     71                temp1->identifier_->allChildren_.add(this);
    7072
    7173                temp1 = temp1->next_;
     
    7779    {
    7880        std::cout << "*** Added " << this->name_ << " to list.\n";
    79         this->objects_->add(object);
     81        this->objects_.add(object);
    8082    }
    8183
     
    8385    {
    8486        std::cout << "*** Removed " << this->name_ << " from list.\n";
    85         this->objects_->remove(object);
     87        this->objects_.remove(object);
    8688    }
    8789
    8890    bool Identifier::isA(Identifier* identifier)
    8991    {
    90         return (identifier == this || this->allParents_->isInList(identifier));
     92        return (identifier == this || this->allParents_.isInList(identifier));
    9193    }
    9294
     
    98100    bool Identifier::isChildOf(Identifier* identifier)
    99101    {
    100         return this->allParents_->isInList(identifier);
     102        return this->allParents_.isInList(identifier);
    101103    }
    102104
    103105    bool Identifier::isDirectChildOf(Identifier* identifier)
    104106    {
    105         return this->directParents_->isInList(identifier);
     107        return this->directParents_.isInList(identifier);
    106108    }
    107109
    108110    bool Identifier::isParentOf(Identifier* identifier)
    109111    {
    110         return this->allChildren_->isInList(identifier);
     112        return this->allChildren_.isInList(identifier);
    111113    }
    112114
    113115    bool Identifier::isDirectParentOf(Identifier* identifier)
    114116    {
    115         return this->directChildren_->isInList(identifier);
     117        return this->directChildren_.isInList(identifier);
    116118    }
    117119}
  • code/branches/objecthierarchie/src/Identifier.h

    r218 r219  
    22#define _Identifier_H__
    33
    4 #include "ClassHierarchy.h"
     4#include <iostream>
     5
    56#include "IdentifierList.h"
    67#include "ObjectList.h"
    7 #include "OrxonoxClass.h"
     8//#include "OrxonoxClass.h"
    89#include "Factory.h"
     10
     11// DONE AND TESTED:
     12// - build class hierarchy
     13// - isA, isChildOf, ...
     14// - insert into class-lists
     15// - ClassIdentifier
     16// - BaseIdentifier
     17// - Factory
     18
     19// IN WORK:
     20
     21// TO DO:
     22// - iterate through lists
    923
    1024namespace orxonox
    1125{
     26    class BaseObject;
     27
    1228    // ##### Identifier #####
    1329    class Identifier
     
    2339            void removeObject(OrxonoxClass* object);
    2440
    25             virtual OrxonoxClass* fabricate() {};
     41            virtual BaseObject* fabricate() {};
    2642
    2743            bool isA(Identifier* identifier);
     
    3349
    3450            std::string getName() { return this->name_; }
    35             IdentifierList* getDirectParents() { return this->directParents_; }
    36             IdentifierList* getAllParents() { return this->allParents_; }
    37             IdentifierList* getDirectChildren() { return this->directChildren_; }
    38             IdentifierList* getAllChildren() { return this->allChildren_; }
     51            IdentifierList* getDirectParents() { return &(this->directParents_); }
     52            IdentifierList* getAllParents() { return &(this->allParents_); }
     53            IdentifierList* getDirectChildren() { return &(this->directChildren_); }
     54            IdentifierList* getAllChildren() { return &(this->allChildren_); }
     55
     56            static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
    3957
    4058        private:
     
    4462            void initialize(IdentifierList* parents);
    4563
    46             IdentifierList* directParents_;
    47             IdentifierList* allParents_;
    48             IdentifierList* directChildren_;
    49             IdentifierList* allChildren_;
    50 
    51             ObjectList* objects_;
     64            static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; std::cout << "*** Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n"; }
     65            static void stopCreatingHierarchy() { hierarchyCreatingCounter_s--; std::cout << "*** Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n"; }
     66
     67            IdentifierList directParents_;
     68            IdentifierList allParents_;
     69            IdentifierList directChildren_;
     70            IdentifierList allChildren_;
     71
     72            ObjectList objects_;
    5273            std::string name_;
    5374
    5475            bool bIsAbstractClass_;
    5576            bool bCreatedOneObject_;
     77
     78            static int hierarchyCreatingCounter_s;
    5679    };
    5780
     
    6487            static ClassIdentifier<T>* registerClass(IdentifierList* parents, std::string name, bool bRootClass, bool bIsAbstractClass);
    6588            static ClassIdentifier<T>* getIdentifier();
    66             OrxonoxClass* fabricate();
     89            BaseObject* fabricate();
    6790            T* fabricateClass();
    6891
     
    7295            ~ClassIdentifier();
    7396
    74             static ClassIdentifier<T>* pointer_;
     97            static ClassIdentifier<T>* pointer_s;
    7598
    7699    };
    77100
    78101    template <class T>
    79     ClassIdentifier<T>* ClassIdentifier<T>::pointer_ = NULL;
     102    ClassIdentifier<T>* ClassIdentifier<T>::pointer_s = NULL;
    80103
    81104    template <class T>
     
    87110    ClassIdentifier<T>::~ClassIdentifier()
    88111    {
    89         this->pointer_ = NULL;
    90     }
    91 
    92     template <class T>
    93     OrxonoxClass* ClassIdentifier<T>::fabricate()
    94     {
    95         return this->fabricateClass();
     112        this->pointer_s = NULL;
     113    }
     114
     115    template <class T>
     116    BaseObject* ClassIdentifier<T>::fabricate()
     117    {
     118        return dynamic_cast<BaseObject*>(this->fabricateClass());
    96119    }
    97120
     
    99122    T* ClassIdentifier<T>::fabricateClass()
    100123    {
    101         return new T;
     124        if (!this->bIsAbstractClass_)
     125        {
     126            return new T;
     127        }
     128        else
     129        {
     130            std::cout << "Error: Couldn't create a new Object - Class " << this->name_ << " is abstract!\n";
     131            std::cout << "Aborting...\n";
     132            abort();
     133        }
    102134    }
    103135
     
    106138    {
    107139        std::cout << "*** Register Class in " << name << "-Singleton.\n";
    108         if (!pointer_)
     140        if (!pointer_s)
    109141        {
    110142            std::cout << "*** Register Class in " << name << "-Singleton -> Create Singleton.\n";
    111143            if (parents || bRootClass)
    112144            {
    113                 pointer_ = new ClassIdentifier();
    114                 pointer_->name_ = name;
    115                 pointer_->bIsAbstractClass_ = bIsAbstractClass;
    116 
    117                 ClassFactory::add(name, pointer_);
    118 
    119                 pointer_->initialize(parents);
     145                pointer_s = new ClassIdentifier();
     146                pointer_s->name_ = name;
     147                pointer_s->bIsAbstractClass_ = bIsAbstractClass;
     148
     149                ClassFactory::add(name, pointer_s);
     150
     151                pointer_s->initialize(parents);
    120152            }
    121153            else
    122154            {
    123                 pointer_ = getIdentifier();
    124             }
    125         }
    126 
    127         return pointer_;
     155                pointer_s = getIdentifier();
     156            }
     157        }
     158
     159        return pointer_s;
    128160    }
    129161
     
    132164    {
    133165//        std::cout << "*** Get Identifier.\n";
    134         if (!pointer_)
     166        if (!pointer_s)
    135167        {
    136168            std::cout << "*** Get Identifier -> Create Class\n";
    137             ClassHierarchy::getSingleton()->startCreatingHierarchy();
     169            Identifier::startCreatingHierarchy();
    138170            T* temp = new T();
    139             ClassHierarchy::getSingleton()->stopCreatingHierarchy();
     171            Identifier::stopCreatingHierarchy();
    140172            delete temp;
    141173        }
    142174
    143         return pointer_;
     175        return pointer_s;
    144176    }
    145177
     
    176208            B* fabricate()
    177209            {
    178                 OrxonoxClass* newObject = this->identifier_->fabricate();
     210                BaseObject* newObject = this->identifier_->fabricate();
    179211                if (newObject)
    180212                {
  • code/branches/objecthierarchie/src/IdentifierIncludes.h

    r218 r219  
    1 #include "ClassHierarchy.h"
    21#include "Identifier.h"
    32#include "Factory.h"
     
    54#include "ObjectList.h"
    65#include "OrxonoxClass.h"
     6
     7
     8#define registerRootObject(ClassName) \
     9    std::cout << "*** Register Root-Object: " << #ClassName << "\n"; \
     10    if (Identifier::isCreatingHierarchy() && !this->getParents()) \
     11        this->setParents(new IdentifierList()); \
     12    if (this->getIdentifier()) \
     13        this->getIdentifier()->removeObject(this); \
     14    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, true, false)); \
     15    if (Identifier::isCreatingHierarchy() && this->getParents()) \
     16        this->getParents()->add(this->getIdentifier()); \
     17    this->getIdentifier()->addObject(this)
     18
     19#define registerAbstractRootObject(ClassName) \
     20    std::cout << "*** Register Root-Object: " << #ClassName << "\n"; \
     21    if (Identifier::isCreatingHierarchy() && !this->getParents()) \
     22        this->setParents(new IdentifierList()); \
     23    if (this->getIdentifier()) \
     24        this->getIdentifier()->removeObject(this); \
     25    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, true, true)); \
     26    if (Identifier::isCreatingHierarchy() && this->getParents()) \
     27        this->getParents()->add(this->getIdentifier()); \
     28    this->getIdentifier()->addObject(this)
     29
     30#define registerObject(ClassName) \
     31    std::cout << "*** Register Object: " << #ClassName << "\n"; \
     32    this->getIdentifier()->removeObject(this); \
     33    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, false, false)); \
     34    if (Identifier::isCreatingHierarchy() && this->getParents()) \
     35        this->getParents()->add(this->getIdentifier()); \
     36    this->getIdentifier()->addObject(this)
     37
     38#define registerAbstractObject(ClassName) \
     39    std::cout << "*** Register Object: " << #ClassName << "\n"; \
     40    this->getIdentifier()->removeObject(this); \
     41    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, false, true)); \
     42    if (Identifier::isCreatingHierarchy() && this->getParents()) \
     43        this->getParents()->add(this->getIdentifier()); \
     44    this->getIdentifier()->addObject(this)
     45
     46#define unregisterObject() \
     47    this->getIdentifier()->removeObject(this)
     48
     49#define Class(ClassName) \
     50    ClassIdentifier<ClassName>::getIdentifier()
     51
     52#define CreateFactory(ClassName) \
     53    Identifier* global_##ClassName##_Identifier = ClassIdentifier<ClassName>::getIdentifier()
     54
     55#define Factory(Name) \
     56    ClassFactory::fabricate(Name)
  • code/branches/objecthierarchie/src/OrxonoxClass.cc

    r197 r219  
    1 #include "ClassHierarchy.h"
    21#include "OrxonoxClass.h"
    32
  • code/branches/objecthierarchie/src/OrxonoxClass.h

    r218 r219  
    22#define _OrxonoxClass_H__
    33
     4#include "Identifier.h"
    45#include "IdentifierList.h"
    5 #include "Identifier.h"
    66
    77namespace orxonox
  • code/branches/objecthierarchie/src/Test.h

    r218 r219  
    1010    {
    1111        public:
    12             Interface1() { registerRootObject(Interface1); }
     12            Interface1() { registerAbstractRootObject(Interface1); }
    1313    };
    1414
     
    1616    {
    1717        public:
    18             Interface2() { registerRootObject(Interface2); }
     18            Interface2() { registerAbstractRootObject(Interface2); }
    1919    };
    2020
  • code/branches/objecthierarchie/src/orxonox.cc

    r218 r219  
    504504        std::cout << "1\n";
    505505        Identifier* test9_01 = Class(A3);
    506         OrxonoxClass* test9_02 = test9_01->fabricate();
     506        BaseObject* test9_02 = test9_01->fabricate();
    507507        std::cout << test9_02->getIdentifier()->getName() << "\n";
    508508
    509509        std::cout << "\n2\n";
    510         OrxonoxClass* test9_03 = Class(A1B2)->fabricate();
     510        BaseObject* test9_03 = Class(A1B2)->fabricate();
    511511        std::cout << test9_03->getIdentifier()->getName() << "\n";
    512512
     
    518518
    519519        std::cout << "\n4\n";
    520         OrxonoxClass* test9_06 = Factory("A2B2");
     520        BaseObject* test9_06 = Factory("A2B2");
    521521        std::cout << test9_06->getIdentifier()->getName() << "\n";
    522522
Note: See TracChangeset for help on using the changeset viewer.