From 6afe127d1308693862ccd7eb3cb055a0f0e73e38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emmanuel=20Beno=C3=AEt?= Date: Wed, 2 Jan 2019 17:14:08 +0100 Subject: [PATCH] Reference-counting helpers - Copy/move cons/ass w/ casts Added tests and fixed a few bugs. --- include/ebcl/RefCount.hh | 18 ++++ include/ebcl/inline/RefCount.hh | 4 +- tests/ref-count.cc | 169 +++++++++++++++++++++++++++++++- 3 files changed, 189 insertions(+), 2 deletions(-) diff --git a/include/ebcl/RefCount.hh b/include/ebcl/RefCount.hh index fe48ec6..64054a0 100644 --- a/include/ebcl/RefCount.hh +++ b/include/ebcl/RefCount.hh @@ -73,6 +73,9 @@ class T_RcPtr T_AtomicRcClass , T_SimpleRcClass >; + // All RcPtr's are friends + template< typename > friend class T_RcPtr; + private: T_Target* target_; void setTarget_( T_Target* t ) noexcept; @@ -88,6 +91,10 @@ class T_RcPtr template< typename... AT > static T_RcPtr< Type > New( AT&& ... arguments ); + // Initialise from raw pointer. The instance must have a reference + // count of zero, and must have been allocated using new. + static T_RcPtr< Type > FromRaw( Type* ptr ) noexcept; + void clear( ) noexcept; // --------------------------------------------------------------------- @@ -145,6 +152,17 @@ class T_RcPtr template< typename T > void swap( T_RcPtr< T >& lhs , T_RcPtr< T >& rhs ) noexcept; +template< typename T > +inline T_RcPtr< T > T_RcPtr< T >::FromRaw( + T* ptr ) noexcept +{ + assert( ptr->getReferenceCount( ) == 0 ); + T_RcPtr< T > rv; + ptr->increaseReferences_( ); + rv.target_ = ptr; + return rv; +} + } // namespace #endif // _H_EBCL_REFCOUNT diff --git a/include/ebcl/inline/RefCount.hh b/include/ebcl/inline/RefCount.hh index a58ddbc..a10d80f 100644 --- a/include/ebcl/inline/RefCount.hh +++ b/include/ebcl/inline/RefCount.hh @@ -168,7 +168,9 @@ template< T_RcPtr< Q >&& other ) noexcept : target_{ nullptr } { - std::swap( target_ , other.target_ ); + T* const ptr{ (T*) other.target_ }; + other.target_ = nullptr; + target_ = ptr; } template< typename T > diff --git a/tests/ref-count.cc b/tests/ref-count.cc index 740b32f..41ab6a4 100644 --- a/tests/ref-count.cc +++ b/tests/ref-count.cc @@ -12,10 +12,13 @@ class RefCountTest : public CppUnit::TestFixture static uint32_t cNew; static uint32_t cDel; T_Test( ) noexcept { cNew ++; } - ~T_Test( ) noexcept { cDel ++; } + virtual ~T_Test( ) noexcept { cDel ++; } }; using P_Test = T_RcPtr< T_Test >; + class T_Child : public T_Test { }; + using P_Child = T_RcPtr< T_Child >; + private: CPPUNIT_TEST_SUITE( RefCountTest ); CPPUNIT_TEST( testStackInstance ); @@ -24,9 +27,24 @@ class RefCountTest : public CppUnit::TestFixture CPPUNIT_TEST( testConstruct ); CPPUNIT_TEST( testCopyCons ); + CPPUNIT_TEST( testCopyConsToBase ); + CPPUNIT_TEST( testCopyConsToChildOk ); + CPPUNIT_TEST( testCopyConsToChildBad ); + CPPUNIT_TEST( testCopyAss ); + CPPUNIT_TEST( testCopyAssToBase ); + CPPUNIT_TEST( testCopyAssToChildOk ); + CPPUNIT_TEST( testCopyAssToChildBad ); + CPPUNIT_TEST( testMoveCons ); + CPPUNIT_TEST( testMoveConsToBase ); + CPPUNIT_TEST( testMoveConsToChildOk ); + CPPUNIT_TEST( testMoveConsToChildBad ); + CPPUNIT_TEST( testMoveAss ); + CPPUNIT_TEST( testMoveAssToBase ); + CPPUNIT_TEST( testMoveAssToChildOk ); + CPPUNIT_TEST( testMoveAssToChildBad ); CPPUNIT_TEST( testSwap ); CPPUNIT_TEST_SUITE_END( ); @@ -40,9 +58,24 @@ class RefCountTest : public CppUnit::TestFixture void testConstruct( ); void testCopyCons( ); + void testCopyConsToBase( ); + void testCopyConsToChildOk( ); + void testCopyConsToChildBad( ); + void testCopyAss( ); + void testCopyAssToBase( ); + void testCopyAssToChildOk( ); + void testCopyAssToChildBad( ); + void testMoveCons( ); + void testMoveConsToBase( ); + void testMoveConsToChildOk( ); + void testMoveConsToChildBad( ); + void testMoveAss( ); + void testMoveAssToBase( ); + void testMoveAssToChildOk( ); + void testMoveAssToChildBad( ); void testSwap( ); }; @@ -127,6 +160,38 @@ void RefCountTest< A >::testCopyCons( ) CPPUNIT_ASSERT_EQUAL( 1u , T_Test::cDel ); } +template< bool A > +void RefCountTest< A >::testCopyConsToBase( ) +{ + P_Child p1{ P_Child::New( ) }; + P_Test p2{ p1 }; + + CPPUNIT_ASSERT( bool( p2 ) ); + CPPUNIT_ASSERT( p1.get( ) == p2.get( ) ); + CPPUNIT_ASSERT_EQUAL( 2u , p1->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testCopyConsToChildOk( ) +{ + P_Test p1{ P_Test::FromRaw( new T_Child( ) ) }; + P_Child p2{ p1 }; + + CPPUNIT_ASSERT( bool( p2 ) ); + CPPUNIT_ASSERT( p1.get( ) == p2.get( ) ); + CPPUNIT_ASSERT_EQUAL( 2u , p1->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testCopyConsToChildBad( ) +{ + P_Test p1{ P_Test::New( ) }; + CPPUNIT_ASSERT_THROW( P_Child p2{ p1 } , std::bad_cast ); + CPPUNIT_ASSERT_EQUAL( 1u , p1->getReferenceCount( ) ); +} + +/*----------------------------------------------------------------------------*/ + template< bool A > void RefCountTest< A >::testCopyAss( ) { @@ -147,6 +212,41 @@ void RefCountTest< A >::testCopyAss( ) CPPUNIT_ASSERT_EQUAL( 1u , T_Test::cDel ); } +template< bool A > +void RefCountTest< A >::testCopyAssToBase( ) +{ + P_Child p1{ P_Child::New( ) }; + P_Test p2; + p2 = p1; + + CPPUNIT_ASSERT( bool( p2 ) ); + CPPUNIT_ASSERT( p1.get( ) == p2.get( ) ); + CPPUNIT_ASSERT_EQUAL( 2u , p1->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testCopyAssToChildOk( ) +{ + P_Test p1{ P_Test::FromRaw( new T_Child( ) ) }; + P_Child p2; + p2 = p1; + + CPPUNIT_ASSERT( bool( p2 ) ); + CPPUNIT_ASSERT( p1.get( ) == p2.get( ) ); + CPPUNIT_ASSERT_EQUAL( 2u , p1->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testCopyAssToChildBad( ) +{ + P_Test p1{ P_Test::New( ) }; + P_Child p2; + CPPUNIT_ASSERT_THROW( p2 = p1 , std::bad_cast ); + CPPUNIT_ASSERT_EQUAL( 1u , p1->getReferenceCount( ) ); +} + +/*----------------------------------------------------------------------------*/ + template< bool A > void RefCountTest< A >::testMoveCons( ) { @@ -162,6 +262,39 @@ void RefCountTest< A >::testMoveCons( ) CPPUNIT_ASSERT_EQUAL( 1u , T_Test::cDel ); } +template< bool A > +void RefCountTest< A >::testMoveConsToBase( ) +{ + P_Child p1{ P_Child::New( ) }; + P_Test p2{ std::move( p1 ) }; + + CPPUNIT_ASSERT( bool( p2 ) ); + CPPUNIT_ASSERT( !p1 ); + CPPUNIT_ASSERT_EQUAL( 1u , p2->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testMoveConsToChildOk( ) +{ + P_Test p1{ P_Test::FromRaw( new T_Child( ) ) }; + P_Child p2{ std::move( p1 ) }; + + CPPUNIT_ASSERT( bool( p2 ) ); + CPPUNIT_ASSERT( !p1 ); + CPPUNIT_ASSERT_EQUAL( 1u , p2->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testMoveConsToChildBad( ) +{ + P_Test p1{ P_Test::New( ) }; + CPPUNIT_ASSERT_THROW( P_Child p2{ std::move( p1 ) } , std::bad_cast ); + CPPUNIT_ASSERT( p1 ); + CPPUNIT_ASSERT_EQUAL( 1u , p1->getReferenceCount( ) ); +} + +/*----------------------------------------------------------------------------*/ + template< bool A > void RefCountTest< A >::testMoveAss( ) { @@ -179,6 +312,40 @@ void RefCountTest< A >::testMoveAss( ) CPPUNIT_ASSERT_EQUAL( 1u , T_Test::cDel ); } +template< bool A > +void RefCountTest< A >::testMoveAssToBase( ) +{ + P_Child p1{ P_Child::New( ) }; + P_Test p2; + p2 = std::move( p1 ); + + CPPUNIT_ASSERT( p2 ); + CPPUNIT_ASSERT( !p1 ); + CPPUNIT_ASSERT_EQUAL( 1u , p2->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testMoveAssToChildOk( ) +{ + P_Test p1{ P_Test::FromRaw( new T_Child( ) ) }; + P_Child p2; + p2 = std::move( p1 ); + + CPPUNIT_ASSERT( p2 ); + CPPUNIT_ASSERT( !p1 ); + CPPUNIT_ASSERT_EQUAL( 1u , p2->getReferenceCount( ) ); +} + +template< bool A > +void RefCountTest< A >::testMoveAssToChildBad( ) +{ + P_Test p1{ P_Test::New( ) }; + P_Child p2; + CPPUNIT_ASSERT_THROW( p2 = std::move( p1 ) , std::bad_cast ); + CPPUNIT_ASSERT( p1 ); + CPPUNIT_ASSERT_EQUAL( 1u , p1->getReferenceCount( ) ); +} + /*----------------------------------------------------------------------------*/ template< bool A >