TCSharedPtr.h

Go to the documentation of this file.

//*******************************************************************************
//
// *******   ***   ***               *
//    *     *     *                  *
//    *    *      *                *****
//    *    *       ***  *   *   **   *    **    ***
//    *    *          *  * *   *     *   ****  * * *
//    *     *         *   *      *   * * *     * * *
//    *      ***   ***    *     **   **   **   *   *
//                        *
//*******************************************************************************
// see http://sourceforge.net/projects/tcsystem/ for details.
// Copyright (C) 2003 - 2008 Thomas Goessler. All Rights Reserved. 
//*******************************************************************************
//
// TCSystem is the legal property of its developers.
// Please refer to the COPYRIGHT file distributed with this source distribution.
// 
// This library is free software; you can redistribute it and/or             
// modify it under the terms of the GNU Lesser General Public                
// License as published by the Free Software Foundation; either              
// version 2.1 of the License, or (at your option) any later version.        
//                                                                           
// This library is distributed in the hope that it will be useful,           
// but WITHOUT ANY WARRANTY; without even the implied warranty of            
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         
// Lesser General Public License for more details.                           
//                                                                           
// You should have received a copy of the GNU Lesser General Public          
// License along with this library; if not, write to the Free Software       
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
//*******************************************************************************
//  $Id: TCSharedPtr.h 863 2008-07-14 20:54:39Z the_____tiger $
//*******************************************************************************
#ifndef _TC_SHARED_PTR_H_
#define _TC_SHARED_PTR_H_

#include "TCTypes.h"
#include "TCDelete.h"
#include "TCSharedPtrImpl.h"

namespace TC
{
   template<class T> class SharedPtr;
   template<class T> class WeakPtr;

   template<class T> struct SharedPtrTraits { typedef T& Reference; };
   template<> struct SharedPtrTraits<void> { typedef void Reference; };
   template<> struct SharedPtrTraits<const void> { typedef void Reference; };
   template<> struct SharedPtrTraits<const volatile void> { typedef void Reference; };

   template <class T>
   class SharedPtr
   {
   private:
      typedef SharedPtr<T> ThisType;

   public:
      typedef T  ValueType;
      typedef T* PointerType;
      typedef typename SharedPtrTraits<T>::Reference ReferenceType;

   public:
      SharedPtr():m_ptr(0), m_count() {}

      template <class N_PTR>
      explicit SharedPtr(N_PTR* ptr):m_ptr(ptr), m_count(ptr, CheckedDelete()) {}

      template <class N_PTR, class DELETER>
      SharedPtr(N_PTR* ptr, DELETER deleter):m_ptr(ptr), m_count(ptr, deleter) {}

      template <class N_PTR>
      SharedPtr(std::auto_ptr<N_PTR>& ptr):m_ptr(ptr.get()), m_count(ptr, CheckedDelete()) {}

      template<class N_PTR>
      explicit SharedPtr(const WeakPtr<N_PTR>& ptr):m_ptr(ptr.m_ptr), m_count(ptr.m_count) {}

      template <class N_PTR>
      SharedPtr(const SharedPtr<N_PTR>& src):m_ptr(src.m_ptr), m_count(src.m_count) {}

      const T* operator->() const { return m_ptr;}
      T* operator->() { return m_ptr; }

      typedef T* ThisType::*unspecified_bool_type;
      operator unspecified_bool_type() const { return m_ptr == 0 ? 0 : &ThisType::m_ptr; }
      bool operator !() const { return m_ptr == 0; }

      typedef void* unspecified_pointer_type;
      friend bool operator==(const SharedPtr<T>& a, unspecified_pointer_type b) {return a.m_ptr == b;}
      friend bool operator!=(const SharedPtr<T>& a, unspecified_pointer_type b) {return a.m_ptr != b;}

      uint32 GetUseCount() const {return m_count.GetUseCount();}

      bool IsUnique() const {return m_count.GetUseCount() == 1;}

      void Reset() { SharedPtr<T> new_ptr; new_ptr.Swap(*this); }
      template<class N_PTR>
      void Reset(N_PTR* p) { SharedPtr<N_PTR> new_ptr(p); new_ptr.Swap(*this); }
      template <class N_PTR, class DELETER>
      void Reset(N_PTR* p, DELETER deleter) { SharedPtr<N_PTR> new_ptr(p, deleter); new_ptr.Swap(*this); }

      void Swap(SharedPtr<T>& a) { std::swap(m_ptr, a.m_ptr); m_count.Swap(a.m_count); }

      template <class N_PTR>
      bool Equal(const SharedPtr<N_PTR>& src) const { return m_ptr == src.m_ptr; }

      template <class N_PTR>
      bool Less(const SharedPtr<N_PTR>& src) const { return m_count < src.m_count; }

#ifdef TC_SHARED_PTR_TEST
      PointerType GetPtr() {return m_ptr;}
      ReferenceType operator*() {return *m_ptr;}
#endif

      template <class N_PTR>
      static ThisType DynamicCast(const SharedPtr<N_PTR>& src)
      {
         ThisType dest;
         dest.m_ptr = dynamic_cast<T*>(src.m_ptr);
         if (dest.m_ptr)
         {
            dest.m_count = src.m_count;
         }
         return dest;
      }

      template <class N_PTR>
      static ThisType StaticCast(const SharedPtr<N_PTR>& src)
      {
         ThisType dest;
         dest.m_ptr   = static_cast<T*>(src.m_ptr);
         dest.m_count = src.m_count;

         return dest;
      }

      template <class N_PTR>
      static ThisType ConstCast(const SharedPtr<N_PTR>& src)
      {
         ThisType dest;
         dest.m_ptr = const_cast<T*>(src.m_ptr);
         dest.m_count = src.m_count;

         return dest;
      }

#ifndef TC_NO_FRIEND_TEMPLATES
   private:
      template <class N_PTR> friend class SharedPtr;
      template <class N_PTR> friend class WeakPtr;
#endif

      T* m_ptr;
      SharedPtrCount m_count;

   };

   template <class M_PTR, class N_PTR>
   bool operator==(const SharedPtr<M_PTR>& a, const SharedPtr<N_PTR>& b) { return a.Equal(b); }

   template <class M_PTR, class N_PTR>
   bool operator!=(const SharedPtr<M_PTR>& a, const SharedPtr<N_PTR>& b) { return !a.Equal(b); }

   template <class M_PTR, class N_PTR>
   bool operator<(const SharedPtr<M_PTR>& a, const SharedPtr<N_PTR>& b) { return a.Less(b); }

} // namespace TC

#endif // _TC_SHARED_PTR_H_