A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
ptr.h
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2005,2006 INRIA
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  */
20 
21 #ifndef PTR_H
22 #define PTR_H
23 
24 #include <iostream>
25 #include <stdint.h>
26 #include "assert.h"
27 
28 namespace ns3 {
29 
58 template <typename T>
59 class Ptr
60 {
61 private:
62  T *m_ptr;
63  class Tester {
64 private:
65  void operator delete (void *);
66  };
67  friend class Ptr<const T>;
68  template <typename U>
69  friend U *GetPointer (const Ptr<U> &p);
70  template <typename U>
71  friend U *PeekPointer (const Ptr<U> &p);
72 
73  inline void Acquire (void) const;
74 public:
78  Ptr ();
89  Ptr (T *ptr);
98  Ptr (T *ptr, bool ref);
99  Ptr (Ptr const&o);
100  // allow conversions from T to T const.
101  template <typename U>
102  Ptr (Ptr<U> const &o);
103  ~Ptr ();
104  Ptr<T> &operator = (Ptr const& o);
105 
106  T *operator -> () const;
107  T *operator -> ();
108  const T &operator * () const;
109  T &operator * ();
110  // allow if (!sp)
111  bool operator! ();
112  // allow if (sp)
113  // disable delete sp
114  operator Tester * () const;
115 };
116 
117 template <typename T>
118 Ptr<T> Create (void);
119 
120 template <typename T, typename T1>
121 Ptr<T> Create (T1 a1);
122 
123 template <typename T, typename T1, typename T2>
124 Ptr<T> Create (T1 a1, T2 a2);
125 
126 template <typename T, typename T1, typename T2, typename T3>
127 Ptr<T> Create (T1 a1, T2 a2, T3 a3);
128 
129 template <typename T, typename T1, typename T2, typename T3, typename T4>
130 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4);
131 
132 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
133 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
134 
135 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
136 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
137 
138 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
139 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7);
140 
150 template <typename T>
151 T * PeekPointer (const Ptr<T> &p);
152 
162 template <typename T>
163 T * GetPointer (const Ptr<T> &p);
164 
165 template <typename T>
166 std::ostream &operator << (std::ostream &, const Ptr<T> &p);
167 
168 
169 // allow if (sp == 0)
170 template <typename T1, typename T2>
171 bool operator == (Ptr<T1> const &lhs, T2 const *rhs);
172 
173 // allow if (0 == sp)
174 template <typename T1, typename T2>
175 bool operator == (T1 const *lhs, Ptr<T2> &rhs);
176 
177 // allow if (sp != 0)
178 template <typename T1, typename T2>
179 bool operator != (Ptr<T1> const &lhs, T2 const *rhs);
180 
181 // allow if (0 != sp)
182 template <typename T1, typename T2>
183 bool operator != (T1 const *lhs, Ptr<T2> &rhs);
184 
185 // allow if (sp0 == sp1)
186 template <typename T1, typename T2>
187 bool operator == (Ptr<T1> const &lhs, Ptr<T2> const &rhs);
188 
189 // allow if (sp0 != sp1)
190 template <typename T1, typename T2>
191 bool operator != (Ptr<T1> const &lhs, Ptr<T2> const &rhs);
192 
193 template <typename T1, typename T2>
194 Ptr<T1> const_pointer_cast (Ptr<T2> const&p);
195 
196 template <typename T>
197 struct CallbackTraits;
198 
199 template <typename T>
200 struct CallbackTraits<Ptr<T> >
201 {
202  static T & GetReference (Ptr<T> const p)
203  {
204  return *PeekPointer (p);
205  }
206 };
207 
208 template <typename T>
210 
211 template <typename T>
213 {
214  static T &GetReference (Ptr<T> p) {
215  return *PeekPointer (p);
216  }
217 };
218 
219 
220 
221 } // namespace ns3
222 
223 
224 namespace ns3 {
225 
226 /*************************************************
227  * friend non-member function implementations
228  ************************************************/
229 
230 template <typename T>
231 Ptr<T> Create (void)
232 {
233  return Ptr<T> (new T (), false);
234 }
235 
236 template <typename T, typename T1>
237 Ptr<T> Create (T1 a1)
238 {
239  return Ptr<T> (new T (a1), false);
240 }
241 
242 template <typename T, typename T1, typename T2>
243 Ptr<T> Create (T1 a1, T2 a2)
244 {
245  return Ptr<T> (new T (a1, a2), false);
246 }
247 
248 template <typename T, typename T1, typename T2, typename T3>
249 Ptr<T> Create (T1 a1, T2 a2, T3 a3)
250 {
251  return Ptr<T> (new T (a1, a2, a3), false);
252 }
253 
254 template <typename T, typename T1, typename T2, typename T3, typename T4>
255 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4)
256 {
257  return Ptr<T> (new T (a1, a2, a3, a4), false);
258 }
259 
260 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
261 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
262 {
263  return Ptr<T> (new T (a1, a2, a3, a4, a5), false);
264 }
265 
266 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
267 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
268 {
269  return Ptr<T> (new T (a1, a2, a3, a4, a5, a6), false);
270 }
271 
272 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
273 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
274 {
275  return Ptr<T> (new T (a1, a2, a3, a4, a5, a6, a7), false);
276 }
277 
278 template <typename T>
279 T * PeekPointer (const Ptr<T> &p)
280 {
281  return p.m_ptr;
282 }
283 
284 template <typename T>
285 T * GetPointer (const Ptr<T> &p)
286 {
287  p.Acquire ();
288  return p.m_ptr;
289 }
290 
291 template <typename T>
292 std::ostream &operator << (std::ostream &os, const Ptr<T> &p)
293 {
294  os << PeekPointer (p);
295  return os;
296 }
297 
298 template <typename T1, typename T2>
299 bool
300 operator == (Ptr<T1> const &lhs, T2 const *rhs)
301 {
302  return PeekPointer (lhs) == rhs;
303 }
304 
305 template <typename T1, typename T2>
306 bool
307 operator == (T1 const *lhs, Ptr<T2> &rhs)
308 {
309  return lhs == PeekPointer (rhs);
310 }
311 
312 template <typename T1, typename T2>
313 bool
314 operator != (Ptr<T1> const &lhs, T2 const *rhs)
315 {
316  return PeekPointer (lhs) != rhs;
317 }
318 
319 template <typename T1, typename T2>
320 bool
321 operator != (T1 const *lhs, Ptr<T2> &rhs)
322 {
323  return lhs != PeekPointer (rhs);
324 }
325 
326 template <typename T1, typename T2>
327 bool
328 operator == (Ptr<T1> const &lhs, Ptr<T2> const &rhs)
329 {
330  return PeekPointer (lhs) == PeekPointer (rhs);
331 }
332 
333 template <typename T1, typename T2>
334 bool
335 operator != (Ptr<T1> const &lhs, Ptr<T2> const &rhs)
336 {
337  return PeekPointer (lhs) != PeekPointer (rhs);
338 }
339 
340 template <typename T>
341 bool operator < (const Ptr<T> &lhs, const Ptr<T> &rhs)
342 {
343  return PeekPointer<T> (lhs) < PeekPointer<T> (rhs);
344 }
345 
346 template <typename T>
347 bool operator <= (const Ptr<T> &lhs, const Ptr<T> &rhs)
348 {
349  return PeekPointer<T> (lhs) <= PeekPointer<T> (rhs);
350 }
351 
352 template <typename T>
353 bool operator > (const Ptr<T> &lhs, const Ptr<T> &rhs)
354 {
355  return PeekPointer<T> (lhs) > PeekPointer<T> (rhs);
356 }
357 
358 template <typename T>
359 bool operator >= (const Ptr<T> &lhs, const Ptr<T> &rhs)
360 {
361  return PeekPointer<T> (lhs) >= PeekPointer<T> (rhs);
362 }
363 
364 template <typename T1, typename T2>
365 Ptr<T1>
366 ConstCast (Ptr<T2> const&p)
367 {
368  return Ptr<T1> (const_cast<T1 *> (PeekPointer (p)));
369 }
370 
371 template <typename T1, typename T2>
372 Ptr<T1>
373 DynamicCast (Ptr<T2> const&p)
374 {
375  return Ptr<T1> (dynamic_cast<T1 *> (PeekPointer (p)));
376 }
377 
378 template <typename T1, typename T2>
379 Ptr<T1>
380 StaticCast (Ptr<T2> const&p)
381 {
382  return Ptr<T1> (static_cast<T1 *> (PeekPointer (p)));
383 }
384 
385 
386 template <typename T>
387 Ptr<T> Copy (Ptr<T> object)
388 {
389  Ptr<T> p = Ptr<T> (new T (*PeekPointer (object)), false);
390  return p;
391 }
392 
393 template <typename T>
394 Ptr<T> Copy (Ptr<const T> object)
395 {
396  Ptr<T> p = Ptr<T> (new T (*PeekPointer (object)), false);
397  return p;
398 }
399 
400 /****************************************************
401  * Member method implementations.
402  ***************************************************/
403 
404 template <typename T>
405 void
406 Ptr<T>::Acquire (void) const
407 {
408  if (m_ptr != 0)
409  {
410  m_ptr->Ref ();
411  }
412 }
413 
414 template <typename T>
416  : m_ptr (0)
417 {
418 }
419 
420 template <typename T>
421 Ptr<T>::Ptr (T *ptr)
422  : m_ptr (ptr)
423 {
424  Acquire ();
425 }
426 
427 template <typename T>
428 Ptr<T>::Ptr (T *ptr, bool ref)
429  : m_ptr (ptr)
430 {
431  if (ref)
432  {
433  Acquire ();
434  }
435 }
436 
437 template <typename T>
438 Ptr<T>::Ptr (Ptr const&o)
439  : m_ptr (PeekPointer (o))
440 {
441  Acquire ();
442 }
443 template <typename T>
444 template <typename U>
445 Ptr<T>::Ptr (Ptr<U> const &o)
446  : m_ptr (PeekPointer (o))
447 {
448  Acquire ();
449 }
450 
451 template <typename T>
452 Ptr<T>::~Ptr ()
453 {
454  if (m_ptr != 0)
455  {
456  m_ptr->Unref ();
457  }
458 }
459 
460 template <typename T>
461 Ptr<T> &
462 Ptr<T>::operator = (Ptr const& o)
463 {
464  if (&o == this)
465  {
466  return *this;
467  }
468  if (m_ptr != 0)
469  {
470  m_ptr->Unref ();
471  }
472  m_ptr = o.m_ptr;
473  Acquire ();
474  return *this;
475 }
476 
477 template <typename T>
478 T *
479 Ptr<T>::operator -> ()
480 {
481  return m_ptr;
482 }
483 
484 template <typename T>
485 T *
486 Ptr<T>::operator -> () const
487 {
488  return m_ptr;
489 }
490 
491 template <typename T>
492 const T &
493 Ptr<T>::operator * () const
494 {
495  return *m_ptr;
496 }
497 
498 template <typename T>
499 T &
500 Ptr<T>::operator * ()
501 {
502  return *m_ptr;
503 }
504 
505 template <typename T>
506 bool
507 Ptr<T>::operator! ()
508 {
509  return m_ptr == 0;
510 }
511 
512 template <typename T>
513 Ptr<T>::operator Tester * () const
514 {
515  if (m_ptr == 0)
516  {
517  return 0;
518  }
519  static Tester test;
520  return &test;
521 }
522 
523 
524 } // namespace ns3
525 
526 #endif /* PTR_H */
smart pointer class similar to boost::intrusive_ptr
Definition: ptr.h:59
Ptr()
Definition: ptr.h:415