TCSharedPtrImpl.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: TCSharedPtrImpl.h 836 2008-04-08 21:24:19Z the_____tiger $
//*******************************************************************************
#ifndef _TC_SHARED_PTR_IMP_H_
#define _TC_SHARED_PTR_IMP_H_

#include "TCInterlocked.h"

#include <memory>    // for std::auto_ptr
#include <algorithm> // for std::swap

#include "TCNewEnable.h"

namespace TC
{
   class WeakPtrCount;
   class SharedPtrCount;

   namespace Impl
   {
      class SharedPtrCountBase
      {
      protected:
         virtual ~SharedPtrCountBase() {}
         virtual void DeletePtr() = 0;

         SharedPtrCountBase()
             :m_count(1),
            m_weak_count(1)
         {
         }

      private:
         inline void AddReference()
         {
            Interlocked::Increment(m_count);
         }
         inline void ReleaseReference()
         {
            if (Interlocked::Decrement(m_count) == 0)
            {
               DeletePtr();
               ReleaseWeakReference();
            }
         }
         inline uint32 GetUseCount() const { return m_count;}

         inline void AddWeakReference()
         {
            Interlocked::Increment(m_weak_count);
         }
         inline void ReleaseWeakReference()
         {
            if (Interlocked::Decrement(m_weak_count) == 0)
            {
               Destroy();
            }
         }

         inline void Destroy() { delete this;}

      private:
         Interlocked::Type m_count;
         Interlocked::Type m_weak_count;

         friend class TC::SharedPtrCount;
         friend class TC::WeakPtrCount;
      };

      template <class T, class DELETER>
      class SharedPtrCountType: protected SharedPtrCountBase
      {
      protected:
         SharedPtrCountType(T* ptr, DELETER deleter)
            :m_ptr(ptr),
            m_deleter(deleter)
         {
         }
         
         virtual void DeletePtr()
         {
            m_deleter(m_ptr);
         }
      private:
         T* m_ptr;
         DELETER m_deleter;

         friend class TC::SharedPtrCount;
      };

   } // namspace Impl

   class SharedPtrCount
   {
   public:
      SharedPtrCount():m_count(0) {}

      template <class PTR_TYPE, class DELETER>
      SharedPtrCount(PTR_TYPE* ptr, DELETER deleter)
      {
         m_count = new Impl::SharedPtrCountType<PTR_TYPE, DELETER>(ptr, deleter);
      }

      template <class PTR_TYPE, class DELETER>
      SharedPtrCount(std::auto_ptr<PTR_TYPE>& ptr, DELETER deleter)
      {
         m_count = new Impl::SharedPtrCountType<PTR_TYPE, DELETER>(ptr.get(), deleter);
         ptr.release();
      }

      explicit SharedPtrCount(const SharedPtrCount& count)
         :m_count(count.m_count)
      {
         if (m_count) m_count->AddReference();
      }

      explicit SharedPtrCount(const WeakPtrCount& count);

      ~SharedPtrCount()
      {
         if (m_count)
         {
            m_count->ReleaseReference();
            m_count = 0;
         }
      }

      SharedPtrCount& operator=(const SharedPtrCount& count)
      {
         if (count.m_count != m_count)
         {
            if (count.m_count) count.m_count->AddReference();
            if (m_count) m_count->ReleaseReference();
            m_count = count.m_count;
         }

         return *this;
      }

      uint32 GetUseCount() const
      {
         return m_count ? m_count->GetUseCount() : 0;
      }

      void Swap(SharedPtrCount& a)
      {
         std::swap(m_count, a.m_count);
      }

      friend inline bool operator==(const SharedPtrCount& a, const SharedPtrCount& b)
      {
         return a.m_count == b.m_count;
      }

      friend inline bool operator<(const SharedPtrCount& a, const SharedPtrCount& b)
      {
         return a.m_count < b.m_count;;
      }

   private:
      Impl::SharedPtrCountBase* m_count;
      friend class TC::WeakPtrCount;
   };

   class WeakPtrCount
   {
   public:
      WeakPtrCount() :m_count(0) {}

      explicit WeakPtrCount(const WeakPtrCount& r) :m_count(r.m_count)
      {
         if (m_count != 0) m_count->AddWeakReference();
      }

      explicit WeakPtrCount(const SharedPtrCount& r) :m_count(r.m_count)
      {
         if (m_count != 0) m_count->AddWeakReference();
      }

      ~WeakPtrCount()
      {
         if (m_count != 0)
         {
            m_count->ReleaseWeakReference();
            m_count = 0;
         }
      }

      WeakPtrCount& operator=(const SharedPtrCount& r)
      {
         if (r.m_count != 0) r.m_count->AddWeakReference();
         if (m_count   != 0) m_count->ReleaseWeakReference();
         m_count = r.m_count;

         return *this;
      }

      WeakPtrCount& operator=(const WeakPtrCount& r)
      {
         if (r.m_count != 0) r.m_count->AddWeakReference();
         if (m_count   != 0) m_count->ReleaseWeakReference();
         m_count = r.m_count;

         return *this;
      }

      uint32 GetUseCount() const
      {
         return m_count != 0 ? m_count->GetUseCount(): 0;
      }

      void Swap(WeakPtrCount& a)
      {
         std::swap(m_count, a.m_count);
      }

      friend inline bool operator==(const WeakPtrCount& a, const WeakPtrCount& b)
      {
         return a.m_count == b.m_count;
      }

      friend inline bool operator<(const WeakPtrCount& a, const WeakPtrCount& b)
      {
         return a.m_count < b.m_count;
      }

   private:
      Impl::SharedPtrCountBase* m_count;
      friend class TC::SharedPtrCount;
   };


   inline SharedPtrCount::SharedPtrCount(const WeakPtrCount& count)
      :m_count(count.m_count)
   {
      if (m_count) m_count->AddReference();
   }

} // namespace TC

#include "TCNewDisable.h"

#endif // _TC_SHARED_PTR_IMP_H_