Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 29, 2013, 12:42:24 AM (11 years ago)
Author:
landauf
Message:

ObjectListBaseElement now stores a pointer to the object list it belongs to. Removed ObjectListBase::Export. Iterator will now always use the list from the element.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • code/branches/core6/src/libraries/core/object/Iterator.h

    r9573 r9596  
    5656#include "core/CorePrereqs.h"
    5757
    58 #include "core/class/Identifier.h"
    5958#include "ObjectListBase.h"
    6059
     
    7877            inline Iterator()
    7978            {
    80                 this->element_ = 0;
    81                 this->list_ = 0;
    82             }
    83 
    84             /**
    85                 @brief Constructor: Sets this element to the exported element.
    86                 @param exp The exported element
    87             */
    88             inline Iterator(const ObjectListBase::Export& exp)
    89             {
    90                 this->element_ = exp.element_;
    91                 this->list_ = exp.list_;
    92                 this->list_->registerIterator(this);
     79                this->element_ = NULL;
     80                this->list_ = NULL;
    9381            }
    9482
     
    10088            {
    10189                this->element_ = other.element_;
    102                 this->list_ = other.list_;
    103                 this->list_->registerIterator(this);
     90                this->registerIterator();
    10491            }
    10592
     
    10895                @param element The element
    10996            */
    110             template <class O>
    111             inline Iterator(ObjectListElement<O>* element)
     97            inline Iterator(ObjectListBaseElement* element)
    11298            {
    11399                this->element_ = element;
    114                 this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
    115                 this->list_->registerIterator(this);
     100                this->registerIterator();
    116101            }
    117102
     
    124109            {
    125110                this->element_ = other.element_;
    126                 this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
    127                 this->list_->registerIterator(this);
     111                this->registerIterator();
    128112            }
    129113
     
    133117            inline ~Iterator()
    134118            {
    135                 this->list_->unregisterIterator(this);
    136             }
    137 
    138             /**
    139                 @brief Assigns an exported element.
    140                 @param exp The exported element
    141             */
    142             inline Iterator<T>& operator=(const ObjectListBase::Export& exp)
    143             {
    144                 if (this->list_)
    145                     this->list_->unregisterIterator(this);
    146 
    147                 this->element_ = exp.element_;
    148                 this->list_ = exp.list_;
    149                 this->list_->registerIterator(this);
    150 
    151                 return (*this);
     119                this->unregisterIterator();
    152120            }
    153121
     
    158126            inline Iterator<T>& operator=(const Iterator<T>& other)
    159127            {
    160                 if (this->list_)
    161                     this->list_->unregisterIterator(this);
    162 
    163                 this->element_ = other.element_;
    164                 this->list_ = other.list_;
    165                 this->list_->registerIterator(this);
     128                this->unregisterIterator();
     129                this->element_ = other.element_;
     130                this->registerIterator();
    166131
    167132                return (*this);
     
    172137                @param element The element
    173138            */
    174             template <class O>
    175             inline Iterator<T>& operator=(ObjectListElement<O>* element)
    176             {
    177                 if (this->list_)
    178                     this->list_->unregisterIterator(this);
    179 
     139            inline Iterator<T>& operator=(ObjectListBaseElement* element)
     140            {
     141                this->unregisterIterator();
    180142                this->element_ = element;
    181                 this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
    182                 this->list_->registerIterator(this);
     143                this->registerIterator();
    183144
    184145                return (*this);
     
    192153            inline Iterator<T>& operator=(const ObjectListIterator<O>& other)
    193154            {
    194                 if (this->list_)
    195                     this->list_->unregisterIterator(this);
    196 
    197                 this->element_ = other.element_;
    198                 this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
    199                 this->list_->registerIterator(this);
     155                this->unregisterIterator();
     156                this->element_ = other.element_;
     157                this->registerIterator();
    200158
    201159                return (*this);
     
    268226            inline operator bool() const
    269227            {
    270                 return (this->element_ != 0);
     228                return (this->element_ != NULL);
    271229            }
    272230
     
    301259            }
    302260
    303         protected:
    304             ObjectListBaseElement* element_;       //!< The element the Iterator points at
    305             ObjectListBase* list_;                 //!< The list wherein the element is
     261        private:
     262            /**
     263             * @brief Registers the Iterator at the list to which it belongs
     264             */
     265            inline void registerIterator()
     266            {
     267                if (this->element_)
     268                {
     269                    this->list_ = this->element_->list_;
     270                    this->list_->registerIterator(this);
     271                }
     272                else
     273                    this->list_ = NULL;
     274            }
     275
     276            /**
     277             * @brief Unregisters the Iterator from the list (if any)
     278             */
     279            inline void unregisterIterator()
     280            {
     281                if (this->list_)
     282                    this->list_->unregisterIterator(this);
     283            }
     284
     285            ObjectListBaseElement* element_;    //!< The element the Iterator points at
     286            ObjectListBase* list_;              //!< The list in which the Iterator registered itself
    306287    };
    307288}
Note: See TracChangeset for help on using the changeset viewer.