////////////////////////////////////////////////////////////////////////////////
// The Loki Library
// Copyright (c) 2006 Rich Sposato
// The copyright on this file is protected under the terms of the MIT license.
//
// Permission to use, copy, modify, distribute and sell this software for any
//     purpose is hereby granted without fee, provided that the above copyright
//     notice appear in all copies and that both that copyright notice and this
//     permission notice appear in supporting documentation.
// The author makes no representations about the
//     suitability of this software for any purpose. It is provided "as is"
//     without express or implied warranty.
////////////////////////////////////////////////////////////////////////////////
#ifndef LOKI_STRONG_PTR_INC_
#define LOKI_STRONG_PTR_INC_

// $Id: StrongPtr.h 914 2008-12-19 00:39:29Z rich_sposato $


#include <loki/SmartPtr.h>
#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
#include <loki/Threads.h>
#endif


////////////////////////////////////////////////////////////////////////////////
///
///  \par Terminology
///   These terms are used within this file's comments.
///   -# StrongPtr : Class used to implement both strong and weak pointers. The
///      second template parameter determines if a StrongPtr is weak or strong.
///   -# Strong pointer : A pointer that claims ownership of a shared object.
///      When the last strong copointer dies, the object is destroyed even if
///      there are weak copointers.
///   -# Weak pointer : A pointer that does not own the shared object it points
///       to.  It only destroys the shared object if there no strong copointers
///       exist when it dies.
///   -# Copointers : All the pointers that refer to the same shared object.
///      The copointers must have the same ownership policy, but the other
///      policies may be different.
///   -# Pointee : The shared object.
///
///  \par OwnershipPolicy
///   The ownership policy has the pointer to the actual object, and it also
///   keeps track of the strong and weak copointers so that it can know if any
///   strong copointers remain.  The plain pointer it maintains is stored as a
///   void pointer, which allows the ownership policy classes to be monolithic
///   classes instead of template classes.  As monolithic classes, they reduce
///   amount of code-bloat.
///
///  \par Writing Your Own OwnershipPolicy
///   If you write your own policy, you must implement these 12 functions:
///   -# explicit YourPolicy( bool strong )
///   -# YourPolicy( void * p, bool strong )
///   -# YourPolicy( const YourPolicy & rhs, bool strong )
///   -# bool Release( bool strong )
///   -# void Increment( bool strong )
///   -# bool Decrement( bool strong )
///   -# bool HasStrongPointer( void ) const
///   -# void Swap( YourPolicy & rhs )
///   -# void SetPointer( void * p )
///   -# void ZapPointer( void )
///   -# void * GetPointer( void ) const
///   -# void * & GetPointerRef( void ) const
///   It is strongly recommended that all 12 of these functions be protected
///   instead of public.  These two functions are optional for single-threaded
///   policies, but required for multi-threaded policies:
///   -# void Lock( void ) const
///   -# void Unlock( void ) const
///   This function is entirely optional:
///   -# bool Merge( TwoRefLinks & rhs )
///
///  \par DeletePolicy
///   The delete policy provides a mechanism to destroy an object and a default
///   value for an uninitialized pointer.  You can override this policy with
///   your own when using the Singleton, NullObject, or Prototype design
///   patterns.
///
///  \par Writing Your Own DeletePolicy
///   If you write your own policy, you must implement these 3 functions:
///   -# void static Delete( const P * p )
///   -# static P * Default( void )
///   -# void Swap( YourResetPolicy & )
///
///  \par ResetPolicy
///   A reset policy tells the ReleaseAll and ResetAll functions whether they
///   should release or reset the StrongPtr copointers.  These functions do
///   not affect just one StrongPtr, but all copointers.  That is unlike
///   SmartPtr where the Release and Reset functions only affect 1 SmartPtr,
///   and leave all copointers untouched.  A useful trick you can do with the
///   ResetPolicy is to not allow reset when a strong pointer exists, and then
///   use the NoCheck policy for all strong pointers.  The reset policy
///   guarantees the strong pointers always have a valid pointee, so checking
///   is not required; but weak pointers may still require checking.
///
///  \par Writing Your Own ResetPolicy
///   If you write your own policy, you must implement these 2 functions:
///   -# bool OnReleaseAll( bool ) const
///   -# bool OnResetAll( bool ) const
///   The bool parameter means that this was called with a strong pointer or
///   one of its copointers is strong.  The return value means the pointer
///   can be reset or released.
///
///  \defgroup  StrongPointerOwnershipGroup StrongPtr Ownership policies
///  \ingroup   SmartPointerGroup
///  \defgroup  StrongPointerDeleteGroup Delete policies
///  \ingroup   SmartPointerGroup
///  \defgroup  StrongPointerResetGroup Reset policies
///  \ingroup   SmartPointerGroup
////////////////////////////////////////////////////////////////////////////////


