Main MRPT website > C++ reference
MRPT logo

safe_pointers.h

Go to the documentation of this file.
00001 /* +---------------------------------------------------------------------------+
00002    |          The Mobile Robot Programming Toolkit (MRPT) C++ library          |
00003    |                                                                           |
00004    |                   http://mrpt.sourceforge.net/                            |
00005    |                                                                           |
00006    |   Copyright (C) 2005-2011  University of Malaga                           |
00007    |                                                                           |
00008    |    This software was written by the Machine Perception and Intelligent    |
00009    |      Robotics Lab, University of Malaga (Spain).                          |
00010    |    Contact: Jose-Luis Blanco  <jlblanco@ctima.uma.es>                     |
00011    |                                                                           |
00012    |  This file is part of the MRPT project.                                   |
00013    |                                                                           |
00014    |     MRPT is free software: you can redistribute it and/or modify          |
00015    |     it under the terms of the GNU General Public License as published by  |
00016    |     the Free Software Foundation, either version 3 of the License, or     |
00017    |     (at your option) any later version.                                   |
00018    |                                                                           |
00019    |   MRPT is distributed in the hope that it will be useful,                 |
00020    |     but WITHOUT ANY WARRANTY; without even the implied warranty of        |
00021    |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         |
00022    |     GNU General Public License for more details.                          |
00023    |                                                                           |
00024    |     You should have received a copy of the GNU General Public License     |
00025    |     along with MRPT.  If not, see <http://www.gnu.org/licenses/>.         |
00026    |                                                                           |
00027    +---------------------------------------------------------------------------+ */
00028 #ifndef  safe_pointers_H
00029 #define  safe_pointers_H
00030 
00031 #include <mrpt/config.h>
00032 #include <mrpt/utils/utils_defs.h>
00033 
00034 /*---------------------------------------------------------------
00035         Class
00036   ---------------------------------------------------------------*/
00037 namespace mrpt
00038 {
00039 namespace utils
00040 {
00041         /** A wrapper class for pointers that can be safely copied with "=" operator without problems.
00042           * This class does not keep any reference count nor automatically destroy the pointed data.
00043           * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
00044           */
00045         template <class T>
00046         struct safe_ptr_basic
00047         {
00048         protected:
00049                 T *ptr;
00050 
00051         public:
00052                 safe_ptr_basic() : ptr(NULL) { }
00053                 safe_ptr_basic(const safe_ptr_basic<T> &o) : ptr(o.ptr) { }
00054                 safe_ptr_basic(const T* p) : ptr(const_cast<T*>(p)) { }
00055                 safe_ptr_basic<T> &operator =(T * p) { ptr = p; return *this; }
00056 
00057                 safe_ptr_basic<T> &operator =(const safe_ptr_basic<T>&o)
00058                 {
00059                         ptr = o.ptr;
00060                         return *this;
00061                 }
00062 
00063                 virtual ~safe_ptr_basic() {  }
00064 
00065                 bool operator == ( const T *o ) const { return o==ptr; }
00066                 bool operator == ( const safe_ptr_basic<T> &o )const { return o.ptr==ptr; }
00067 
00068                 bool operator != ( const T *o )const { return o!=ptr; }
00069                 bool operator != ( const safe_ptr_basic<T> &o )const { return o.ptr!=ptr; }
00070 
00071                 T*& get() { return ptr; }
00072                 const T* get()const { return ptr; }
00073 
00074                 T *& operator ->() { ASSERT_(ptr); return ptr; }
00075                 const T * operator ->() const  { ASSERT_(ptr); return ptr; }
00076         };
00077 
00078         /** A wrapper class for pointers that can be safely copied with "=" operator without problems.
00079           * This class does not keep any reference count nor automatically destroy the pointed data.
00080           * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
00081           */
00082         template <class T>
00083         struct safe_ptr : safe_ptr_basic<T>
00084         {
00085         public:
00086                 safe_ptr() : safe_ptr_basic<T>() { }
00087                 safe_ptr(const safe_ptr<T> &o) : safe_ptr_basic<T>(o) { }
00088                 safe_ptr(const T* p) : safe_ptr_basic<T>(p) { }
00089 
00090                 virtual ~safe_ptr() { }
00091 
00092                 T & operator *() { ASSERT_(safe_ptr_basic<T>::ptr); return *safe_ptr_basic<T>::ptr; }
00093                 const T & operator *() const  { ASSERT_(safe_ptr_basic<T>::ptr); return *safe_ptr_basic<T>::ptr; }
00094 
00095                 T & operator [](const size_t &i) { ASSERT_(safe_ptr_basic<T>::ptr); return safe_ptr_basic<T>::ptr[i]; }
00096                 const T & operator [](const size_t &i) const { ASSERT_(safe_ptr_basic<T>::ptr); return safe_ptr_basic<T>::ptr[i]; }
00097         };
00098 
00099 
00100         /** A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted.
00101           * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
00102           */
00103         template <class T>
00104         struct non_copiable_ptr_basic
00105         {
00106         protected:
00107                 T *ptr;
00108 
00109         public:
00110                 non_copiable_ptr_basic() : ptr(NULL) { }
00111                 non_copiable_ptr_basic(const non_copiable_ptr_basic<T> &o) : ptr(NULL) { THROW_EXCEPTION("Pointer non-copiable..."); }
00112                 non_copiable_ptr_basic(const T* p) : ptr(const_cast<T*>(p)) { }
00113                 non_copiable_ptr_basic<T> &operator =(T * p) { ptr = p; return *this; }
00114 
00115                 non_copiable_ptr_basic<T> &operator =(const non_copiable_ptr_basic<T>&o)
00116                 { THROW_EXCEPTION("Pointer non-copiable..."); }
00117 
00118                 /** This method can change the pointer, since the change is made explicitly, not through copy operators transparent to the user. */
00119                 void set( const T* p ) { ptr = const_cast<T*>(p); }
00120 
00121                 virtual ~non_copiable_ptr_basic() {  }
00122 
00123                 bool operator == ( const T *o ) const { return o==ptr; }
00124                 bool operator == ( const non_copiable_ptr_basic<T> &o )const { return o.ptr==ptr; }
00125 
00126                 bool operator != ( const T *o )const { return o!=ptr; }
00127                 bool operator != ( const non_copiable_ptr_basic<T> &o )const { return o.ptr!=ptr; }
00128 
00129                 T*& get() { return ptr; }
00130                 const T* get()const { return ptr; }
00131 
00132                 T** getPtrToPtr() { return &ptr; }
00133 
00134                 T *& operator ->() { ASSERT_(ptr); return ptr; }
00135                 const T * operator ->() const  { ASSERT_(ptr); return ptr; }
00136         };
00137 
00138         /** A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted.
00139           * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
00140           */
00141         template <class T>
00142         struct non_copiable_ptr : non_copiable_ptr_basic<T>
00143         {
00144         public:
00145                 non_copiable_ptr() : non_copiable_ptr_basic<T>() { }
00146                 non_copiable_ptr(const non_copiable_ptr<T> &o) : non_copiable_ptr_basic<T>(o) { }
00147                 non_copiable_ptr(const T* p) : non_copiable_ptr_basic<T>(p) { }
00148 
00149                 non_copiable_ptr<T> &operator =(const T* p) { non_copiable_ptr_basic<T>::ptr = const_cast<T*>(p); return *this; }
00150 
00151                 non_copiable_ptr<T> &operator =(const non_copiable_ptr<T>&o)
00152                 { THROW_EXCEPTION("Pointer non-copiable..."); }
00153 
00154                 virtual ~non_copiable_ptr() {  }
00155 
00156                 T & operator *() { ASSERT_(non_copiable_ptr_basic<T>::ptr); return *non_copiable_ptr_basic<T>::ptr; }
00157                 const T & operator *() const  { ASSERT_(non_copiable_ptr_basic<T>::ptr); return *non_copiable_ptr_basic<T>::ptr; }
00158 
00159                 T & operator [](const size_t &i) { ASSERT_(non_copiable_ptr_basic<T>::ptr); return non_copiable_ptr_basic<T>::ptr[i]; }
00160                 const T & operator [](const size_t &i) const { ASSERT_(non_copiable_ptr_basic<T>::ptr); return non_copiable_ptr_basic<T>::ptr[i]; }
00161         };
00162 
00163 
00164         /** A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy.
00165           * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
00166           */
00167         template <class T>
00168         struct copiable_NULL_ptr_basic
00169         {
00170         protected:
00171                 T *ptr;
00172 
00173         public:
00174                 copiable_NULL_ptr_basic() : ptr(NULL) { }
00175                 copiable_NULL_ptr_basic(const copiable_NULL_ptr_basic<T> &o) : ptr(NULL) {  }
00176 
00177                 copiable_NULL_ptr_basic<T> &operator =(T * p) { ptr=p; return *this; }
00178 
00179                 copiable_NULL_ptr_basic<T> &operator =(const copiable_NULL_ptr_basic<T>&o) { ptr=NULL; return *this; }
00180 
00181                 virtual ~copiable_NULL_ptr_basic() {  }
00182 
00183                 bool operator == ( const T *o ) const { return o==ptr; }
00184                 bool operator == ( const copiable_NULL_ptr_basic<T> &o )const { return o.ptr==ptr; }
00185 
00186                 bool operator != ( const T *o )const { return o!=ptr; }
00187                 bool operator != ( const copiable_NULL_ptr_basic<T> &o )const { return o.ptr!=ptr; }
00188 
00189                 T*& get() { return ptr; }
00190                 const T*& get()const { return ptr; }
00191 
00192                 T *& operator ->() { ASSERT_(ptr); return ptr; }
00193                 const T *& operator ->() const  { ASSERT_(ptr); return ptr; }
00194         };
00195 
00196         /** A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new copy.
00197           * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
00198           */
00199         template <class T>
00200         struct copiable_NULL_ptr : copiable_NULL_ptr_basic<T>
00201         {
00202         public:
00203                 copiable_NULL_ptr() : copiable_NULL_ptr_basic<T>() { }
00204                 copiable_NULL_ptr(const copiable_NULL_ptr<T> &o) : copiable_NULL_ptr_basic<T>(o) { }
00205 
00206                 copiable_NULL_ptr<T> &operator =(T * p) { copiable_NULL_ptr_basic<T>::ptr=p; return *this; }
00207 
00208                 virtual ~copiable_NULL_ptr() { }
00209 
00210                 T & operator *() { ASSERT_(copiable_NULL_ptr_basic<T>::ptr); return *copiable_NULL_ptr_basic<T>::ptr; }
00211                 const T & operator *() const  { ASSERT_(copiable_NULL_ptr_basic<T>::ptr); return *copiable_NULL_ptr_basic<T>::ptr; }
00212 
00213                 T & operator [](const size_t &i) { ASSERT_(copiable_NULL_ptr_basic<T>::ptr); return copiable_NULL_ptr_basic<T>::ptr[i]; }
00214                 const T & operator [](const size_t &i) const { ASSERT_(copiable_NULL_ptr_basic<T>::ptr); return copiable_NULL_ptr_basic<T>::ptr[i]; }
00215         };
00216 
00217 
00218 
00219         typedef safe_ptr_basic<void> void_ptr;
00220         typedef non_copiable_ptr_basic<void> void_ptr_noncopy;
00221 
00222         } // End of namespace
00223 } // End of namespace
00224 #endif



Page generated by Doxygen 1.7.3 for MRPT 0.9.4 SVN: at Sat Mar 26 06:16:28 UTC 2011