Main MRPT website > C++ reference for MRPT 1.3.2
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-2015, 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>
13 #include <mrpt/utils/boost_join.h>
14 #include <mrpt/utils/mrpt_macros.h> // ASSERT_()
15 
16 /*---------------------------------------------------------------
17  Class
18  ---------------------------------------------------------------*/
19 namespace mrpt
20 {
21 namespace utils
22 {
23  /** A wrapper class for pointers that can be safely copied with "=" operator without problems.
24  * This class does not keep any reference count nor automatically destroy the pointed data.
25  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
26  * \ingroup mrpt_base_grp
27  */
28  template <class T>
30  {
31  protected:
32  T *ptr;
33 
34  public:
35  safe_ptr_basic() : ptr(NULL) { }
36  safe_ptr_basic(const safe_ptr_basic<T> &o) : ptr(o.ptr) { }
37  safe_ptr_basic(const T* p) : ptr(const_cast<T*>(p)) { }
38  safe_ptr_basic<T> &operator =(T * p) { ptr = p; return *this; }
39 
41  {
42  ptr = o.ptr;
43  return *this;
44  }
45 
46  virtual ~safe_ptr_basic() { }
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  bool operator != ( const T *o )const { return o!=ptr; }
52  bool operator != ( const safe_ptr_basic<T> &o )const { return o.ptr!=ptr; }
53 
54  T*& get() { return ptr; }
55  const T* get()const { return ptr; }
56 
57  T *& operator ->() { ASSERT_(ptr); return ptr; }
58  const T * operator ->() const { ASSERT_(ptr); return ptr; }
59  };
60 
61  /** A wrapper class for pointers that can be safely copied with "=" operator without problems.
62  * This class does not keep any reference count nor automatically destroy the pointed data.
63  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
64  * \ingroup mrpt_base_grp
65  */
66  template <class T>
68  {
69  public:
70  safe_ptr() : safe_ptr_basic<T>() { }
71  safe_ptr(const safe_ptr<T> &o) : safe_ptr_basic<T>(o) { }
72  safe_ptr(const T* p) : safe_ptr_basic<T>(p) { }
73 
74  virtual ~safe_ptr() { }
75 
78 
79  T & operator [](const size_t &i) { ASSERT_(safe_ptr_basic<T>::ptr); return safe_ptr_basic<T>::ptr[i]; }
80  const T & operator [](const size_t &i) const { ASSERT_(safe_ptr_basic<T>::ptr); return safe_ptr_basic<T>::ptr[i]; }
81  };
82 
83 
84  /** A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted.
85  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
86  * \ingroup mrpt_base_grp
87  */
88  template <class T>
90  {
91  protected:
92  T *ptr;
93 
94  public:
95  non_copiable_ptr_basic() : ptr(NULL) { }
96  non_copiable_ptr_basic(const non_copiable_ptr_basic<T> &) : ptr(NULL) { THROW_EXCEPTION("Pointer non-copiable..."); }
97  non_copiable_ptr_basic(const T* p) : ptr(const_cast<T*>(p)) { }
98  non_copiable_ptr_basic<T> &operator =(T * p) { ptr = p; return *this; }
99 
101  { THROW_EXCEPTION("Pointer non-copiable..."); }
102 
103  /** This method can change the pointer, since the change is made explicitly, not through copy operators transparent to the user. */
104  void set( const T* p ) { ptr = const_cast<T*>(p); }
105 
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  bool operator != ( const T *o )const { return o!=ptr; }
112  bool operator != ( const non_copiable_ptr_basic<T> &o )const { return o.ptr!=ptr; }
113 
114  T*& get() { return ptr; }
115  const T* get()const { return ptr; }
116 
117  T** getPtrToPtr() { return &ptr; }
118 
119  T *& operator ->() { ASSERT_(ptr); return ptr; }
120  const T * operator ->() const { ASSERT_(ptr); return ptr; }
121  };
122 
123  /** A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted.
124  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
125  * \ingroup mrpt_base_grp
126  */
127  template <class T>
129  {
130  public:
133  non_copiable_ptr(const T* p) : non_copiable_ptr_basic<T>(p) { }
134 
135  non_copiable_ptr<T> &operator =(const T* p) { non_copiable_ptr_basic<T>::ptr = const_cast<T*>(p); return *this; }
136 
138  { THROW_EXCEPTION("Pointer non-copiable..."); }
139 
140  virtual ~non_copiable_ptr() { }
141 
144 
145  T & operator [](const size_t &i) { ASSERT_(non_copiable_ptr_basic<T>::ptr); return non_copiable_ptr_basic<T>::ptr[i]; }
146  const T & operator [](const size_t &i) const { ASSERT_(non_copiable_ptr_basic<T>::ptr); return non_copiable_ptr_basic<T>::ptr[i]; }
147  };
148 
149  /** 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".
150  * In turn, assigning a pointer with a direct "=" operation from a plain "T*" type is permited.
151  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
152  * \ingroup mrpt_base_grp
153  */
154  template <class T>
156  {
157  protected:
158  T *ptr;
159 
160  public:
161  ignored_copy_ptr() : ptr(NULL) { }
162  ignored_copy_ptr(const ignored_copy_ptr<T> &) : ptr(NULL) { }
163  ignored_copy_ptr(const T* p) : ptr(const_cast<T*>(p)) { }
164  ignored_copy_ptr<T> &operator =(T * p) { ptr=p; return *this; }
165 
167 
168  /** This method can change the pointer, since the change is made explicitly, not through copy operators transparent to the user. */
169  void set( const T* p ) { ptr = const_cast<T*>(p); }
170 
171  virtual ~ignored_copy_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  bool operator != ( const T *o )const { return o!=ptr; }
177  bool operator != ( const ignored_copy_ptr<T> &o )const { return o.ptr!=ptr; }
178 
179  T*& get() { return ptr; }
180  const T* get()const { return ptr; }
181 
182  T** getPtrToPtr() { return &ptr; }
183 
184  T *& operator ->() { ASSERT_(ptr); return ptr; }
185  const T * operator ->() const { ASSERT_(ptr); return ptr; }
186  };
187 
188 
189  /** A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy.
190  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
191  * \ingroup mrpt_base_grp
192  */
193  template <class T>
195  {
196  protected:
197  T *ptr;
198 
199  public:
200  copiable_NULL_ptr_basic() : ptr(NULL) { }
202 
203  copiable_NULL_ptr_basic<T> &operator =(T * p) { ptr=p; return *this; }
204 
206 
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  bool operator != ( const T *o )const { return o!=ptr; }
213  bool operator != ( const copiable_NULL_ptr_basic<T> &o )const { return o.ptr!=ptr; }
214 
215  T*& get() { return ptr; }
216  const T*& get()const { return ptr; }
217 
218  T *& operator ->() { ASSERT_(ptr); return ptr; }
219  const T *& operator ->() const { ASSERT_(ptr); return ptr; }
220  };
221 
222  /** A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new copy.
223  * \sa CReferencedMemBlock, safe_ptr, non_copiable_ptr, copiable_NULL_ptr
224  * \ingroup mrpt_base_grp
225  */
226  template <class T>
228  {
229  public:
232 
234 
235  virtual ~copiable_NULL_ptr() { }
236 
239 
240  T & operator [](const size_t &i) { ASSERT_(copiable_NULL_ptr_basic<T>::ptr); return copiable_NULL_ptr_basic<T>::ptr[i]; }
241  const T & operator [](const size_t &i) const { ASSERT_(copiable_NULL_ptr_basic<T>::ptr); return copiable_NULL_ptr_basic<T>::ptr[i]; }
242  };
243 
244 
245 
248 
249  } // End of namespace
250 } // End of namespace
251 #endif
A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy...
A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtim...
Definition: safe_pointers.h:89
#define THROW_EXCEPTION(msg)
bool operator!=(const T *o) const
Definition: safe_pointers.h:51
copiable_NULL_ptr(const copiable_NULL_ptr< T > &o)
ignored_copy_ptr(const ignored_copy_ptr< T > &)
non_copiable_ptr(const non_copiable_ptr< T > &o)
safe_ptr_basic(const safe_ptr_basic< T > &o)
Definition: safe_pointers.h:36
bool operator==(const T *o) const
Definition: safe_pointers.h:48
non_copiable_ptr_basic< void > void_ptr_noncopy
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
safe_ptr(const safe_ptr< T > &o)
Definition: safe_pointers.h:71
copiable_NULL_ptr_basic(const copiable_NULL_ptr_basic< T > &)
safe_ptr_basic< void > void_ptr
#define ASSERT_(f)
A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new ...
safe_ptr_basic< T > & operator=(T *p)
Definition: safe_pointers.h:38
A wrapper class for pointers whose copy operations from other objects of the same type are ignored...
A wrapper class for pointers that can be safely copied with "=" operator without problems.
Definition: safe_pointers.h:29
A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtim...
std::vector< T1 > operator*(const std::vector< T1 > &a, const std::vector< T2 > &b)
a*b (element-wise multiplication)
Definition: ops_vectors.h:59
A wrapper class for pointers that can be safely copied with "=" operator without problems.
Definition: safe_pointers.h:67
non_copiable_ptr_basic(const non_copiable_ptr_basic< T > &)
Definition: safe_pointers.h:96



Page generated by Doxygen 1.8.11 for MRPT 1.3.2 SVN: at Wed May 25 02:34:21 UTC 2016