namespace Loki
{


////////////////////////////////////////////////////////////////////////////////
///  \class DeleteUsingFree
///
///  \ingroup  StrongPointerDeleteGroup
///  Implementation of the DeletePolicy used by StrongPtr.  Uses explicit call
///   to T's destructor followed by call to free.  This policy is useful for
///   managing the lifetime of pointers to structs returned by C functions.
////////////////////////////////////////////////////////////////////////////////

template < class P >
class DeleteUsingFree
{
public:
    inline void static Delete( const P* p )
    {
        if ( 0 != p )
        {
            p->~P();
            ::free( p );
        }
    }

    /// Provides default value to initialize the pointer
    inline static P* Default( void )
    {
        return 0;
    }

    inline void Swap( DeleteUsingFree& ) {}
};

////////////////////////////////////////////////////////////////////////////////
///  \class DeleteNothing
///
///  \ingroup  StrongPointerDeleteGroup
///  Implementation of the DeletePolicy used by StrongPtr.  This will never
///   delete anything.  You can use this policy with pointers to an undefined
///   type or a pure interface class with a protected destructor.
////////////////////////////////////////////////////////////////////////////////

template < class P >
class DeleteNothing
{
public:
    inline static void Delete( const P* )
    {
        // Do nothing at all!
    }

    inline static P* Default( void )
    {
        return 0;
    }

    inline void Swap( DeleteNothing& ) {}
};

////////////////////////////////////////////////////////////////////////////////
///  \class DeleteSingle
///
///  \ingroup  StrongPointerDeleteGroup
///  Implementation of the DeletePolicy used by StrongPtr.  This deletes just
///   one shared object.  This is the default class for the DeletePolicy.
////////////////////////////////////////////////////////////////////////////////

template < class P >
class DeleteSingle
{
public:
    inline static void Delete( const P* p )
    {
        /** @note If you see an error message about a negative subscript, that
         means your are attempting to use Loki to delete an incomplete type.
         Please don't use this policy with incomplete types; you may want to
         use DeleteNothing instead.
         */
        typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ];
        delete p;
    }

    inline static P* Default( void )
    {
        return 0;
    }

    inline void Swap( DeleteSingle& ) {}
};

////////////////////////////////////////////////////////////////////////////////
///  \class DeleteArray
///
///  \ingroup  StrongPointerDeleteGroup
///  Implementation of the DeletePolicy used by StrongPtr.  This deletes an
///   array of shared objects.
////////////////////////////////////////////////////////////////////////////////

template < class P >
class DeleteArray
{
public:
    inline static void Delete( const P* p )
    {
        /** @note If you see an error message about a negative subscript, that
         means your are attempting to use Loki to delete an incomplete type.
         Please don't use this policy with incomplete types; you may want to
         use DeleteNothing instead.
         */
        typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ];
        delete [] p;
    }

    inline static P* Default( void )
    {
        return 0;
    }

    inline void Swap( DeleteArray& ) {}
};

////////////////////////////////////////////////////////////////////////////////
///  \class CantResetWithStrong
///
///  \ingroup  StrongPointerResetGroup
///  Implementation of the ResetPolicy used by StrongPtr.  This is the default
///   ResetPolicy for StrongPtr.  It forbids reset and release only if a strong
///   copointer exists.
////////////////////////////////////////////////////////////////////////////////

template < class P >
struct CantResetWithStrong
{
    inline bool OnReleaseAll( bool hasStrongPtr ) const
    {
        return ! hasStrongPtr;
    }

    inline bool OnResetAll( bool hasStrongPtr ) const
    {
        return ! hasStrongPtr;
    }
};

////////////////////////////////////////////////////////////////////////////////
///  \class AllowReset
///
///  \ingroup  StrongPointerResetGroup
///  Implementation of the ResetPolicy used by StrongPtr.  It allows reset and
///   release under any circumstance.
////////////////////////////////////////////////////////////////////////////////

template < class P >
struct AllowReset
{
    inline bool OnReleaseAll( bool ) const
    {
        return true;
    }
    inline bool OnResetAll( bool ) const
    {
        return true;
    }
};

////////////////////////////////////////////////////////////////////////////////
///  \class NeverReset
///
///  \ingroup  StrongPointerResetGroup
///  Implementation of the ResetPolicy used by StrongPtr.  It forbids reset and
///   release under any circumstance.
////////////////////////////////////////////////////////////////////////////////

