00001 /* +---------------------------------------------------------------------------+ 00002 | The Mobile Robot Programming Toolkit (MRPT) C++ library | 00003 | | 00004 | http://mrpt.sourceforge.net/ | 00005 | | 00006 | Copyright (C) 2005-2009 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 { 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 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 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 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 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 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 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.5.7.1 for MRPT 0.6.5 SVN: at Mon Feb 23 13:35:09 EST 2009 |