Main MRPT website > C++ reference for MRPT 1.4.0
safe_pointers.h
Go to the documentation of this file.
1/* +---------------------------------------------------------------------------+
2 | Mobile Robot Programming Toolkit (MRPT) |
3 | http://www.mrpt.org/ |
4 | |
5 | Copyright (c) 2005-2016, Individual contributors, see AUTHORS file |
6 | See: http://www.mrpt.org/Authors - All rights reserved. |
7 | Released under BSD License. See details in http://www.mrpt.org/License |
8 +---------------------------------------------------------------------------+ */
9#ifndef safe_pointers_H
10#define safe_pointers_H
11
12#include <mrpt/config.h>
14#include <mrpt/utils/mrpt_macros.h> // ASSERT_()
15
16namespace mrpt
17{
18namespace utils
19{
20 /** A wrapper class for pointers that can be safely copied with "=" operator without problems.
21 * This class does not keep any reference count nor automatically destroy the pointed data.
22 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
23 * \ingroup mrpt_base_grp
24 */
25 template <class T>
27 {
28 protected:
29 T *ptr;
30
31 public:
32 safe_ptr_basic() : ptr(NULL) { }
34 safe_ptr_basic(const T* p) : ptr(const_cast<T*>(p)) { }
35 safe_ptr_basic<T> &operator =(T * p) { ptr = p; return *this; }
36
38 {
39 ptr = o.ptr;
40 return *this;
41 }
42
43 virtual ~safe_ptr_basic() { }
44
45 bool operator == ( const T *o ) const { return o==ptr; }
46 bool operator == ( const safe_ptr_basic<T> &o )const { return o.ptr==ptr; }
47
48 bool operator != ( const T *o )const { return o!=ptr; }
49 bool operator != ( const safe_ptr_basic<T> &o )const { return o.ptr!=ptr; }
50
51 T*& get() { return ptr; }
52 const T* get()const { return ptr; }
53
54 T *& operator ->() { ASSERT_(ptr); return ptr; }
55 const T * operator ->() const { ASSERT_(ptr); return ptr; }
56 };
57
58 /** A wrapper class for pointers that can be safely copied with "=" operator without problems.
59 * This class does not keep any reference count nor automatically destroy the pointed data.
60 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
61 * \ingroup mrpt_base_grp
62 */
63 template <class T>
65 {
66 public:
68 safe_ptr(const safe_ptr<T> &o) : safe_ptr_basic<T>(o) { }
69 safe_ptr(const T* p) : safe_ptr_basic<T>(p) { }
70
71 virtual ~safe_ptr() { }
72
75
77 const T & operator [](const size_t &i) const { ASSERT_(safe_ptr_basic<T>::ptr); return safe_ptr_basic<T>::ptr[i]; }
78 };
79
80
81 /** A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted.
82 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
83 * \ingroup mrpt_base_grp
84 */
85 template <class T>
87 {
88 protected:
89 T *ptr;
90
91 public:
93 non_copiable_ptr_basic(const non_copiable_ptr_basic<T> &) : ptr(NULL) { THROW_EXCEPTION("Pointer non-copiable..."); }
94 non_copiable_ptr_basic(const T* p) : ptr(const_cast<T*>(p)) { }
95 non_copiable_ptr_basic<T> &operator =(T * p) { ptr = p; return *this; }
96
99
100 /** This method can change the pointer, since the change is made explicitly, not through copy operators transparent to the user. */
101 void set( const T* p ) { ptr = const_cast<T*>(p); }
102
104
105 bool operator == ( const T *o ) const { return o==ptr; }
106 bool operator == ( const non_copiable_ptr_basic<T> &o )const { return o.ptr==ptr; }
107
108 bool operator != ( const T *o )const { return o!=ptr; }
109 bool operator != ( const non_copiable_ptr_basic<T> &o )const { return o.ptr!=ptr; }
110
111 T*& get() { return ptr; }
112 const T* get()const { return ptr; }
113
114 T** getPtrToPtr() { return &ptr; }
115
116 T *& operator ->() { ASSERT_(ptr); return ptr; }
117 const T * operator ->() const { ASSERT_(ptr); return ptr; }
118 };
119
120 /** A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted.
121 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
122 * \ingroup mrpt_base_grp
123 */
124 template <class T>
145
146 /** A wrapper class for pointers whose copy operations from other objects of the same type are ignored, that is, doing "a=b;" has no effect neiter on "a" or "b".
147 * In turn, assigning a pointer with a direct "=" operation from a plain "T*" type is permited.
148 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
149 * \ingroup mrpt_base_grp
150 */
151 template <class T>
153 {
154 protected:
155 T *ptr;
156
157 public:
158 ignored_copy_ptr() : ptr(NULL) { }
160 ignored_copy_ptr(const T* p) : ptr(const_cast<T*>(p)) { }
161 ignored_copy_ptr<T> &operator =(T * p) { ptr=p; return *this; }
162
164
165 /** This method can change the pointer, since the change is made explicitly, not through copy operators transparent to the user. */
166 void set( const T* p ) { ptr = const_cast<T*>(p); }
167
168 virtual ~ignored_copy_ptr() { }
169
170 bool operator == ( const T *o ) const { return o==ptr; }
171 bool operator == ( const ignored_copy_ptr<T> &o )const { return o.ptr==ptr; }
172
173 bool operator != ( const T *o )const { return o!=ptr; }
174 bool operator != ( const ignored_copy_ptr<T> &o )const { return o.ptr!=ptr; }
175
176 T*& get() { return ptr; }
177 const T* get()const { return ptr; }
178
179 T** getPtrToPtr() { return &ptr; }
180
181 T *& operator ->() { ASSERT_(ptr); return ptr; }
182 const T * operator ->() const { ASSERT_(ptr); return ptr; }
183 };
184
185
186 /** A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy.
187 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
188 * \ingroup mrpt_base_grp
189 */
190 template <class T>
192 {
193 protected:
194 T *ptr;
195
196 public:
199
200 copiable_NULL_ptr_basic<T> &operator =(T * p) { ptr=p; return *this; }
201
203
205
206 bool operator == ( const T *o ) const { return o==ptr; }
207 bool operator == ( const copiable_NULL_ptr_basic<T> &o )const { return o.ptr==ptr; }
208
209 bool operator != ( const T *o )const { return o!=ptr; }
210 bool operator != ( const copiable_NULL_ptr_basic<T> &o )const { return o.ptr!=ptr; }
211
212 T*& get() { return ptr; }
213 const T*& get()const { return ptr; }
214
215 T *& operator ->() { ASSERT_(ptr); return ptr; }
216 const T *& operator ->() const { ASSERT_(ptr); return ptr; }
217 };
218
219 /** A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new copy.
220 * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
221 * \ingroup mrpt_base_grp
222 */
223 template <class T>
240
241
242
245
246 } // End of namespace
247} // End of namespace
248#endif
#define ASSERT_(f)
#define THROW_EXCEPTION(msg)
safe_ptr_basic< void > void_ptr
non_copiable_ptr_basic< void > void_ptr_noncopy
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy...
copiable_NULL_ptr_basic< T > & operator=(T *p)
copiable_NULL_ptr_basic(const copiable_NULL_ptr_basic< T > &)
A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new ...
copiable_NULL_ptr< T > & operator=(T *p)
T & operator[](const size_t &i)
copiable_NULL_ptr(const copiable_NULL_ptr< T > &o)
A wrapper class for pointers whose copy operations from other objects of the same type are ignored,...
ignored_copy_ptr(const ignored_copy_ptr< T > &)
void set(const T *p)
This method can change the pointer, since the change is made explicitly, not through copy operators t...
bool operator!=(const T *o) const
bool operator==(const T *o) const
ignored_copy_ptr< T > & operator=(T *p)
A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtim...
non_copiable_ptr_basic(const non_copiable_ptr_basic< T > &)
bool operator!=(const T *o) const
void set(const T *p)
This method can change the pointer, since the change is made explicitly, not through copy operators t...
non_copiable_ptr_basic< T > & operator=(T *p)
bool operator==(const T *o) const
A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtim...
T & operator[](const size_t &i)
non_copiable_ptr< T > & operator=(const T *p)
non_copiable_ptr(const non_copiable_ptr< T > &o)
A wrapper class for pointers that can be safely copied with "=" operator without problems.
bool operator==(const T *o) const
safe_ptr_basic(const safe_ptr_basic< T > &o)
safe_ptr_basic< T > & operator=(T *p)
bool operator!=(const T *o) const
A wrapper class for pointers that can be safely copied with "=" operator without problems.
T & operator[](const size_t &i)
safe_ptr(const safe_ptr< T > &o)



Page generated by Doxygen 1.9.8 for MRPT 1.4.0 SVN: at Wed Dec 6 15:06:50 UTC 2023