template < class P >
struct NeverReset
{
    inline bool OnReleaseAll( bool ) const
    {
        return false;
    }
    inline bool OnResetAll( bool ) const
    {
        return false;
    }
};

// ----------------------------------------------------------------------------

namespace Private
{

////////////////////////////////////////////////////////////////////////////////
///  \class TwoRefCountInfo
///
///  \ingroup  StrongPointerOwnershipGroup
///   Implementation detail for reference counting strong and weak pointers.
///   It maintains a void pointer and 2 reference counts.  Since it is just a
///   class for managing implementation details, it is not intended to be used
///   directly - which is why it is in a private namespace.  Each instance is a
///   shared resource for all copointers, and there should be only one of these
///   for each set of copointers.  This class is small, trivial, and inline.
////////////////////////////////////////////////////////////////////////////////

class LOKI_EXPORT TwoRefCountInfo
{
public:

    inline explicit TwoRefCountInfo( bool strong )
        : m_pointer( 0 )
        , m_strongCount( strong ? 1 : 0 )
        , m_weakCount( strong ? 0 : 1 )
    {
    }

    inline TwoRefCountInfo( void* p, bool strong )
        : m_pointer( p )
        , m_strongCount( strong ? 1 : 0 )
        , m_weakCount( strong ? 0 : 1 )
    {
    }

    inline ~TwoRefCountInfo( void )
    {
        assert( 0 == m_strongCount );
        assert( 0 == m_weakCount );
    }

    inline bool HasStrongPointer( void ) const
    {
        return ( 0 < m_strongCount );
    }

    inline bool HasWeakPointer( void ) const
    {
        return ( 0 < m_weakCount );
    }

    inline void IncStrongCount( void )
    {
        ++m_strongCount;
    }

    inline void IncWeakCount( void )
    {
        ++m_weakCount;
    }

    inline bool DecStrongCount( void )
    {
        assert( 0 < m_strongCount );
        --m_strongCount;
        const bool isZero = ( 0 == m_strongCount );
        return isZero;
    }

    inline void DecWeakCount( void )
    {
        assert( 0 < m_weakCount );
        --m_weakCount;
    }

    inline void ZapPointer( void )
    {
        m_pointer = 0;
    }

    void SetPointer( void* p )
    {
        m_pointer = p;
    }

    inline void* GetPointer( void ) const
    {
        return m_pointer;
    }

    inline void*& GetPointerRef( void ) const
    {
        return const_cast< void *& >( m_pointer );
    }

private:
    /// Copy-constructor not implemented.
    TwoRefCountInfo( const TwoRefCountInfo& );
    /// Copy-assignment operator not implemented.
    TwoRefCountInfo& operator = ( const TwoRefCountInfo& );

