Menu
▾
▴
[Loki-lib-cvs] SF.net SVN: loki-lib:[896] trunk
|
From: <syn...@us...> - 2008-08-08 22:20:21
|
Revision: 896
http://loki-lib.svn.sourceforge.net/loki-lib/?rev=896&view=rev
Author: syntheticpp
Date: 2008-08-08 22:20:05 +0000 (Fri, 08 Aug 2008)
Log Message:
-----------
fix line endings
Modified Paths:
--------------
trunk/include/loki/Allocator.h
trunk/include/loki/CheckReturn.h
trunk/include/loki/Checker.h
trunk/include/loki/SPCachedFactory.h
trunk/test/CheckReturn/CheckReturn.dev
trunk/test/CheckReturn/CheckReturn.vcproj
trunk/test/CheckReturn/CheckReturn_MSVC_8.vcproj
trunk/test/CheckReturn/main.cpp
trunk/test/Checker/Checker_MSVC_9.vcproj
trunk/test/Checker/main.cpp
trunk/test/LevelMutex/LevelMutex_MSVC_9.vcproj
trunk/test/LevelMutex/MultiThreadTests.cpp
trunk/test/LevelMutex/MultiThreadTests.hpp
trunk/test/LevelMutex/Thing.cpp
trunk/test/LevelMutex/Thing.hpp
trunk/test/LevelMutex/ThreadPool.cpp
trunk/test/LevelMutex/ThreadPool.hpp
trunk/test/LevelMutex/main.cpp
Property Changed:
----------------
trunk/include/loki/Allocator.h
trunk/include/loki/CheckReturn.h
trunk/include/loki/Checker.h
trunk/include/loki/LevelMutex.h
trunk/include/loki/SPCachedFactory.h
trunk/src/LevelMutex.cpp
trunk/src/Library_MSVC_8.vcproj
trunk/test/CachedFactory/CachedFactory.cbp
trunk/test/CachedFactory/CachedFactory_MSVC_8.vcproj
trunk/test/CheckReturn/CheckReturn.cbp
trunk/test/CheckReturn/CheckReturn.dev
trunk/test/CheckReturn/CheckReturn.vcproj
trunk/test/CheckReturn/CheckReturn_MSVC_8.vcproj
trunk/test/CheckReturn/main.cpp
trunk/test/Checker/Checker.cbp
trunk/test/Checker/Checker_MSVC_9.vcproj
trunk/test/Checker/main.cpp
trunk/test/DeletableSingleton/DeletableSingleton.cbp
trunk/test/DeletableSingleton/DeletableSingleton_MSVC_8.vcproj
trunk/test/Factory/Factory.cbp
trunk/test/Factory/Factory_MSVC_8.vcproj
trunk/test/Function/Function.cbp
trunk/test/Function/Function_MSVC_8.vcproj
trunk/test/LevelMutex/LevelMutex.cbp
trunk/test/LevelMutex/LevelMutex_MSVC_9.vcproj
trunk/test/LevelMutex/MultiThreadTests.cpp
trunk/test/LevelMutex/MultiThreadTests.hpp
trunk/test/LevelMutex/Thing.cpp
trunk/test/LevelMutex/Thing.hpp
trunk/test/LevelMutex/ThreadPool.cpp
trunk/test/LevelMutex/ThreadPool.hpp
trunk/test/LevelMutex/main.cpp
trunk/test/LockingPtr/LockingPtr.cbp
trunk/test/LockingPtr/LockingPtr_MSVC_8.vcproj
trunk/test/Longevity/Longevity.cbp
trunk/test/Longevity/Longevity_MSVC_8.vcproj
trunk/test/OrderedStatic/OrderedStatic.cbp
trunk/test/OrderedStatic/OrderedStatic_MSVC_8.vcproj
trunk/test/Pimpl/Pimpl.cbp
trunk/test/Pimpl/Pimpl_MSVC_8.vcproj
trunk/test/Register/Register.cbp
trunk/test/RegressionTest/MSVCUnitTest_MSVC_8.vcproj
trunk/test/RegressionTest/RegressionTest.cbp
trunk/test/SafeFormat/SafeFormat.cbp
trunk/test/SafeFormat/SafeFormat_MSVC_8.vcproj
trunk/test/ScopeGuard/ScopeGuard.cbp
trunk/test/ScopeGuard/ScopeGuard_MSVC_8.vcproj
trunk/test/Singleton/Singleton.cbp
trunk/test/Singleton/Singleton_MSVC_8.vcproj
trunk/test/SmallObj/DefaultAlloc.cbp
trunk/test/SmallObj/DefaultAlloc_MSVC_8.vcproj
trunk/test/SmallObj/SmallObj.cbp
trunk/test/SmallObj/SmallObjCompare_MSVC_8.vcproj
trunk/test/SmallObj/SmallObjSingleton_MSVC_8.vcproj
trunk/test/SmartPtr/SmartPtr.cbp
trunk/test/SmartPtr/SmartPtr_MSVC_8.vcproj
trunk/test/Visitor/Visitor.cbp
trunk/test/Visitor/Visitor_MSVC_8.vcproj
trunk/test/flex_string/flex_string.cbp
trunk/test/flex_string/flex_string_MSVC_8.vcproj
Modified: trunk/include/loki/Allocator.h
===================================================================
--- trunk/include/loki/Allocator.h 2008-08-08 22:06:26 UTC (rev 895)
+++ trunk/include/loki/Allocator.h 2008-08-08 22:20:05 UTC (rev 896)
@@ -1,153 +1,153 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2008 by 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 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_ALLOCATOR_HPP_INCLUDED
-#define LOKI_ALLOCATOR_HPP_INCLUDED
-
-// $Id$
-
-// Requires project to be compiled with loki/src/SmallObj.cpp and loki/src/Singleton.cpp
-
-#include <loki/SmallObj.h>
-
-
-namespace Loki
-{
-
-
-//-----------------------------------------------------------------------------
-
-/** @class LokiAllocator
- Adapts Loki's Small-Object Allocator for STL container classes.
- This class provides all the functionality required for STL allocators, but
- uses Loki's Small-Object Allocator to perform actual memory operations.
- Implementation comes from a post in Loki forums (by Rasmus Ekman?).
- */
-template
-<
- typename Type,
- typename AllocT = Loki::AllocatorSingleton<>
->
-class LokiAllocator
-{
-public:
-
- typedef ::std::size_t size_type;
- typedef ::std::ptrdiff_t difference_type;
- typedef Type * pointer;
- typedef const Type * const_pointer;
- typedef Type & reference;
- typedef const Type & const_reference;
- typedef Type value_type;
-
- /// Default constructor does nothing.
- inline LokiAllocator( void ) throw() { }
-
- /// Copy constructor does nothing.
- inline LokiAllocator( const LokiAllocator & ) throw() { }
-
- /// Type converting allocator constructor does nothing.
- template < typename Type1 >
- inline LokiAllocator( const LokiAllocator< Type1 > & ) throw() { }
-
- /// Destructor does nothing.
- inline ~LokiAllocator() throw() { }
-
- /// Convert an allocator<Type> to an allocator <Type1>.
- template < typename Type1 >
- struct rebind
- {
- typedef LokiAllocator< Type1 > other;
- };
-
- /// Return address of reference to mutable element.
- pointer address( reference elem ) const { return &elem; }
-
- /// Return address of reference to const element.
- const_pointer address( const_reference elem ) const { return &elem; }
-
- /** Allocate an array of count elements. Warning! The true parameter in
- the call to Allocate means this function can throw exceptions. This is
- better than not throwing, and returning a null pointer in case the caller
- assumes the return value is not null.
- @param count # of elements in array.
- @param hint Place where caller thinks allocation should occur.
- @return Pointer to block of memory.
- */
- pointer allocate( size_type count, const void * hint = 0 )
- {
- (void)hint; // Ignore the hint.
- void * p = AllocT::Instance().Allocate( count * sizeof( Type ), true );
- return reinterpret_cast< pointer >( p );
- }
-
- /// Ask allocator to release memory at pointer with size bytes.
- void deallocate( pointer p, size_type size )
- {
- AllocT::Instance().Deallocate( p, size * sizeof( Type ) );
- }
-
- /// Calculate max # of elements allocator can handle.
- size_type max_size( void ) const throw()
- {
- // A good optimizer will see these calculations always produce the same
- // value and optimize this function away completely.
- const size_type max_bytes = size_type( -1 );
- const size_type bytes = max_bytes / sizeof( Type );
- return bytes;
- }
-
- /// Construct an element at the pointer.
- void construct( pointer p, const Type & value )
- {
- // A call to global placement new forces a call to copy constructor.
- ::new( p ) Type( value );
- }
-
- /// Destruct the object at pointer.
- void destroy( pointer p )
- {
- // If the Type has no destructor, then some compilers complain about
- // an unreferenced parameter, so use the void cast trick to prevent
- // spurious warnings.
- (void)p;
- p->~Type();
- }
-
-};
-
-//-----------------------------------------------------------------------------
-
-/** All equality operators return true since LokiAllocator is basically a
- monostate design pattern, so all instances of it are identical.
- */
-template < typename Type >
-inline bool operator == ( const LokiAllocator< Type > &, const LokiAllocator< Type > & )
-{
- return true;
-}
-
-/** All inequality operators return false since LokiAllocator is basically a
- monostate design pattern, so all instances of it are identical.
- */
-template < typename Type >
-inline bool operator != ( const LokiAllocator< Type > & , const LokiAllocator< Type > & )
-{
- return false;
-}
-
-//-----------------------------------------------------------------------------
-
-} // namespace Loki
-
-#endif // LOKI_ALLOCATOR_INCLUDED
+////////////////////////////////////////////////////////////////////////////////
+// The Loki Library
+// Copyright (c) 2008 by 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 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_ALLOCATOR_HPP_INCLUDED
+#define LOKI_ALLOCATOR_HPP_INCLUDED
+
+// $Id$
+
+// Requires project to be compiled with loki/src/SmallObj.cpp and loki/src/Singleton.cpp
+
+#include <loki/SmallObj.h>
+
+
+namespace Loki
+{
+
+
+//-----------------------------------------------------------------------------
+
+/** @class LokiAllocator
+ Adapts Loki's Small-Object Allocator for STL container classes.
+ This class provides all the functionality required for STL allocators, but
+ uses Loki's Small-Object Allocator to perform actual memory operations.
+ Implementation comes from a post in Loki forums (by Rasmus Ekman?).
+ */
+template
+<
+ typename Type,
+ typename AllocT = Loki::AllocatorSingleton<>
+>
+class LokiAllocator
+{
+public:
+
+ typedef ::std::size_t size_type;
+ typedef ::std::ptrdiff_t difference_type;
+ typedef Type * pointer;
+ typedef const Type * const_pointer;
+ typedef Type & reference;
+ typedef const Type & const_reference;
+ typedef Type value_type;
+
+ /// Default constructor does nothing.
+ inline LokiAllocator( void ) throw() { }
+
+ /// Copy constructor does nothing.
+ inline LokiAllocator( const LokiAllocator & ) throw() { }
+
+ /// Type converting allocator constructor does nothing.
+ template < typename Type1 >
+ inline LokiAllocator( const LokiAllocator< Type1 > & ) throw() { }
+
+ /// Destructor does nothing.
+ inline ~LokiAllocator() throw() { }
+
+ /// Convert an allocator<Type> to an allocator <Type1>.
+ template < typename Type1 >
+ struct rebind
+ {
+ typedef LokiAllocator< Type1 > other;
+ };
+
+ /// Return address of reference to mutable element.
+ pointer address( reference elem ) const { return &elem; }
+
+ /// Return address of reference to const element.
+ const_pointer address( const_reference elem ) const { return &elem; }
+
+ /** Allocate an array of count elements. Warning! The true parameter in
+ the call to Allocate means this function can throw exceptions. This is
+ better than not throwing, and returning a null pointer in case the caller
+ assumes the return value is not null.
+ @param count # of elements in array.
+ @param hint Place where caller thinks allocation should occur.
+ @return Pointer to block of memory.
+ */
+ pointer allocate( size_type count, const void * hint = 0 )
+ {
+ (void)hint; // Ignore the hint.
+ void * p = AllocT::Instance().Allocate( count * sizeof( Type ), true );
+ return reinterpret_cast< pointer >( p );
+ }
+
+ /// Ask allocator to release memory at pointer with size bytes.
+ void deallocate( pointer p, size_type size )
+ {
+ AllocT::Instance().Deallocate( p, size * sizeof( Type ) );
+ }
+
+ /// Calculate max # of elements allocator can handle.
+ size_type max_size( void ) const throw()
+ {
+ // A good optimizer will see these calculations always produce the same
+ // value and optimize this function away completely.
+ const size_type max_bytes = size_type( -1 );
+ const size_type bytes = max_bytes / sizeof( Type );
+ return bytes;
+ }
+
+ /// Construct an element at the pointer.
+ void construct( pointer p, const Type & value )
+ {
+ // A call to global placement new forces a call to copy constructor.
+ ::new( p ) Type( value );
+ }
+
+ /// Destruct the object at pointer.
+ void destroy( pointer p )
+ {
+ // If the Type has no destructor, then some compilers complain about
+ // an unreferenced parameter, so use the void cast trick to prevent
+ // spurious warnings.
+ (void)p;
+ p->~Type();
+ }
+
+};
+
+//-----------------------------------------------------------------------------
+
+/** All equality operators return true since LokiAllocator is basically a
+ monostate design pattern, so all instances of it are identical.
+ */
+template < typename Type >
+inline bool operator == ( const LokiAllocator< Type > &, const LokiAllocator< Type > & )
+{
+ return true;
+}
+
+/** All inequality operators return false since LokiAllocator is basically a
+ monostate design pattern, so all instances of it are identical.
+ */
+template < typename Type >
+inline bool operator != ( const LokiAllocator< Type > & , const LokiAllocator< Type > & )
+{
+ return false;
+}
+
+//-----------------------------------------------------------------------------
+
+} // namespace Loki
+
+#endif // LOKI_ALLOCATOR_INCLUDED
Property changes on: trunk/include/loki/Allocator.h
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: trunk/include/loki/CheckReturn.h
===================================================================
--- trunk/include/loki/CheckReturn.h 2008-08-08 22:06:26 UTC (rev 895)
+++ trunk/include/loki/CheckReturn.h 2008-08-08 22:20:05 UTC (rev 896)
@@ -1,96 +1,96 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2007 by 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 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_CHECK_RETURN_INC_
-#define LOKI_CHECK_RETURN_INC_
-
-// $Id$
-
-
-#include <assert.h>
-
-namespace Loki
-{
-
-// ----------------------------------------------------------------------------
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class CheckReturn
-///
-/// \par Purpose
-/// C++ provides no mechanism within the language itself to force code to
-/// check the return value from a function call. This simple class provides
-/// a mechanism by which programmers can force calling functions to check the
-/// return value. Or at least make them consciously choose to disregard the
-/// return value. If the calling function fails to use or store the return
-/// value, the destructor asserts.
-///
-/// \par Return Type
-/// The returned value is copied into CheckReturn rather than accessed via a
-/// a reference or pointer since return value could be local to a function.
-/// CheckReturn works best when the return type is a built-in primitive (bool,
-/// int, etc...) a pointer, or an enum (such as an error condition enum). It
-/// can work with other types that have cheap copy operations.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class Value >
-class CheckReturn
-{
-public:
-
- /// Conversion constructor changes Value type to CheckReturn type.
- inline CheckReturn( Value value ) :
- m_value( value ), m_checked( false ) {}
-
- /// Copy-constructor allows functions to call another function within the
- /// return statement. The other CheckReturn's m_checked flag is set since
- /// its duty has been passed to the m_checked flag in this one.
- inline CheckReturn( const CheckReturn & that ) :
- m_value( that.m_value ), m_checked( false )
- { that.m_checked = true; }
-
- /// Destructor checks if return value was used.
- inline ~CheckReturn( void )
- {
- // If this assertion fails, then a function failed to check the
- // return value from a function call.
- assert( m_checked );
- }
-
- /// Conversion operator changes CheckReturn back to Value type.
- inline operator Value ( void )
- {
- m_checked = true;
- return m_value;
- }
-
-private:
- /// Default constructor not implemented.
- CheckReturn( void );
-
- /// Copy-assignment operator not implemented.
- CheckReturn & operator = ( const CheckReturn & that );
-
- /// Copy of returned value.
- Value m_value;
-
- /// Flag for whether calling function checked return value yet.
- mutable bool m_checked;
-};
-
-// ----------------------------------------------------------------------------
-
-} // namespace Loki
-
-#endif // end file guardian
-
-// $Log$
+////////////////////////////////////////////////////////////////////////////////
+// The Loki Library
+// Copyright (c) 2007 by 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 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_CHECK_RETURN_INC_
+#define LOKI_CHECK_RETURN_INC_
+
+// $Id$
+
+
+#include <assert.h>
+
+namespace Loki
+{
+
+// ----------------------------------------------------------------------------
+
+////////////////////////////////////////////////////////////////////////////////
+/// \class CheckReturn
+///
+/// \par Purpose
+/// C++ provides no mechanism within the language itself to force code to
+/// check the return value from a function call. This simple class provides
+/// a mechanism by which programmers can force calling functions to check the
+/// return value. Or at least make them consciously choose to disregard the
+/// return value. If the calling function fails to use or store the return
+/// value, the destructor asserts.
+///
+/// \par Return Type
+/// The returned value is copied into CheckReturn rather than accessed via a
+/// a reference or pointer since return value could be local to a function.
+/// CheckReturn works best when the return type is a built-in primitive (bool,
+/// int, etc...) a pointer, or an enum (such as an error condition enum). It
+/// can work with other types that have cheap copy operations.
+////////////////////////////////////////////////////////////////////////////////
+
+template < class Value >
+class CheckReturn
+{
+public:
+
+ /// Conversion constructor changes Value type to CheckReturn type.
+ inline CheckReturn( Value value ) :
+ m_value( value ), m_checked( false ) {}
+
+ /// Copy-constructor allows functions to call another function within the
+ /// return statement. The other CheckReturn's m_checked flag is set since
+ /// its duty has been passed to the m_checked flag in this one.
+ inline CheckReturn( const CheckReturn & that ) :
+ m_value( that.m_value ), m_checked( false )
+ { that.m_checked = true; }
+
+ /// Destructor checks if return value was used.
+ inline ~CheckReturn( void )
+ {
+ // If this assertion fails, then a function failed to check the
+ // return value from a function call.
+ assert( m_checked );
+ }
+
+ /// Conversion operator changes CheckReturn back to Value type.
+ inline operator Value ( void )
+ {
+ m_checked = true;
+ return m_value;
+ }
+
+private:
+ /// Default constructor not implemented.
+ CheckReturn( void );
+
+ /// Copy-assignment operator not implemented.
+ CheckReturn & operator = ( const CheckReturn & that );
+
+ /// Copy of returned value.
+ Value m_value;
+
+ /// Flag for whether calling function checked return value yet.
+ mutable bool m_checked;
+};
+
+// ----------------------------------------------------------------------------
+
+} // namespace Loki
+
+#endif // end file guardian
+
+// $Log$
Property changes on: trunk/include/loki/CheckReturn.h
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: trunk/include/loki/Checker.h
===================================================================
--- trunk/include/loki/Checker.h 2008-08-08 22:06:26 UTC (rev 895)
+++ trunk/include/loki/Checker.h 2008-08-08 22:20:05 UTC (rev 896)
@@ -1,453 +1,453 @@
-////////////////////////////////////////////////////////////////////////////////
-//
-// The Loki Library
-// Copyright (c) 2008 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.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// $Id$
-
-/// @file Checker.h This file provides Loki's Checker facility.
-
-
-// ----------------------------------------------------------------------------
-
-#ifndef LOKI_CHECKER_H_INCLUDED
-#define LOKI_CHECKER_H_INCLUDED
-
-#include <exception> // needed for calls to uncaught_exception.
-#include <assert.h>
-
-
-namespace Loki
-{
-
-/** @par Checker and StaticChecker Overview
- The Checker and StaticChecker classes have two purposes:
- - provide a mechanism by which programmers can determine which functions
- violate class/data invariants,
- - and determine which exception safety a function provides.
-
- @par Class & Data Invariants
- The Checker and StaticChecker utilities define invariants as "expressions that
- are true for particular data". They uses a function which returns true if all
- data are valid, and returns false if any datum is invalid. This is called the
- validator function, and the host class or function provides a pointer to it.
- The validator could also assert for any invariant which fails rather than
- return false. If the validator is a static member function, you can use it
- with checkers in any function, but especially standalone functions and class
- static functions. If the validator is a non-static member function, you can
- use it only within non-static member functions.
-
- @par Exception Safety Levels
- Years ago, David Abrahams formalized a framework for assessing the exception
- safety level a function provides. His framework describes three levels of
- guarantees. Any function which does not provide any of these levels is
- considered unsafe. Checker and StaticChecker determine a function's safety
- level through the use of policy classes. Checker's policy classes can show if
- a function provides any of these three guarantees. (Caveat: Checker can't
- detect leaks directly by itself, but it can call a validator which does.)
- StaticChecker's policy classes only provide direct checking for the no-throw
- and invariant guarantees. With some finesse, a programmer can write a
- validator for StaticChecker that checks for the Strong guarantee.
-
- - No-throw guarantee: A function will not throw any exceptions.
- - Strong guarantee: A function will not change data if an exception occurs.
- (Also called the no-change guarantee.)
- - Basic guarantee: A function will not leak resources and data will remain
- in a valid state if an exception occurs. (Also called a no-leak guarantee.)
- */
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNoThrow
-
- @par Exception Safety Level:
- This exception-checking policy class for Checker asserts if an exception exists.
- Host classes can use this to show that some member functions provide the no-throw
- exception safety guarantees.
-
- @par Requirements For Host Class:
- This policy imposes no requirements on a host class.
- */
-template < class Host >
-class CheckForNoThrow
-{
-public:
-
- inline explicit CheckForNoThrow( const Host * ) {}
-
- inline void Check( const Host * ) const
- {
- assert( !::std::uncaught_exception() );
- }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNoChange
-
- @par Exception Safety Level:
- This exception-checking policy class for Checker asserts only if a copy of the
- host differs from the host object when an exception occurs. Host classes can
- use this policy to show which member functions provide the strong exception
- guarantee.
-
- @par Requirements:
- This policy requires hosts to provide both the copy-constructor and the
- equality operator, and is intended for classes with value semantics.
- equality operator.
- */
-
-template < class Host >
-class CheckForNoChange
-{
-public:
-
- inline explicit CheckForNoChange( const Host * host ) :
- m_compare( *host ) {}
-
- inline void Check( const Host * host ) const
- {
- if ( ::std::uncaught_exception() )
- {
- assert( m_compare == *host );
- }
- }
-
-private:
- Host m_compare;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNoChangeOrThrow
-
- @par Exception Safety Level:
- This exception-checking policy class for Checker asserts either if a copy of
- the host differs from the original host object, or if an exception occurs.
- Host classes can use this policy to show which member functions provide the
- no-throw exception guarantee, and would never change data anyway.
-
- @par Requirements For Host Class:
- This policy requires hosts to provide both the copy-constructor and the
- equality operator, and is intended for classes with value semantics.
- */
-
-template < class Host >
-class CheckForNoChangeOrThrow
-{
-public:
-
- inline explicit CheckForNoChangeOrThrow( const Host * host ) :
- m_compare( *host ) {}
-
- inline void Check( const Host * host ) const
- {
- assert( !::std::uncaught_exception() );
- assert( m_compare == *host );
- }
-
-private:
- Host m_compare;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForEquality
-
- @par Exception Safety Level:
- This exception-checking policy class for Checker asserts only if a copy of the
- host differs from the host object regardless of whether an exception occurs.
- Host classes can use this policy to show which member functions never change
- data members, and thereby provide the strong exception safety level by default.
-
- @par Requirements For Host Class:
- This policy requires hosts to provide both the copy-constructor and the
- equality operator, and is intended for classes with value semantics.
- */
-
-template < class Host >
-class CheckForEquality
-{
-public:
-
- inline explicit CheckForEquality( const Host * host ) :
- m_compare( *host ) {}
-
- inline void Check( const Host * host ) const
- {
- assert( m_compare == *host );
- }
-
-private:
- Host m_compare;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNothing
-
- @par Exception Safety Level:
- This exception-checking policy class for Checker does nothing when called.
- Host classes can use this to show which member functions provide neither the
- strong nor no-throw exception guarantees. The best guarantee such functions
- can provide is that nothing gets leaked.
-
- @par Requirements For Host Class:
- This policy imposes no requirements on a host class.
- */
-
-template < class Host >
-class CheckForNothing
-{
-public:
- inline explicit CheckForNothing( const Host * ) {}
- inline void Check( const Host * ) const {}
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class Checker
- This class checks if a host class violated an invariant. This asserts if any
- check for an invariant failed. It can also demonstrate which functions provide
- which exception safety level.
-
- @par Usage
- -# Implement a function that checks each class invariant. The function must
- have the signature similar to the Validator type. Something like:
- "bool Host::IsValid( void ) const;"
- - The function should return true if everything is okay, but false if
- something is wrong.
- - Or it could assert if anything is wrong.
- -# Declare some typedef's inside the class declaration like these. Make one
- typedef for each exception policy you use. I typedef'ed the CheckForNothing
- policy as CheckInvariants because even if a function can't provide either the
- no-throw nor the no-change policies, it should still make sure the object
- remains in a valid state.
- - typedef ::Loki::Checker< Host, ::Loki::CheckForNoThrow > CheckForNoThrow;
- - typedef ::Loki::Checker< Host, ::Loki::CheckForNoChange > CheckForNoChange;
- - typedef ::Loki::Checker< Host, ::Loki::CheckForEquality > CheckForEquality;
- - typedef ::Loki::Checker< Host, ::Loki::CheckForNothing > CheckInvariants;
- -# Construct a checker near the top of each member function - except in the
- validator member function. Pass the this pointer and the address of your
- validator function into the checker's constructor.
- - If the function never throws, then use the CheckForNoThrow policy.
- - If the function never changes any data members, then use CheckForEquality
- policy.
- - If the function's normal execution flow changes data, but must make sure
- data remains unchanged when any exceptions occur, then use the
- CheckForNoChange policy.
- - Otherwise use the CheckInvariants policy.
- -# Recompile a debug version of your program, run it, and look for which
- assertions failed.
- */
-
-template
-<
- class Host,
- template < class > class ExceptionPolicy
->
-class Checker : public ExceptionPolicy< Host >
-{
- /// Shorthand for the ExceptionPolicy class.
- typedef ExceptionPolicy< Host > Ep;
-
-public:
-
- /// Signature for the validation function.
- typedef bool ( Host:: * Validator )( void ) const;
-
- /** The constructor makes sure the host is valid at the time the checker
- was created, thus insuring the host object was not corrupt from the start.
- */
- inline Checker( const Host * host, Validator validator ) :
- Ep( host ),
- m_host( host ),
- m_validator( validator )
- {
- Check();
- }
-
- /** The destructor checks if any Host invariants failed, and then calls the
- ExceptionPolicy's Check function to determine what to do in case of an
- exception.
- */
- inline ~Checker( void )
- {
- Check();
- Ep::Check( m_host );
- }
-
- /** This first checks the invariants for Checker, and then calls the
- validator function for the host to make sure no class invariants
- were broken by the host within the Host's member function body. The
- host member function can call Check directly to verify the object
- remains valid at any time.
- */
- inline void Check( void ) const
- {
- assert( 0 != this );
- assert( 0 != m_host );
- assert( 0 != m_validator );
- // Now that this confirms the pointers to the host and validation
- // functions are not null, go ahead and validate the host object.
- assert( ( m_host->*( m_validator ) )() );
- }
-
-private:
-
- /// Default constructor is not implemented.
- Checker( void );
- /// Copy constructor is not implemented.
- Checker( const Checker & );
- /// Copy-assignment operator is not implemented.
- Checker & operator = ( const Checker & );
-
- /// Pointer to the host object.
- const Host * m_host;
-
- /// Pointer to member function that checks Host object's invariants.
- Validator m_validator;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckStaticForNoThrow
-
- @par Exception Safety Level:
- This exception-checking policy class for StaticChecker asserts if an exception
- exists. Functions can use this to show they provide the no-throw exception
- safety guarantee.
- */
-class CheckStaticForNoThrow
-{
-public:
- static inline void Check( void )
- {
- assert( !::std::uncaught_exception() );
- }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckStaticForNothing
-
- @par Exception Safety Level:
- This exception-checking policy class for StaticChecker does nothing when called.
- Functions can use this to show they might provide the weak exception guarantee.
- The best guarantee such functions can provide is that nothing gets leaked.
- */
-class CheckStaticForNothing
-{
-public:
- static inline void Check( void ) {}
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class StaticChecker
- This class checks if a function provides the no-throw exception safety level
- and if the function violated any invariants. Invariants for stand-alone and
- static functions act as pre-conditions and post-conditions.
-
- @par Usage
- -# Implement a function that checks the invariants associated with a function,
- or with the static data for a class. The function must
- have the signature similar to the Validator type. Something like:
- "static bool Host::StaticIsValid( void );" or "bool IsOkay( void );"
- - The function should return true if everything is okay, but false if
- something is wrong.
- - Or it could assert if anything is wrong.
- -# If the checker is for static functions within a class, declare typedef's
- inside the class declaration like these. Make one typedef for each policy
- you use. I typedef'ed the CheckForNothing policy as CheckInvariants because
- even if a function can't provide the no-throw guarantee, it should still
- make sure that static data remains in a valid state.
- - typedef ::Loki::StaticChecker< ::Loki::CheckForNoThrow > CheckStaticForNoThrow;
- - typedef ::Loki::StaticChecker< ::Loki::CheckForNothing > CheckStaticInvariants;
- -# Construct a checker near the top of each member function - except in the
- validator member function. Pass the address of your validator function into
- the checker's constructor.
- - If the function never throws, then use the CheckForNoThrow policy.
- - Otherwise use the CheckInvariants policy.
- -# Recompile a debug version of your program, run it, and look for which
- assertions failed.
- */
-
-template
-<
- class ExceptionPolicy
->
-class StaticChecker : public ExceptionPolicy
-{
- /// Shorthand for the ExceptionPolicy class.
- typedef ExceptionPolicy Ep;
-
-public:
-
- /// Signature for the validation function.
- typedef bool ( * Validator )( void );
-
- /** The constructor makes sure the host is valid at the time the checker
- was created, thus insuring the host object was not corrupt from the start.
- */
- inline explicit StaticChecker( Validator validator ) :
- Ep(),
- m_validator( validator )
- {
- Check();
- }
-
- /** The destructor checks if any Host invariants failed, and then calls the
- ExceptionPolicy's Check function to determine what to do in case of an
- exception.
- */
- inline ~StaticChecker( void )
- {
- Check();
- Ep::Check();
- }
-
- /** This first checks its own invariants, and then calls the validator
- function to make sure no invariants were broken by the function which
- created this checker. That function can call Check directly to verify
- the data remains valid at any time.
- */
- inline void Check( void ) const
- {
- assert( 0 != this );
- assert( 0 != m_validator );
- // Now that this confirms the pointers to the host and validation
- // functions are not null, go ahead and validate the host object.
- assert( ( m_validator )() );
- }
-
-private:
-
- /// Default constructor is not implemented.
- StaticChecker( void );
- /// Copy constructor is not implemented.
- StaticChecker( const StaticChecker & );
- /// Copy-assignment operator is not implemented.
- StaticChecker & operator = ( const StaticChecker & );
-
- /// Pointer to member function that checks Host object's invariants.
- Validator m_validator;
-
-};
-
-// ----------------------------------------------------------------------------
-
-}; // end namespace Loki
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+//
+// The Loki Library
+// Copyright (c) 2008 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// $Id$
+
+/// @file Checker.h This file provides Loki's Checker facility.
+
+
+// ----------------------------------------------------------------------------
+
+#ifndef LOKI_CHECKER_H_INCLUDED
+#define LOKI_CHECKER_H_INCLUDED
+
+#include <exception> // needed for calls to uncaught_exception.
+#include <assert.h>
+
+
+namespace Loki
+{
+
+/** @par Checker and StaticChecker Overview
+ The Checker and StaticChecker classes have two purposes:
+ - provide a mechanism by which programmers can determine which functions
+ violate class/data invariants,
+ - and determine which exception safety a function provides.
+
+ @par Class & Data Invariants
+ The Checker and StaticChecker utilities define invariants as "expressions that
+ are true for particular data". They uses a function which returns true if all
+ data are valid, and returns false if any datum is invalid. This is called the
+ validator function, and the host class or function provides a pointer to it.
+ The validator could also assert for any invariant which fails rather than
+ return false. If the validator is a static member function, you can use it
+ with checkers in any function, but especially standalone functions and class
+ static functions. If the validator is a non-static member function, you can
+ use it only within non-static member functions.
+
+ @par Exception Safety Levels
+ Years ago, David Abrahams formalized a framework for assessing the exception
+ safety level a function provides. His framework describes three levels of
+ guarantees. Any function which does not provide any of these levels is
+ considered unsafe. Checker and StaticChecker determine a function's safety
+ level through the use of policy classes. Checker's policy classes can show if
+ a function provides any of these three guarantees. (Caveat: Checker can't
+ detect leaks directly by itself, but it can call a validator which does.)
+ StaticChecker's policy classes only provide direct checking for the no-throw
+ and invariant guarantees. With some finesse, a programmer can write a
+ validator for StaticChecker that checks for the Strong guarantee.
+
+ - No-throw guarantee: A function will not throw any exceptions.
+ - Strong guarantee: A function will not change data if an exception occurs.
+ (Also called the no-change guarantee.)
+ - Basic guarantee: A function will not leak resources and data will remain
+ in a valid state if an exception occurs. (Also called a no-leak guarantee.)
+ */
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckForNoThrow
+
+ @par Exception Safety Level:
+ This exception-checking policy class for Checker asserts if an exception exists.
+ Host classes can use this to show that some member functions provide the no-throw
+ exception safety guarantees.
+
+ @par Requirements For Host Class:
+ This policy imposes no requirements on a host class.
+ */
+template < class Host >
+class CheckForNoThrow
+{
+public:
+
+ inline explicit CheckForNoThrow( const Host * ) {}
+
+ inline void Check( const Host * ) const
+ {
+ assert( !::std::uncaught_exception() );
+ }
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckForNoChange
+
+ @par Exception Safety Level:
+ This exception-checking policy class for Checker asserts only if a copy of the
+ host differs from the host object when an exception occurs. Host classes can
+ use this policy to show which member functions provide the strong exception
+ guarantee.
+
+ @par Requirements:
+ This policy requires hosts to provide both the copy-constructor and the
+ equality operator, and is intended for classes with value semantics.
+ equality operator.
+ */
+
+template < class Host >
+class CheckForNoChange
+{
+public:
+
+ inline explicit CheckForNoChange( const Host * host ) :
+ m_compare( *host ) {}
+
+ inline void Check( const Host * host ) const
+ {
+ if ( ::std::uncaught_exception() )
+ {
+ assert( m_compare == *host );
+ }
+ }
+
+private:
+ Host m_compare;
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckForNoChangeOrThrow
+
+ @par Exception Safety Level:
+ This exception-checking policy class for Checker asserts either if a copy of
+ the host differs from the original host object, or if an exception occurs.
+ Host classes can use this policy to show which member functions provide the
+ no-throw exception guarantee, and would never change data anyway.
+
+ @par Requirements For Host Class:
+ This policy requires hosts to provide both the copy-constructor and the
+ equality operator, and is intended for classes with value semantics.
+ */
+
+template < class Host >
+class CheckForNoChangeOrThrow
+{
+public:
+
+ inline explicit CheckForNoChangeOrThrow( const Host * host ) :
+ m_compare( *host ) {}
+
+ inline void Check( const Host * host ) const
+ {
+ assert( !::std::uncaught_exception() );
+ assert( m_compare == *host );
+ }
+
+private:
+ Host m_compare;
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckForEquality
+
+ @par Exception Safety Level:
+ This exception-checking policy class for Checker asserts only if a copy of the
+ host differs from the host object regardless of whether an exception occurs.
+ Host classes can use this policy to show which member functions never change
+ data members, and thereby provide the strong exception safety level by default.
+
+ @par Requirements For Host Class:
+ This policy requires hosts to provide both the copy-constructor and the
+ equality operator, and is intended for classes with value semantics.
+ */
+
+template < class Host >
+class CheckForEquality
+{
+public:
+
+ inline explicit CheckForEquality( const Host * host ) :
+ m_compare( *host ) {}
+
+ inline void Check( const Host * host ) const
+ {
+ assert( m_compare == *host );
+ }
+
+private:
+ Host m_compare;
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckForNothing
+
+ @par Exception Safety Level:
+ This exception-checking policy class for Checker does nothing when called.
+ Host classes can use this to show which member functions provide neither the
+ strong nor no-throw exception guarantees. The best guarantee such functions
+ can provide is that nothing gets leaked.
+
+ @par Requirements For Host Class:
+ This policy imposes no requirements on a host class.
+ */
+
+template < class Host >
+class CheckForNothing
+{
+public:
+ inline explicit CheckForNothing( const Host * ) {}
+ inline void Check( const Host * ) const {}
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class Checker
+ This class checks if a host class violated an invariant. This asserts if any
+ check for an invariant failed. It can also demonstrate which functions provide
+ which exception safety level.
+
+ @par Usage
+ -# Implement a function that checks each class invariant. The function must
+ have the signature similar to the Validator type. Something like:
+ "bool Host::IsValid( void ) const;"
+ - The function should return true if everything is okay, but false if
+ something is wrong.
+ - Or it could assert if anything is wrong.
+ -# Declare some typedef's inside the class declaration like these. Make one
+ typedef for each exception policy you use. I typedef'ed the CheckForNothing
+ policy as CheckInvariants because even if a function can't provide either the
+ no-throw nor the no-change policies, it should still make sure the object
+ remains in a valid state.
+ - typedef ::Loki::Checker< Host, ::Loki::CheckForNoThrow > CheckForNoThrow;
+ - typedef ::Loki::Checker< Host, ::Loki::CheckForNoChange > CheckForNoChange;
+ - typedef ::Loki::Checker< Host, ::Loki::CheckForEquality > CheckForEquality;
+ - typedef ::Loki::Checker< Host, ::Loki::CheckForNothing > CheckInvariants;
+ -# Construct a checker near the top of each member function - except in the
+ validator member function. Pass the this pointer and the address of your
+ validator function into the checker's constructor.
+ - If the function never throws, then use the CheckForNoThrow policy.
+ - If the function never changes any data members, then use CheckForEquality
+ policy.
+ - If the function's normal execution flow changes data, but must make sure
+ data remains unchanged when any exceptions occur, then use the
+ CheckForNoChange policy.
+ - Otherwise use the CheckInvariants policy.
+ -# Recompile a debug version of your program, run it, and look for which
+ assertions failed.
+ */
+
+template
+<
+ class Host,
+ template < class > class ExceptionPolicy
+>
+class Checker : public ExceptionPolicy< Host >
+{
+ /// Shorthand for the ExceptionPolicy class.
+ typedef ExceptionPolicy< Host > Ep;
+
+public:
+
+ /// Signature for the validation function.
+ typedef bool ( Host:: * Validator )( void ) const;
+
+ /** The constructor makes sure the host is valid at the time the checker
+ was created, thus insuring the host object was not corrupt from the start.
+ */
+ inline Checker( const Host * host, Validator validator ) :
+ Ep( host ),
+ m_host( host ),
+ m_validator( validator )
+ {
+ Check();
+ }
+
+ /** The destructor checks if any Host invariants failed, and then calls the
+ ExceptionPolicy's Check function to determine what to do in case of an
+ exception.
+ */
+ inline ~Checker( void )
+ {
+ Check();
+ Ep::Check( m_host );
+ }
+
+ /** This first checks the invariants for Checker, and then calls the
+ validator function for the host to make sure no class invariants
+ were broken by the host within the Host's member function body. The
+ host member function can call Check directly to verify the object
+ remains valid at any time.
+ */
+ inline void Check( void ) const
+ {
+ assert( 0 != this );
+ assert( 0 != m_host );
+ assert( 0 != m_validator );
+ // Now that this confirms the pointers to the host and validation
+ // functions are not null, go ahead and validate the host object.
+ assert( ( m_host->*( m_validator ) )() );
+ }
+
+private:
+
+ /// Default constructor is not implemented.
+ Checker( void );
+ /// Copy constructor is not implemented.
+ Checker( const Checker & );
+ /// Copy-assignment operator is not implemented.
+ Checker & operator = ( const Checker & );
+
+ /// Pointer to the host object.
+ const Host * m_host;
+
+ /// Pointer to member function that checks Host object's invariants.
+ Validator m_validator;
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckStaticForNoThrow
+
+ @par Exception Safety Level:
+ This exception-checking policy class for StaticChecker asserts if an exception
+ exists. Functions can use this to show they provide the no-throw exception
+ safety guarantee.
+ */
+class CheckStaticForNoThrow
+{
+public:
+ static inline void Check( void )
+ {
+ assert( !::std::uncaught_exception() );
+ }
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class CheckStaticForNothing
+
+ @par Exception Safety Level:
+ This exception-checking policy class for StaticChecker does nothing when called.
+ Functions can use this to show they might provide the weak exception guarantee.
+ The best guarantee such functions can provide is that nothing gets leaked.
+ */
+class CheckStaticForNothing
+{
+public:
+ static inline void Check( void ) {}
+};
+
+// ----------------------------------------------------------------------------
+
+/** @class StaticChecker
+ This class checks if a function provides the no-throw exception safety level
+ and if the function violated any invariants. Invariants for stand-alone and
+ static functions act as pre-conditions and post-conditions.
+
+ @par Usage
+ -# Implement a function that checks the invariants associated with a function,
+ or with the static data for a class. The function must
+ have the signature similar to the Validator type. Something like:
+ "static bool Host::StaticIsValid( void );" or "bool IsOkay( void );"
+ - The function should return true if everything is okay, but false if
+ something is wrong.
+ - Or it could assert if anything is wrong.
+ -# If the checker is for static functions within a class, declare typedef's
+ inside the class declaration like these. Make one typedef for each policy
+ you use. I typedef'ed the CheckForNothing policy as CheckInvariants because
+ even if a function can't provide the no-throw guarantee, it should still
+ make sure that static data remains in a valid state.
+ - typedef ::Loki::StaticChecker< ::Loki::CheckForNoThrow > CheckStaticForNoThrow;
+ - typedef ::Loki::StaticChecker< ::Loki::CheckForNothing > CheckStaticInvariants;
+ -# Construct a checker near the top of each member function - except in the
+ validator member function. Pass the address of your validator function into
+ the checker's constructor.
+ - If the function never throws, then use the CheckForNoThrow policy.
+ - Otherwise use the CheckInvariants policy.
+ -# Recompile a debug version of your program, run it, and look for which
+ assertions failed.
+ */
+
+template
+<
+ class ExceptionPolicy
+>
+class StaticChecker : public ExceptionPolicy
+{
+ /// Shorthand for the ExceptionPolicy class.
+ typedef ExceptionPolicy Ep;
+
+public:
+
+ /// Signature for the validation function.
+ typedef bool ( * Validator )( void );
+
+ /** The constructor makes sure the host is valid at the time the checker
+ was created, thus insuring the host object was not corrupt from the start.
+ */
+ inline explicit StaticChecker( Validator validator ) :
+ Ep(),
+ m_validator( validator )
+ {
+ Check();
+ }
+
+ /** The destructor checks if any Host invariants failed, and then calls the
+ ExceptionPolicy's Check function to determine what to do in case of an
+ exception.
+ */
+ inline ~StaticChecker( void )
+ {
+ Check();
+ Ep::Check();
+ }
+
+ /** This first checks its own invariants, and then calls the validator
+ function to make sure no invariants were broken by the function which
+ created this checker. That function can call Check directly to verify
+ the data remains valid at any time.
+ */
+ inline void Check( void ) const
+ {
+ assert( 0 != this );
+ assert( 0 != m_validator );
+ // Now that this confirms the pointers to the host and validation
+ // functions are not null, go ahead and validate the host object.
+ assert( ( m_validator )() );
+ }
+
+private:
+
+ /// Default constructor is not implemented.
+ StaticChecker( void );
+ /// Copy constructor is not implemented.
+ StaticChecker( const StaticChecker & );
+ /// Copy-assignment operator is not implemented.
+ StaticChecker & operator = ( const StaticChecker & );
+
+ /// Pointer to member function that checks Host object's invariants.
+ Validator m_validator;
+
+};
+
+// ----------------------------------------------------------------------------
+
+}; // end namespace Loki
+
+#endif
Property changes on: trunk/include/loki/Checker.h
___________________________________________________________________
Added: svn:eol-style
+ native
Property changes on: trunk/include/loki/LevelMutex.h
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: trunk/include/loki/SPCachedFactory.h
===================================================================
--- trunk/include/loki/SPCachedFactory.h 2008-08-08 22:06:26 UTC (rev 895)
+++ trunk/include/loki/SPCachedFactory.h 2008-08-08 22:20:05 UTC (rev 896)
@@ -1,204 +1,204 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2006 by Guillaume Chatelet
-//
-// Code covered by 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 authors make no representations about the suitability of this software
-// for any purpose. It is provided "as is" without express or implied warranty.
-//
-// This code DOES NOT accompany the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
-// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// $Id$
-
-#ifndef SPCACHEDFACTORY_H_
-#define SPCACHEDFACTORY_H_
-
-/**
- * This file is intented to be used if you want a CachedFactory with
- * a SmartPointer encapsulation policy.
- * It as been defined in a separate file because of the many introduced
- * dependencies (SmartPtr.h would depend on Functor.h and CachedFactory.h
- * would depend on SmartPtr.h). By defining another header you pay for those
- * extra dependencies only if you need it.
- *
- * This file defines FunctionStorage a new SmartPointer storage policy and
- * SmartPointer a new CachedFactory encapsulation policy.
- */
-
-#include <loki/Functor.h>
-#include <loki/SmartPtr.h>
-#include <loki/CachedFactory.h>
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class FunctionStorage
-///
-/// \ingroup SmartPointerStorageGroup
-/// \brief Implementation of the StoragePolicy used by SmartPtr.
-///
-/// This storage policy is used by SmartPointer CachedFactory's encapsulation
-/// policy. It's purpose is to call a Functor instead of deleting the
-/// underlying pointee object. You have to set the callback functor by calling
-/// SetCallBackFunction(const FunctorType &functor).
-///
-/// Unfortunately, the functor argument is not a reference to the SmartPtr but
-/// a void *. Making functor argument a reference to the pointer would require
-/// the FunctionStorage template to know the full definition of the SmartPtr.
-////////////////////////////////////////////////////////////////////////////////
-
- template <class T>
- class FunctionStorage
- {
- public:
- /// the type of the pointee_ object
- typedef T* StoredType;
- /// type used to declare OwnershipPolicy type.
- typedef T* InitPointerType;
- /// type returned by operator->
- typedef T* PointerType;
- /// type returned by operator*
- typedef T& ReferenceType;
- /// type of the Functor to set
- typedef Functor< void , Seq< void* > > FunctorType;
-
- FunctionStorage() : pointee_(Default()), functor_()
- {}
-
- // The storage policy doesn't initialize the stored pointer
- // which will be initialized by the OwnershipPolicy's Clone fn
- FunctionStorage(const FunctionStorage& rsh) : pointee_(0), functor_(rsh.functor_)
- {}
-
- template <class U>
- FunctionStorage(const FunctionStorage<U>& rsh) : pointee_(0), functor_(rsh.functor_)
- {}
-
- FunctionStorage(const StoredType& p) : pointee_(p), functor_() {}
-
- PointerType operator->() const { return pointee_; }
-
- ReferenceType operator*() const { return *pointee_; }
-
- void Swap(FunctionStorage& rhs)
- {
- std::swap(pointee_, rhs.pointee_);
- std::swap(functor_, rhs.functor_);
- }
-
- /// Sets the callback function to call. You have to specify it or
- /// the smartPtr will throw a bad_function_call exception.
- void SetCallBackFunction(const FunctorType &functor)
- {
- functor_ = functor;
- }
-
- // Accessors
- template <class F>
- friend typename FunctionStorage<F>::PointerType GetImpl(const FunctionStorage<F>& sp);
-
- template <class F>
- friend const typename FunctionStorage<F>::StoredType& GetImplRef(const FunctionStorage<F>& sp);
-
- template <class F>
- friend typename FunctionStorage<F>::StoredType& GetImplRef(FunctionStorage<F>& sp);
-
- protected:
- // Destroys the data stored
- // (Destruction might be taken over by the OwnershipPolicy)
- void Destroy()
- {
- functor_(this);
- }
-
- // Default value to initialize the pointer
- static StoredType Default()
- { return 0; }
-
- private:
- // Data
- StoredType pointee_;
- FunctorType functor_;
- };
-
- template <class T>
- inline typename FunctionStorage<T>::PointerType GetImpl(const FunctionStorage<T>& sp)
- { return sp.pointee_; }
-
- template <class T>
- ...
[truncated message content] |
