4.1

1 files changed, 0 insertions, 1697 deletions

diff --git a/shared/loki/StrongPtr.h b/shared/loki/StrongPtr.h
deleted file mode 100644
index 868eb48f..00000000
--- a/shared/loki/StrongPtr.h
+++ /dev/null
@@ -1,1697 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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
-