From: <ric...@us...> - 2010-09-16 17:22:59
|
Revision: 1074 http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1074&view=rev Author: rich_sposato Date: 2010-09-16 17:22:53 +0000 (Thu, 16 Sep 2010) Log Message: ----------- Used initialization instead of assignment within constructor. Modified Paths: -------------- trunk/src/StrongPtr.cpp Modified: trunk/src/StrongPtr.cpp =================================================================== --- trunk/src/StrongPtr.cpp 2010-09-08 02:22:28 UTC (rev 1073) +++ trunk/src/StrongPtr.cpp 2010-09-16 17:22:53 UTC (rev 1074) @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 Rich Sposato -// 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 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" +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// @@ -22,7 +22,12 @@ #include <loki/SmallObj.h> +#if defined( _MSC_VER ) + #pragma warning( push ) + #pragma warning( disable: 4355 ) +#endif + // ---------------------------------------------------------------------------- namespace Loki @@ -134,8 +139,9 @@ TwoRefLinks::TwoRefLinks( const void * p, bool strong ) : m_pointer( const_cast< void * >( p ) ) , m_strong( strong ) + , m_prev( this ) + , m_next( this ) { - m_prev = m_next = this; #ifdef DO_EXTRA_LOKI_TESTS assert( CountPrevCycle( this ) == CountNextCycle( this ) ); #endif @@ -246,7 +252,7 @@ return false; } else if (m_next == this) - { + { #ifdef DO_EXTRA_LOKI_TESTS assert(m_prev == this); #endif @@ -573,5 +579,8 @@ // ---------------------------------------------------------------------------- +#if defined( _MSC_VER ) + #pragma warning( pop ) +#endif + } // end namespace Loki - This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ric...@us...> - 2010-10-30 03:11:13
|
Revision: 1080 http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1080&view=rev Author: rich_sposato Date: 2010-10-30 03:11:07 +0000 (Sat, 30 Oct 2010) Log Message: ----------- Added 3 new policy classes to support single-owner smart pointers. Fixed 2 obscure bugs in TwoRefLinks policy. Modified Paths: -------------- trunk/src/StrongPtr.cpp Modified: trunk/src/StrongPtr.cpp =================================================================== --- trunk/src/StrongPtr.cpp 2010-10-30 03:09:25 UTC (rev 1079) +++ trunk/src/StrongPtr.cpp 2010-10-30 03:11:07 UTC (rev 1080) @@ -33,8 +33,44 @@ namespace Loki { +namespace Private +{ + // ---------------------------------------------------------------------------- +OneOwnerRefCountInfo::OneOwnerRefCountInfo( SingleOwnerRefCount * ptr ) + : m_pointer( NULL ) + , m_strongPtr( ptr ) + , m_weakCount( ( NULL == ptr ) ? 1 : 0 ) +{ + assert( NULL != this ); +} + +// ---------------------------------------------------------------------------- + +OneOwnerRefCountInfo::OneOwnerRefCountInfo( const void * p, + SingleOwnerRefCount * ptr ) + : m_pointer( p ) + , m_strongPtr( ptr ) + , m_weakCount( ( NULL == ptr ) ? 1 : 0 ) +{ + assert( NULL != this ); +} + +// ---------------------------------------------------------------------------- + +void OneOwnerRefCountInfo::SetStrongCoPtr( SingleOwnerRefCount * ptr ) +{ + assert( NULL != this ); + m_strongPtr = ptr; +} + +// ---------------------------------------------------------------------------- + +} // end namespace Private + +// ---------------------------------------------------------------------------- + TwoRefCounts::TwoRefCounts( bool strong ) : m_counts( NULL ) { @@ -111,7 +147,7 @@ void TwoRefCounts::Swap( TwoRefCounts & rhs ) { - std::swap( m_counts, rhs.m_counts ); + ::std::swap( m_counts, rhs.m_counts ); } // ---------------------------------------------------------------------------- @@ -133,18 +169,174 @@ } } +// ---------------------------------------------------------------------------- +SingleOwnerRefCount::SingleOwnerRefCount( bool strong ) + : m_info( NULL ) +{ + assert( NULL != this ); + + void * temp = SmallObject<>::operator new( + sizeof(Loki::Private::OneOwnerRefCountInfo) ); +#ifdef DO_EXTRA_LOKI_TESTS + assert( temp != 0 ); +#endif + + SingleOwnerRefCount * ptr = ( strong ) ? this : NULL; + m_info = new ( temp ) ::Loki::Private::OneOwnerRefCountInfo( ptr ); +} + // ---------------------------------------------------------------------------- +SingleOwnerRefCount::SingleOwnerRefCount( const void * p, bool strong ) + : m_info( NULL ) +{ + assert( NULL != this ); + + void * temp = SmallObject<>::operator new( + sizeof(Loki::Private::OneOwnerRefCountInfo) ); +#ifdef DO_EXTRA_LOKI_TESTS + assert( temp != 0 ); +#endif + + SingleOwnerRefCount * ptr = ( strong ) ? this : NULL; + m_info = new ( temp ) ::Loki::Private::OneOwnerRefCountInfo( p, ptr ); +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefCount::SingleOwnerRefCount( const SingleOwnerRefCount & rhs, + bool strong ) + : m_info( NULL ) +{ + assert( NULL != this ); + + if ( strong && rhs.HasStrongPointer() ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + + m_info = rhs.m_info; + if ( strong ) + { + m_info->SetStrongCoPtr( this ); + } + else + { + m_info->IncWeakCount(); + } +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefCount::SingleOwnerRefCount( const SingleOwnerRefCount & rhs, + bool isNull, bool strong ) + : m_info( NULL ) +{ + assert( NULL != this ); + + if ( isNull ) + { + void * temp = SmallObject<>::operator new( + sizeof(Loki::Private::OneOwnerRefCountInfo) ); +#ifdef DO_EXTRA_LOKI_TESTS + assert( temp != 0 ); +#endif + + SingleOwnerRefCount * ptr = ( strong ) ? this : NULL; + m_info = new ( temp ) ::Loki::Private::OneOwnerRefCountInfo( ptr ); + return; + } + + if ( strong && rhs.HasStrongPointer() ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + + m_info = rhs.m_info; + if ( strong ) + { + m_info->SetStrongCoPtr( this ); + } + else + { + m_info->IncWeakCount(); + } +} + +// ---------------------------------------------------------------------------- + +void SingleOwnerRefCount::Swap( SingleOwnerRefCount & rhs ) +{ + assert( NULL != this ); + + if ( IsStrong() && rhs.IsStrong() ) + { + // These two strong pointers are trading resources. + SingleOwnerRefCount * temp = rhs.m_info->GetStrongCoPointer(); + rhs.m_info->SetStrongCoPtr( this ); + m_info->SetStrongCoPtr( temp ); + } + ::std::swap( m_info, rhs.m_info ); +} + +// ---------------------------------------------------------------------------- + +bool SingleOwnerRefCount::Release( bool strong ) +{ + assert( NULL != this ); + + assert( strong == IsStrong() ); + if ( strong ) + { + m_info->SetStrongCoPtr( NULL ); + return true; + } + + assert( 0 < m_info->GetWeakCount() ); + m_info->DecWeakCount(); + const bool noOwner = ( !m_info->HasStrongPointer() ); + return ( ( 0 == m_info->GetWeakCount() ) && noOwner ); +} + +// ---------------------------------------------------------------------------- + +void SingleOwnerRefCount::ZapPointer( void ) +{ + assert( !m_info->HasStrongPointer() ); + if ( m_info->HasWeakPointer() ) + { + m_info->ZapPointer(); + } + else + { + SmallObject<>::operator delete ( m_info, + sizeof(Loki::Private::OneOwnerRefCountInfo) ); + m_info = NULL; + } +} + +// ---------------------------------------------------------------------------- + +void SingleOwnerRefCount::SetPointer( void * p ) +{ + assert( NULL != this ); + if ( IsStrong() || ( 1 == m_info->GetWeakCount() ) ) + { + // Only a strong pointer or the last weak pointer may change a resource. + m_info->SetPointer( p ); + } +} + +// ---------------------------------------------------------------------------- + TwoRefLinks::TwoRefLinks( const void * p, bool strong ) : m_pointer( const_cast< void * >( p ) ) , m_strong( strong ) , m_prev( this ) , m_next( this ) { -#ifdef DO_EXTRA_LOKI_TESTS - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); -#endif + assert( IsValid() ); } // ---------------------------------------------------------------------------- @@ -159,14 +351,11 @@ m_next->m_prev = this; #ifdef DO_EXTRA_LOKI_TESTS - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); assert( rhs.m_next->HasNextNode( this ) ); assert( rhs.m_prev->HasPrevNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( &rhs ) ); - assert( AllNodesHaveSamePointer() ); #endif + assert( IsValid() ); } // ---------------------------------------------------------------------------- @@ -177,6 +366,8 @@ , m_next( ( isNull ) ? 0 : rhs.m_next ) , m_strong( strong ) { + assert( rhs.IsValid() ); + if ( isNull ) { m_prev = m_next = this; @@ -185,77 +376,66 @@ { m_prev->m_next = this; m_next->m_prev = this; - -#ifdef DO_EXTRA_LOKI_TESTS - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); assert( rhs.m_next->HasNextNode( this ) ); assert( rhs.m_prev->HasPrevNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( &rhs ) ); - assert( AllNodesHaveSamePointer() ); -#endif } + assert( IsValid() ); } // ---------------------------------------------------------------------------- +TwoRefLinks::~TwoRefLinks( void ) +{ + assert( IsValid() ); + + if ( ( NULL != m_prev ) && ( this != m_prev ) ) + { + TwoRefLinks * next = m_next; + m_prev->m_next = next; + m_next->m_prev = m_prev; + } +} + +// ---------------------------------------------------------------------------- + void TwoRefLinks::SetPointer( void * p ) { - TwoRefLinks * node = m_prev; - if ( ( this == node ) || ( 0 == node ) ) + assert( IsValid() ); + + TwoRefLinks * node = m_next; + if ( ( this == node ) || ( NULL == node ) ) + { + m_pointer = p; return; + } -#ifdef DO_EXTRA_LOKI_TESTS - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); - assert( AllNodesHaveSamePointer() ); -#endif - while ( node != this ) { node->m_pointer = p; node = node->m_next; } - m_pointer = node; + m_pointer = p; -#ifdef DO_EXTRA_LOKI_TESTS - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); - assert( AllNodesHaveSamePointer() ); -#endif + assert( IsValid() ); } // ---------------------------------------------------------------------------- bool TwoRefLinks::Release( bool strong ) { - + assert( IsValid() ); + assert( strong == m_strong ); (void)strong; -#ifdef DO_EXTRA_LOKI_TESTS - assert( strong == m_strong ); - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); - assert( AllNodesHaveSamePointer() ); -#endif if ( NULL == m_next ) { -#ifdef DO_EXTRA_LOKI_TESTS - assert( NULL == m_prev ); -#endif // Return false so it does not try to destroy shared object // more than once. return false; } - else if (m_next == this) + else if ( m_next == this ) { -#ifdef DO_EXTRA_LOKI_TESTS - assert(m_prev == this); -#endif // Set these to NULL to prevent re-entrancy. m_prev = NULL; m_next = NULL; @@ -263,22 +443,21 @@ return true; } -#ifdef DO_EXTRA_LOKI_TESTS assert( this != m_prev ); assert( NULL != m_prev ); - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); -#endif - // If a single node is strong, then return false so it won't release. if ( HasStrongPointer() ) { // A cyclic chain of pointers is only as strong as the strongest link. m_prev->m_next = m_next; m_next->m_prev = m_prev; + m_next = this; + m_prev = this; + assert( IsValid() ); return false; } + assert( IsValid() ); return true; } @@ -286,8 +465,10 @@ void TwoRefLinks::ZapAllNodes( void ) { + assert( IsValid() ); + TwoRefLinks * p = m_prev; - if ( ( this == p ) || ( 0 == p ) ) + if ( ( this == p ) || ( NULL == p ) ) return; #ifdef DO_EXTRA_LOKI_TESTS assert( AllNodesHaveSamePointer() ); @@ -296,28 +477,28 @@ while ( p != this ) { TwoRefLinks * p1 = p->m_prev; - p->m_pointer = 0; + p->m_pointer = NULL; p->m_next = p; p->m_prev = p; p = p1; } - m_pointer = 0; + m_pointer = NULL; + m_next = this; + m_prev = this; + + assert( IsValid() ); } // ---------------------------------------------------------------------------- void TwoRefLinks::Swap( TwoRefLinks & rhs ) { + assert( IsValid() ); + assert( rhs.IsValid() ); + if ( GetPointer() == rhs.GetPointer() ) + return; -#ifdef DO_EXTRA_LOKI_TESTS - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); - assert( AllNodesHaveSamePointer() ); - assert( rhs.AllNodesHaveSamePointer() ); -#endif - - std::swap( rhs.m_pointer, m_pointer ); + ::std::swap( rhs.m_pointer, m_pointer ); if (m_next == this) { #ifdef DO_EXTRA_LOKI_TESTS @@ -376,19 +557,8 @@ std::swap(m_next->m_prev, rhs.m_next->m_prev); } -#ifdef DO_EXTRA_LOKI_TESTS - assert( m_next == this ? m_prev == this : m_prev != this); - assert( m_prev == this ? m_next == this : m_next != this); - assert( m_prev->HasPrevNode( this ) ); - assert( m_next->HasNextNode( this ) ); - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); - assert( rhs.m_prev->HasPrevNode( &rhs ) ); - assert( rhs.m_next->HasNextNode( &rhs ) ); - assert( CountPrevCycle( &rhs ) == CountNextCycle( &rhs ) ); - assert( AllNodesHaveSamePointer() ); - assert( rhs.AllNodesHaveSamePointer() ); -#endif - + assert( IsValid() ); + assert( rhs.IsValid() ); } // ---------------------------------------------------------------------------- @@ -457,6 +627,7 @@ { if ( this == p ) return true; + const TwoRefLinks * prev = m_prev; if ( NULL == prev ) return false; @@ -475,6 +646,7 @@ { if ( this == p ) return true; + const TwoRefLinks * next = m_next; if ( NULL == next ) return false; @@ -491,6 +663,8 @@ bool TwoRefLinks::HasStrongPointer( void ) const { + assert( IsValid() ); + const TwoRefLinks * next = m_next; if ( NULL == next ) return false; @@ -507,12 +681,12 @@ bool TwoRefLinks::Merge( TwoRefLinks & rhs ) { + assert( IsValid() ); + assert( rhs.IsValid() ); if ( NULL == m_next ) { -#ifdef DO_EXTRA_LOKI_TESTS assert( NULL == m_prev ); -#endif return false; } TwoRefLinks * prhs = &rhs; @@ -520,14 +694,11 @@ return true; if ( NULL == prhs->m_next ) { -#ifdef DO_EXTRA_LOKI_TESTS assert( NULL == prhs->m_prev ); -#endif return true; } #ifdef DO_EXTRA_LOKI_TESTS - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( CountPrevCycle( prhs ) == CountNextCycle( prhs ) ); #endif // If rhs node is already in this cycle, then no need to merge. @@ -542,9 +713,7 @@ if ( prhs == prhs->m_next ) { /// rhs is in a cycle with 1 node. -#ifdef DO_EXTRA_LOKI_TESTS assert( prhs->m_prev == prhs ); -#endif prhs->m_prev = m_prev; prhs->m_next = this; m_prev->m_next = prhs; @@ -553,9 +722,7 @@ else if ( this == m_next ) { /// this is in a cycle with 1 node. -#ifdef DO_EXTRA_LOKI_TESTS assert( m_prev == this ); -#endif m_prev = prhs->m_prev; m_next = prhs; prhs->m_prev->m_next = this; @@ -571,7 +738,7 @@ #ifdef DO_EXTRA_LOKI_TESTS - assert( CountPrevCycle( this ) == CountNextCycle( this ) ); + assert( IsValid() ); #endif return true; @@ -579,6 +746,230 @@ // ---------------------------------------------------------------------------- +unsigned int TwoRefLinks::GetStrongPointerCount( void ) const +{ + assert( IsValid() ); + + unsigned int strongCount = ( m_strong ) ? 1 : 0; + const TwoRefLinks * next = m_next; + if ( ( this == next ) || ( NULL == next ) ) + return strongCount; + + while ( next != this ) + { + if ( next->m_strong ) + { + ++strongCount; + } + next = next->m_next; + } + + return strongCount; +} + +// ---------------------------------------------------------------------------- + +const TwoRefLinks * TwoRefLinks::GetNextStrongPointer( void ) const +{ + assert( IsValid() ); + + for ( const TwoRefLinks * next = m_next; + ( next != this ); next = next->m_next ) + { + if ( next->m_strong ) + { + return next; + } + } + + return this; +} + +// ---------------------------------------------------------------------------- + +bool TwoRefLinks::IsValid( void ) const +{ + assert( NULL != this ); + + const bool isThisNext = ( m_next == this ); + const bool isThisPrev = ( m_prev == this ); + assert( isThisNext == isThisPrev ); + (void)isThisNext; + (void)isThisPrev; + + const bool isNextNull = ( m_next == NULL ); + const bool isPrevNull = ( m_prev == NULL ); + assert( isNextNull == isPrevNull ); + (void)isNextNull; + (void)isPrevNull; + + if ( NULL != m_prev ) + { + assert( NULL != m_next ); + assert( this == m_next->m_prev ); + assert( this == m_prev->m_next ); + assert( m_prev->HasPrevNode( this ) ); + } + if ( NULL != m_next ) + { + assert( NULL != m_prev ); + assert( this == m_next->m_prev ); + assert( this == m_prev->m_next ); + assert( m_next->HasNextNode( this ) ); + } + const unsigned int prevCycleCount = CountPrevCycle( this ); + const unsigned int nextCycleCount = CountNextCycle( this ); + assert( prevCycleCount == nextCycleCount ); + (void)prevCycleCount; + (void)nextCycleCount; + + assert( AllNodesHaveSamePointer() ); + + return true; +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefLinks::SingleOwnerRefLinks( bool strong ) + : TwoRefLinks( strong ) +{ + assert( NULL != this ); + const unsigned int strongCount = GetStrongPointerCount(); + if ( 1 < strongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefLinks::SingleOwnerRefLinks( const void * p, bool strong ) + : TwoRefLinks( p, strong ) +{ + assert( NULL != this ); + const unsigned int strongCount = GetStrongPointerCount(); + if ( 1 < strongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefLinks::SingleOwnerRefLinks( const SingleOwnerRefLinks & rhs, bool strong ) + : TwoRefLinks( rhs, strong ) +{ + assert( NULL != this ); + const unsigned int strongCount = rhs.GetStrongPointerCount(); + if ( 1 < strongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefLinks::SingleOwnerRefLinks( const SingleOwnerRefLinks & rhs, + bool isNull, bool strong ) + : TwoRefLinks( rhs, isNull, strong ) +{ + assert( NULL != this ); + const unsigned int strongCount = GetStrongPointerCount(); + if ( 1 < strongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } +} + +// ---------------------------------------------------------------------------- + +SingleOwnerRefLinks::~SingleOwnerRefLinks( void ) +{ + assert( NULL != this ); + const unsigned int strongCount = GetStrongPointerCount(); + // Use assert instead of throw inside a destructor. + assert( strongCount < 2 ); + (void)strongCount; +} + +// ---------------------------------------------------------------------------- + +void SingleOwnerRefLinks::Swap( SingleOwnerRefLinks & rhs ) +{ + assert( NULL != this ); + if ( GetPointer() == rhs.GetPointer() ) + return; + + const unsigned int lhsStrongCount = GetStrongPointerCount(); + if ( 1 < lhsStrongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + const unsigned int rhsStrongCount = rhs.GetStrongPointerCount(); + if ( 1 < rhsStrongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + + TwoRefLinks::Swap( rhs ); +} + +// ---------------------------------------------------------------------------- + +bool SingleOwnerRefLinks::Merge( SingleOwnerRefLinks & rhs ) +{ + assert( NULL != this ); + + const unsigned int lhsStrongCount = GetStrongPointerCount(); + if ( 1 < lhsStrongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + const unsigned int rhsStrongCount = rhs.GetStrongPointerCount(); + if ( 1 < rhsStrongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + if ( 1 < lhsStrongCount + rhsStrongCount ) + { + throw ::std::logic_error( StrongPtr_Single_Owner_Exception_Message ); + } + + const bool success = TwoRefLinks::Merge( rhs ); + return success; +} + +// ---------------------------------------------------------------------------- + +bool SingleOwnerRefLinks::Release( bool strong ) +{ + assert( NULL != this ); + + if ( strong ) + { + const TwoRefLinks * pStrong = GetNextStrongPointer(); + if ( this != pStrong ) + { + // There is another strong pointer in this linked pointer cycle, + // so just return false to prevent this strong pointer from + // deleting the same resource multiple times. + TwoRefLinks::Release( strong ); + return false; + } + } + + const unsigned int strongCount = GetStrongPointerCount(); + // Use assert instead of throw because Release function only gets called + // from StrongPtr destructor, and destructors must not throw exceptions. + assert( strongCount < 2 ); + (void)strongCount; + + const bool doZap = TwoRefLinks::Release( strong ); + return doZap; +} + +// ---------------------------------------------------------------------------- + #if defined( _MSC_VER ) #pragma warning( pop ) #endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ric...@us...> - 2011-09-20 17:51:52
|
Revision: 1105 http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1105&view=rev Author: rich_sposato Date: 2011-09-20 17:51:46 +0000 (Tue, 20 Sep 2011) Log Message: ----------- Added ability for StrongPtr to handle arrays. Modified Paths: -------------- trunk/src/StrongPtr.cpp Modified: trunk/src/StrongPtr.cpp =================================================================== --- trunk/src/StrongPtr.cpp 2011-09-20 17:51:26 UTC (rev 1104) +++ trunk/src/StrongPtr.cpp 2011-09-20 17:51:46 UTC (rev 1105) @@ -15,6 +15,9 @@ #include <loki/StrongPtr.h> +#include <stdexcept> +#include <string> + #include <memory.h> #ifdef DO_EXTRA_LOKI_TESTS #include <cassert> @@ -38,6 +41,45 @@ // ---------------------------------------------------------------------------- +void DeleteArrayBase::Swap( DeleteArrayBase & rhs ) +{ + assert( NULL != this ); + + const size_t temp = m_itemCount; + m_itemCount = rhs.m_itemCount; + rhs.m_itemCount = temp; +} + +// ---------------------------------------------------------------------------- + +void DeleteArrayBase::OnInit( const void * p ) const +{ + assert( NULL != this ); + if ( NULL == p ) + { + assert( 0 == m_itemCount ); + } + else + { + assert( 0 < m_itemCount ); + } +} + +// ---------------------------------------------------------------------------- + +void DeleteArrayBase::OnCheckRange( size_t index ) const +{ + assert( NULL != this ); + + if ( index < m_itemCount ) + return; + + const ::std::string message( "index out of range in ::Loki::DeleteArrayBase::OnCheckRange" ); + throw ::std::out_of_range( message ); +} + +// ---------------------------------------------------------------------------- + OneOwnerRefCountInfo::OneOwnerRefCountInfo( SingleOwnerRefCount * ptr ) : m_pointer( NULL ) , m_strongPtr( ptr ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |