4.1

1 files changed, 0 insertions, 644 deletions

diff --git a/shared/loki/SmallObj.h b/shared/loki/SmallObj.h
deleted file mode 100644
index 10624cc2..00000000
--- a/shared/loki/SmallObj.h
+++ /dev/null
@@ -1,644 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2001 by Andrei Alexandrescu
-// This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
-//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
-// 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 or Addison-Wesley Longman make no representations about the
-//     suitability of this software for any purpose. It is provided "as is"
-//     without express or implied warranty.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_SMALLOBJ_INC_
-#define LOKI_SMALLOBJ_INC_
-
-// $Id: SmallObj.h 806 2007-02-03 00:01:52Z rich_sposato $
-
-
-#include "LokiExport.h"
-#include "Threads.h"
-#include "Singleton.h"
-#include <cstddef>
-#include <new> // needed for std::nothrow_t parameter.
-
-#ifndef LOKI_DEFAULT_CHUNK_SIZE
-#define LOKI_DEFAULT_CHUNK_SIZE 4096
-#endif
-
-#ifndef LOKI_MAX_SMALL_OBJECT_SIZE
-#define LOKI_MAX_SMALL_OBJECT_SIZE 256
-#endif
-
-#ifndef LOKI_DEFAULT_OBJECT_ALIGNMENT
-#define LOKI_DEFAULT_OBJECT_ALIGNMENT 4
-#endif
-
-#ifndef LOKI_DEFAULT_SMALLOBJ_LIFETIME
-#define LOKI_DEFAULT_SMALLOBJ_LIFETIME ::Loki::LongevityLifetime::DieAsSmallObjectParent
-#endif
-
-#if defined(LOKI_SMALL_OBJECT_USE_NEW_ARRAY) && defined(_MSC_VER)
-#pragma message("Don't define LOKI_SMALL_OBJECT_USE_NEW_ARRAY when using a Microsoft compiler to prevent memory leaks.")
-#pragma message("now calling '#undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY'")
-#undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY
-#endif
-
-///  \defgroup  SmallObjectGroup Small objects
-///
-///  \defgroup  SmallObjectGroupInternal Internals
-///  \ingroup   SmallObjectGroup
-
-namespace Loki
-{
-namespace LongevityLifetime
-{
-/** @struct DieAsSmallObjectParent
-    @ingroup SmallObjectGroup
-    Lifetime policy to manage lifetime dependencies of
-    SmallObject base and child classes.
-    The Base class should have this lifetime
-*/
-template <class T>
-struct DieAsSmallObjectParent  : DieLast<T> {};
-
-/** @struct DieAsSmallObjectChild
-    @ingroup SmallObjectGroup
-    Lifetime policy to manage lifetime dependencies of
-    SmallObject base and child classes.
-    The Child class should have this lifetime
-*/
-template <class T>
-struct DieAsSmallObjectChild  : DieDirectlyBeforeLast<T> {};
-
-}
-
-class FixedAllocator;
-
-/** @class SmallObjAllocator
-    @ingroup SmallObjectGroupInternal
- Manages pool of fixed-size allocators.
- Designed to be a non-templated base class of AllocatorSingleton so that
- implementation details can be safely hidden in the source code file.
- */
-class LOKI_EXPORT SmallObjAllocator
-{
-protected:
-    /** The only available constructor needs certain parameters in order to
-     initialize all the FixedAllocator's.  This throws only if
-     @param pageSize # of bytes in a page of memory.
-     @param maxObjectSize Max # of bytes which this may allocate.
-     @param objectAlignSize # of bytes between alignment boundaries.
-     */
-    SmallObjAllocator( std::size_t pageSize, std::size_t maxObjectSize,
-                       std::size_t objectAlignSize );
-
-    /** Destructor releases all blocks, all Chunks, and FixedAllocator's.
-     Any outstanding blocks are unavailable, and should not be used after
-     this destructor is called.  The destructor is deliberately non-virtual
-     because it is protected, not public.
-     */
-    ~SmallObjAllocator( void );
-
-public:
-    /** Allocates a block of memory of requested size.  Complexity is often
-     constant-time, but might be O(C) where C is the number of Chunks in a
-     FixedAllocator.
-
-     @par Exception Safety Level
-     Provides either strong-exception safety, or no-throw exception-safety
-     level depending upon doThrow parameter.  The reason it provides two
-     levels of exception safety is because it is used by both the nothrow
-     and throwing new operators.  The underlying implementation will never
-     throw of its own accord, but this can decide to throw if it does not
-     allocate.  The only exception it should emit is std::bad_alloc.
-
-     @par Allocation Failure
-     If it does not allocate, it will call TrimExcessMemory and attempt to
-     allocate again, before it decides to throw or return NULL.  Many
-     allocators loop through several new_handler functions, and terminate
-     if they can not allocate, but not this one.  It only makes one attempt
-     using its own implementation of the new_handler, and then returns NULL
-     or throws so that the program can decide what to do at a higher level.
-     (Side note: Even though the C++ Standard allows allocators and
-     new_handlers to terminate if they fail, the Loki allocator does not do
-     that since that policy is not polite to a host program.)
-
-     @param size # of bytes needed for allocation.
-     @param doThrow True if this should throw if unable to allocate, false
-      if it should provide no-throw exception safety level.
-     @return NULL if nothing allocated and doThrow is false.  Else the
-      pointer to an available block of memory.
-     */
-    void* Allocate( std::size_t size, bool doThrow );
-
-    /** Deallocates a block of memory at a given place and of a specific
-    size.  Complexity is almost always constant-time, and is O(C) only if
-    it has to search for which Chunk deallocates.  This never throws.
-     */
-    void Deallocate( void* p, std::size_t size );
-
-    /** Deallocates a block of memory at a given place but of unknown size
-    size.  Complexity is O(F + C) where F is the count of FixedAllocator's
-    in the pool, and C is the number of Chunks in all FixedAllocator's.  This
-    does not throw exceptions.  This overloaded version of Deallocate is
-    called by the nothow delete operator - which is called when the nothrow
-    new operator is used, but a constructor throws an exception.
-     */
-    void Deallocate( void* p );
-
-    /// Returns max # of bytes which this can allocate.
-    inline std::size_t GetMaxObjectSize() const
-    { return maxSmallObjectSize_; }
-
-    /// Returns # of bytes between allocation boundaries.
-    inline std::size_t GetAlignment() const { return objectAlignSize_; }
-
-    /** Releases empty Chunks from memory.  Complexity is O(F + C) where F
-    is the count of FixedAllocator's in the pool, and C is the number of
-    Chunks in all FixedAllocator's.  This will never throw.  This is called
-    by AllocatorSingleto::ClearExtraMemory, the new_handler function for
-    Loki's allocator, and is called internally when an allocation fails.
-    @return True if any memory released, or false if none released.
-     */
-    bool TrimExcessMemory( void );
-
-    /** Returns true if anything in implementation is corrupt.  Complexity
-     is O(F + C + B) where F is the count of FixedAllocator's in the pool,
-     C is the number of Chunks in all FixedAllocator's, and B is the number
-     of blocks in all Chunks.  If it determines any data is corrupted, this
-     will return true in release version, but assert in debug version at
-     the line where it detects the corrupted data.  If it does not detect
-     any corrupted data, it returns false.
-     */
-    bool IsCorrupt( void ) const;
-
-private:
-    /// Default-constructor is not implemented.
-    SmallObjAllocator( void );
-    /// Copy-constructor is not implemented.
-    SmallObjAllocator( const SmallObjAllocator& );
-    /// Copy-assignment operator is not implemented.
-    SmallObjAllocator& operator = ( const SmallObjAllocator& );
-
-    /// Pointer to array of fixed-size allocators.
-    Loki::FixedAllocator* pool_;
-
-    /// Largest object size supported by allocators.
-    const std::size_t maxSmallObjectSize_;
-
-    /// Size of alignment boundaries.
-    const std::size_t objectAlignSize_;
-};
-
-
-/** @class AllocatorSingleton
-    @ingroup SmallObjectGroupInternal
- This template class is derived from
- SmallObjAllocator in order to pass template arguments into it, and still
- have a default constructor for the singleton.  Each instance is a unique
- combination of all the template parameters, and hence is singleton only
- with respect to those parameters.  The template parameters have default
- values and the class has typedefs identical to both SmallObject and
- SmallValueObject so that this class can be used directly instead of going
- through SmallObject or SmallValueObject.  That design feature allows
- clients to use the new_handler without having the name of the new_handler
- function show up in classes derived from SmallObject or SmallValueObject.
- Thus, the only functions in the allocator which show up in SmallObject or
- SmallValueObject inheritance hierarchies are the new and delete
- operators.
-*/
-template
-<
-template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
-         std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
-         std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
-         std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
-         template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
-         class MutexPolicy = LOKI_DEFAULT_MUTEX
-         >
-class AllocatorSingleton : public SmallObjAllocator
-{
-public:
-
-    /// Defines type of allocator.
-    typedef AllocatorSingleton < ThreadingModel, chunkSize,
-            maxSmallObjectSize, objectAlignSize, LifetimePolicy > MyAllocator;
-
-    /// Defines type for thread-safety locking mechanism.
-    typedef ThreadingModel< MyAllocator, MutexPolicy > MyThreadingModel;
-
-    /// Defines singleton made from allocator.
-    typedef Loki::SingletonHolder < MyAllocator, Loki::CreateStatic,
-            LifetimePolicy, ThreadingModel > MyAllocatorSingleton;
-
-    /// Returns reference to the singleton.
-    inline static AllocatorSingleton& Instance( void )
-    {
-        return MyAllocatorSingleton::Instance();
-    }
-
-    /// The default constructor is not meant to be called directly.
-    inline AllocatorSingleton() :
-        SmallObjAllocator( chunkSize, maxSmallObjectSize, objectAlignSize )
-    {}
-
-    /// The destructor is not meant to be called directly.
-    inline ~AllocatorSingleton( void ) {}
-
-    /** Clears any excess memory used by the allocator.  Complexity is
-     O(F + C) where F is the count of FixedAllocator's in the pool, and C
-     is the number of Chunks in all FixedAllocator's.  This never throws.
-     @note This function can be used as a new_handler when Loki and other
-     memory allocators can no longer allocate.  Although the C++ Standard
-     allows new_handler functions to terminate the program when they can
-     not release any memory, this will not do so.
-     */
-    static void ClearExtraMemory( void );
-
-    /** Returns true if anything in implementation is corrupt.  Complexity
-     is O(F + C + B) where F is the count of FixedAllocator's in the pool,
-     C is the number of Chunks in all FixedAllocator's, and B is the number
-     of blocks in all Chunks.  If it determines any data is corrupted, this
-     will return true in release version, but assert in debug version at
-     the line where it detects the corrupted data.  If it does not detect
-     any corrupted data, it returns false.
-     */
-    static bool IsCorrupted( void );
-
-private:
-    /// Copy-constructor is not implemented.
-    AllocatorSingleton( const AllocatorSingleton& );
-    /// Copy-assignment operator is not implemented.
-    AllocatorSingleton& operator = ( const AllocatorSingleton& );
-};
-
-template
-<
-template <class, class> class T,
-         std::size_t C,
-         std::size_t M,
-         std::size_t O,
-         template <class> class L,
-         class X
-         >
-void AllocatorSingleton< T, C, M, O, L, X >::ClearExtraMemory( void )
-{
-    typename MyThreadingModel::Lock lock;
-    (void)lock; // get rid of warning
-    Instance().TrimExcessMemory();
-}
-
-template
-<
-template <class, class> class T,
-         std::size_t C,
-         std::size_t M,
-         std::size_t O,
-         template <class> class L,
-         class X
-         >
-bool AllocatorSingleton< T, C, M, O, L, X >::IsCorrupted( void )
-{
-    typename MyThreadingModel::Lock lock;
-    (void)lock; // get rid of warning
-    return Instance().IsCorrupt();
-}
-
-/** This standalone function provides the longevity level for Small-Object
- Allocators which use the Loki::SingletonWithLongevity policy.  The
- SingletonWithLongevity class can find this function through argument-
- dependent lookup.
-
- @par Longevity Levels
- No Small-Object Allocator depends on any other Small-Object allocator, so
- this does not need to calculate dependency levels among allocators, and
- it returns just a constant.  All allocators must live longer than the
- objects which use the allocators, it must return a longevity level higher
- than any such object.
- */
-template
-<
-template <class, class> class T,
-         std::size_t C,
-         std::size_t M,
-         std::size_t O,
-         template <class> class L,
-         class X
-         >
-inline unsigned int GetLongevity(
-    AllocatorSingleton< T, C, M, O, L, X > * )
-{
-    // Returns highest possible value.
-    return 0xFFFFFFFF;
-}
-
-
-/** @class SmallObjectBase
-    @ingroup SmallObjectGroup
- Base class for small object allocation classes.
- The shared implementation of the new and delete operators are here instead
- of being duplicated in both SmallObject or SmallValueObject, later just
- called Small-Objects.  This class is not meant to be used directly by clients,
- or derived from by clients. Class has no data members so compilers can
- use Empty-Base-Optimization.
-
- @par ThreadingModel
- This class doesn't support ObjectLevelLockable policy for ThreadingModel.
- The allocator is a singleton, so a per-instance mutex is not necessary.
- Nor is using ObjectLevelLockable recommended with SingletonHolder since
- the SingletonHolder::MakeInstance function requires a mutex that exists
- prior to when the object is created - which is not possible if the mutex
- is inside the object, such as required for ObjectLevelLockable.  If you
- attempt to use ObjectLevelLockable, the compiler will emit errors because
- it can't use the default constructor in ObjectLevelLockable.  If you need
- a thread-safe allocator, use the ClassLevelLockable policy.
-
- @par Lifetime Policy
-
- The SmallObjectBase template needs a lifetime policy because it owns
- a singleton of SmallObjAllocator which does all the low level functions.
- When using a Small-Object in combination with the SingletonHolder template
- you have to choose two lifetimes, that of the Small-Object and that of
- the singleton. The rule is: The Small-Object lifetime must be greater than
- the lifetime of the singleton hosting the Small-Object. Violating this rule
- results in a crash on exit, because the hosting singleton tries to delete
- the Small-Object which is then already destroyed.
-
- The lifetime policies recommended for use with Small-Objects hosted
- by a SingletonHolder template are
-     - LongevityLifetime::DieAsSmallObjectParent / LongevityLifetime::DieAsSmallObjectChild
-     - SingletonWithLongevity
-     - FollowIntoDeath (not supported by MSVC 7.1)
-     - NoDestroy
-
- The default lifetime of Small-Objects is
- LongevityLifetime::DieAsSmallObjectParent to
- insure that memory is not released before a object with the lifetime
- LongevityLifetime::DieAsSmallObjectChild using that
- memory is destroyed. The LongevityLifetime::DieAsSmallObjectParent
- lifetime has the highest possible value of a SetLongevity lifetime, so
- you can use it in combination with your own lifetime not having also
- the highest possible value.
-
- The DefaultLifetime and PhoenixSingleton policies are *not* recommended
- since they can cause the allocator to be destroyed and release memory
- for singletons hosting a object which inherit from either SmallObject
- or SmallValueObject.
-
- @par Lifetime usage
-
-    - LongevityLifetime: The Small-Object has
-      LongevityLifetime::DieAsSmallObjectParent policy and the Singleton
-      hosting the Small-Object has LongevityLifetime::DieAsSmallObjectChild.
-      The child lifetime has a hard coded SetLongevity lifetime which is
-      shorter than the lifetime of the parent, thus the child dies
-      before the parent.
-
-    - Both Small-Object and Singleton use SingletonWithLongevity policy.
-      The longevity level for the singleton must be lower than that for the
-      Small-Object. This is why the AllocatorSingleton's GetLongevity function
-      returns the highest value.
-
-    - FollowIntoDeath lifetime: The Small-Object has
-      FollowIntoDeath::With<LIFETIME>::AsMasterLiftime
-      policy and the Singleton has
-      FollowIntoDeath::AfterMaster<MASTERSINGLETON>::IsDestroyed policy,
-      where you could choose the LIFETIME.
-
-    - Both Small-Object and Singleton use NoDestroy policy.
-      Since neither is ever destroyed, the destruction order does not matter.
-      Note: you will get memory leaks!
-
-    - The Small-Object has NoDestroy policy but the Singleton has
-      SingletonWithLongevity policy. Note: you will get memory leaks!
-
-
- You should *not* use NoDestroy for the singleton, and then use
- SingletonWithLongevity for the Small-Object.
-
- @par Examples:
-
- - test/SmallObj/SmallSingleton.cpp
- - test/Singleton/Dependencies.cpp
- */
-template
-<
-template <class, class> class ThreadingModel,
-         std::size_t chunkSize,
-         std::size_t maxSmallObjectSize,
-         std::size_t objectAlignSize,
-         template <class> class LifetimePolicy,
-         class MutexPolicy
-         >
-class SmallObjectBase
-{
-
-#if (LOKI_MAX_SMALL_OBJECT_SIZE != 0) && (LOKI_DEFAULT_CHUNK_SIZE != 0) && (LOKI_DEFAULT_OBJECT_ALIGNMENT != 0)
-
-public:
-    /// Defines type of allocator singleton, must be public
-    /// to handle singleton lifetime dependencies.
-    typedef AllocatorSingleton < ThreadingModel, chunkSize,
-            maxSmallObjectSize, objectAlignSize, LifetimePolicy > ObjAllocatorSingleton;
-
-private:
-
-    /// Defines type for thread-safety locking mechanism.
-    typedef ThreadingModel< ObjAllocatorSingleton, MutexPolicy > MyThreadingModel;
-
-    /// Use singleton defined in AllocatorSingleton.
-    typedef typename ObjAllocatorSingleton::MyAllocatorSingleton MyAllocatorSingleton;
-
-public:
-
-    /// Throwing single-object new throws bad_alloc when allocation fails.
-#ifdef _MSC_VER
-    /// @note MSVC complains about non-empty exception specification lists.
-    static void* operator new ( std::size_t size )
-#else
-    static void* operator new ( std::size_t size ) throw ( std::bad_alloc )
-#endif
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        return MyAllocatorSingleton::Instance().Allocate( size, true );
-    }
-
-    /// Non-throwing single-object new returns NULL if allocation fails.
-    static void* operator new ( std::size_t size, const std::nothrow_t& ) throw ()
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        return MyAllocatorSingleton::Instance().Allocate( size, false );
-    }
-
-    /// Placement single-object new merely calls global placement new.
-    inline static void* operator new ( std::size_t size, void* place )
-    {
-        return ::operator new( size, place );
-    }
-
-    /// Single-object delete.
-    static void operator delete ( void* p, std::size_t size ) throw ()
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        MyAllocatorSingleton::Instance().Deallocate( p, size );
-    }
-
-    /** Non-throwing single-object delete is only called when nothrow
-     new operator is used, and the constructor throws an exception.
-     */
-    static void operator delete ( void* p, const std::nothrow_t& ) throw()
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        MyAllocatorSingleton::Instance().Deallocate( p );
-    }
-
-    /// Placement single-object delete merely calls global placement delete.
-    inline static void operator delete ( void* p, void* place )
-    {
-        ::operator delete ( p, place );
-    }
-
-#ifdef LOKI_SMALL_OBJECT_USE_NEW_ARRAY
-
-    /// Throwing array-object new throws bad_alloc when allocation fails.
-#ifdef _MSC_VER
-    /// @note MSVC complains about non-empty exception specification lists.
-    static void* operator new [] ( std::size_t size )
-#else
-    static void* operator new [] ( std::size_t size )
-    throw ( std::bad_alloc )
-#endif
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        return MyAllocatorSingleton::Instance().Allocate( size, true );
-    }
-
-    /// Non-throwing array-object new returns NULL if allocation fails.
-    static void* operator new [] ( std::size_t size,
-                                   const std::nothrow_t& ) throw ()
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        return MyAllocatorSingleton::Instance().Allocate( size, false );
-    }
-
-    /// Placement array-object new merely calls global placement new.
-    inline static void* operator new [] ( std::size_t size, void* place )
-    {
-        return ::operator new( size, place );
-    }
-
-    /// Array-object delete.
-    static void operator delete [] ( void* p, std::size_t size ) throw ()
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        MyAllocatorSingleton::Instance().Deallocate( p, size );
-    }
-
-    /** Non-throwing array-object delete is only called when nothrow
-     new operator is used, and the constructor throws an exception.
-     */
-    static void operator delete [] ( void* p,
-                                     const std::nothrow_t& ) throw()
-    {
-        typename MyThreadingModel::Lock lock;
-        (void)lock; // get rid of warning
-        MyAllocatorSingleton::Instance().Deallocate( p );
-    }
-
-    /// Placement array-object delete merely calls global placement delete.
-    inline static void operator delete [] ( void* p, void* place )
-    {
-        ::operator delete ( p, place );
-    }
-#endif  // #if use new array functions.
-
-#endif  // #if default template parameters are not zero
-
-protected:
-    inline SmallObjectBase( void ) {}
-    inline SmallObjectBase( const SmallObjectBase& ) {}
-    inline SmallObjectBase& operator = ( const SmallObjectBase& )
-    { return *this; }
-    inline ~SmallObjectBase() {}
-}; // end class SmallObjectBase
-
-
-/** @class SmallObject
-    @ingroup SmallObjectGroup
- SmallObject Base class for polymorphic small objects, offers fast
- allocations & deallocations.  Destructor is virtual and public.  Default
- constructor is trivial.   Copy-constructor and copy-assignment operator are
- not implemented since polymorphic classes almost always disable those
- operations.  Class has no data members so compilers can use
- Empty-Base-Optimization.
- */
-template
-<
-template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
-         std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
-         std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
-         std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
-         template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
-         class MutexPolicy = LOKI_DEFAULT_MUTEX
-         >
-class SmallObject : public SmallObjectBase < ThreadingModel, chunkSize,
-    maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
-{
-
-public:
-    virtual ~SmallObject() {}
-protected:
-    inline SmallObject( void ) {}
-
-private:
-    /// Copy-constructor is not implemented.
-    SmallObject( const SmallObject& );
-    /// Copy-assignment operator is not implemented.
-    SmallObject& operator = ( const SmallObject& );
-}; // end class SmallObject
-
-
-/** @class SmallValueObject
-    @ingroup SmallObjectGroup
- SmallValueObject Base class for small objects with value-type
- semantics - offers fast allocations & deallocations.  Destructor is
- non-virtual, inline, and protected to prevent unintentional destruction
- through base class.  Default constructor is trivial.   Copy-constructor
- and copy-assignment operator are trivial since value-types almost always
- need those operations.  Class has no data members so compilers can use
- Empty-Base-Optimization.
- */
-template
-<
-template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
-         std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE,
-         std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
-         std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
-         template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
-         class MutexPolicy = LOKI_DEFAULT_MUTEX
-         >
-class SmallValueObject : public SmallObjectBase < ThreadingModel, chunkSize,
-    maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
-{
-protected:
-    inline SmallValueObject( void ) {}
-    inline SmallValueObject( const SmallValueObject& ) {}
-    inline SmallValueObject& operator = ( const SmallValueObject& )
-    { return *this; }
-    inline ~SmallValueObject() {}
-}; // end class SmallValueObject
-
-} // namespace Loki
-
-#endif // end file guardian
-