00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef PTR_H
00022 #define PTR_H
00023
00024 #include <iostream>
00025 #include <stdint.h>
00026 #include "assert.h"
00027
00028 namespace ns3 {
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058 template <typename T>
00059 class Ptr
00060 {
00061 private:
00062 T *m_ptr;
00063 class Tester {
00064 private:
00065 void operator delete (void *);
00066 };
00067 friend class Ptr<const T>;
00068 template <typename U>
00069 friend U *GetPointer (const Ptr<U> &p);
00070 template <typename U>
00071 friend U *PeekPointer (const Ptr<U> &p);
00072
00073 inline void Acquire (void) const;
00074 public:
00075
00076
00077
00078 Ptr ();
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089 Ptr (T *ptr);
00090
00091
00092
00093
00094
00095
00096
00097
00098 Ptr (T *ptr, bool ref);
00099 Ptr (Ptr const&o);
00100
00101 template <typename U>
00102 Ptr (Ptr<U> const &o);
00103 ~Ptr () ;
00104 Ptr<T> &operator = (Ptr const& o);
00105
00106 T *operator -> () const;
00107 T *operator -> ();
00108 const T &operator * () const;
00109 const T &operator * ();
00110
00111 bool operator! ();
00112
00113
00114 operator Tester * () const;
00115 };
00116
00117 template <typename T>
00118 Ptr<T> Create (void);
00119
00120 template <typename T, typename T1>
00121 Ptr<T> Create (T1 a1);
00122
00123 template <typename T, typename T1, typename T2>
00124 Ptr<T> Create (T1 a1, T2 a2);
00125
00126 template <typename T, typename T1, typename T2, typename T3>
00127 Ptr<T> Create (T1 a1, T2 a2, T3 a3);
00128
00129 template <typename T, typename T1, typename T2, typename T3, typename T4>
00130 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4);
00131
00132 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
00133 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
00134
00135 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00136 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
00137
00138 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00139 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7);
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149 template <typename T>
00150 T * PeekPointer (const Ptr<T> &p);
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160 template <typename T>
00161 T * GetPointer (const Ptr<T> &p);
00162
00163 template <typename T>
00164 std::ostream &operator << (std::ostream &, const Ptr<T> &p);
00165
00166
00167
00168 template <typename T1, typename T2>
00169 bool operator == (Ptr<T1> const &lhs, T2 const *rhs);
00170
00171
00172 template <typename T1, typename T2>
00173 bool operator == (T1 const *lhs, Ptr<T2> &rhs);
00174
00175
00176 template <typename T1, typename T2>
00177 bool operator != (Ptr<T1> const &lhs, T2 const *rhs);
00178
00179
00180 template <typename T1, typename T2>
00181 bool operator != (T1 const *lhs, Ptr<T2> &rhs);
00182
00183
00184 template <typename T1, typename T2>
00185 bool operator == (Ptr<T1> const &lhs, Ptr<T2> const &rhs);
00186
00187
00188 template <typename T1, typename T2>
00189 bool operator != (Ptr<T1> const &lhs, Ptr<T2> const &rhs);
00190
00191 template <typename T1, typename T2>
00192 Ptr<T1> const_pointer_cast (Ptr<T2> const&p);
00193
00194 template <typename T>
00195 struct CallbackTraits;
00196
00197 template <typename T>
00198 struct CallbackTraits<Ptr<T> >
00199 {
00200 static T & GetReference (Ptr<T> const p)
00201 {
00202 return *PeekPointer (p);
00203 }
00204 };
00205
00206 template <typename T>
00207 struct EventMemberImplObjTraits;
00208
00209 template <typename T>
00210 struct EventMemberImplObjTraits<Ptr<T> >
00211 {
00212 static T &GetReference (Ptr<T> p) {
00213 return *PeekPointer (p);
00214 }
00215 };
00216
00217
00218
00219 }
00220
00221
00222 namespace ns3 {
00223
00224
00225
00226
00227
00228 template <typename T>
00229 Ptr<T> Create (void)
00230 {
00231 return Ptr<T> (new T (), false);
00232 }
00233
00234 template <typename T, typename T1>
00235 Ptr<T> Create (T1 a1)
00236 {
00237 return Ptr<T> (new T (a1), false);
00238 }
00239
00240 template <typename T, typename T1, typename T2>
00241 Ptr<T> Create (T1 a1, T2 a2)
00242 {
00243 return Ptr<T> (new T (a1, a2), false);
00244 }
00245
00246 template <typename T, typename T1, typename T2, typename T3>
00247 Ptr<T> Create (T1 a1, T2 a2, T3 a3)
00248 {
00249 return Ptr<T> (new T (a1, a2, a3), false);
00250 }
00251
00252 template <typename T, typename T1, typename T2, typename T3, typename T4>
00253 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4)
00254 {
00255 return Ptr<T> (new T (a1, a2, a3, a4), false);
00256 }
00257
00258 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
00259 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
00260 {
00261 return Ptr<T> (new T (a1, a2, a3, a4, a5), false);
00262 }
00263
00264 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00265 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
00266 {
00267 return Ptr<T> (new T (a1, a2, a3, a4, a5, a6), false);
00268 }
00269
00270 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00271 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
00272 {
00273 return Ptr<T> (new T (a1, a2, a3, a4, a5, a6, a7), false);
00274 }
00275
00276 template <typename T>
00277 T * PeekPointer (const Ptr<T> &p)
00278 {
00279 return p.m_ptr;
00280 }
00281
00282 template <typename T>
00283 T * GetPointer (const Ptr<T> &p)
00284 {
00285 p.Acquire ();
00286 return p.m_ptr;
00287 }
00288
00289 template <typename T>
00290 std::ostream &operator << (std::ostream &os, const Ptr<T> &p)
00291 {
00292 os << PeekPointer (p);
00293 return os;
00294 }
00295
00296 template <typename T1, typename T2>
00297 bool
00298 operator == (Ptr<T1> const &lhs, T2 const *rhs)
00299 {
00300 return PeekPointer (lhs) == rhs;
00301 }
00302
00303 template <typename T1, typename T2>
00304 bool
00305 operator == (T1 const *lhs, Ptr<T2> &rhs)
00306 {
00307 return lhs == PeekPointer (rhs);
00308 }
00309
00310 template <typename T1, typename T2>
00311 bool
00312 operator != (Ptr<T1> const &lhs, T2 const *rhs)
00313 {
00314 return PeekPointer (lhs) != rhs;
00315 }
00316
00317 template <typename T1, typename T2>
00318 bool
00319 operator != (T1 const *lhs, Ptr<T2> &rhs)
00320 {
00321 return lhs != PeekPointer (rhs);
00322 }
00323
00324 template <typename T1, typename T2>
00325 bool
00326 operator == (Ptr<T1> const &lhs, Ptr<T2> const &rhs)
00327 {
00328 return PeekPointer (lhs) == PeekPointer (rhs);
00329 }
00330
00331 template <typename T1, typename T2>
00332 bool
00333 operator != (Ptr<T1> const &lhs, Ptr<T2> const &rhs)
00334 {
00335 return PeekPointer (lhs) != PeekPointer (rhs);
00336 }
00337
00338 template <typename T>
00339 bool operator < (const Ptr<T> &lhs, const Ptr<T> &rhs)
00340 {
00341 return PeekPointer<T> (lhs) < PeekPointer<T> (rhs);
00342 }
00343
00344 template <typename T>
00345 bool operator <= (const Ptr<T> &lhs, const Ptr<T> &rhs)
00346 {
00347 return PeekPointer<T> (lhs) <= PeekPointer<T> (rhs);
00348 }
00349
00350 template <typename T>
00351 bool operator > (const Ptr<T> &lhs, const Ptr<T> &rhs)
00352 {
00353 return PeekPointer<T> (lhs) > PeekPointer<T> (rhs);
00354 }
00355
00356 template <typename T>
00357 bool operator >= (const Ptr<T> &lhs, const Ptr<T> &rhs)
00358 {
00359 return PeekPointer<T> (lhs) >= PeekPointer<T> (rhs);
00360 }
00361
00362 template <typename T1, typename T2>
00363 Ptr<T1>
00364 ConstCast (Ptr<T2> const&p)
00365 {
00366 return Ptr<T1> (const_cast<T1 *> (PeekPointer (p)));
00367 }
00368
00369 template <typename T1, typename T2>
00370 Ptr<T1>
00371 DynamicCast (Ptr<T2> const&p)
00372 {
00373 return Ptr<T1> (dynamic_cast<T1 *> (PeekPointer (p)));
00374 }
00375
00376
00377
00378
00379
00380
00381 template <typename T>
00382 void
00383 Ptr<T>::Acquire (void) const
00384 {
00385 if (m_ptr != 0)
00386 {
00387 m_ptr->Ref ();
00388 }
00389 }
00390
00391 template <typename T>
00392 Ptr<T>::Ptr ()
00393 : m_ptr (0)
00394 {}
00395
00396 template <typename T>
00397 Ptr<T>::Ptr (T *ptr)
00398 : m_ptr (ptr)
00399 {
00400 Acquire ();
00401 }
00402
00403 template <typename T>
00404 Ptr<T>::Ptr (T *ptr, bool ref)
00405 : m_ptr (ptr)
00406 {
00407 if (ref)
00408 {
00409 Acquire ();
00410 }
00411 }
00412
00413 template <typename T>
00414 Ptr<T>::Ptr (Ptr const&o)
00415 : m_ptr (PeekPointer (o))
00416 {
00417 Acquire ();
00418 }
00419 template <typename T>
00420 template <typename U>
00421 Ptr<T>::Ptr (Ptr<U> const &o)
00422 : m_ptr (PeekPointer (o))
00423 {
00424 Acquire ();
00425 }
00426
00427 template <typename T>
00428 Ptr<T>::~Ptr ()
00429 {
00430 if (m_ptr != 0)
00431 {
00432 m_ptr->Unref();
00433 }
00434 }
00435
00436 template <typename T>
00437 Ptr<T> &
00438 Ptr<T>::operator = (Ptr const& o)
00439 {
00440 if (&o == this)
00441 {
00442 return *this;
00443 }
00444 if (m_ptr != 0)
00445 {
00446 m_ptr->Unref();
00447 }
00448 m_ptr = o.m_ptr;
00449 Acquire ();
00450 return *this;
00451 }
00452
00453 template <typename T>
00454 T *
00455 Ptr<T>::operator -> ()
00456 {
00457 return m_ptr;
00458 }
00459
00460 template <typename T>
00461 T *
00462 Ptr<T>::operator -> () const
00463 {
00464 return m_ptr;
00465 }
00466
00467 template <typename T>
00468 const T &
00469 Ptr<T>::operator * () const
00470 {
00471 return *m_ptr;
00472 }
00473
00474 template <typename T>
00475 const T &
00476 Ptr<T>::operator * ()
00477 {
00478 return *m_ptr;
00479 }
00480
00481 template <typename T>
00482 bool
00483 Ptr<T>::operator! ()
00484 {
00485 return m_ptr == 0;
00486 }
00487
00488 template <typename T>
00489 Ptr<T>::operator Tester * () const
00490 {
00491 if (m_ptr == 0)
00492 {
00493 return 0;
00494 }
00495 static Tester test;
00496 return &test;
00497 }
00498
00499
00500 };
00501
00502 #endif