Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 24, 2013, 8:51:37 PM (12 years ago)
Author:
landauf
Message:

moved functions and attributes needed to safely destroy objects from OrxonoxClass to Destroyable

Location:
code/branches/core6/src/libraries/core/class
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • code/branches/core6/src/libraries/core/class/Identifiable.h

    r9565 r9570  
    5757            virtual ~Identifiable();
    5858
    59             void destroy();
    6059            void unregisterObject();
    6160
  • code/branches/core6/src/libraries/core/class/OrxonoxClass.cc

    r9565 r9570  
    3535
    3636#include <cassert>
    37 #include "core/object/MetaObjectList.h"
    38 #include "core/object/Context.h"
    39 #include "Identifier.h"
    4037
    4138namespace orxonox
     
    4643    OrxonoxClass::OrxonoxClass()
    4744    {
    48         this->referenceCount_ = 0;
    49         this->requestedDestruction_ = false;
    5045    }
    5146
     
    5550    OrxonoxClass::~OrxonoxClass()
    5651    {
    57         assert(this->referenceCount_ <= 0);
    58 
    59         // notify all destruction listeners
    60         for (std::set<DestructionListener*>::iterator it = this->destructionListeners_.begin(); it != this->destructionListeners_.end(); )
    61             (*(it++))->objectDeleted();
    62     }
    63 
    64     /**
    65         @brief Deletes the object if no @ref orxonox::SmartPtr "smart pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
    66     */
    67     void OrxonoxClass::destroy()
    68     {
    69         assert(this); // Just in case someone tries to delete a NULL pointer
    70         this->requestedDestruction_ = true;
    71         if (this->referenceCount_ == 0)
    72         {
    73             this->preDestroy();
    74             if (this->referenceCount_ == 0)
    75                 delete this;
    76         }
    7752    }
    7853}
  • code/branches/core6/src/libraries/core/class/OrxonoxClass.h

    r9565 r9570  
    4343#include "core/CorePrereqs.h"
    4444
    45 #include <set>
    46 //#include "Super.h"
    4745#include "Identifiable.h"
     46#include "core/object/Destroyable.h"
    4847
    4948namespace orxonox
     
    5453        The BaseObject and Interfaces are derived with @c virtual @c public @c OrxonoxClass from OrxonoxClass.
    5554    */
    56     class _CoreExport OrxonoxClass : public Identifiable
     55    class _CoreExport OrxonoxClass : public Identifiable, public Destroyable
    5756    {
    58         template <class T>
    59         friend class SmartPtr;
    60 
    61         friend class DestructionListener;
    62 
    6357        public:
    6458            OrxonoxClass();
    6559            virtual ~OrxonoxClass();
    6660
    67             void destroy();
    68 
    6961            /// Function to collect the SetConfigValue-macro calls.
    7062            void setConfigValues() {};
    71 
    72             /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
    73             inline unsigned int getReferenceCount() const
    74                 { return this->referenceCount_; }
    75 
    76         protected:
    77             /// This virtual function is called if destroy() is called and no SmartPtr points to this object. Used in some cases to create a new SmartPtr to prevent destruction.
    78             virtual void preDestroy() {}
    79 
    80         private:
    81             /// Increments the reference counter (for smart pointers).
    82             inline void incrementReferenceCount()
    83                 { ++this->referenceCount_; }
    84             /// Decrements the reference counter (for smart pointers).
    85             inline void decrementReferenceCount()
    86             {
    87                 --this->referenceCount_;
    88                 if (this->referenceCount_ == 0 && this->requestedDestruction_)
    89                     this->destroy();
    90             }
    91 
    92             /// Register a destruction listener (for example a weak pointer which points to this object).
    93             inline void registerDestructionListener(DestructionListener* pointer)
    94                 { this->destructionListeners_.insert(pointer); }
    95             /// Unegister a destruction listener (for example a weak pointer which pointed to this object before).
    96             inline void unregisterDestructionListener(DestructionListener* pointer)
    97                 { this->destructionListeners_.erase(pointer); }
    98 
    99             int referenceCount_;                                    //!< Counts the references from smart pointers to this object
    100             bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
    101             std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)
    10263    };
    103 
    104     /**
    105         @brief This listener is used to inform weak pointers if an object of type OrxonoxClass gets destroyed.
    106     */
    107     class _CoreExport DestructionListener
    108     {
    109         friend class OrxonoxClass;
    110 
    111         protected:
    112             virtual ~DestructionListener() {}
    113 
    114             inline void registerAsDestructionListener(OrxonoxClass* object)
    115                 { if (object) { object->registerDestructionListener(this); } }
    116             inline void unregisterAsDestructionListener(OrxonoxClass* object)
    117                 { if (object) { object->unregisterDestructionListener(this); } }
    118 
    119             virtual void objectDeleted() = 0;
    120     };
    121 
    12264}
    12365
Note: See TracChangeset for help on using the changeset viewer.