Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 149


Ignore:
Timestamp:
Nov 2, 2007, 1:25:00 AM (12 years ago)
Author:
landauf
Message:

update; dont look at it, its not finished

Location:
code/branches/objecthierarchie/src
Files:
4 edited

Legend:

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

    r132 r149  
    11#include "BaseObject.h"
    22
    3 //namespace orxonox
    4 //{
     3namespace orxonox
     4{
    55    BaseObject::BaseObject()
    66    {
    7 //        registerObject(BaseObject, true);
     7        registerRootObject(BaseObject);
    88    }
    99
    1010    BaseObject::~BaseObject()
    1111    {
    12 //        unregisterObject();
     12        unregisterObject();
    1313    }
    14 /*
    15     void* BaseObject::operator new (size_t size)
    16     {
    17         void *pMem = new char[size];
    18         memset(pMem,0,size);
    19 
    20         return pMem;
    21     }
    22 */
    23 //}
     14}
  • code/branches/objecthierarchie/src/BaseObject.h

    r132 r149  
    44#include "ClassHierarchy.h"
    55
    6 //namespace orxonox
    7 //{
     6namespace orxonox
     7{
    88    class BaseObject
    99    {
     
    1212            ~BaseObject();
    1313
    14             bool isA(ClassName* className);
    15             bool isChildOf(ClassName* className);
    16             bool isParentOf(ClassName* className);
    17             static bool getParentOf(ClassName* className);
     14            inline bool isA(Identifier* identifier)
     15                { this->identifier_->isA(identifier); }
     16            inline bool isDirectA(Identifier* identifier)
     17                { this->identifier_->isDirectA(identifier); }
     18            inline bool isChildOf(Identifier* identifier)
     19                { this->identifier_->isChildOf(identifier); }
     20            inline bool isDirectChildOf(Identifier* identifier)
     21                { this->identifier_->isDirectChildOf(identifier); }
     22            inline bool isParentOf(Identifier* identifier)
     23                { this->identifier_->isParentOf(identifier); }
     24            inline bool isDirectParentOf(Identifier* identifier)
     25                { this->identifier_->isDirectParentOf(identifier); }
    1826
    19 //            static void operator new (size_t size);
     27            Identifier* identifier_;
    2028
    21             ClassName *className;
     29        protected:
     30            IdentifierList* parents_; // INTERN! Don't touch this!
    2231
    2332        private:
    2433
    2534    };
    26 //}
     35}
    2736
    2837#endif
  • code/branches/objecthierarchie/src/ClassHierarchy.cc

    r132 r149  
    11#include "ClassHierarchy.h"
    2 #include "BaseObject.h"
    3 
    4 //namespace orxonox
    5 //{
    6     // ##### ClassName #####
    7     ClassName::ClassName(const std::string& name, ClassNameSingleton<class T>* factory)
    8     {
    9         this->parentClass = NULL;
    10         this->childClasses = new ClassList();
    11         this->objects = new ObjectList();
    12         this->name = name;
    13         this->factory = factory;
    14     }
    15 
    16     ClassName::~ClassName()
    17     {
    18         delete this->childClasses;
    19         delete this->objects;
    20     }
    21 
    22 
    23     // ##### ClassListItem #####
    24     ClassListItem::ClassListItem(ClassName* className)
    25     {
    26         this->next = NULL;
    27         this->className = className;
    28     }
    29 
    30     ClassListItem::~ClassListItem()
    31     {
    32         delete this->className;
    33         delete this->next;
    34     }
    35 
    36 
    37     // ##### ClassList #####
    38     ClassList::ClassList()
    39     {
    40         this->first = NULL;
    41     }
    42 
    43     ClassList::~ClassList()
    44     {
    45         delete this->first;
    46     }
    47 
    48     void ClassList::add(ClassName* className)
    49     {
    50         if (!this->first)
    51         {
    52             this->first = new ClassListItem(className);
    53             return;
    54         }
    55 
    56         ClassListItem* iterator = this->first;
    57         while (iterator != NULL)
    58         {
    59             if (iterator->next == NULL)
    60             {
    61                 iterator->next = new ClassListItem(className);
     2
     3namespace orxonox
     4{
     5    // ###############################
     6    // ###       Identifier        ###
     7    // ###############################
     8    Identifier* Identifier::pointer_ = NULL;
     9/*
     10    Identifier* Identifier::registerClass(IdentifierList* parents)
     11    {
     12        if (!pointer_)
     13        {
     14            pointer_ = new Identifier();
     15            pointer_->initialize(parents);
     16        }
     17
     18        return pointer_;
     19    }
     20*/
     21    Identifier::Identifier()
     22    {
     23        this->bCreatedOneObject_ = false;
     24        this->directParents_ = new IdentifierList();
     25        this->allParents_ = new IdentifierList();
     26        this->directChildren_ = new IdentifierList();
     27        this->allChildren_ = new IdentifierList();
     28        this->objects_ = new ObjectList();
     29    }
     30
     31    void Identifier::initialize(IdentifierList* parents)
     32    {
     33        if (parents)
     34        {
     35            this->bCreatedOneObject_ = true;
     36
     37            IdentifierListElement* temp1;
     38            IdentifierListElement* temp2;
     39            IdentifierListElement* temp3;
     40
     41            temp1 = parents->first_;
     42            while (temp1)
     43            {
     44                temp2 = temp1->identifier_->directParents_->first_;
     45                while (temp2)
     46                {
     47                    temp3 = parents->first_;
     48                    while(temp3)
     49                    {
     50                        if (temp3->identifier_ == temp2->identifier_)
     51                            temp3->bDirect_ = false;
     52
     53                        temp3 = temp3->next_;
     54                    }
     55
     56                    temp2 = temp2->next_;
     57                }
     58                temp1 = temp1->next_;
     59            }
     60
     61            temp1 = parents->first_;
     62            while (temp1)
     63            {
     64                if (temp1->bDirect_)
     65                {
     66                    this->directParents_->add(temp1->identifier_);
     67                    temp1->identifier_->directChildren_->add(this->pointer_);
     68                }
     69
     70                this->allParents_->add(temp1->identifier_);
     71                temp1->identifier_->allChildren_->add(this->pointer_);
     72
     73                temp1 = temp1->next_;
     74            }
     75        }
     76    }
     77
     78    void Identifier::addObject(BaseObject* object)
     79    {
     80        this->objects_->add(object);
     81    }
     82
     83    void Identifier::removeObject(BaseObject* object)
     84    {
     85        this->objects_->remove(object);
     86    }
     87
     88    bool Identifier::isA(Identifier* identifier)
     89    {
     90        return (identifier == this->pointer_ || this->allParents_->isInList(identifier));
     91    }
     92
     93    bool Identifier::isDirectA(Identifier* identifier)
     94    {
     95        return (identifier == this->pointer_);
     96    }
     97
     98    bool Identifier::isChildOf(Identifier* identifier)
     99    {
     100        return this->allParents_->isInList(identifier);
     101    }
     102
     103    bool Identifier::isDirectChildOf(Identifier* identifier)
     104    {
     105        return this->directParents_->isInList(identifier);
     106    }
     107
     108    bool Identifier::isParentOf(Identifier* identifier)
     109    {
     110        return this->allChildren_->isInList(identifier);
     111    }
     112
     113    bool Identifier::isDirectParentOf(Identifier* identifier)
     114    {
     115        return this->directChildren_->isInList(identifier);
     116    }
     117
     118
     119    // ###############################
     120    // ###     IdentifierList      ###
     121    // ###############################
     122    IdentifierList::IdentifierList()
     123    {
     124        this->first_ = NULL;
     125    }
     126
     127    IdentifierList::~IdentifierList()
     128    {
     129        IdentifierListElement* temp;
     130        while (this->first_)
     131        {
     132            temp = this->first_->next_;
     133            delete this->first_;
     134            this->first_ = temp;
     135        }
     136    }
     137
     138    void IdentifierList::add(Identifier* identifier)
     139    {
     140        IdentifierListElement* temp = this->first_;
     141        this->first_ = new IdentifierListElement(identifier);
     142        this->first_->next_ = temp;
     143    }
     144
     145    void IdentifierList::remove(Identifier* identifier)
     146    {
     147        if (!identifier)
     148            return;
     149
     150        if (this->first_->identifier_ == identifier)
     151        {
     152            IdentifierListElement* temp = this->first_->next_;
     153            delete this->first_;
     154            this->first_ = temp;
     155
     156            return;
     157        }
     158
     159        IdentifierListElement* temp = this->first_;
     160        while (temp->next_)
     161        {
     162            if (temp->next_->identifier_ == identifier)
     163            {
     164                IdentifierListElement* temp2 = temp->next_->next_;
     165                delete temp->next_;
     166                temp->next_ = temp2;
     167
    62168                return;
    63169            }
    64170
    65             iterator = iterator->next;
    66         }
    67     }
    68 
    69     // ##### ObjectListItem #####
    70     ObjectListItem::ObjectListItem(BaseObject* object)
    71     {
    72         this->next = NULL;
    73         this->object = object;
    74     }
    75 
    76     ObjectListItem::~ObjectListItem()
    77     {
    78         delete this->object;
    79         delete this->next;
    80     }
    81 
    82 
    83     // ##### ObjectList #####
     171            temp = temp->next_;
     172        }
     173    }
     174
     175    bool IdentifierList::isInList(Identifier* identifier)
     176    {
     177        IdentifierListElement* temp = this->first_;
     178        while (temp)
     179        {
     180            if (temp->identifier_ == identifier)
     181                return true;
     182
     183            temp = temp->next_;
     184        }
     185
     186        return false;
     187    }
     188
     189
     190    // ###############################
     191    // ###  IdentifierListElement  ###
     192    // ###############################
     193    IdentifierListElement::IdentifierListElement(Identifier* identifier)
     194    {
     195        this->identifier_ = identifier;
     196        this->next_ = NULL;
     197        this->bDirect_ = true;
     198    }
     199
     200
     201    // ###############################
     202    // ###       ObjectList        ###
     203    // ###############################
    84204    ObjectList::ObjectList()
    85205    {
    86         this->first = NULL;
     206        this->first_ = NULL;
    87207    }
    88208
    89209    ObjectList::~ObjectList()
    90210    {
    91         delete this->first;
     211        ObjectListElement* temp;
     212        while (this->first_)
     213        {
     214            temp = this->first_->next_;
     215            delete this->first_;
     216            this->first_ = temp;
     217        }
    92218    }
    93219
    94220    void ObjectList::add(BaseObject* object)
    95221    {
    96         if (!this->first)
    97         {
    98             this->first = new ObjectListItem(object);
    99             return;
    100         }
    101 
    102         ObjectListItem* iterator = this->first;
    103         while (iterator != NULL)
    104         {
    105             if (iterator->next == NULL)
    106             {
    107                 iterator->next = new ObjectListItem(object);
     222        ObjectListElement* temp = this->first_;
     223        this->first_ = new ObjectListElement(object);
     224        this->first_->next_ = temp;
     225    }
     226
     227    void ObjectList::remove(BaseObject* object)
     228    {
     229        if (!object)
     230            return;
     231
     232        if (this->first_->object_ == object)
     233        {
     234            ObjectListElement* temp = this->first_->next_;
     235            delete this->first_;
     236            this->first_ = temp;
     237
     238            return;
     239        }
     240
     241        ObjectListElement* temp = this->first_;
     242        while (temp->next_)
     243        {
     244            if (temp->next_->object_ == object)
     245            {
     246                ObjectListElement* temp2 = temp->next_->next_;
     247                delete temp->next_;
     248                temp->next_ = temp2;
     249
    108250                return;
    109251            }
    110252
    111             iterator = iterator->next;
    112         }
    113     }
    114 
    115     void ObjectList::remove(BaseObject* object)
    116     {
    117         if (!this->first || !object)
    118             return;
    119 
    120         if (this->first->object == object)
    121         {
    122             ObjectListItem* temp = this->first->next;
    123             delete this->first;
    124             this->first = temp;
    125 
    126             return;
    127         }
    128 
    129         ObjectListItem* iterator = this->first;
    130         while (iterator->next != NULL)
    131         {
    132             if (iterator->next->object == object)
    133             {
    134                 ObjectListItem* temp = iterator->next->next;
    135                 delete iterator->next;
    136                 iterator->next = temp;
    137 
    138                 return;
    139             }
    140 
    141             iterator = iterator->next;
    142         }
    143     }
    144 
    145     // ##### ClassNameTree #####
    146     ClassNameTree* ClassNameTree::pointer = NULL;
    147 
    148     ClassNameTree::ClassNameTree()
    149     {
    150     }
    151 
    152     ClassNameTree::~ClassNameTree()
    153     {
    154         this->pointer = NULL;
    155     }
    156 
    157     ClassNameTree* ClassNameTree::getSingleton()
    158     {
    159         if (!pointer)
    160         {
    161             pointer = new ClassNameTree();
    162         }
    163 
    164         return pointer;
    165     }
    166 /*
    167     BaseObject* ClassNameTree::create(ClassName* className)
    168     {
    169         return className->factory->create();
    170     }
    171 
    172     BaseObject* ClassNameTree::create(std::string& name)
    173     {
    174         return this->getClassName(name)->factory->create();
    175     }
    176 */
    177     ClassName* ClassNameTree::getClassName(std::string& name)
    178     {
    179         return getClassName(name, this->rootClass);
    180     }
    181 
    182     ClassName* ClassNameTree::getClassName(std::string& name, ClassName* root)
    183     {
    184         if (root->name == name)
    185             return root;
    186 
    187         ClassListItem* temp = root->childClasses->first;
    188         while (temp != NULL)
    189         {
    190             ClassName* temp2 = this->getClassName(name, temp->className);
    191             if (temp2)
    192                 return temp2;
    193 
    194             temp = temp->next;
    195         }
    196 
    197         return NULL;
    198     }
    199 
    200 
    201     // ##### ClassNameSingleton #####
    202     #define getClassNameString(ClassName) \
    203         #ClassName
    204 
    205     template <class T>
    206     ClassNameSingleton<T>* ClassNameSingleton<T>::pointer = NULL;
    207 
    208     template <class T>
    209     ClassName* ClassNameSingleton<T>::className = NULL;
    210 
    211     template <class T>
    212     ClassName* ClassNameSingleton<T>::getClassName(BaseObject* object, bool bIsRootClass)
    213     {
    214         if (!pointer || !className)
    215         {
    216             pointer = new ClassNameSingleton<T>();
    217             className = new ClassName(getClassNameString(T), pointer);
    218 
    219             if (bIsRootClass)
    220             {
    221                 className->parentClass = NULL;
    222                 ClassNameTree::getSingleton()->setRootClass(className);
    223             }
    224             else
    225             {
    226                 className->parentClass = object->className;
    227                 object->className->childClasses->add(className);
    228             }
    229         }
    230 
    231         return className;
    232     }
    233 
    234     template <class T>
    235     ClassName* ClassNameSingleton<T>::getNewClassName()
    236     {
    237         if (!pointer || !className)
    238         {
    239             T* temp = new T();
    240             delete temp;
    241         }
    242 
    243         return className;
    244     }
    245 
    246     template <class T>
    247     BaseObject* ClassNameSingleton<T>::create()
    248     {
    249         return new T();
    250     }
    251 
    252     template <class T>
    253     ClassNameSingleton<T>::~ClassNameSingleton()
    254     {
    255         this->pointer = NULL;
    256         delete this->className;
    257         this->className = NULL;
    258     }
    259 //}
     253            temp = temp->next_;
     254        }
     255    }
     256
     257
     258    // ###############################
     259    // ###    ObjectListElement    ###
     260    // ###############################
     261    ObjectListElement::ObjectListElement(BaseObject* object)
     262    {
     263        this->object_ = object;
     264        this->next_ = NULL;
     265    }
     266}
  • code/branches/objecthierarchie/src/ClassHierarchy.h

    r132 r149  
    66// DONE:
    77// - klassenhierarchie aufbauen
     8// - in listen einfügen
     9// - factory
    810// - klassen-identifier
     11// - isA u.ä. vergleiche
    912
    1013// TODO:
    1114// - durch listen iterieren
    12 // - isA usw vergleiche
    13 // - new überladen + objekt in liste eintragen
    1415// - searchtree für classname-strings
    1516
    16 //namespace orxonox
    17 //{
    18     class ClassName;
    19     class ClassList;
     17
     18namespace orxonox
     19{
     20    // ##### Identifier #####
     21    class IdentifierList;
    2022    class ObjectList;
    2123    class BaseObject;
    2224
     25    class Identifier
     26    {
     27        template <class T>
     28        friend class ClassIdentifier;
     29
     30        public:
     31//            static Identifier* registerClass(IdentifierList* parents);
     32            void addObject(BaseObject* object);
     33            void removeObject(BaseObject* object);
     34
     35            bool isA(Identifier* identifier);
     36            bool isDirectA(Identifier* identifier);
     37            bool isChildOf(Identifier* identifier);
     38            bool isDirectChildOf(Identifier* identifier);
     39            bool isParentOf(Identifier* identifier);
     40            bool isDirectParentOf(Identifier* identifier);
     41
     42        protected:
     43            Identifier();
     44            void initialize(IdentifierList* identifier);
     45
     46            static Identifier* pointer_;
     47
     48            IdentifierList* directParents_;
     49            IdentifierList* allParents_;
     50            IdentifierList* directChildren_;
     51            IdentifierList* allChildren_;
     52
     53            ObjectList* objects_;
     54            std::string name_;
     55
     56        private:
     57            bool bCreatedOneObject_;
     58    };
     59
    2360    template <class T>
    24     class ClassNameSingleton
     61    class ClassIdentifier : public Identifier
     62    {
     63//        friend class Identifier;
     64
     65        public:
     66            static Identifier* registerClass(IdentifierList* parents);
     67            static Identifier* getIdentifier();
     68            static T* create();
     69
     70        private:
     71            ClassIdentifier();
     72    };
     73
     74    #define getStringFromClassName(ClassName) \
     75        #ClassName
     76
     77    template <class T>
     78    ClassIdentifier<T>::ClassIdentifier()
     79    {
     80    }
     81
     82    template <class T>
     83    Identifier* ClassIdentifier<T>::registerClass(IdentifierList* parents)
     84    {
     85        if (!pointer_)
     86        {
     87            pointer_ = new ClassIdentifier();
     88            pointer_->name_ = getStringFromClassName(T);
     89            pointer_->initialize(parents);
     90        }
     91
     92        return pointer_;
     93    }
     94
     95    template <class T>
     96    Identifier* ClassIdentifier<T>::getIdentifier()
     97    {
     98        if (!pointer_)
     99        {
     100            T* temp = new T();
     101            delete temp;
     102        }
     103
     104        return pointer_;
     105    }
     106
     107    template <class T>
     108    T* ClassIdentifier<T>::create()
     109    {
     110        return new T();
     111    }
     112
     113    // ##### Identifier List #####
     114    class IdentifierListElement;
     115
     116    class IdentifierList
    25117    {
    26118        public:
    27             static ClassName* getClassName(BaseObject* object, bool bIsRootClass);
    28             static ClassName* getNewClassName();
    29             BaseObject* create();
     119            IdentifierList();
     120            ~IdentifierList();
     121            void add(Identifier* identifier);
     122            void remove(Identifier* identifier);
     123            bool isInList(Identifier* identifier);
    30124
    31         private:
    32             ClassNameSingleton();
    33             ~ClassNameSingleton();
    34             static ClassNameSingleton *pointer;
    35             static ClassName *className;
     125            IdentifierListElement* first_;
    36126    };
    37127
    38     class ClassName
     128    class IdentifierListElement
    39129    {
    40130        public:
    41             ClassName(const std::string& name, ClassNameSingleton<class T>* factory);
    42             ~ClassName();
     131            IdentifierListElement(Identifier* identifier);
    43132
    44             std::string name;
    45             ClassName *parentClass;
    46             ClassList *childClasses;
    47             ObjectList *objects;
    48             ClassNameSingleton<class T> *factory;
     133            Identifier* identifier_;
     134            IdentifierListElement* next_;
     135            bool bDirect_;
    49136    };
    50137
    51     class ClassListItem
    52     {
    53         public:
    54             ClassListItem(ClassName* className);
    55             ~ClassListItem();
    56138
    57             ClassListItem *next;
    58             ClassName *className;
    59     };
    60 
    61     class ClassList
    62     {
    63         public:
    64             ClassList();
    65             ~ClassList();
    66             void add(ClassName* className);
    67 
    68             ClassListItem *first;
    69     };
    70 
    71     class ObjectListItem
    72     {
    73         public:
    74             ObjectListItem(BaseObject* object);
    75             ~ObjectListItem();
    76 
    77             ObjectListItem *next;
    78             BaseObject *object;
    79     };
     139    // ##### Object List #####
     140    class ObjectListElement;
    80141
    81142    class ObjectList
     
    87148            void remove(BaseObject* object);
    88149
    89             ObjectListItem *first;
     150            ObjectListElement* first_;
    90151    };
    91152
    92     class ClassNameTree
     153    class ObjectListElement
    93154    {
    94155        public:
    95             static ClassNameTree* getSingleton();
    96             BaseObject* create(ClassName* className);
    97             BaseObject* create(std::string& name);
    98             ClassName* getClassName(std::string& name);
    99             ClassName* getClassName(std::string& name, ClassName* root);
    100             ClassName* getRootClass() { return this->rootClass; }
    101             void setRootClass(ClassName* className) { this->rootClass = className; }
     156            ObjectListElement(BaseObject* object);
    102157
    103         private:
    104             ClassNameTree();
    105             ~ClassNameTree();
    106             static ClassNameTree *pointer;
    107             ClassName* rootClass;
     158            BaseObject* object_;
     159            ObjectListElement* next_;
    108160    };
    109161
    110162
    111     #define className(ClassName) \
    112         ClassNameSingleton<ClassName>::getNewClassName()
     163    // ##### Macros #####
     164    #define registerRootObject(ClassName) \
     165        this->parents_ = new IdentifierList(); \
     166        this->identifier_ = ClassIdentifier<ClassName>::registerClass(this->parents_); \
     167        this->parents_->add(this->identifier_); \
     168        this->identifier_->addObject(this)
    113169
    114     #define registerObject(ClassName, bIsRootClass) \
    115         this->className = ClassNameSingleton<ClassName>::getClassName(this, bIsRootClass)
     170    #define registerObject(ClassName) \
     171        this->identifier_->removeObject(this); \
     172        this->identifier_ = ClassIdentifier<ClassName>::registerClass(this->parents_); \
     173        this->parents_->add(this->identifier_); \
     174        this->identifier_->addObject(this)
    116175
    117176    #define unregisterObject() \
    118         this->className->objects->remove(this)
     177        delete this->parents_; \
     178        this->identifier_->removeObject(this)
    119179
    120     #define factory(ClassName) \
    121         ClassNameTree::getSingleton()->create(ClassName)
    122 //}
     180    #define Class(ClassName) \
     181        ClassIdentifier<ClassName>::getIdentifier()
     182
     183    #define Factory(ClassName) \
     184        ClassIdentifier<ClassName>::create()
     185}
    123186
    124187#endif
Note: See TracChangeset for help on using the changeset viewer.