    void* m_pointer;
    unsigned int m_strongCount;
    unsigned int m_weakCount;
};

////////////////////////////////////////////////////////////////////////////////
///  \class LockableTwoRefCountInfo
///
///  \ingroup  StrongPointerOwnershipGroup
///   Implementation detail for thread-safe reference counting for strong and
///   weak pointers.  It uses TwoRefCountInfo to manage the pointer and counts.
///   All this does is provide a thread safety mechanism.  Since it is just a
///   class for managing implementation details, it is not intended to be used
///   directly - which is why it is in a private namespace.  Each instance is a
///   shared resource for all copointers, and there should be only one of these
///   for each set of copointers.  This class is small, trivial, and inline.
///
///  \note This class is not designed for use with a single-threaded model.
///   Tests using a single-threaded model will not run properly, but tests in a
///   multi-threaded model with either class-level-locking or object-level-locking
///   do run properly.
////////////////////////////////////////////////////////////////////////////////

#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)

class LOKI_EXPORT LockableTwoRefCountInfo
    : private Loki::Private::TwoRefCountInfo
{
public:

    inline explicit LockableTwoRefCountInfo( bool strong )
        : TwoRefCountInfo( strong )
        , m_Mutex()
    {
    }

    LockableTwoRefCountInfo( void* p, bool strong )
        : TwoRefCountInfo( p, strong )
        , m_Mutex()
    {
    }

    inline ~LockableTwoRefCountInfo( void )
    {
    }

    inline void Lock( void ) const
    {
        m_Mutex.Lock();
    }

    inline void Unlock( void ) const
    {
        m_Mutex.Unlock();
    }

    inline bool HasStrongPointer( void ) const
    {
        m_Mutex.Lock();
        const bool has = TwoRefCountInfo::HasStrongPointer();
        m_Mutex.Unlock();
        return has;
    }

    inline bool HasWeakPointer( void ) const
    {
        m_Mutex.Lock();
        const bool has = TwoRefCountInfo::HasWeakPointer();
        m_Mutex.Unlock();
        return has;
    }

    inline void IncStrongCount( void )
    {
        m_Mutex.Lock();
        TwoRefCountInfo::IncStrongCount();
        m_Mutex.Unlock();
    }

    inline void IncWeakCount( void )
    {
        m_Mutex.Lock();
        TwoRefCountInfo::IncWeakCount();
        m_Mutex.Unlock();
    }

    inline bool DecStrongCount( void )
    {
        m_Mutex.Lock();
        const bool isZero = TwoRefCountInfo::DecStrongCount();
        m_Mutex.Unlock();
        return isZero;
    }

    inline void DecWeakCount( void )
    {
        m_Mutex.Lock();
        TwoRefCountInfo::DecWeakCount();
        m_Mutex.Unlock();
    }

    inline void ZapPointer( void )
    {
        m_Mutex.Lock();
        TwoRefCountInfo::ZapPointer();
        m_Mutex.Unlock();
    }

    void SetPointer( void* p )
    {
        m_Mutex.Lock();
        TwoRefCountInfo::SetPointer( p );
        m_Mutex.Unlock();
    }

    inline void* GetPointer( void ) const
    {
        return TwoRefCountInfo::GetPointer();
    }

    inline void*& GetPointerRef( void ) const
    {
        return TwoRefCountInfo::GetPointerRef();
    }

private:
    /// Default constructor is not available.
    LockableTwoRefCountInfo( void );
    /// Copy constructor is not available.
    LockableTwoRefCountInfo( const LockableTwoRefCountInfo& );
    /// Copy-assignment operator is not available.
    LockableTwoRefCountInfo& operator = ( const LockableTwoRefCountInfo& );

    mutable LOKI_DEFAULT_MUTEX m_Mutex;
};

#endif // if object-level-locking or class-level-locking

} // end namespace Private

////////////////////////////////////////////////////////////////////////////////
///  \class TwoRefCounts
///
///  \ingroup  StrongPointerOwnershipGroup
///   This implementation of StrongPtr's OwnershipPolicy uses a pointer to a
///   shared instance of TwoRefCountInfo.  This is the default policy for
///   OwnershipPolicy.  Some functions are trivial enough to be inline, while
///   others are implemented elsewhere.  It is not thread safe, and is intended
///   for single-threaded environments.
////////////////////////////////////////////////////////////////////////////////

class LOKI_EXPORT TwoRefCounts
{
protected:

    explicit TwoRefCounts( bool strong );

    TwoRefCounts( const void* p, bool strong );

    TwoRefCounts( const TwoRefCounts& rhs, bool strong ) :
        m_counts( rhs.m_counts )
    {
        Increment( strong );
    }

    /** The destructor does not need to do anything since the call to
     ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which
     this dtor would have done.
     */
    inline ~TwoRefCounts( void ) {}

    inline bool Release( bool strong )
    {
        return Decrement( strong );
    }

    bool HasStrongPointer( void ) const
    {
        return m_counts->HasStrongPointer();
    }

    void Swap( TwoRefCounts& rhs );

    void SetPointer( void* p )
    {
        m_counts->SetPointer( p );
    }

    void ZapPointer( void );

    inline void*& GetPointerRef( void ) const
    {
        return m_counts->GetPointerRef();
    }

    inline void* GetPointer( void ) const
    {
        return m_counts->GetPointer();
    }

private:
    TwoRefCounts( void );
    TwoRefCounts& operator = ( const TwoRefCounts& );

    void Increment( bool strong );

    bool Decrement( bool strong );

    /// Pointer to all shared data.
    Loki::Private::TwoRefCountInfo* m_counts;
};

////////////////////////////////////////////////////////////////////////////////
///  \class LockableTwoRefCounts
///
///  \ingroup  StrongPointerOwnershipGroup
///   This implementation of StrongPtr's OwnershipPolicy uses a pointer to a
///   shared instance of LockableTwoRefCountInfo.  It behaves very similarly to
///   TwoRefCounts, except that it provides thread-safety.  Some functions are
///   trivial enough to be inline, while others are implemented elsewhere.
///
///  \note This class is not designed for use with a single-threaded model.
///   Tests using a single-threaded model will not run properly, but tests in a
///   multi-threaded model with either class-level-locking or object-level-locking
///   do run properly.
////////////////////////////////////////////////////////////////////////////////

#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)

class LOKI_EXPORT LockableTwoRefCounts
{
    typedef SmallValueObject< ::Loki::ClassLevelLockable > ThreadSafePointerAllocator;

protected:

