Changeset 29 for nrEngine


Ignore:
Timestamp:
04/04/2007 08:12:01 PM (12 years ago)
Author:
art
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/ResourcePtr.h

    r28 r29  
    2424 
    2525namespace nrEngine{ 
    26          
     26 
    2727        //! Base untemplated class for resource pointers 
    2828        /** 
     
    3939        class _NRExport IResourcePtr{ 
    4040                public: 
    41                  
     41 
    4242                        /** 
    4343                        * Copy constructor 
    4444                        **/ 
    4545                        IResourcePtr(const IResourcePtr& resPtr); 
    46                          
     46 
    4747                        /** 
    4848                        * Virtual destructor 
     
    5252                                mHolder.reset(); 
    5353                        }; 
    54                  
     54 
    5555                        /** 
    5656                        * Check if the given pointer is the same as this one. 
    5757                        * @note Two pointers are the same, if they showing to the same resource, and 
    58                         *                if their holders are the same or if  
     58                        *                if their holders are the same or if 
    5959                        *                both pointers points to NULL. If one of the pointers is an empty pointer, 
    6060                        *                so also false will be returned. 
    6161                        **/ 
    6262                        virtual bool operator==(IResourcePtr& res) const; 
    63                          
    64                          
     63 
     64 
    6565                        /** 
    6666                        * Check equality to normal pointers. 
    6767                        **/ 
    6868                        virtual bool operator==(const IResource* p) const; 
    69                          
    70                          
     69 
     70 
    7171                        /** 
    7272                        * Check whenver two pointers are not the same. 
     
    7474                        **/ 
    7575                        virtual bool operator!=(IResourcePtr& res) const; 
    76                          
    77                          
     76 
     77 
    7878                        /** 
    7979                        * Check whenver two pointers are not the same. 
     
    8181                        **/ 
    8282                        virtual bool operator!=(const IResource* res) const; 
    83                          
    84                          
     83 
     84 
    8585                        /** 
    8686                        * Check whenever this pointer is NULL - does not contain data 
     
    8989                                return (mHolder.get() == NULL); 
    9090                        } 
    91                  
    92                         inline bool valid() const { 
     91 
     92                        /** 
     93                         * Check whenever the pointer contains valid data. The method 
     94                         * if opossite to isNull() 
     95                         **/ 
     96                        inline bool valid()const { 
    9397                                return (mHolder.get() != NULL); 
    9498                        } 
    95                          
     99 
    96100                        /** 
    97101                        * Lock the resource to which one this pointer points, to prevent using 
     
    104108                        **/ 
    105109                        virtual Result lockPure(); 
    106                  
    107                          
     110 
     111 
    108112                        /** 
    109113                        * Unlock the resource to which one this pointer points, to prevent using 
     
    113117                        **/ 
    114118                        virtual Result unlockPure(); 
    115                          
    116                          
     119 
     120 
    117121                        /** 
    118122                        * Access to the resource to which one this pointer points. This access need 
     
    121125                        **/ 
    122126                        virtual IResource* getBase() const; 
    123                  
    124                          
     127 
     128 
    125129                        /** 
    126130                        * Access to the resource to which one this pointer points. This access need 
     
    129133                        **/ 
    130134                        //virtual IResource& operator*() const; 
    131                                  
     135 
    132136                protected: 
    133                  
     137 
    134138                        //! Resource Manager is a friend, so it can freely work with this pointers 
    135139                        friend class IResourceLoader; 
     
    137141                        //! Also resource manager is a friend 
    138142                        friend class ResourceManager; 
    139                          
     143 
    140144                        //! Shared pointer holding the holder of the resource 
    141145                        SharedPtr<ResourceHolder> mHolder; 
    142                  
     146 
    143147                        /** 
    144148                        * Get the holder to which one this pointer shows 
     
    148152                                return mHolder; 
    149153                        } 
    150                          
     154 
    151155                        /** 
    152156                        * Create an instance of the resource pointer. This pointer is pointing 
     
    158162                                mHolder = holder; 
    159163                        } 
    160                  
     164 
    161165                        /** 
    162166                        * Simple constructor that is declared as protected/private, so that this 
     
    167171                                mHolder.reset(); 
    168172                        } 
    169                          
     173 
    170174        }; 
    171          
    172          
    173          
     175 
     176 
     177 
    174178        //! Resource pointer is a smart pointer pointing to the resource 
    175179        /** 
     
    199203        class _NRExport ResourcePtr: public IResourcePtr{ 
    200204                public: 
    201                  
     205 
    202206                        /** 
    203207                         * Create an empty resource pointer. Such a pointer 
     
    206210                         **/ 
    207211                        ResourcePtr() : IResourcePtr() {} 
    208                                          
     212 
    209213                        /** 
    210214                        * Copy constructor to allow copying from base class 
    211215                        **/ 
    212216                        ResourcePtr(const IResourcePtr& res) : IResourcePtr(res){} 
     217<<<<<<< .mine 
     218 
     219 
     220======= 
    213221                         
     222>>>>>>> .r28 
    214223                        /** 
    215224                        * Access to the resource to which one this pointer points. This access need 
     
    223232                                return ptr; 
    224233                        } 
    225                  
     234 
    226235                        /** 
    227236                        * Get the object stored by this pointer. 
    228237                        * NOTE: The instance is controlled by the pointer, so do not delete it 
    229238                        **/ 
    230                         NR_FORCEINLINE ResType* get()  
     239                        NR_FORCEINLINE ResType* get() 
    231240                        { 
    232241                                return operator->(); 
    233                         }                        
    234                          
     242                        } 
     243 
    235244                        /** 
    236245                        * Access to the resource to which one this pointer points. This access need 
     
    245254                        } 
    246255        }; 
    247                  
     256 
    248257}; 
    249258#endif 
Note: See TracChangeset for help on using the changeset viewer.