libBiNC: src/ptr.h Source File

00001 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
00002 /*
00003  * Copyright (c) 2005,2006 INRIA
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License version 2 as
00007  * published by the Free Software Foundation;
00008  *
00009  * This program is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program; if not, write to the Free Software
00016  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017  *
00018  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
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 Binc {
00029 
00057 template <typename T>
00058 class Ptr 
00059 {
00060 private:
00061   T *m_ptr;
00062   class Tester {
00063   private:
00064     void operator delete (void *);
00065   };
00066   friend class Ptr<const T>;
00067   template <typename U>
00068   friend U *GetPointer (const Ptr<U> &p);
00069   template <typename U>
00070   friend U *PeekPointer (const Ptr<U> &p);
00071 
00072   inline void Acquire (void) const;
00073 public:
00077   Ptr ();
00088   Ptr (T *ptr);  
00097   Ptr (T *ptr, bool ref);
00098   Ptr (Ptr const&o);
00099   // allow conversions from T to T const.
00100   template <typename U>
00101   Ptr (Ptr<U> const &o);
00102   ~Ptr () ;
00103   Ptr<T> &operator = (Ptr const& o);
00104 
00105   T *operator -> () const;
00106   T *operator -> ();
00107   const T &operator * () const;
00108   T &operator * ();
00109   // allow if (!sp)
00110   bool operator! ();
00111   // allow if (sp)
00112   // disable delete sp
00113   operator Tester * () const;
00114 };
00115 
00116 template <typename T>
00117 Ptr<T> Create (void);
00118 
00119 template <typename T, typename T1>
00120 Ptr<T> Create (T1 a1);
00121 
00122 template <typename T, typename T1, typename T2>
00123 Ptr<T> Create (T1 a1, T2 a2);
00124 
00125 template <typename T, typename T1, typename T2, typename T3>
00126 Ptr<T> Create (T1 a1, T2 a2, T3 a3);
00127 
00128 template <typename T, typename T1, typename T2, typename T3, typename T4>
00129 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4);
00130 
00131 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
00132 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
00133 
00134 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00135 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
00136 
00137 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00138 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7);
00139 
00149 template <typename T>
00150 T * PeekPointer (const Ptr<T> &p);
00151 
00161 template <typename T>
00162 T * GetPointer (const Ptr<T> &p);
00163 
00164 template <typename T>
00165 std::ostream &operator << (std::ostream &, const Ptr<T> &p);
00166 
00167 
00168 // allow if (sp == 0)
00169 template <typename T1, typename T2>
00170 bool operator == (Ptr<T1> const &lhs, T2 const *rhs);
00171 
00172 // allow if (0 == sp)
00173 template <typename T1, typename T2>
00174 bool operator == (T1 const *lhs, Ptr<T2> &rhs);
00175 
00176 // allow if (sp != 0)
00177 template <typename T1, typename T2>
00178 bool operator != (Ptr<T1> const &lhs, T2 const *rhs);
00179 
00180 // allow if (0 != sp)
00181 template <typename T1, typename T2>
00182 bool operator != (T1 const *lhs, Ptr<T2> &rhs);
00183 
00184 // allow if (sp0 == sp1)
00185 template <typename T1, typename T2>
00186 bool operator == (Ptr<T1> const &lhs, Ptr<T2> const &rhs);
00187 
00188 // allow if (sp0 != sp1)
00189 template <typename T1, typename T2>
00190 bool operator != (Ptr<T1> const &lhs, Ptr<T2> const &rhs);
00191 
00192 template <typename T1, typename T2>
00193 Ptr<T1> const_pointer_cast (Ptr<T2> const&p);
00194 
00195 template <typename T>
00196 struct CallbackTraits;
00197 
00198 template <typename T>
00199 struct CallbackTraits<Ptr<T> >
00200 {
00201   static T & GetReference (Ptr<T> const p)
00202   {
00203     return *PeekPointer (p);
00204   }
00205 };
00206 
00207 template <typename T>
00208 struct EventMemberImplObjTraits;
00209 
00210 template <typename T>
00211 struct EventMemberImplObjTraits<Ptr<T> >
00212 {
00213   static T &GetReference (Ptr<T> p) {
00214     return *PeekPointer (p);
00215   }
00216 };
00217 
00218 
00219 
00220 } // namespace Binc
00221 
00222 
00223 namespace Binc {
00224 
00225   /*************************************************
00226    *  friend non-member function implementations
00227    ************************************************/
00228 
00229 template <typename T>
00230 Ptr<T> Create (void)
00231 {
00232   return Ptr<T> (new T (), false);
00233 }
00234 
00235 template <typename T, typename T1>
00236 Ptr<T> Create (T1 a1)
00237 {
00238   return Ptr<T> (new T (a1), false);
00239 }
00240 
00241 template <typename T, typename T1, typename T2>
00242 Ptr<T> Create (T1 a1, T2 a2)
00243 {
00244   return Ptr<T> (new T (a1, a2), false);
00245 }
00246 
00247 template <typename T, typename T1, typename T2, typename T3>
00248 Ptr<T> Create (T1 a1, T2 a2, T3 a3)
00249 {
00250   return Ptr<T> (new T (a1, a2, a3), false);
00251 }
00252 
00253 template <typename T, typename T1, typename T2, typename T3, typename T4>
00254 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4)
00255 {
00256   return Ptr<T> (new T (a1, a2, a3, a4), false);
00257 }
00258 
00259 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
00260 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
00261 {
00262   return Ptr<T> (new T (a1, a2, a3, a4, a5), false);
00263 }
00264 
00265 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00266 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
00267 {
00268   return Ptr<T> (new T (a1, a2, a3, a4, a5, a6), false);
00269 }
00270 
00271 template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00272 Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
00273 {
00274   return Ptr<T> (new T (a1, a2, a3, a4, a5, a6, a7), false);
00275 }
00276 
00277 template <typename T>
00278 T * PeekPointer (const Ptr<T> &p)
00279 {
00280   return p.m_ptr;
00281 }
00282 
00283 template <typename T>
00284 T * GetPointer (const Ptr<T> &p)
00285 {
00286   p.Acquire ();
00287   return p.m_ptr;
00288 }
00289 
00290 template <typename T>
00291 std::ostream &operator << (std::ostream &os, const Ptr<T> &p)
00292 {
00293   os << PeekPointer (p);
00294   return os;
00295 }
00296 
00297 template <typename T1, typename T2>
00298 bool 
00299 operator == (Ptr<T1> const &lhs, T2 const *rhs)
00300 {
00301   return PeekPointer (lhs) == rhs;
00302 }
00303 
00304 template <typename T1, typename T2>
00305 bool 
00306 operator == (T1 const *lhs, Ptr<T2> &rhs)
00307 {
00308   return lhs == PeekPointer (rhs);
00309 }
00310 
00311 template <typename T1, typename T2>
00312 bool 
00313 operator != (Ptr<T1> const &lhs, T2 const *rhs)
00314 {
00315   return PeekPointer (lhs) != rhs;
00316 }
00317 
00318 template <typename T1, typename T2>
00319 bool 
00320 operator != (T1 const *lhs, Ptr<T2> &rhs)
00321 {
00322   return lhs != PeekPointer (rhs);
00323 }
00324 
00325 template <typename T1, typename T2>
00326 bool 
00327 operator == (Ptr<T1> const &lhs, Ptr<T2> const &rhs)
00328 {
00329   return PeekPointer (lhs) == PeekPointer (rhs);
00330 }
00331 
00332 template <typename T1, typename T2>
00333 bool 
00334 operator != (Ptr<T1> const &lhs, Ptr<T2> const &rhs)
00335 {
00336   return PeekPointer (lhs) != PeekPointer (rhs);
00337 }
00338 
00339 template <typename T>
00340 bool operator < (const Ptr<T> &lhs, const Ptr<T> &rhs)
00341 {
00342   return PeekPointer<T> (lhs) < PeekPointer<T> (rhs);
00343 }
00344 
00345 template <typename T>
00346 bool operator <= (const Ptr<T> &lhs, const Ptr<T> &rhs)
00347 {
00348   return PeekPointer<T> (lhs) <= PeekPointer<T> (rhs);
00349 }
00350 
00351 template <typename T>
00352 bool operator > (const Ptr<T> &lhs, const Ptr<T> &rhs)
00353 {
00354   return PeekPointer<T> (lhs) > PeekPointer<T> (rhs);
00355 }
00356 
00357 template <typename T>
00358 bool operator >= (const Ptr<T> &lhs, const Ptr<T> &rhs)
00359 {
00360   return PeekPointer<T> (lhs) >= PeekPointer<T> (rhs);
00361 }
00362 
00363 template <typename T1, typename T2>
00364 Ptr<T1>
00365 ConstCast (Ptr<T2> const&p)
00366 {
00367   return Ptr<T1> (const_cast<T1 *> (PeekPointer (p)));
00368 }
00369 
00370 template <typename T1, typename T2>
00371 Ptr<T1>
00372 DynamicCast (Ptr<T2> const&p)
00373 {
00374   return Ptr<T1> (dynamic_cast<T1 *> (PeekPointer (p)));
00375 }
00376 
00377 template <typename T1, typename T2>
00378 Ptr<T1>
00379 StaticCast (Ptr<T2> const&p)
00380 {
00381   return Ptr<T1> (static_cast<T1 *> (PeekPointer (p)));
00382 }
00383 
00384 
00385 template <typename T>
00386 Ptr<T> Copy (Ptr<T> object)
00387 {
00388   Ptr<T> p = Ptr<T> (new T (*PeekPointer (object)), false);
00389   return p;
00390 }
00391 
00392 template <typename T>
00393 Ptr<T> Copy (Ptr<const T> object)
00394 {
00395   Ptr<T> p = Ptr<T> (new T (*PeekPointer (object)), false);
00396   return p;
00397 }
00398 
00399 /****************************************************
00400  *      Member method implementations.
00401  ***************************************************/
00402 
00403 template <typename T>
00404 void 
00405 Ptr<T>::Acquire (void) const
00406 {
00407   if (m_ptr != 0)
00408     {
00409       m_ptr->Ref ();
00410     }  
00411 }
00412 
00413 template <typename T>
00414 Ptr<T>::Ptr ()
00415   : m_ptr (0)
00416 {}
00417 
00418 template <typename T>
00419 Ptr<T>::Ptr (T *ptr) 
00420   : m_ptr (ptr)
00421 {
00422   Acquire ();
00423 }
00424 
00425 template <typename T>
00426 Ptr<T>::Ptr (T *ptr, bool ref) 
00427   : m_ptr (ptr)
00428 {
00429   if (ref)
00430     {
00431       Acquire ();
00432     }
00433 }
00434 
00435 template <typename T>
00436 Ptr<T>::Ptr (Ptr const&o) 
00437   : m_ptr (PeekPointer (o))
00438 {
00439   Acquire ();
00440 }
00441 template <typename T>
00442 template <typename U>
00443 Ptr<T>::Ptr (Ptr<U> const &o)
00444   : m_ptr (PeekPointer (o))
00445 {
00446   Acquire ();
00447 }
00448 
00449 template <typename T>
00450 Ptr<T>::~Ptr () 
00451 {
00452   if (m_ptr != 0) 
00453     {
00454       m_ptr->Unref();
00455     }
00456 }
00457 
00458 template <typename T>
00459 Ptr<T> &
00460 Ptr<T>::operator = (Ptr const& o) 
00461 {
00462   if (&o == this)
00463     {
00464       return *this;
00465     }
00466   if (m_ptr != 0) 
00467     {
00468       m_ptr->Unref();
00469     }
00470   m_ptr = o.m_ptr;
00471   Acquire ();
00472   return *this;
00473 }
00474 
00475 template <typename T>
00476 T *
00477 Ptr<T>::operator -> () 
00478 {
00479   return m_ptr;
00480 }
00481 
00482 template <typename T>
00483 T *
00484 Ptr<T>::operator -> () const
00485 {
00486   return m_ptr;
00487 }
00488 
00489 template <typename T>
00490 const T &
00491 Ptr<T>::operator * () const
00492 {
00493   return *m_ptr;
00494 }
00495 
00496 template <typename T>
00497 T &
00498 Ptr<T>::operator * ()
00499 {
00500   return *m_ptr;
00501 }
00502 
00503 template <typename T>
00504 bool 
00505 Ptr<T>::operator! () 
00506 {
00507   return m_ptr == 0;
00508 }
00509 
00510 template <typename T>
00511 Ptr<T>::operator Tester * () const
00512 {
00513   if (m_ptr == 0) 
00514     {
00515       return 0;
00516     }
00517   static Tester test;
00518   return &test;
00519 }
00520 
00521 
00522 }; // namespace Binc
00523 
00524 #endif /* PTR_H */