    explicit LockableTwoRefCounts( bool strong )
        : m_counts( NULL )
    {
        void* temp = ThreadSafePointerAllocator::operator new(
                         sizeof(Loki::Private::LockableTwoRefCountInfo) );
#ifdef DO_EXTRA_LOKI_TESTS
        assert( temp != 0 );
#endif
        m_counts = new ( temp ) Loki::Private::LockableTwoRefCountInfo( strong );
    }

    LockableTwoRefCounts( const void* p, bool strong )
        : m_counts( NULL )
    {
        void* temp = ThreadSafePointerAllocator::operator new(
                         sizeof(Loki::Private::LockableTwoRefCountInfo) );
#ifdef DO_EXTRA_LOKI_TESTS
        assert( temp != 0 );
#endif
        void* p2 = const_cast< void* >( p );
        m_counts = new ( temp )
        Loki::Private::LockableTwoRefCountInfo( p2, strong );
    }

    LockableTwoRefCounts( const LockableTwoRefCounts& rhs, bool strong ) :
        m_counts( rhs.m_counts )
    {
        Increment( strong );
    }

    /** The destructor does not need to do anything since the call to
     ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which
     this dtor would have done.
     */
    inline ~LockableTwoRefCounts( void ) {}

    inline void Lock( void ) const
    {
        m_counts->Lock();
    }

    inline void Unlock( void ) const
    {
        m_counts->Unlock();
    }

    inline bool Release( bool strong )
    {
        return Decrement( strong );
    }

    void Increment( bool strong )
    {
        if ( strong )
        {
            m_counts->IncStrongCount();
        }
        else
        {
            m_counts->IncWeakCount();
        }
    }

    bool Decrement( bool strong )
    {
        bool noStrongPointers = false;
        if ( strong )
        {
            noStrongPointers = m_counts->DecStrongCount();
        }
        else
        {
            m_counts->DecWeakCount();
            noStrongPointers = !m_counts->HasStrongPointer();
        }
        return noStrongPointers;
    }

    bool HasStrongPointer( void ) const
    {
        return m_counts->HasStrongPointer();
    }

    void Swap( LockableTwoRefCounts& rhs )
    {
        std::swap( m_counts, rhs.m_counts );
    }

    void SetPointer( void* p )
    {
        m_counts->SetPointer( p );
    }

    void ZapPointer( void )
    {
#ifdef DO_EXTRA_LOKI_TESTS
        assert( !m_counts->HasStrongPointer() );
#endif
        if ( m_counts->HasWeakPointer() )
        {
            m_counts->ZapPointer();
        }
        else
        {
            ThreadSafePointerAllocator::operator delete ( m_counts,
                                                          sizeof(Loki::Private::LockableTwoRefCountInfo) );
            m_counts = NULL;
        }
    }

    inline void* GetPointer( void ) const
    {
        return m_counts->GetPointer();
    }

    inline void*& GetPointerRef( void ) const
    {
        return m_counts->GetPointerRef();
    }

private:
    LockableTwoRefCounts( void );
    LockableTwoRefCounts& operator = ( const LockableTwoRefCounts& );

    /// Pointer to all shared data.
    Loki::Private::LockableTwoRefCountInfo* m_counts;
};

#endif // if object-level-locking or class-level-locking

////////////////////////////////////////////////////////////////////////////////
///  \class TwoRefLinks
///
///  \ingroup  StrongPointerOwnershipGroup
///   This implementation of StrongPtr's OwnershipPolicy uses a doubly-linked
///   cycle of copointers to a shared object. Some functions are trivial enough
///   to be inline, while others are implemented in elsewhere.  It is not thread
///   safe, and is intended for single-threaded environments.
////////////////////////////////////////////////////////////////////////////////

class LOKI_EXPORT TwoRefLinks
{
protected:

    inline explicit TwoRefLinks( bool strong )
        : m_pointer( 0 )
        , m_strong( strong )
    {
        m_prev = m_next = this;
    }

    TwoRefLinks( const void* p, bool strong );

    TwoRefLinks( const TwoRefLinks& rhs, bool strong );

    bool Release( bool strong );

    void Swap( TwoRefLinks& rhs );

    bool Merge( TwoRefLinks& rhs );

    bool HasStrongPointer( void ) const;

    inline void ZapPointer( void )
    {
        ZapAllNodes();
    }

    void SetPointer( void* p );

    inline void* GetPointer( void ) const
    {
        return m_pointer;
    }

    inline void*& GetPointerRef( void ) const
    {
        return const_cast< void *& >( m_pointer );
    }

private:
    static unsigned int CountPrevCycle( const TwoRefLinks* pThis );
    static unsigned int CountNextCycle( const TwoRefLinks* pThis );

