3706b5d249
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@1083 7ec92016-0320-0410-acc4-a06ded1c099a
550 lines
12 KiB
C++
550 lines
12 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
||
// The Loki Library
|
||
// Copyright (c) 2006 Peter K<>mmel
|
||
// 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.
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
|
||
// $Id$
|
||
|
||
|
||
#include <loki/ScopeGuard.h>
|
||
|
||
#include <vector>
|
||
#include <string>
|
||
#include <iostream>
|
||
#include <assert.h>
|
||
|
||
using namespace Loki;
|
||
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void HasNone( void )
|
||
{
|
||
}
|
||
|
||
void HasOne( int p1 )
|
||
{
|
||
(void)p1;
|
||
}
|
||
|
||
void HasTwo( int p1, int p2 )
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
}
|
||
|
||
void HasThree( int p1, int p2, int p3 )
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
(void)p3;
|
||
}
|
||
|
||
void HasFour( int p1, int p2, int p3, int p4 )
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
(void)p3;
|
||
(void)p4;
|
||
}
|
||
|
||
void HasFive( int p1, int p2, int p3, int p4, int p5 )
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
(void)p3;
|
||
(void)p4;
|
||
(void)p5;
|
||
}
|
||
|
||
void Decrement( unsigned int & x )
|
||
{
|
||
--x;
|
||
}
|
||
|
||
struct UserDatabase
|
||
{
|
||
void AddFriend(const std::string&, const std::string&)
|
||
{
|
||
throw 55;
|
||
}
|
||
};
|
||
|
||
class User
|
||
{
|
||
public:
|
||
User(UserDatabase* db) : fCount(0), pDB_(db)
|
||
{}
|
||
|
||
std::string GetName() const;
|
||
|
||
void AddFriend(User& newFriend);
|
||
void AddFriendGuarded(User& newFriend);
|
||
void AddFriendGuardedMacros(User& newFriend);
|
||
|
||
size_t countFriends() const;
|
||
|
||
void DoSomething() const;
|
||
|
||
unsigned int fCount;
|
||
|
||
void HasNone( void ) const;
|
||
void HasOne( int p1 ) const;
|
||
void HasTwo( int p1, int p2 ) const;
|
||
void HasThree( int p1, int p2, int p3 ) const;
|
||
void HasFour( int p1, int p2, int p3, int p4 ) const;
|
||
void HasFive( int p1, int p2, int p3, int p4, int p5 ) const;
|
||
|
||
private:
|
||
void CheckIfValid( const char * function, unsigned int line ) const;
|
||
|
||
typedef std::vector<User*> UserCont;
|
||
UserCont friends_;
|
||
UserDatabase* pDB_;
|
||
};
|
||
|
||
void User::HasNone( void ) const
|
||
{
|
||
}
|
||
|
||
void User::HasOne( int p1 ) const
|
||
{
|
||
(void)p1;
|
||
}
|
||
|
||
void User::HasTwo( int p1, int p2 ) const
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
}
|
||
|
||
void User::HasThree( int p1, int p2, int p3 ) const
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
(void)p3;
|
||
}
|
||
|
||
void User::HasFour( int p1, int p2, int p3, int p4 ) const
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
(void)p3;
|
||
(void)p4;
|
||
}
|
||
|
||
void User::HasFive( int p1, int p2, int p3, int p4, int p5 ) const
|
||
{
|
||
(void)p1;
|
||
(void)p2;
|
||
(void)p3;
|
||
(void)p4;
|
||
(void)p5;
|
||
}
|
||
|
||
void User::DoSomething() const
|
||
{
|
||
}
|
||
|
||
void User::CheckIfValid( const char * function, unsigned int line ) const
|
||
{
|
||
assert( friends_.size() == fCount );
|
||
(void)function;
|
||
(void)line;
|
||
}
|
||
|
||
std::string User::GetName() const
|
||
{
|
||
return "A name";
|
||
}
|
||
|
||
size_t User::countFriends() const
|
||
{
|
||
return friends_.size();
|
||
}
|
||
|
||
void User::AddFriend(User& newFriend)
|
||
{
|
||
ScopeGuard invariantGuard = MakeObjGuard( *this,
|
||
&User::CheckIfValid, __FUNCTION__, __LINE__ );
|
||
(void)invariantGuard;
|
||
friends_.push_back(&newFriend);
|
||
fCount++;
|
||
pDB_->AddFriend(GetName(), newFriend.GetName());
|
||
}
|
||
|
||
void User::AddFriendGuarded(User& newFriend)
|
||
{
|
||
ScopeGuard invariantGuard = MakeObjGuard( *this,
|
||
&User::CheckIfValid, __FUNCTION__, __LINE__ );
|
||
(void)invariantGuard;
|
||
ScopeGuard guard1 = MakeObjGuard( *this, &User::DoSomething );
|
||
(void)guard1;
|
||
|
||
friends_.push_back(&newFriend);
|
||
Loki::ScopeGuard guard = Loki::MakeObjGuard(friends_, &UserCont::pop_back);
|
||
|
||
fCount++;
|
||
Loki::ScopeGuard guardRef = Loki::MakeGuard(Decrement, Loki::ByRef(fCount));
|
||
|
||
pDB_->AddFriend(GetName(), newFriend.GetName());
|
||
guard.Dismiss();
|
||
guardRef.Dismiss();
|
||
}
|
||
|
||
void User::AddFriendGuardedMacros(User&)
|
||
{
|
||
ScopeGuard invariantGuard = MakeObjGuard( *this,
|
||
&User::CheckIfValid, __FUNCTION__, __LINE__ );
|
||
(void)invariantGuard;
|
||
LOKI_ON_BLOCK_EXIT_OBJ(friends_, &UserCont::pop_back); (void) LOKI_ANONYMOUS_VARIABLE(scopeGuard);
|
||
// GCC 4.2 Bug
|
||
#if defined(__GNUC__)
|
||
#define GCC_VERSION (__GNUC__ * 10 + __GNUC_MINOR__ * 1)
|
||
#endif
|
||
#if !defined(__GNUC__) || (GCC_VERSION < 42) || (GCC_VERSION > 42)
|
||
LOKI_ON_BLOCK_EXIT(Decrement, Loki::ByRef(fCount)); (void) LOKI_ANONYMOUS_VARIABLE(scopeGuard);
|
||
#endif
|
||
}
|
||
|
||
void DoStandaloneFunctionTests()
|
||
{
|
||
ScopeGuard guard0 = MakeGuard( &HasNone );
|
||
ScopeGuard guard1 = MakeGuard( &HasOne, 1 );
|
||
ScopeGuard guard2 = MakeGuard( &HasTwo, 1, 2 );
|
||
ScopeGuard guard3 = MakeGuard( &HasThree, 1, 2, 3 );
|
||
ScopeGuard guard4 = MakeGuard( &HasFour, 1, 2, 3, 4 );
|
||
ScopeGuard guard5 = MakeGuard( &HasFive, 1, 2, 3, 4, 5 );
|
||
(void)guard0;
|
||
(void)guard1;
|
||
(void)guard2;
|
||
(void)guard3;
|
||
(void)guard4;
|
||
(void)guard5;
|
||
}
|
||
|
||
void DoMemberFunctionTests( User & user )
|
||
{
|
||
ScopeGuard guard0 = MakeObjGuard( user, &User::HasNone );
|
||
ScopeGuard guard1 = MakeObjGuard( user, &User::HasOne, 1 );
|
||
ScopeGuard guard2 = MakeObjGuard( user, &User::HasTwo, 1, 2 );
|
||
ScopeGuard guard3 = MakeObjGuard( user, &User::HasThree, 1, 2, 3 );
|
||
(void)guard0;
|
||
(void)guard1;
|
||
(void)guard2;
|
||
(void)guard3;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void CalledAlways( void )
|
||
{
|
||
const bool anyThrown = ::std::uncaught_exception();
|
||
const char * message = ( anyThrown ) ? "thrown" : "not thrown";
|
||
::std::cout << __FUNCTION__ << " Exception was " << message << ::std::endl;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void CalledIfNoException( void )
|
||
{
|
||
const bool anyThrown = ::std::uncaught_exception();
|
||
const char * message = ( anyThrown ) ? "thrown" : "not thrown";
|
||
::std::cout << __FUNCTION__ << " Exception was " << message << ::std::endl;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void CalledIfException( void )
|
||
{
|
||
const bool anyThrown = ::std::uncaught_exception();
|
||
const char * message = ( anyThrown ) ? "thrown" : "not thrown";
|
||
::std::cout << __FUNCTION__ << " Exception was " << message << ::std::endl;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void FunctionMightThrow( bool willThrow )
|
||
{
|
||
if ( willThrow )
|
||
throw ::std::exception();
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void DoExceptionTests( void )
|
||
{
|
||
::std::cout << ::std::endl;
|
||
|
||
{
|
||
try
|
||
{
|
||
::std::cout << "The function should be called." << ::std::endl;
|
||
ScopeGuard guard = MakeGuard( &CalledAlways );
|
||
(void)guard;
|
||
FunctionMightThrow( false );
|
||
}
|
||
catch ( ... )
|
||
{
|
||
::std::cout << "Caught exception." << ::std::endl;
|
||
assert( false );
|
||
}
|
||
}
|
||
|
||
::std::cout << ::std::endl;
|
||
|
||
{
|
||
try
|
||
{
|
||
::std::cout << "The function should be called." << ::std::endl;
|
||
ScopeGuard guard = MakeGuard( &CalledAlways );
|
||
(void)guard;
|
||
FunctionMightThrow( true );
|
||
assert( false );
|
||
}
|
||
catch ( ... )
|
||
{
|
||
::std::cout << "Caught exception." << ::std::endl;
|
||
}
|
||
}
|
||
|
||
::std::cout << ::std::endl;
|
||
|
||
{
|
||
try
|
||
{
|
||
::std::cout << "The function should be called." << ::std::endl;
|
||
ScopeGuard guard = MakeGuard( &CalledIfNoException );
|
||
guard.SetExceptionPolicy( ScopeGuardImplBase::CallIfNoException );
|
||
FunctionMightThrow( false );
|
||
::std::cout << "No exception thrown." << ::std::endl;
|
||
}
|
||
catch ( ... )
|
||
{
|
||
::std::cout << "Caught exception." << ::std::endl;
|
||
assert( false );
|
||
}
|
||
}
|
||
|
||
::std::cout << ::std::endl;
|
||
|
||
{
|
||
try
|
||
{
|
||
::std::cout << "The function should not be called." << ::std::endl;
|
||
ScopeGuard guard = MakeGuard( &CalledIfNoException );
|
||
guard.SetExceptionPolicy( ScopeGuardImplBase::CallIfNoException );
|
||
FunctionMightThrow( true );
|
||
assert( false );
|
||
}
|
||
catch ( ... )
|
||
{
|
||
::std::cout << "Caught exception." << ::std::endl;
|
||
}
|
||
}
|
||
|
||
::std::cout << ::std::endl;
|
||
|
||
{
|
||
try
|
||
{
|
||
::std::cout << "The function should not be called." << ::std::endl;
|
||
ScopeGuard guard = MakeGuard( &CalledIfException );
|
||
guard.SetExceptionPolicy( ScopeGuardImplBase::CallIfException );
|
||
FunctionMightThrow( false );
|
||
::std::cout << "No exception thrown." << ::std::endl;
|
||
}
|
||
catch ( ... )
|
||
{
|
||
::std::cout << "Caught exception." << ::std::endl;
|
||
assert( false );
|
||
}
|
||
}
|
||
|
||
::std::cout << ::std::endl;
|
||
|
||
{
|
||
try
|
||
{
|
||
::std::cout << "The function should be called." << ::std::endl;
|
||
ScopeGuard guard = MakeGuard( &CalledIfException );
|
||
guard.SetExceptionPolicy( ScopeGuardImplBase::CallIfException );
|
||
FunctionMightThrow( true );
|
||
assert( false );
|
||
}
|
||
catch ( ... )
|
||
{
|
||
::std::cout << "Caught exception." << ::std::endl;
|
||
}
|
||
}
|
||
|
||
::std::cout << ::std::endl;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
class Junk
|
||
{
|
||
public:
|
||
|
||
Junk( void );
|
||
~Junk( void );
|
||
|
||
bool IsUgly( void ) const;
|
||
|
||
bool IsUseful( void ) const;
|
||
|
||
};
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
Junk::Junk( void )
|
||
{
|
||
assert( NULL != this );
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
Junk::~Junk( void )
|
||
{
|
||
assert( NULL != this );
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
bool Junk::IsUgly( void ) const
|
||
{
|
||
assert( NULL != this );
|
||
return true;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
bool Junk::IsUseful( void ) const
|
||
{
|
||
assert( NULL != this );
|
||
return true;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
class Attic
|
||
{
|
||
public:
|
||
|
||
Attic( void );
|
||
~Attic( void );
|
||
|
||
Junk * RemoveUselessJunk( void );
|
||
|
||
private:
|
||
|
||
typedef ::std::vector< Junk * > JunkPile;
|
||
typedef JunkPile::iterator JunkPileIter;
|
||
|
||
void CheckInvariants( const char * function, unsigned int line ) const;
|
||
|
||
void CallObservers( void ) const;
|
||
|
||
void EliminateHoles( void );
|
||
|
||
JunkPile m_storage;
|
||
|
||
};
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
Attic::Attic( void ) :
|
||
m_storage()
|
||
{
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
Attic::~Attic( void )
|
||
{
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
Junk * Attic::RemoveUselessJunk( void )
|
||
{
|
||
ScopeGuard callGuard = MakeObjGuard( *this, &Attic::CallObservers );
|
||
ScopeGuard testGuard = MakeObjGuard( *this, &Attic::CheckInvariants, __FUNCTION__, __LINE__ );
|
||
ScopeGuard fixGuard = MakeObjGuard( *this, &Attic::EliminateHoles );
|
||
callGuard.SetExceptionPolicy( ScopeGuardImplBase::CallIfNoException );
|
||
(void)testGuard;
|
||
(void)fixGuard;
|
||
|
||
for ( JunkPileIter it( m_storage.begin() );
|
||
it != m_storage.end();
|
||
++it )
|
||
{
|
||
Junk * junk = *it;
|
||
if ( junk->IsUgly() )
|
||
return junk;
|
||
if ( junk->IsUseful() )
|
||
continue;
|
||
delete junk;
|
||
*it = NULL;
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void Attic::CheckInvariants( const char * function, unsigned int line ) const
|
||
{
|
||
assert( NULL != this );
|
||
(void)function;
|
||
(void)line;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void Attic::CallObservers( void ) const
|
||
{
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
void Attic::EliminateHoles( void )
|
||
{
|
||
}
|
||
|
||
// ----------------------------------------------------------------------------
|
||
|
||
int main()
|
||
{
|
||
UserDatabase db;
|
||
|
||
User u1(&db);
|
||
User u2(&db);
|
||
|
||
try{ u1.AddFriend(u2); }
|
||
catch (...){}
|
||
std::cout << "u1 countFriends: " << u1.countFriends() << "\n";
|
||
std::cout << "u1 fCount : " << u1.fCount << "\n";
|
||
|
||
try{ u2.AddFriendGuarded(u1); }
|
||
catch (...){}
|
||
std::cout << "u2 countFriends: " << u2.countFriends() << "\n";
|
||
std::cout << "u2 fCount : " << u2.fCount << "\n";
|
||
|
||
DoStandaloneFunctionTests();
|
||
DoMemberFunctionTests( u1 );
|
||
DoExceptionTests();
|
||
|
||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||
system("PAUSE");
|
||
#endif
|
||
|
||
}
|