    /// Not implemented.
    TwoRefLinks( void );
    /// Not implemented.
    TwoRefLinks& operator = ( const TwoRefLinks& );

    bool HasPrevNode( const TwoRefLinks* p ) const;
    bool HasNextNode( const TwoRefLinks* p ) const;
    bool AllNodesHaveSamePointer( void ) const;
    void ZapAllNodes( void );

    void* m_pointer;
    mutable TwoRefLinks* m_prev;
    mutable TwoRefLinks* m_next;
    const bool m_strong;
};

////////////////////////////////////////////////////////////////////////////////
///  \class StrongPtr
///
///  \ingroup SmartPointerGroup
///
///  \param Strong           default = true,
///  \param OwnershipPolicy  default = TwoRefCounts,
///  \param ConversionPolicy default = DisallowConversion,
///  \param CheckingPolicy   default = AssertCheck,
///  \param ResetPolicy      default = CantResetWithStrong,
///  \param DeletePolicy     default = DeleteSingle
///  \param ConstnessPolicy  default = LOKI_DEFAULT_CONSTNESS
////////////////////////////////////////////////////////////////////////////////

template
<
typename T,
         bool Strong = true,
         class OwnershipPolicy = Loki::TwoRefCounts,
         class ConversionPolicy = Loki::DisallowConversion,
         template < class > class CheckingPolicy = Loki::AssertCheck,
         template < class > class ResetPolicy = Loki::CantResetWithStrong,
         template < class > class DeletePolicy = Loki::DeleteSingle,
         template < class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
         >
class StrongPtr
    : public OwnershipPolicy
    , public ConversionPolicy
    , public CheckingPolicy< T* >
    , public ResetPolicy< T >
    , public DeletePolicy< T >
{
    typedef ConversionPolicy CP;
    typedef CheckingPolicy< T* > KP;
    typedef ResetPolicy< T > RP;
    typedef DeletePolicy< T > DP;

public:

    typedef OwnershipPolicy OP;

    typedef T* StoredType;     // the type of the pointer
    typedef T* PointerType;    // type returned by operator->
    typedef T& ReferenceType;  // type returned by operator*

    typedef typename ConstnessPolicy< T >::Type* ConstPointerType;
    typedef typename ConstnessPolicy< T >::Type& ConstReferenceType;

private:
    struct NeverMatched {};

#ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY
    typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg;
    typedef typename Select < !CP::allow, const StoredType&, NeverMatched >::Result ExplicitArg;
#else
    typedef const StoredType& ImplicitArg;
    typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg;
#endif

public:

    StrongPtr( void ) : OP( Strong )
    {
        KP::OnDefault( GetPointer() );
    }

    explicit StrongPtr( ExplicitArg p ) : OP( p, Strong )
    {
        KP::OnInit( GetPointer() );
    }

    StrongPtr( ImplicitArg p ) : OP( p, Strong )
    {
        KP::OnInit( GetPointer() );
    }

    StrongPtr( const StrongPtr& rhs )
        : OP( rhs, Strong ), CP( rhs ), KP( rhs ), DP( rhs )
    {
    }

    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    StrongPtr(
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
        : OP( rhs, Strong )
    {
    }

    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    StrongPtr(
        StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
        : OP( rhs, Strong )
    {
    }

    StrongPtr( RefToValue< StrongPtr > rhs )
        : OP( rhs, Strong ), KP( rhs ), CP( rhs ), DP( rhs )
    {
    }

    operator RefToValue< StrongPtr >( void )
    {
        return RefToValue< StrongPtr >( *this );
    }

    StrongPtr& operator = ( const StrongPtr& rhs )
    {
        if ( GetPointer() != rhs.GetPointer() )
        {
            StrongPtr temp( rhs );
            temp.Swap( *this );
        }
        return *this;
    }

    StrongPtr& operator = ( T* p )
    {
        if ( GetPointer() != p )
        {
            StrongPtr temp( p );
            Swap( temp );
        }
        return *this;
    }

    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    StrongPtr& operator = (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
    {
        if ( !rhs.Equals( GetPointer() ) )
        {
            StrongPtr temp( rhs );
            temp.Swap( *this );
        }
        return *this;
    }

    bool IsStrong( void ) const
    {
        return Strong;
    }

    void Swap( StrongPtr& rhs )
    {
        OP::Swap( rhs );
        CP::Swap( rhs );
        KP::Swap( rhs );
        DP::Swap( rhs );
    }

    ~StrongPtr()
    {
        if ( OP::Release( Strong ) )
        {
            // Must zap the pointer before deleteing the object. Otherwise a
            // cycle of weak pointers will lead to recursion, which leads to
            // to deleting the shared object multiple times, which leads to
            // undefined behavior.  Therefore, this must get pointer before
            // zapping it, and then delete the temp pointer.
            T* p = GetPointer();
            OP::ZapPointer();
            if ( p != 0 )
            {
                DP::Delete( p );
            }
        }
    }

#ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND

    // old non standard in class definition of friends
    friend bool ReleaseAll( StrongPtr& sp,
                            typename StrongPtr::StoredType& p )
    {
        if ( !sp.RP::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
        {
            return false;
        }
        p = sp.GetPointer();
        sp.OP::SetPointer( sp.DP::Default() );
        return true;
    }

    friend bool ResetAll( StrongPtr& sp,
                          typename StrongPtr::StoredType p )
    {
        if ( sp.OP::GetPointer() == p )
        {
            return true;
        }
        if ( !sp.RP::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
        {
            return false;
        }
        sp.DP::Delete( sp.GetPointer() );
        sp.OP::SetPointer( p );
        return true;
    }

#else

    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    friend bool ReleaseAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp,
                            typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType& p );


    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    friend bool ResetAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp,
                          typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType p );

#endif


    /** Merges ownership of two StrongPtr's that point to same shared object
      but are not copointers.  Requires Merge function in OwnershipPolicy.
      \return True for success, false if not pointer to same object.
     */
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    bool Merge( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
    {
        if ( OP::GetPointer() != rhs.OP::GetPointer() )
        {
            return false;
        }
        return OP::Merge( rhs );
    }

    /** Locks StrongPtr so other threads can't affect pointer.  Requires the
     OwnershipPolicy to have Lock function.
     */
    void Lock( void )
    {
        OP::Lock();
    }

    /** Unlocks StrongPtr so other threads can affect pointer.  Requires the
     OwnershipPolicy to have Unlock function.
     */
    void Unlock( void )
    {
        OP::Unlock();
    }

    PointerType operator -> ()
    {
        KP::OnDereference( GetPointer() );
        return GetPointer();
    }

    ConstPointerType operator -> () const
    {
        KP::OnDereference( GetPointer() );
        return GetPointer();
    }

    ReferenceType operator * ()
    {
        KP::OnDereference( GetPointer() );
        return * GetPointer();
    }

    ConstReferenceType operator * () const
    {
        KP::OnDereference( GetPointer() );
        return * GetPointer();
    }

    /// Helper function which can be called to avoid exposing GetPointer function.
    template < class T1 >
    bool Equals( const T1* p ) const
    {
        return ( GetPointer() == p );
    }

    /// Helper function which can be called to avoid exposing GetPointer function.
    template < class T1 >
    bool LessThan( const T1* p ) const
    {
        return ( GetPointer() < p );
    }

    /// Helper function which can be called to avoid exposing GetPointer function.
    template < class T1 >
    bool GreaterThan( const T1* p ) const
    {
        return ( GetPointer() > p );
    }

    /// Equality comparison operator is templated to handle ambiguity.
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    bool operator == (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
    {
        return ( rhs.Equals( GetPointer() ) );
    }

    /// Inequality comparison operator is templated to handle ambiguity.
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    bool operator != (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
    {
        return !( rhs.Equals( GetPointer() ) );
    }

    /// Less-than comparison operator is templated to handle ambiguity.
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    bool operator < (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
    {
        return ( rhs.GreaterThan( GetPointer() ) );
    }

    /// Greater-than comparison operator is templated to handle ambiguity.
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    inline bool operator > (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
    {
        return ( rhs.LessThan( GetPointer() ) );
    }

    /// Less-than-or-equal-to operator is templated to handle ambiguity.
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    inline bool operator <= (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
    {
        return !( rhs.LessThan( GetPointer() ) );
    }

    /// Greater-than-or-equal-to operator is templated to handle ambiguity.
    template
    <
    typename T1,
             bool S1,
             class OP1,
             class CP1,
             template < class > class KP1,
             template < class > class RP1,
             template < class > class DP1,
             template < class > class CNP1
             >
    inline bool operator >= (
        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
    {
        return !( rhs.GreaterThan( GetPointer() ) );
    }

    inline bool operator ! () const // Enables "if ( !sp ) ..."
    {
        return ( 0 == OP::GetPointer() );
    }

protected:

    inline PointerType GetPointer( void )
    {
        return reinterpret_cast< PointerType >( OP::GetPointer() );
    }

    inline ConstPointerType GetPointer( void ) const
    {
        return reinterpret_cast< ConstPointerType >( OP::GetPointer() );
    }

private:

    inline ReferenceType GetPointerRef( void )
    {
        return reinterpret_cast< ReferenceType >( OP::GetPointerRef() );
    }

    inline ConstReferenceType GetPointerRef( void ) const
    {
        return reinterpret_cast< ConstReferenceType >( OP::GetPointerRef() );
    }

    // Helper for enabling 'if (sp)'
    struct Tester
    {
        Tester(int) {}
        void dummy() {}
    };

    typedef void (Tester::*unspecified_boolean_type_)();

    typedef typename Select< CP::allow, Tester, unspecified_boolean_type_ >::Result
    unspecified_boolean_type;

public:
    // enable 'if (sp)'
    operator unspecified_boolean_type() const
    {
        return !*this ? 0 : &Tester::dummy;
    }

private:
    // Helper for disallowing automatic conversion
    struct Insipid
    {
        Insipid(PointerType) {}
    };

    typedef typename Select< CP::allow, PointerType, Insipid >::Result
    AutomaticConversionResult;

public:
    operator AutomaticConversionResult() const
    {
        return GetPointer();
    }

};

// ----------------------------------------------------------------------------

// friend functions

#ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND

template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
bool ReleaseAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp,
                 typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType& p )
{
    if ( !sp.RP<T>::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
    {
        return false;
    }
    p = sp.GetPointer();
    sp.OP::SetPointer( sp.DP<T>::Default() );
    return true;
}

template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
bool ResetAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp,
               typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType p )
{
    if ( sp.OP::GetPointer() == p )
    {
        return true;
    }
    if ( !sp.RP<T>::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
    {
        return false;
    }
    sp.DP<T>::Delete( sp.GetPointer() );
    sp.OP::SetPointer( p );
    return true;
}
#endif


// free comparison operators for class template StrongPtr

///  operator== for lhs = StrongPtr, rhs = raw pointer
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator == (
    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
{
    return ( lhs.Equals( rhs ) );
}

///  operator== for lhs = raw pointer, rhs = StrongPtr
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator == ( U* lhs,
                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
{
    return ( rhs.Equals( lhs ) );
}

///  operator!= for lhs = StrongPtr, rhs = raw pointer
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator != (
    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
{
    return !( lhs.Equals( rhs ) );
}

///  operator!= for lhs = raw pointer, rhs = StrongPtr
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator != ( U* lhs,
                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
{
    return !( rhs.Equals( lhs ) );
}

///  operator< for lhs = StrongPtr, rhs = raw pointer
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator < (
    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
{
    return ( lhs.LessThan( rhs ) );
}

///  operator< for lhs = raw pointer, rhs = StrongPtr
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator < ( U* lhs,
                         const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
{
    return ( rhs.GreaterThan( lhs ) );
}

//  operator> for lhs = StrongPtr, rhs = raw pointer
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator > (
    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
{
    return ( lhs.GreaterThan( rhs ) );
}

///  operator> for lhs = raw pointer, rhs = StrongPtr
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator > ( U* lhs,
                         const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
{
    return ( rhs.LessThan( lhs ) );
}

///  operator<= for lhs = StrongPtr, rhs = raw pointer
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator <= (
    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
{
    return !( lhs.GreaterThan( rhs ) );
}

///  operator<= for lhs = raw pointer, rhs = StrongPtr
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator <= ( U* lhs,
                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
{
    return !( rhs.LessThan( lhs ) );
}

///  operator>= for lhs = StrongPtr, rhs = raw pointer
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator >= (
    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
{
    return !( lhs.LessThan( rhs ) );
}

///  operator>= for lhs = raw pointer, rhs = StrongPtr
///  \ingroup SmartPointerGroup
template
<
typename U,
         typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
inline bool operator >= ( U* lhs,
                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
{
    return !( rhs.GreaterThan( lhs ) );
}

} // namespace Loki

namespace std
{
////////////////////////////////////////////////////////////////////////////////
///  specialization of std::less for StrongPtr
///  \ingroup SmartPointerGroup
////////////////////////////////////////////////////////////////////////////////
template
<
typename T,
         bool S,
         class OP,
         class CP,
         template < class > class KP,
         template < class > class RP,
         template < class > class DP,
         template < class > class CNP
         >
struct less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
        : public binary_function <
        Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >,
        Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >, bool >
{
    bool operator () (
        const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs,
        const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) const
    {
        return ( lhs < rhs );
    }
};
}

////////////////////////////////////////////////////////////////////////////////

#endif // end file guardian