4.1

44 files changed, 0 insertions, 22831 deletions

diff --git a/shared/loki/AbstractFactory.h b/shared/loki/AbstractFactory.h
deleted file mode 100644
index 615652bd..00000000
--- a/shared/loki/AbstractFactory.h
+++ /dev/null
@@ -1,185 +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_ABSTRACTFACTORY_INC_
-#define LOKI_ABSTRACTFACTORY_INC_
-
-// $Id: AbstractFactory.h 771 2006-10-27 18:05:03Z clitte_bbt $
-
-
-#include "Typelist.h"
-#include "Sequence.h"
-#include "TypeManip.h"
-#include "HierarchyGenerators.h"
-
-#include <cassert>
-
-/**
- * \defgroup	FactoriesGroup Factories
- * \defgroup	AbstractFactoryGroup Abstract Factory
- * \ingroup		FactoriesGroup
- * \brief		Implements an abstract object factory.
- */
-
-/**
- * \class		AbstractFactory
- * \ingroup		AbstractFactoryGroup
- * \brief		Implements an abstract object factory.
- */
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-// class template AbstractFactoryUnit
-// The building block of an Abstract Factory
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-class AbstractFactoryUnit
-{
-public:
-    virtual T* DoCreate(Type2Type<T>) = 0;
-    virtual ~AbstractFactoryUnit() {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template AbstractFactory
-// Defines an Abstract Factory interface starting from a typelist
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class TList,
-      template <class> class Unit = AbstractFactoryUnit
-      >
-class AbstractFactory : public GenScatterHierarchy<TList, Unit>
-{
-public:
-    typedef TList ProductList;
-
-    template <class T> T* Create()
-    {
-        Unit<T>& unit = *this;
-        return unit.DoCreate(Type2Type<T>());
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template OpNewFactoryUnit
-// Creates an object by invoking the new operator
-////////////////////////////////////////////////////////////////////////////////
-
-template <class ConcreteProduct, class Base>
-class OpNewFactoryUnit : public Base
-{
-    typedef typename Base::ProductList BaseProductList;
-
-protected:
-    typedef typename BaseProductList::Tail ProductList;
-
-public:
-    typedef typename BaseProductList::Head AbstractProduct;
-    ConcreteProduct* DoCreate(Type2Type<AbstractProduct>)
-    {
-        return new ConcreteProduct;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template PrototypeFactoryUnit
-// Creates an object by cloning a prototype
-// There is a difference between the implementation herein and the one described
-//     in the book: GetPrototype and SetPrototype use the helper friend
-//     functions DoGetPrototype and DoSetPrototype. The friend functions avoid
-//     name hiding issues. Plus, GetPrototype takes a reference to pointer
-//     instead of returning the pointer by value.
-////////////////////////////////////////////////////////////////////////////////
-
-template <class ConcreteProduct, class Base>
-class PrototypeFactoryUnit : public Base
-{
-    typedef typename Base::ProductList BaseProductList;
-
-protected:
-    typedef typename BaseProductList::Tail ProductList;
-
-public:
-    typedef typename BaseProductList::Head AbstractProduct;
-
-    PrototypeFactoryUnit(AbstractProduct* p = 0)
-        : pPrototype_(p)
-    {}
-
-    template <class CP, class Base1>
-    friend void DoGetPrototype(const PrototypeFactoryUnit<CP, Base1>& me,
-                               typename Base1::ProductList::Head*& pPrototype);
-
-    template <class CP, class Base1>
-    friend void DoSetPrototype(PrototypeFactoryUnit<CP, Base1>& me,
-                               typename Base1::ProductList::Head* pObj);
-
-    template <class U>
-    void GetPrototype(U*& p)
-    { return DoGetPrototype(*this, p); }
-
-    template <class U>
-    void SetPrototype(U* pObj)
-    { DoSetPrototype(*this, pObj); }
-
-    AbstractProduct* DoCreate(Type2Type<AbstractProduct>)
-    {
-        assert(pPrototype_);
-        return pPrototype_->Clone();
-    }
-
-private:
-    AbstractProduct* pPrototype_;
-};
-
-template <class CP, class Base>
-inline void DoGetPrototype(const PrototypeFactoryUnit<CP, Base>& me,
-                           typename Base::ProductList::Head*& pPrototype)
-{ pPrototype = me.pPrototype_; }
-
-template <class CP, class Base>
-inline void DoSetPrototype(PrototypeFactoryUnit<CP, Base>& me,
-                           typename Base::ProductList::Head* pObj)
-{ me.pPrototype_ = pObj; }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template ConcreteFactory
-// Implements an AbstractFactory interface
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class AbstractFact,
-      template <class, class> class Creator = OpNewFactoryUnit,
-      class TList = typename AbstractFact::ProductList
-      >
-class ConcreteFactory
-    : public GenLinearHierarchy <
-    typename TL::Reverse<TList>::Result, Creator, AbstractFact >
-{
-public:
-    typedef typename AbstractFact::ProductList ProductList;
-    typedef TList ConcreteProductList;
-};
-
-} // namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/Allocator.h b/shared/loki/Allocator.h
deleted file mode 100644
index 39b63912..00000000
--- a/shared/loki/Allocator.h
+++ /dev/null
@@ -1,153 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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: Allocator.h 896 2008-08-08 22:20:05Z syntheticpp $
-
-// 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
diff --git a/shared/loki/AssocVector.h b/shared/loki/AssocVector.h
deleted file mode 100644
index 7f259281..00000000
--- a/shared/loki/AssocVector.h
+++ /dev/null
@@ -1,358 +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_ASSOCVECTOR_INC_
-#define LOKI_ASSOCVECTOR_INC_
-
-// $Id: AssocVector.h 765 2006-10-18 13:55:32Z syntheticpp $
-
-
-#include <algorithm>
-#include <functional>
-#include <vector>
-#include <utility>
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template AssocVectorCompare
-// Used by AssocVector
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template <class Value, class C>
-class AssocVectorCompare : public C
-{
-    typedef std::pair<typename C::first_argument_type, Value>
-    Data;
-    typedef typename C::first_argument_type first_argument_type;
-
-public:
-    AssocVectorCompare()
-    {}
-
-    AssocVectorCompare(const C& src) : C(src)
-    {}
-
-    bool operator()(const first_argument_type& lhs,
-                    const first_argument_type& rhs) const
-    { return C::operator()(lhs, rhs); }
-
-    bool operator()(const Data& lhs, const Data& rhs) const
-    { return operator()(lhs.first, rhs.first); }
-
-    bool operator()(const Data& lhs,
-                    const first_argument_type& rhs) const
-    { return operator()(lhs.first, rhs); }
-
-    bool operator()(const first_argument_type& lhs,
-                    const Data& rhs) const
-    { return operator()(lhs, rhs.first); }
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class template AssocVector
-// An associative vector built as a syntactic drop-in replacement for std::map
-// BEWARE: AssocVector doesn't respect all map's guarantees, the most important
-//     being:
-// * iterators are invalidated by insert and erase operations
-// * the complexity of insert/erase is O(N) not O(log N)
-// * value_type is std::pair<K, V> not std::pair<const K, V>
-// * iterators are random
-////////////////////////////////////////////////////////////////////////////////
-
-
-template
-<
-class K,
-      class V,
-      class C = std::less<K>,
-      class A = std::allocator< std::pair<K, V> >
-      >
-class AssocVector
-    : private std::vector< std::pair<K, V>, A >
-    , private Private::AssocVectorCompare<V, C>
-{
-    typedef std::vector<std::pair<K, V>, A> Base;
-    typedef Private::AssocVectorCompare<V, C> MyCompare;
-
-public:
-    typedef K key_type;
-    typedef V mapped_type;
-    typedef typename Base::value_type value_type;
-
-    typedef C key_compare;
-    typedef A allocator_type;
-    typedef typename A::reference reference;
-    typedef typename A::const_reference const_reference;
-    typedef typename Base::iterator iterator;
-    typedef typename Base::const_iterator const_iterator;
-    typedef typename Base::size_type size_type;
-    typedef typename Base::difference_type difference_type;
-    typedef typename A::pointer pointer;
-    typedef typename A::const_pointer const_pointer;
-    typedef typename Base::reverse_iterator reverse_iterator;
-    typedef typename Base::const_reverse_iterator const_reverse_iterator;
-
-    class value_compare
-        : public std::binary_function<value_type, value_type, bool>
-        , private key_compare
-    {
-        friend class AssocVector;
-
-    protected:
-        value_compare(key_compare pred) : key_compare(pred)
-        {}
-
-    public:
-        bool operator()(const value_type& lhs, const value_type& rhs) const
-        { return key_compare::operator()(lhs.first, rhs.first); }
-    };
-
-    // 23.3.1.1 construct/copy/destroy
-
-    explicit AssocVector(const key_compare& comp = key_compare(),
-                         const A& alloc = A())
-        : Base(alloc), MyCompare(comp)
-    {}
-
-    template <class InputIterator>
-    AssocVector(InputIterator first, InputIterator last,
-                const key_compare& comp = key_compare(),
-                const A& alloc = A())
-        : Base(first, last, alloc), MyCompare(comp)
-    {
-        MyCompare& me = *this;
-        std::sort(begin(), end(), me);
-    }
-
-    AssocVector& operator=(const AssocVector& rhs)
-    {
-        AssocVector(rhs).swap(*this);
-        return *this;
-    }
-
-    // iterators:
-    // The following are here because MWCW gets 'using' wrong
-    iterator begin() { return Base::begin(); }
-    const_iterator begin() const { return Base::begin(); }
-    iterator end() { return Base::end(); }
-    const_iterator end() const { return Base::end(); }
-    reverse_iterator rbegin() { return Base::rbegin(); }
-    const_reverse_iterator rbegin() const { return Base::rbegin(); }
-    reverse_iterator rend() { return Base::rend(); }
-    const_reverse_iterator rend() const { return Base::rend(); }
-
-    // capacity:
-    bool empty() const { return Base::empty(); }
-    size_type size() const { return Base::size(); }
-    size_type max_size() { return Base::max_size(); }
-
-    // 23.3.1.2 element access:
-    mapped_type& operator[](const key_type& key)
-    { return insert(value_type(key, mapped_type())).first->second; }
-
-    // modifiers:
-    std::pair<iterator, bool> insert(const value_type& val)
-    {
-        bool found(true);
-        iterator i(lower_bound(val.first));
-
-        if (i == end() || this->operator()(val.first, i->first))
-        {
-            i = Base::insert(i, val);
-            found = false;
-        }
-        return std::make_pair(i, !found);
-    }
-    //Section [23.1.2], Table 69
-    //http://developer.apple.com/documentation/DeveloperTools/gcc-3.3/libstdc++/23_containers/howto.html#4
-    iterator insert(iterator pos, const value_type& val)
-    {
-        if ( (pos == begin() || this->operator()(*(pos - 1), val)) &&
-             (pos == end()    || this->operator()(val, *pos)) )
-        {
-            return Base::insert(pos, val);
-        }
-        return insert(val).first;
-    }
-
-    template <class InputIterator>
-    void insert(InputIterator first, InputIterator last)
-    { for (; first != last; ++first) insert(*first); }
-
-    void erase(iterator pos)
-    { Base::erase(pos); }
-
-    size_type erase(const key_type& k)
-    {
-        iterator i(find(k));
-        if (i == end()) return 0;
-        erase(i);
-        return 1;
-    }
-
-    void erase(iterator first, iterator last)
-    { Base::erase(first, last); }
-
-    void swap(AssocVector& other)
-    {
-        Base::swap(other);
-        MyCompare& me = *this;
-        MyCompare& rhs = other;
-        std::swap(me, rhs);
-    }
-
-    void clear()
-    { Base::clear(); }
-
-    // observers:
-    key_compare key_comp() const
-    { return *this; }
-
-    value_compare value_comp() const
-    {
-        const key_compare& comp = *this;
-        return value_compare(comp);
-    }
-
-    // 23.3.1.3 map operations:
-    iterator find(const key_type& k)
-    {
-        iterator i(lower_bound(k));
-        if (i != end() && this->operator()(k, i->first))
-        {
-            i = end();
-        }
-        return i;
-    }
-
-    const_iterator find(const key_type& k) const
-    {
-        const_iterator i(lower_bound(k));
-        if (i != end() && this->operator()(k, i->first))
-        {
-            i = end();
-        }
-        return i;
-    }
-
-    size_type count(const key_type& k) const
-    { return find(k) != end(); }
-
-    iterator lower_bound(const key_type& k)
-    {
-        MyCompare& me = *this;
-        return std::lower_bound(begin(), end(), k, me);
-    }
-
-    const_iterator lower_bound(const key_type& k) const
-    {
-        const MyCompare& me = *this;
-        return std::lower_bound(begin(), end(), k, me);
-    }
-
-    iterator upper_bound(const key_type& k)
-    {
-        MyCompare& me = *this;
-        return std::upper_bound(begin(), end(), k, me);
-    }
-
-    const_iterator upper_bound(const key_type& k) const
-    {
-        const MyCompare& me = *this;
-        return std::upper_bound(begin(), end(), k, me);
-    }
-
-    std::pair<iterator, iterator> equal_range(const key_type& k)
-    {
-        MyCompare& me = *this;
-        return std::equal_range(begin(), end(), k, me);
-    }
-
-    std::pair<const_iterator, const_iterator> equal_range(
-        const key_type& k) const
-    {
-        const MyCompare& me = *this;
-        return std::equal_range(begin(), end(), k, me);
-    }
-
-    template <class K1, class V1, class C1, class A1>
-    friend bool operator==(const AssocVector<K1, V1, C1, A1>& lhs,
-                           const AssocVector<K1, V1, C1, A1>& rhs);
-
-    bool operator<(const AssocVector& rhs) const
-    {
-        const Base& me = *this;
-        const Base& yo = rhs;
-        return me < yo;
-    }
-
-    template <class K1, class V1, class C1, class A1>
-    friend bool operator!=(const AssocVector<K1, V1, C1, A1>& lhs,
-                           const AssocVector<K1, V1, C1, A1>& rhs);
-
-    template <class K1, class V1, class C1, class A1>
-    friend bool operator>(const AssocVector<K1, V1, C1, A1>& lhs,
-                          const AssocVector<K1, V1, C1, A1>& rhs);
-
-    template <class K1, class V1, class C1, class A1>
-    friend bool operator>=(const AssocVector<K1, V1, C1, A1>& lhs,
-                           const AssocVector<K1, V1, C1, A1>& rhs);
-
-    template <class K1, class V1, class C1, class A1>
-    friend bool operator<=(const AssocVector<K1, V1, C1, A1>& lhs,
-                           const AssocVector<K1, V1, C1, A1>& rhs);
-};
-
-template <class K, class V, class C, class A>
-inline bool operator==(const AssocVector<K, V, C, A>& lhs,
-                       const AssocVector<K, V, C, A>& rhs)
-{
-    const std::vector<std::pair<K, V>, A>& me = lhs;
-    return me == rhs;
-}
-
-template <class K, class V, class C, class A>
-inline bool operator!=(const AssocVector<K, V, C, A>& lhs,
-                       const AssocVector<K, V, C, A>& rhs)
-{ return !(lhs == rhs); }
-
-template <class K, class V, class C, class A>
-inline bool operator>(const AssocVector<K, V, C, A>& lhs,
-                      const AssocVector<K, V, C, A>& rhs)
-{ return rhs < lhs; }
-
-template <class K, class V, class C, class A>
-inline bool operator>=(const AssocVector<K, V, C, A>& lhs,
-                       const AssocVector<K, V, C, A>& rhs)
-{ return !(lhs < rhs); }
-
-template <class K, class V, class C, class A>
-inline bool operator<=(const AssocVector<K, V, C, A>& lhs,
-                       const AssocVector<K, V, C, A>& rhs)
-{ return !(rhs < lhs); }
-
-
-// specialized algorithms:
-template <class K, class V, class C, class A>
-void swap(AssocVector<K, V, C, A>& lhs, AssocVector<K, V, C, A>& rhs)
-{ lhs.swap(rhs); }
-
-} // namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/CHANGES b/shared/loki/CHANGES
deleted file mode 100644
index 67f6505e..00000000
--- a/shared/loki/CHANGES
+++ /dev/null
@@ -1,446 +0,0 @@
-_____________________________________
-
-Version 0.1.7
-January 2009
-_____________________________________
-
-General:
-    - Fixed makefiles for GNU/kFreeBSD, GNU/hurd. (lf)
-    - Fixed build errors with gcc 4.3 pre-release. (lf)
-    - Fixed compiler error that occurs when using 64 bit pointers. (rs)
-    - Added support for Code::Blocks and MSVC 9. (rs, pk)
-    - Added more unit tests (rs)
-    - Several other bug fixes (rs, pk)
-
-Checker:
-    - Added for this release. (rs)
-    - Added test project. (rs)
-
-CheckReturn:
-    - Added for this release. (rs, pk)
-    - Added test project. (rs + pk)
-
-flex_string:
-    - Fixed bugs in several functions and storage policies. (aa, rs, jfg)
-
-LevelMutex:
-    - Added for this release. (rs)
-    - Added unit tests for LevelMutex. (rs)
-
-SafeBits:
-    - Added for this release. (rs, fp)
-    - Added unit tests for SafeBits. (rs, fp)
-
-SmartPtr:
-    - Fixed double-delete race condition. (rs)
-
-StrongPtr:
-    - Fixed destructor so cleanup is only done once. (rs)
-    - Fixed test by using class level locking. (lf)
-
-Threads:
-    - Add possibility to enable recursive mutex support for pthread (pk)
-    - Added more atomic functions.  (rs)
-
-Type Traits:
-    - Added 64 bit support. (cg)
-
-CVS commits by:
-	Andrei Alexandrescu (aa)
-	Guillaume Chatelet (cg)
-	Lukas Fittl (lf)
-	Peter Kümmel (pk)
-	Rich Sposato (rs)
-
-Contributions by:
-	Andrei Alexandrescu (aa)
-	Jean-Francois Bastien (jfb)
-	Guillaume Chatelet (cg)
-	Lukas Fittl (lf)
-	Fedor Pikus (fp)
-	Peter Kümmel (pk)
-	Rich Sposato (rs)
-
-_____________________________________
-
-Version 0.1.6
-February 25, 2007
-_____________________________________
-
-General:
-    - CacheFactory added by Guillaume Chatelet
-    - Factory documentation improved by Guillaume Chatelet
-    - migrated to subversion (pk)
-    - Mac linker errors fixed (lf)
-    - Makefiles can now be called from sub directories (lf)
-    - Makefiles know includes and recompile if they are changed (linux, macosx) (lf)
-    - Build all tests except SingletonDll with the static library (linux, macosx) (lf)
-    - use standard conforming naming, SUN's compiler needs it (pk)
-    - add Loki:: to LOKI_ macros
-    - several bug fixes.
-
-AbstractFactory:
-    - remove injected friends. (thanks to Sigoure Benoit, pk)
-   
-AssocVector:
-    - remove injected friends. (thanks to Sigoure Benoit, pk)
-    
-LockingPtr:
-    - constructor added which gets a std::pair of pointers 
-      to the object and the mutex (pk)
-    
-Pimpl:
-    - ImplT/PimplT/RimplT renamed to a more readable version: ImplOf (pk)
-
-Register:
-    - also produce a informative LOKI_CHECK_CLASS_IN_LIST error message with GCC (pk)
-
-SafeFormat:
-    - add writing to ostream, by Tom Browder (pk)
-    - add unsigned long version for Windows, (Thanks to ShenLei, pk)
-    
-Sequence:
-    - Also compiles with Aix
-    - switched to recursive implementation
-    
-Singleton
-    - example: move instantiation to the source file 
-      fixes linker error with gcc 4.0.1 on the mac, 
-      (Thanks to Idar Tollefsen and Sam Miller, pk)
-    - 64 bit linker error fixed (lf)
-
-SmallObj:
-    - compiler errors on SUN fixed (pk)    
-    - more documentation (rs)
-    - more tests (rs)
-    - AIX fixed, (thanks to Dieter Rosch, pk)
-  
-StrongPtr:
-    - Added typedef so LockableTwoRefCounts uses thread-safe allocator. (rs)
-    - AIX fixed, (thanks to Dieter Rosch, pk)
-    - linker error when using threads fixed (pk)
-  
-Threads:
-    - reentrance support added to the pthread mutex (Thanks to Shen Lei, pk)
-      
-
-CVS commits by Guillaume Chatelet (gc), Lukas Fittl (lf), Peter Kümmel (pk), Rich Sposato (rs)
-      
-
-_____________________________________
-
-Version 0.1.5
-June 19, 2006
-_____________________________________
-
-General:
-    - operator== added to Functor, initiated by Eric Beyeler (pk)
-    - new Strong/Weak smart pointer added. (rs)
-    - loki.spec (Thanks to Regis Desgroppes and Andreas Scherer, pk)
-    - build shared lib also on mac osx (Thanks to Sam Miller, lf)
-    - added MinGW .dev files for the library (rs)
-    - some makefile improvements (Thanks to Sam Miller, lf)
-    - adding an XCode build project (kx)
-    
-    
-flex_string:
-    - compare bug fixed in flex_string_shell.h (Thanks to David A. Capello, pk)
-    
-Function:
-    - test is doesn't need boost any more (pk)
-    - wrong default parameter fixed (pk)
-    
-OrderedStatic:
-    - undef all min/max macros (Thanks to Shen Lei, pk)
-    
-Singleton:
-    - Singleton<> moved into correct namespace (Thanks to Sam Miller, pk)
-    
-SmartPtr:
-    - patch for RedHat 9: undefined uintptr_t (Thanks to Regis Desgroppes, pk)
-    - more tests (rs)
-    - bugs 1452805 and 1451835 fixed (rs)
-    - addded HeapStorage policy as mentioned in Feature Request 1441024 (rs)
-    - added MinGW test project for SmartPtr (rs)
-    
-
-CVS commits by Rich Sposato (rs), Lukas Fittl (lf),
-Christopher Knox (kx), and Peter Kümmel (pk)
-
-
-
-_____________________________________
-
-Version 0.1.4
-March 8, 2006
-_____________________________________
-
-General:
-    - helper templates for Pimpl/Rimpl implementations added (pk)
-    - improved Makefiles (lf)
-    - improved make.msvc.bat files (pk)
-    - cvs LOG keywords added (rs)
-    - removed old c style casts (lf)
-    - more warning enabled on gcc (lf)
-    - new header added: ConstPolicy.h (rs,pk)
-    - new header added: RefToValue.h (rs,pk)
-    - standard RPM specification file for integrated installation 
-      on OpenSUSE Linux added (Thanks to Andreas Scherer, pk)
-    - using Loki as shared library is now possible (pk,lf)
-    - Register.h added (pk)
-    
-    
-Function:
-    - guard including (pk)
-    - test stsic functions (pk)
-    - test LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT  (pk)
-    
-Functor:
-    - Added explicit call to base copy-constructor (rs)  
-    - Changed base class from SmallObject to SmallValueObject. (Thanks to Sam Miller, rs)
-    - add possibility to disable inheritance from SmallValueObject: LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT (pk)
-    
-ScopeGuard:
-    - naming conflict with SmartPtr removed (rs,pk)
-    - ByRef moved to RefByVale (rs,pk)
-  
-Singleton:
-    - support of allocators with a standard interface added (Thanks to Miguel A. Figueroa-Villanueva, pk)
-    - convenience template Singleton added for shared libraries (Thanks to Marcus Lindblom, pk)
-    - example added which shows how to use Singletons with shared libraries added (Thanks to Marcus Lindblom, pk)
-
-SmartPtr:
-    - supports propagating constness by additional policy (rs,pk)
-    - ArrayStorage policy added (Thanks to Sam Miller, pk)
-    - fix in RefCounted for Mac OSX gcc 4.0.0 (Thanks to Sam Miller, pk)
-    - RefCounted ported to 64 bit (pk)
-    - add mutex policy (pk)
-    - new test code (rs)
-    - RecjectNullStrict const member function added (Thanks to Sam Miller, pk)
-    - Moved a monolithic RefLinkedBase class from header file to new source file. (rs)
-    - ByRef moved to RefToVale (rs,pk)
-    - Fixed bug 1425890.  Last SmartPtr in linked chain NULLs its prev & next
-      pointers to prevent infinite recursion.  Added asserts. (rs)
-    - Bug fix: infinite recursion in SmartPtr destructor (rs)
-    
-LockingPtr:
-    - wrong return types fixed (rs)
-    - add mutex policy (rs,pk)
-    - supports now propagating constness (pk,rs)
-    - macro switch LOKI_DEFAULT_CONSTNESS added for propagating constness (pk)
-    - multi threaded example added 
-    
-SafeFormat:
-    - definition moved to src/SafeFormat.cpp, it's now part of the library
-    
-Singleton:
-    - add mutex policy (pk)
-
-SmallObj:
-    - add mutex policy (pk)
-    - Added check for memory leak inside destructor. (Thanks to Kwak Jae Hyuk, rs)
-
-Threads:
-    - Mutex added (rs,pk)
-    - use Loki::Mutex instead of win32/posix mutexes in threading classes (rs,pk)
-
-
-CVS commits by Rich Sposato (rs), Lukas Fittl (lf)
-and Peter Kümmel (pk)
-
-
-
-_____________________________________
-
-Version 0.1.3
-January 9, 2006
-_____________________________________
-
-General:
-    - LockPtr added (rs)
-    - ScopeGuard added (pk,rs)
-    - improved Makefiles (lf,pk)
-    - several gcc fixes and removed warnings by Lukas Fittl (lf)
-    - tested on 64-bit Linux (pk)
-    - MS Visual C++ 2005 project files added (pk)
-    - now also the ms toolkit 2003 generates a library (pk)
-
-OrderedStatic:
-    - point operator added (pk)
-
-SafeFormat:
-    - moved into namespace Loki (pk)
-    - 64 bit problems fixed (Thanks to Zak Kipling)
-    - ported to 64-bit Windows, not tested (pk)
-    - Printf/SPrintfing of std::strings added (pk)
-    - all warnings removed gcc and msvc (pk)
-    - use snprintf for "%p"
-    - test program: speed comparison added (pk)
-
-SmallObject:
-    - added functions to check for memory corruption (rs)
-    - more fine tuning (rs)
-    - warnings removed (pk)
-    
-TypeTraits:
-    - bug 1388477 fixed (pk)
-    
-flex_string:
-    - fixed compare bug by updating (Thanks to Justin Matthews, pk)
-    - fixed seg faults on Linux and Windows (pk)
-    - improved error reporting of the test program (pk)
-    
-SmartPtr:
-    - make object level locking possible (Thanks to Ryan Smith, pk)
-    
-BindFirst:
-    - store Functor arguments by value (bug 1383566) (pk)
-    
-Visitor:
-    - add support for visiting constant member functions (pk)
-    - example added (pk)
-    
-ScopeGuard:
-    - example added (pk)
-    
-    
-CVS commits by Rich Sposato (rs), Lukas Fittl (lf)
-and Peter Kümmel (pk)
-
-
-_____________________________________
-
-Version 0.1.2
-November 16, 2005
-_____________________________________
-
-General:
-    - changes to compile under Linux (Thanks to David Lawrence, pk)
-    - more doxygen documentation, modules added (rs, pk)
-
-SmartPtr:
-    - three year old bugs 626407 and 541846 fixed: 
-      Assertion with SmartPtr<T, LinkedRef> (pk)
-      SmartPtr and COMRefCounted (Thanks to James Mclaren, pk)
-
-Typelists:
-    - it's now possible to completely disable the 
-      LOKI_TYPELIST_  macros (pk)
-    - marco definitions moved to a separate file (pk)
-
-Factory:
-    - Factory now protects its private data (pk)
-    - new method to get the keys: 
-      std::vector<IdType> RegisteredIds() (pk)
-    
-Functor:
-    - TR1 methods added: empty() and clear() (pk)
-    
-Function:
-    - boost/TR1 like Function template with 
-      improved member function pointer usage (pk)
-    - tested with boost's function_test.cpp 
-
-Sequence:
-    - small change in usage: use e.g. Functor<void,Seq<bool &> > 
-      instead of Functor<void,Seq<bool &>::Type > 
-
-SmallObjects:
-    - comparison of new/malloc/std::allocator/boost::object_pool (rs, pk)
-    - #undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY when using a ms compiler (pk)
-    - new lifetimes in namespace LongevityLifetime to manage dependencies: 
-      DieAsSmallObjectParent and DieAsSmallObjectClient (pk)
-    - no memory leaks when using SmallObjects (pk)
-    - new default lifetime is DieAsSmallObjectParent (pk)
-
-Threads:
-    - threads on POSIX systems (Thanks to Ilya Volvovski ,pk)
-    - small regression test program (pk)
-
-Singleton:
-    - new lifetime: FollowIntoDeath (pk)
-    - new namespace LongevityLifetime with lifetimes DieLast, DieFirst,
-      DieDirectlyBeforeLast, and function SingletonFixedLongevity (pk)
-    - new implementation for SetLongevity (pk)
-    - example programs (pk)
-    
-    
-CVS commits by Rich Sposato (rs) and Peter Kümmel (pk)
-
-
-
-_____________________________________
-
-Version 0.1.1
-October 17, 2005
-_____________________________________
-
-Singleton: 
-    - wrong ordered longevity fixed (Thanks to Kwak Jae Hyuk, pk)
-    - less warnings with msvc (Thanks to  John Bates, pk)
-    - new policy, DeletableSingleton, from Curtis Krauskopf, 
-      see also CUJ article 'Creating Dynamic Singletons & the Loki Library',(pk)
-    
-AssocVector:
-    - hinted insert does now preserve ordering (Thanks to Christopher Twigg, pk)
-    - additional 'hinted insert' test for Regression test by Christopher Twigg (pk)
-    - fix name look up (Thanks to Markus Werle, pk)
-
-SmallObj:
-     - several improvements (rs)
-     - more documentation (rs)
-     - improved SmallBench (rs, pk)
-
-Longevity:
-    - example added (pk)
-    - additional example similar to that of the book, by Curtis Krauskopf (pk)
-    
-OrderedStatic:
-    - a proposal to solve the 'static initialization ordered fiasco' problem (pk)
-
-Sequence:
-    - a proposal to replace the LOKI_TYPELIST_XX macros with a template implementation (pk)
-    - e.g.: LOKI_TYPELIST_1(int) becomes Seq<int>::Type 
-      inspired by the functional language OPAL (pk)
-            
-            
-CVS commits by Rich Sposato (rs) and Peter Kümmel (pk)
-
-
-
-_____________________________________
-
-Version 0.1.0
-September 29, 2005
-_____________________________________
-
-General:
-    - version numbering started 
-    - new directory structure 
-    - Andrei's yasli, flex_string, and SafePrint added  (pk)
-    - all macros now in the LOKI "namespace", e.g.: 
-      TYPLELIST_1 -> LOKI_TYPELIST_1  (rs, pk)
-    - Makefiles added: tested with gcc 3.4 (mingw, cygwin),
-      msvc 8.0, and the toolkit  (pk)
-    - added some documentation (rs)
-    - several bug fixes (pk)
-    - added a cvs-list to sourceforge where you can see all changes (pk)
-    
-SmallObjects:
-    - new implementation (rs)
-    
-Factory:
-    - works now with parameters (pk)
-    - regression test added (Thanks to Kalle Rutanen, pk)
-    
-TypeTraits: 
-    - isMemberPointer, isFunction added (Thanks to Kalle Rutanen, pk)
-    - regression test added (Thanks to Kalle Rutanen, pk)
-    
-Threading: 
-    - new macros for better thread support (win32):
-      LOKI_CLASS_LEVEL_THREADING and LOKI_OBJECT_LEVEL_THREADING (pk)
-
-
-CVS commits by Rich Sposato (rs) and Peter Kümmel (pk)
-
diff --git a/shared/loki/CachedFactory.h b/shared/loki/CachedFactory.h
deleted file mode 100644
index dc5a76ae..00000000
--- a/shared/loki/CachedFactory.h
+++ /dev/null
@@ -1,1179 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-//
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_CACHEDFACTORY_INC_
-#define LOKI_CACHEDFACTORY_INC_
-
-// $Id: CachedFactory.h 950 2009-01-26 19:45:54Z syntheticpp $
-
-#include <functional>
-#include <algorithm>
-#include <iostream>
-#include <vector>
-#include <iterator>
-#include <map>
-#include <cassert>
-#include <loki/Key.h>
-
-#ifdef DO_EXTRA_LOKI_TESTS
-#define D( x ) x
-#else
-#define D( x ) ;
-#endif
-
-#if defined(_MSC_VER)  || defined(__CYGWIN__)
-#include <time.h>
-#endif
-
-/**
- * \defgroup	FactoriesGroup Factories
- * \defgroup	CachedFactoryGroup Cached Factory
- * \ingroup		FactoriesGroup
- * \brief		CachedFactory provides an extension of a Factory with caching
- * support.
- *
- * Once used objects are returned to the CachedFactory that manages its
- * destruction.
- * If your code uses lots of "long to construct/destruct objects" using the
- * CachedFactory will surely speedup the execution.
- */
-namespace Loki
-{
-/**
- * \defgroup	EncapsulationPolicyCachedFactoryGroup	Encapsulation policies
- * \ingroup	CachedFactoryGroup
- * \brief	Defines how the object is returned to the client
- */
-/**
- * \class	SimplePointer
- * \ingroup	EncapsulationPolicyCachedFactoryGroup
- * \brief	No encaspulation : returns the pointer
- *
- * This implementation does not make any encapsulation.
- * It simply returns the object's pointer.
- */
-template<class AbstractProduct>
-class SimplePointer
-{
-protected:
-    typedef AbstractProduct* ProductReturn;
-    ProductReturn encapsulate(AbstractProduct* pProduct)
-    {
-        return pProduct;
-    }
-
-    AbstractProduct* release(ProductReturn& pProduct)
-    {
-        AbstractProduct* pPointer(pProduct);
-        pProduct = NULL;
-        return pPointer;
-    }
-    const char* name() {return "pointer";}
-};
-
-/**
- * \defgroup	CreationPolicyCachedFactoryGroup		Creation policies
- * \ingroup		CachedFactoryGroup
- * \brief		Defines a way to limit the creation operation.
- *
- * For instance one may want to be alerted (Exception) when
- * - Cache has created a more than X object within the last x seconds
- * - Cache creation rate has increased dramatically
- * .
- * which may result from bad caching strategy, or critical overload
- */
-/**
- * \class	NeverCreate
- * \ingroup	CreationPolicyCachedFactoryGroup
- * \brief	Never allows creation. Testing purposes only.
- *
- * Using this policy will throw an exception.
- */
-class NeverCreate
-{
-protected:
-    struct Exception : public std::exception
-    {
-        const char* what() const throw() { return "NeverFetch Policy : No Fetching allowed"; }
-    };
-
-    bool canCreate()
-    {
-        throw Exception();
-    }
-
-    void onCreate() {}
-    void onDestroy() {}
-    const char* name() {return "never";}
-};
-
-/**
- * \class		AlwaysCreate
- * \ingroup	CreationPolicyCachedFactoryGroup
- * \brief		Always allows creation.
- *
- * Doesn't limit the creation in any way
- */
-class AlwaysCreate
-{
-protected:
-    bool canCreate()
-    {
-        return true;
-    }
-
-    void onCreate() {}
-    void onDestroy() {}
-    const char* name() {return "always";}
-};
-
-
-/**
- * \class	RateLimitedCreation
- * \ingroup	CreationPolicyCachedFactoryGroup
- * \brief	Limit in rate.
- *
- * This implementation will prevent from Creating more than maxCreation objects
- * within byTime ms by throwing an exception.
- * Could be usefull to detect prevent loads (http connection for instance).
- * Use the setRate method to set the rate parameters.
- * default is 10 objects in a second.
- */
-// !! CAUTION !!
-// The std::clock() function is not quite precise
-// under linux this policy might not work.
-// TODO : get a better implementation (platform dependant)
-class RateLimitedCreation
-{
-private:
-    typedef std::vector< clock_t > Vector;
-    Vector m_vTimes;
-    unsigned maxCreation;
-    clock_t timeValidity;
-    clock_t lastUpdate;
-
-    void cleanVector()
-    {
-        using namespace std;
-        clock_t currentTime = clock();
-        D( cout << "currentTime = " << currentTime << endl; )
-        D( cout << "currentTime - lastUpdate = " << currentTime - lastUpdate << endl; )
-        if (currentTime - lastUpdate > timeValidity)
-        {
-            m_vTimes.clear();
-            D( cout << " is less than time validity " << timeValidity; )
-            D( cout << " so clearing vector" << endl; )
-        }
-        else
-        {
-            D( cout << "Cleaning time less than " << currentTime - timeValidity << endl; )
-            D( displayVector(); )
-            Vector::iterator newEnd = remove_if(m_vTimes.begin(), m_vTimes.end(), bind2nd(less<clock_t>(), currentTime - timeValidity));
-            // this rearrangement might be costly, consider optimization
-            // by calling cleanVector in less used onCreate function
-            // ... although it may not be correct
-            m_vTimes.erase(newEnd, m_vTimes.end());
-            D( displayVector(); )
-        }
-        lastUpdate = currentTime;
-    }
-#ifdef DO_EXTRA_LOKI_TESTS
-    void displayVector()
-    {
-        std::cout << "Vector : ";
-        copy(m_vTimes.begin(), m_vTimes.end(), std::ostream_iterator<clock_t>(std::cout, " "));
-        std::cout << std::endl;
-    }
-#endif
-protected:
-    RateLimitedCreation() : maxCreation(10), timeValidity(CLOCKS_PER_SEC), lastUpdate(clock())
-    {}
-
-    struct Exception : public std::exception
-    {
-        const char* what() const throw() { return "RateLimitedCreation Policy : Exceeded the authorized creation rate"; }
-    };
-
-    bool canCreate()
-    {
-        cleanVector();
-        if (m_vTimes.size() > maxCreation)
-            throw Exception();
-        else
-            return true;
-    }
-
-    void onCreate()
-    {
-        m_vTimes.push_back(clock());
-    }
-
-    void onDestroy()
-    {
-    }
-    const char* name() {return "rate limited";}
-public:
-    // set the creation rate
-    // No more than maxCreation within byTime milliseconds
-    void setRate(unsigned maxCreation, unsigned byTime)
-    {
-        assert(byTime > 0);
-        this->maxCreation = maxCreation;
-        this->timeValidity = static_cast<clock_t>(byTime * CLOCKS_PER_SEC / 1000);
-        D( std::cout << "Setting no more than " << maxCreation << " creation within " << this->timeValidity << " ms" << std::endl; )
-    }
-};
-
-/**
- * \class	AmountLimitedCreation
- * \ingroup	CreationPolicyCachedFactoryGroup
- * \brief	Limit by number of objects
- *
- * This implementation will prevent from Creating more than maxCreation objects
- * within byTime ms by calling eviction policy.
- * Use the setRate method to set the rate parameters.
- * default is 10 objects.
- */
-class AmountLimitedCreation
-{
-private:
-    unsigned maxCreation;
-    unsigned created;
-
-protected:
-    AmountLimitedCreation() : maxCreation(10), created(0)
-    {}
-
-    bool canCreate()
-    {
-        return !(created >= maxCreation);
-    }
-
-    void onCreate()
-    {
-        ++created;
-    }
-
-    void onDestroy()
-    {
-        --created;
-    }
-    const char* name() {return "amount limited";}
-public:
-    // set the creation max amount
-    void setMaxCreation(unsigned maxCreation)
-    {
-        assert(maxCreation > 0);
-        this->maxCreation = maxCreation;
-        D( std::cout << "Setting no more than " << maxCreation << " creation" << std::endl; )
-    }
-};
-
-/**
- * \defgroup	EvictionPolicyCachedFactoryGroup		Eviction policies
- * \ingroup	CachedFactoryGroup
- * \brief	Gathers informations about the stored objects and choose a
- * candidate for eviction.
- */
-
-class EvictionException : public std::exception
-{
-public:
-    const char* what() const throw() { return "Eviction Policy : trying to make room but no objects are available"; }
-};
-
-// The following class is intented to provide helpers to sort
-// the container that will hold an eviction score
-template
-<
-typename ST, // Score type
-         typename DT // Data type
-         >
-class EvictionHelper
-{
-protected:
-    typedef typename std::map< DT, ST >			HitMap;
-    typedef typename HitMap::iterator			HitMapItr;
-private:
-    typedef std::pair< ST, DT >					SwappedPair;
-    typedef std::multimap< ST, DT >				SwappedHitMap;
-    typedef	typename SwappedHitMap::iterator	SwappedHitMapItr;
-protected:
-    HitMap										m_mHitCount;
-
-    // This function sorts the map according to the score
-    // and returns the lower bound of the sorted container
-    DT&	getLowerBound()
-    {
-        assert(!m_mHitCount.empty());
-        // inserting the swapped pair into a multimap
-        SwappedHitMap copyMap;
-        for (HitMapItr itr = m_mHitCount.begin(); itr != m_mHitCount.end(); ++itr)
-            copyMap.insert(SwappedPair((*itr).second, (*itr).first));
-        if ((*copyMap.rbegin()).first == 0) // the higher score is 0 ...
-            throw EvictionException(); // there is no key evict
-        return (*copyMap.begin()).second;
-    }
-};
-
-/**
- * \class	EvictLRU
- * \ingroup	EvictionPolicyCachedFactoryGroup
- * \brief	Evicts least accessed objects first.
- *
- * Implementation of the Least recent used algorithm as
- * described in http://en.wikipedia.org/wiki/Page_replacement_algorithms .
- *
- * WARNING : If an object is heavily fetched
- * (more than ULONG_MAX = UINT_MAX = 4294967295U)
- * it could unfortunately be removed from the cache.
- */
-template
-<
-typename DT, // Data Type (AbstractProduct*)
-         typename ST = unsigned // default data type to use as Score Type
-         >
-class EvictLRU : public EvictionHelper< ST , DT >
-{
-private:
-    typedef EvictionHelper< ST , DT >	EH;
-protected:
-
-    virtual ~EvictLRU() {}
-
-    // OnStore initialize the counter for the new key
-    // If the key already exists, the counter is reseted
-    void onCreate(const DT& key)
-    {
-        EH::m_mHitCount[key] = 0;
-    }
-
-    void onFetch(const DT&)
-    {
-    }
-
-    // onRelease increments the hit counter associated with the object
-    void onRelease(const DT& key)
-    {
-        ++(EH::m_mHitCount[key]);
-    }
-
-    void onDestroy(const DT& key)
-    {
-        EH::m_mHitCount.erase(key);
-    }
-
-    // this function is implemented in Cache and redirected
-    // to the Storage Policy
-    virtual void remove(DT const key) = 0;
-
-    // LRU Eviction policy
-    void evict()
-    {
-        remove(EH::getLowerBound());
-    }
-    const char* name() {return "LRU";}
-};
-
-/**
- * \class	EvictAging
- * \ingroup	EvictionPolicyCachedFactoryGroup
- * \brief	LRU aware of the time span of use
- *
- * Implementation of the Aging algorithm as
- * described in http://en.wikipedia.org/wiki/Page_replacement_algorithms .
- *
- * This method is much more costly than evict LRU so
- * if you need extreme performance consider switching to EvictLRU
- */
-template
-<
-typename DT, // Data Type (AbstractProduct*)
-         typename ST = unsigned // default data type to use as Score Type
-         >
-class EvictAging : public EvictionHelper< ST, DT >
-{
-private:
-    EvictAging(const EvictAging&);
-    EvictAging& operator=(const EvictAging&);
-    typedef EvictionHelper< ST, DT >		       		EH;
-    typedef typename EH::HitMap						HitMap;
-    typedef typename EH::HitMapItr					HitMapItr;
-
-    // update the counter
-    template<class T> struct updateCounter : public std::unary_function<T, void>
-    {
-        updateCounter(const DT& key): key_(key) {}
-        void operator()(T x)
-        {
-            x.second = (x.first == key_ ? (x.second >> 1) | ( 1 << ((sizeof(ST) - 1) * 8) ) : x.second >> 1);
-            D( std::cout <<  x.second << std::endl; )
-        }
-        const DT& key_;
-        updateCounter(const updateCounter& rhs) : key_(rhs.key_) {}
-    private:
-        updateCounter& operator=(const updateCounter& rhs);
-    };
-protected:
-    EvictAging() {}
-    virtual ~EvictAging() {}
-
-    // OnStore initialize the counter for the new key
-    // If the key already exists, the counter is reseted
-    void onCreate(const DT& key)
-    {
-        EH::m_mHitCount[key] = 0;
-    }
-
-    void onFetch(const DT&) {}
-
-    // onRelease increments the hit counter associated with the object
-    // Updating every counters by iterating over the map
-    // If the key is the key of the fetched object :
-    //  the counter is shifted to the right and it's MSB is set to 1
-    // else
-    //  the counter is shifted to the left
-    void onRelease(const DT& key)
-    {
-        std::for_each(EH::m_mHitCount.begin(), EH::m_mHitCount.end(), updateCounter< typename HitMap::value_type >(key));
-    }
-
-    void onDestroy(const DT& key)
-    {
-        EH::m_mHitCount.erase(key);
-    }
-
-    // this function is implemented in Cache and redirected
-    // to the Storage Policy
-    virtual void remove(DT const key) = 0;
-
-    // LRU with Aging Eviction policy
-    void evict()
-    {
-        remove(EH::getLowerBound());
-    }
-    const char* name() {return "LRU with aging";}
-};
-
-/**
- * \class	EvictRandom
- * \ingroup	EvictionPolicyCachedFactoryGroup
- * \brief	Evicts a random object
- *
- * Implementation of the Random algorithm as
- * described in http://en.wikipedia.org/wiki/Page_replacement_algorithms .
- */
-template
-<
-typename DT, // Data Type (AbstractProduct*)
-         typename ST = void // Score Type not used by this policy
-         >
-class EvictRandom
-{
-private:
-    std::vector< DT >	m_vKeys;
-    typedef typename std::vector< DT >::size_type	size_type;
-    typedef typename std::vector< DT >::iterator		iterator;
-
-protected:
-
-    virtual ~EvictRandom() {}
-
-    void onCreate(const DT&)
-    {
-    }
-
-    void onFetch(const DT& )
-    {
-    }
-
-    void onRelease(const DT& key)
-    {
-        m_vKeys.push_back(key);
-    }
-
-    void onDestroy(const DT& key)
-    {
-        using namespace std;
-        m_vKeys.erase(remove_if(m_vKeys.begin(), m_vKeys.end(), bind2nd(equal_to< DT >(), key)), m_vKeys.end());
-    }
-
-    // Implemented in Cache and redirected to the Storage Policy
-    virtual void remove(DT const key) = 0;
-
-    // Random Eviction policy
-    void evict()
-    {
-        if (m_vKeys.empty())
-            throw EvictionException();
-        size_type random = static_cast<size_type>((m_vKeys.size() * rand()) / (static_cast<size_type>(RAND_MAX) + 1));
-        remove(*(m_vKeys.begin() + random));
-    }
-    const char* name() {return "random";}
-};
-
-/**
- * \defgroup	StatisticPolicyCachedFactoryGroup		Statistic policies
- * \ingroup	CachedFactoryGroup
- * \brief	Gathers information about the cache.
- *
- * For debugging purpose this policy proposes to gather informations
- * about the cache. This could be useful to determine whether the cache is
- * mandatory or if the policies are well suited to the application.
- */
-/**
- * \class	NoStatisticPolicy
- * \ingroup	StatisticPolicyCachedFactoryGroup
- * \brief	Do nothing
- *
- * Should be used in release code for better performances
- */
-class NoStatisticPolicy
-{
-protected:
-    void onDebug() {}
-    void onFetch() {}
-    void onRelease() {}
-    void onCreate() {}
-    void onDestroy() {}
-    const char* name() {return "no";}
-};
-
-/**
- * \class	SimpleStatisticPolicy
- * \ingroup	StatisticPolicyCachedFactoryGroup
- * \brief	Simple statistics
- *
- * Provides the following informations about the cache :
- * 		- Created objects
- * 		- Fetched objects
- * 		- Destroyed objects
- * 		- Cache hit
- * 		- Cache miss
- * 		- Currently allocated
- * 		- Currently out
- * 		- Cache overall efficiency
- */
-class SimpleStatisticPolicy
-{
-private:
-    unsigned allocated, created, hit, out, fetched;
-protected:
-    SimpleStatisticPolicy() : allocated(0), created(0), hit(0), out(0), fetched(0)
-    {
-    }
-
-    void onDebug()
-    {
-        using namespace std;
-        cout << "############################" << endl;
-        cout << "## About this cache " << this << endl;
-        cout << "## + Created objects     : " << created << endl;
-        cout << "## + Fetched objects     : " << fetched << endl;
-        cout << "## + Destroyed objects   : " << created - allocated << endl;
-        cout << "## + Cache hit           : " << hit << endl;
-        cout << "## + Cache miss          : " << fetched - hit << endl;
-        cout << "## + Currently allocated : " << allocated << endl;
-        cout << "## + Currently out       : " << out << endl;
-        cout << "############################" << endl;
-        if (fetched != 0)
-        {
-            cout << "## Overall efficiency " << 100 * double(hit) / fetched << "%" << endl;
-            cout << "############################" << endl;
-        }
-        cout << endl;
-    }
-
-    void onFetch()
-    {
-        ++fetched;
-        ++out;
-        ++hit;
-    }
-    void onRelease()
-    {
-        --out;
-    }
-    void onCreate()
-    {
-        ++created;
-        ++allocated;
-        --hit;
-    }
-    void onDestroy()
-    {
-        --allocated;
-    }
-
-    const char* name() {return "simple";}
-public:
-    unsigned getCreated() {return created;}
-    unsigned getFetched() {return fetched;}
-    unsigned getHit() {return hit;}
-    unsigned getMissed() {return fetched - hit;}
-    unsigned getAllocated() {return allocated;}
-    unsigned getOut() {return out;}
-    unsigned getDestroyed() {return created - allocated;}
-};
-
-///////////////////////////////////////////////////////////////////////////
-// Cache Factory definition
-///////////////////////////////////////////////////////////////////////////
-class CacheException : public std::exception
-{
-public:
-    const char* what() const throw() { return "Internal Cache Error"; }
-};
-
-/**
- * \class		CachedFactory
- * \ingroup		CachedFactoryGroup
- * \brief		Factory with caching support
- *
- * This class acts as a Factory (it creates objects)
- * but also keeps the already created objects to prevent
- * long constructions time.
- *
- * Note this implementation do not retain ownership.
- */
-template
-<
-class AbstractProduct,
-      typename IdentifierType,
-      typename CreatorParmTList = NullType,
-      template<class> class EncapsulationPolicy = SimplePointer,
-      class CreationPolicy = AlwaysCreate,
-      template <typename , typename> class EvictionPolicy = EvictRandom,
-      class StatisticPolicy = NoStatisticPolicy,
-      template<typename, class> class FactoryErrorPolicy = DefaultFactoryError,
-      class ObjVector = std::vector<AbstractProduct*>
-      >
-class CachedFactory :
-    protected EncapsulationPolicy<AbstractProduct>,
-    public CreationPolicy, public StatisticPolicy, EvictionPolicy< AbstractProduct* , unsigned >
-{
-private:
-    typedef Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy> MyFactory;
-    typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl;
-    typedef Functor< AbstractProduct* , CreatorParmTList > ProductCreator;
-    typedef EncapsulationPolicy<AbstractProduct> NP;
-    typedef CreationPolicy  CP;
-    typedef StatisticPolicy SP;
-    typedef EvictionPolicy< AbstractProduct* , unsigned > EP;
-
-    typedef typename Impl::Parm1 Parm1;
-    typedef typename Impl::Parm2 Parm2;
-    typedef typename Impl::Parm3 Parm3;
-    typedef typename Impl::Parm4 Parm4;
-    typedef typename Impl::Parm5 Parm5;
-    typedef typename Impl::Parm6 Parm6;
-    typedef typename Impl::Parm7 Parm7;
-    typedef typename Impl::Parm8 Parm8;
-    typedef typename Impl::Parm9 Parm9;
-    typedef typename Impl::Parm10 Parm10;
-    typedef typename Impl::Parm11 Parm11;
-    typedef typename Impl::Parm12 Parm12;
-    typedef typename Impl::Parm13 Parm13;
-    typedef typename Impl::Parm14 Parm14;
-    typedef typename Impl::Parm15 Parm15;
-
-public:
-    typedef typename NP::ProductReturn ProductReturn;
-private:
-    typedef Key< Impl, IdentifierType > MyKey;
-    typedef std::map< MyKey, ObjVector >  KeyToObjVectorMap;
-    typedef std::map< AbstractProduct*, MyKey >  FetchedObjToKeyMap;
-
-    MyFactory			factory;
-    KeyToObjVectorMap   fromKeyToObjVector;
-    FetchedObjToKeyMap  providedObjects;
-    unsigned            outObjects;
-
-    ObjVector& getContainerFromKey(MyKey key)
-    {
-        return fromKeyToObjVector[key];
-    }
-
-    AbstractProduct* const getPointerToObjectInContainer(ObjVector& entry)
-    {
-        if (entry.empty()) // No object available
-        {
-            // the object will be created in the calling function.
-            // It has to be created in the calling function because of
-            // the variable number of parameters for CreateObject(...) method
-            return NULL;
-        }
-        else
-        {
-            // returning the found object
-            AbstractProduct* pObject(entry.back());
-            assert(pObject != NULL);
-            entry.pop_back();
-            return pObject;
-        }
-    }
-
-    bool shouldCreateObject(AbstractProduct* const pProduct)
-    {
-        if (pProduct != NULL) // object already exists
-            return false;
-        if (CP::canCreate() == false) // Are we allowed to Create ?
-            EP::evict(); // calling Eviction Policy to clean up
-        return true;
-    }
-
-    void ReleaseObjectFromContainer(ObjVector& entry, AbstractProduct* const object)
-    {
-        entry.push_back(object);
-    }
-
-    void onFetch(AbstractProduct* const pProduct)
-    {
-        SP::onFetch();
-        EP::onFetch(pProduct);
-        ++outObjects;
-    }
-
-    void onRelease(AbstractProduct* const pProduct)
-    {
-        SP::onRelease();
-        EP::onRelease(pProduct);
-        --outObjects;
-    }
-
-    void onCreate(AbstractProduct* const pProduct)
-    {
-        CP::onCreate();
-        SP::onCreate();
-        EP::onCreate(pProduct);
-    }
-
-    void onDestroy(AbstractProduct* const pProduct)
-    {
-        CP::onDestroy();
-        SP::onDestroy();
-        EP::onDestroy(pProduct);
-    }
-
-    // delete the object
-    template<class T> struct deleteObject : public std::unary_function<T, void>
-    {
-        void operator()(T x) { delete x; }
-    };
-
-    // delete the objects in the vector
-    template<class T> struct deleteVectorObjects : public std::unary_function<T, void>
-    {
-        void operator()(T x)
-        {
-            ObjVector& vec(x.second);
-            std::for_each(vec.begin(), vec.end(), deleteObject< typename ObjVector::value_type>());
-        }
-    };
-
-    // delete the keys of the map
-    template<class T> struct deleteMapKeys : public std::unary_function<T, void>
-    {
-        void operator()(T x) { delete x.first; }
-    };
-
-protected:
-    virtual void remove(AbstractProduct* const pProduct)
-    {
-        typename FetchedObjToKeyMap::iterator fetchedItr = providedObjects.find(pProduct);
-        if (fetchedItr != providedObjects.end()) // object is unreleased.
-            throw CacheException();
-        bool productRemoved = false;
-        typename KeyToObjVectorMap::iterator objVectorItr;
-        typename ObjVector::iterator objItr;
-        for (objVectorItr = fromKeyToObjVector.begin(); objVectorItr != fromKeyToObjVector.end(); ++objVectorItr)
-        {
-            ObjVector& v((*objVectorItr).second);
-            objItr = remove_if(v.begin(), v.end(), std::bind2nd(std::equal_to<AbstractProduct*>(), pProduct));
-            if (objItr != v.end()) // we found the vector containing pProduct and removed it
-            {
-                onDestroy(pProduct); // warning policies we are about to destroy an object
-                v.erase(objItr, v.end()); // real removing
-                productRemoved = true;
-                break;
-            }
-        }
-        if (productRemoved == false)
-            throw CacheException(); // the product is not in the cache ?!
-        delete pProduct; // deleting it
-    }
-
-public:
-    CachedFactory() : factory(), fromKeyToObjVector(), providedObjects(), outObjects(0)
-    {
-    }
-
-    ~CachedFactory()
-    {
-        using namespace std;
-        // debug information
-        SP::onDebug();
-        // cleaning the Cache
-        for_each(fromKeyToObjVector.begin(), fromKeyToObjVector.end(),
-                 deleteVectorObjects< typename KeyToObjVectorMap::value_type >()
-                );
-        if (!providedObjects.empty())
-        {
-            // The factory is responsible for the creation and destruction of objects.
-            // If objects are out during the destruction of the Factory : deleting anyway.
-            // This might not be a good idea. But throwing an exception in a destructor is
-            // considered as a bad pratice and asserting might be too much.
-            // What to do ? Leaking memory or corrupting in use pointers ? hmm...
-            D( cout << "====>>  Cache destructor : deleting " << providedObjects.size() << " in use objects  <<====" << endl << endl; )
-            for_each(providedObjects.begin(), providedObjects.end(),
-                     deleteMapKeys< typename FetchedObjToKeyMap::value_type >()
-                    );
-        }
-    }
-
-    ///////////////////////////////////
-    // Acts as the proxy pattern and //
-    // forwards factory methods      //
-    ///////////////////////////////////
-
-    bool Register(const IdentifierType& id, ProductCreator creator)
-    {
-        return factory.Register(id, creator);
-    }
-
-    template <class PtrObj, typename CreaFn>
-    bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn)
-    {
-        return factory.Register(id, p, fn);
-    }
-
-    bool Unregister(const IdentifierType& id)
-    {
-        return factory.Unregister(id);
-    }
-
-    /// Return the registered ID in this Factory
-    std::vector<IdentifierType>& RegisteredIds()
-    {
-        return factory.RegisteredIds();
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id)
-    {
-        MyKey key(id);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1)
-    {
-        MyKey key(id, p1);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2)
-    {
-        MyKey key(id, p1, p2);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3)
-    {
-        MyKey key(id, p1, p2, p3);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-    {
-        MyKey key(id, p1, p2, p3, p4);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                               Parm6 p6)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                               Parm6 p6, Parm7 p7 )
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                               Parm6 p6, Parm7 p7, Parm8 p8)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                               Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                               Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9, key.p10);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1  p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5  p5,
-                               Parm6  p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10,
-                               Parm11 p11)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9, key.p10, key.p11);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1  p1,  Parm2  p2, Parm3 p3, Parm4 p4, Parm5  p5,
-                               Parm6  p6,  Parm7  p7, Parm8 p8, Parm9 p9, Parm10 p10,
-                               Parm11 p11, Parm12 p12)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9, key.p10, key.p11, key.p12);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1  p1,  Parm2  p2,  Parm3  p3, Parm4 p4, Parm5  p5,
-                               Parm6  p6,  Parm7  p7,  Parm8  p8, Parm9 p9, Parm10 p10,
-                               Parm11 p11, Parm12 p12, Parm13 p13)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9, key.p10, key.p11, key.p12
-                                            , key.p13);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4, Parm5  p5,
-                               Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9, Parm10 p10,
-                               Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9, key.p10, key.p11, key.p12
-                                            , key.p13, key.p14);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    ProductReturn CreateObject(const IdentifierType& id,
-                               Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4,  Parm5  p5,
-                               Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9,  Parm10 p10,
-                               Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
-    {
-        MyKey key(id, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
-        AbstractProduct* pProduct(getPointerToObjectInContainer(getContainerFromKey(key)));
-        if (shouldCreateObject(pProduct))
-        {
-            pProduct = factory.CreateObject(key.id, key.p1, key.p2, key.p3
-                                            , key.p4, key.p5, key.p6, key.p7, key.p8, key.p9, key.p10, key.p11, key.p12
-                                            , key.p13, key.p14, key.p15);
-            onCreate(pProduct);
-        }
-        onFetch(pProduct);
-        providedObjects[pProduct] = key;
-        return NP::encapsulate(pProduct);
-    }
-
-    /// Use this function to release the object
-    /**
-     * if execution brakes in this function then you tried
-     * to release an object that wasn't provided by this Cache
-     * ... which is bad :-)
-     */
-    void ReleaseObject(ProductReturn& object)
-    {
-        AbstractProduct* pProduct(NP::release(object));
-        typename FetchedObjToKeyMap::iterator itr = providedObjects.find(pProduct);
-        if (itr == providedObjects.end())
-            throw CacheException();
-        onRelease(pProduct);
-        ReleaseObjectFromContainer(getContainerFromKey((*itr).second), pProduct);
-        providedObjects.erase(itr);
-    }
-
-    /// display the cache configuration
-    void displayCacheType()
-    {
-        using namespace std;
-        cout << "############################" << endl;
-        cout << "## Cache configuration" << endl;
-        cout << "## + Encapsulation " << NP::name() << endl;
-        cout << "## + Creating      " << CP::name() << endl;
-        cout << "## + Eviction      " << EP::name() << endl;
-        cout << "## + Statistics    " << SP::name() << endl;
-        cout << "############################" << endl;
-    }
-};
-} // namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/CheckReturn.h b/shared/loki/CheckReturn.h
deleted file mode 100644
index c0a65aa5..00000000
--- a/shared/loki/CheckReturn.h
+++ /dev/null
@@ -1,165 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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>
-#include <stdio.h>
-#include <stdexcept>
-
-
-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 calls the OnError policy.
-///
-///  \par Template Parameters
-///  CheckReturn has two template parameters, Value and OnError.
-///  - Value is the return type from the function.  CheckReturn stores a copy of
-///  it rather than 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.
-///  - OnError is a policy class indicating how to handle the situation when a
-///  caller does not check or copy the returned value.  Loki provides some
-///  policy classs and you may also write your own.  For example, you can write
-///  a policy to create a message box when the function ignores the return value.
-///  That would quickly tell you places where code ignores the function call.
-///  If your write your own, you only need a templated class or struct with a
-///  public function named "run" that accepts a reference to a const value.
-///
-/// @par Provided Policy Classes
-///  - IgnoreReturnValue Deliberately ignores when the caller ignores the return value.
-///  - TriggerAssert Asserts in debug builds if the caller ignores the return value.
-///  - FprintfStderr Prints out an error message if the caller ignores the return value.
-///  - ThrowTheValue Throws the ignored value as an exception.
-///  - ThrowLogicError Throws a logic_error exception to indicate a programming error.
-////////////////////////////////////////////////////////////////////////////////
-
-
-template<class T>
-struct IgnoreReturnValue
-{
-    static void run(const T&)
-    {
-        /// Do nothing at all.
-    }
-};
-
-template<class T>
-struct ThrowTheValue
-{
-    static void run(const T& value )
-    {
-        throw value;
-    }
-};
-
-template<class T>
-struct ThrowLogicError
-{
-    static void run( const T& )
-    {
-        throw ::std::logic_error( "CheckReturn: return value was not checked.\n" );
-    }
-};
-
-template<class T>
-struct TriggerAssert
-{
-    static void run(const T&)
-    {
-        assert( 0 );
-    }
-};
-
-template<class T>
-struct FprintfStderr
-{
-    static void run(const T&)
-    {
-        fprintf(stderr, "CheckReturn: return value was not checked.\n");
-    }
-};
-
-
-
-template < class Value , template<class> class OnError = TriggerAssert >
-class CheckReturn
-{
-public:
-
-    /// Conversion constructor changes Value type to CheckReturn type.
-    inline CheckReturn( const 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 m_checked is false, then a function failed to check the
-        // return value from a function call.
-        if (!m_checked)
-            OnError<Value>::run(m_value);
-    }
-
-    /// 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$
-
diff --git a/shared/loki/Checker.h b/shared/loki/Checker.h
deleted file mode 100644
index 64579d2f..00000000
--- a/shared/loki/Checker.h
+++ /dev/null
@@ -1,516 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-//
-// 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 ContractChecker and StaticChecker Overview
- The ContractChecker 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 ContractChecker and StaticChecker 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.  ContractChecker 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.  Since there is no
- universal way to detect leaks, this facility provides no mechanism for finding
- leaks, but users may create their own validators which do.  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.
-   (Which I call the no-change guarantee.)
- - Basic guarantee: A function will not leak resources and data will remain
-   in a valid state if an exception occurs.  (Which I call either the no-leak
-   or no-break guarantee depending on context.)
- */
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNoThrow
-
- @par Exception Safety Level:
- This exception-checking policy class for ContractChecker asserts if an
- exception exists.  Host classes can use this to show that a member function
- provides 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 bool Check( const Host* ) const
-    {
-        const bool okay = ( !::std::uncaught_exception() );
-        assert( okay );
-        return okay;
-    }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNoChange
-
- @par Exception Safety Level:
- This exception-checking policy class for ContractChecker 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 bool Check( const Host* host ) const
-    {
-        const bool okay = ( !::std::uncaught_exception() )
-                          || ( m_compare == *host );
-        assert( okay );
-        return okay;
-    }
-
-private:
-    Host m_compare;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNoChangeOrThrow
-
- @par Exception Safety Level:
- This exception-checking policy class for ContractChecker 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 bool Check( const Host* host ) const
-    {
-        bool okay = ( !::std::uncaught_exception() );
-        assert( okay );
-        okay = ( m_compare == *host );
-        assert( okay );
-        return okay;
-    }
-
-private:
-    Host m_compare;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForEquality
-
- @par Exception Safety Level:
- This exception-checking policy class for ContractChecker asserts 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 bool Check( const Host* host ) const
-    {
-        const bool okay = ( m_compare == *host );
-        assert( okay );
-        return okay;
-    }
-
-private:
-    Host m_compare;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class CheckForNothing
-
- @par Exception Safety Level:
- This exception-checking policy class for ContractChecker 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 bool Check( const Host* ) const { return true; }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class ContractChecker
- This class determines if a function violated any class invariant, but it also
- determines if a function fulfills its contract with client code.  In the
- "Design by Contract" paradigm, each function has certain pre-conditions and
- post-conditions which may differ from the class invariants.  This asserts if a
- check for an invariant fails as well as if any pre- or post-condition fails.
- It also demonstrate which exception safety level a function provides.
-
- @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.
-    - Ideally, it should be private.
- -# Implement similar functions to check for pre-conditions and post-conditions.
-    Functions which verify pre-conditions and post-conditions do not need to
-    check all class invariants, just conditions specific to certain public
-    functions in the host class.
- -# 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::ContractChecker< Host, ::Loki::CheckForNoThrow  > CheckForNoThrow;
-    - typedef ::Loki::ContractChecker< Host, ::Loki::CheckForNoChange > CheckForNoChange;
-    - typedef ::Loki::ContractChecker< Host, ::Loki::CheckForEquality > CheckForEquality;
-    - typedef ::Loki::ContractChecker< 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.  You may also pass in pointers
-    to function which check pre- and post-conditions.
-    - 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 the program and all the unit
-    tests, and look for which assertions failed.
- */
-
-template
-<
-class Host,
-      template < class > class ExceptionPolicy
-      >
-class ContractChecker : 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.
-     @par host Pointer to host object.
-     @par validator Pointer to function that checks class invariants.
-     @par pre Optional pointer to function that checks pre-conditions.
-     @par post Optional pointer to function that checks post-conditions.
-     */
-    inline ContractChecker( const Host* host, Validator validator,
-                            Validator pre = 0, Validator post = 0 ) :
-        Ep( host ),
-        m_host( host ),
-        m_validator( validator ),
-        m_pre( pre ),
-        m_post( post )
-    {
-        assert( Check() );
-        if ( 0 != m_pre )
-            assert( ( m_host->*( m_pre ) )() );
-    }
-
-    /** 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 ~ContractChecker( void )
-    {
-        assert( Check() );
-        if ( 0 != m_post )
-            assert( ( m_host->*( m_post ) )() );
-        assert( Ep::Check( m_host ) );
-    }
-
-    /** This first checks the invariants for ContractChecker, 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.  This does not care if the pre- and post-condition validator
-     pointers are null since a host class may pass in NULL pointers for either
-     to indicate the pre-conditions or post-conditions are the same as the
-     overall class invariants.
-     */
-    inline bool 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.
-        const bool okay = ( m_host->*( m_validator ) )();
-        assert( okay );
-        return okay;
-    }
-
-private:
-
-    /// Default constructor is not implemented.
-    ContractChecker( void );
-    /// Copy constructor is not implemented.
-    ContractChecker( const ContractChecker& );
-    /// Copy-assignment operator is not implemented.
-    ContractChecker& operator = ( const ContractChecker& );
-
-    /// Pointer to the host object.
-    const Host* m_host;
-
-    /// Pointer to member function that checks Host object's invariants.
-    Validator m_validator;
-
-    /// Pointer to member function that checks Host object's pre-conditions.
-    Validator m_pre;
-
-    /// Pointer to member function that checks Host object's post-conditions.
-    Validator m_post;
-
-};
-
-// ----------------------------------------------------------------------------
-
-/** @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:
-    inline bool Check( void )
-    {
-        const bool okay = !::std::uncaught_exception();
-        assert( okay );
-        return okay;
-    }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @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:
-    inline bool Check( void ) { return true; }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @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 see if an assertion
-    fails.
- */
-
-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.
-     @par validator Pointer to function that checks class invariants.
-     @par pre Optional pointer to function that checks pre-conditions.
-     @par post Optional pointer to function that checks post-conditions.
-     */
-    inline explicit StaticChecker( Validator validator,
-                                   Validator pre = 0, Validator post = 0 ) :
-        Ep(),
-        m_validator( validator ),
-        m_pre( pre ),
-        m_post( post )
-    {
-        assert( Check() );
-        if ( 0 != m_pre )
-            assert( m_pre() );
-    }
-
-    /** 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 )
-    {
-        assert( Check() );
-        if ( 0 != m_post )
-            assert( m_post() );
-        assert( 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.  This does not care if the pre- and post-
-     condition validator pointers are null since a host class may pass in NULL
-     pointers for either to indicate the pre-conditions or post-conditions are
-     the same as the overall class invariants.
-     */
-    inline bool 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.
-        const bool okay = m_validator();
-        assert( okay );
-        return okay;
-    }
-
-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;
-
-    /// Pointer to member function that checks Host object's pre-conditions.
-    Validator m_pre;
-
-    /// Pointer to member function that checks Host object's post-conditions.
-    Validator m_post;
-
-};
-
-// ----------------------------------------------------------------------------
-
-}; // end namespace Loki
-
-#endif
diff --git a/shared/loki/ConstPolicy.h b/shared/loki/ConstPolicy.h
deleted file mode 100644
index 1adb227a..00000000
--- a/shared/loki/ConstPolicy.h
+++ /dev/null
@@ -1,61 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2006 Richard Sposato
-// 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 authors make no representations about the
-//     suitability of this software for any purpose. It is provided "as is"
-//     without express or implied warranty.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_CONST_POLICY_INC_
-#define LOKI_CONST_POLICY_INC_
-
-// $Id: ConstPolicy.h 769 2006-10-26 10:58:19Z syntheticpp $
-
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-/// @note These policy classes are used in LockingPtr and SmartPtr to define
-///  how const is propagated from the pointee.
-////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DontPropagateConst
-///
-///  \ingroup ConstGroup
-///  Don't propagate constness of pointed or referred object.
-////////////////////////////////////////////////////////////////////////////////
-
-template< class T >
-struct DontPropagateConst
-{
-    typedef T Type;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class PropagateConst
-///
-///  \ingroup ConstGroup
-///  Propagate constness of pointed or referred object.
-////////////////////////////////////////////////////////////////////////////////
-
-template< class T >
-struct PropagateConst
-{
-    typedef const T Type;
-};
-
-// default will not break existing code
-#ifndef LOKI_DEFAULT_CONSTNESS
-#define LOKI_DEFAULT_CONSTNESS ::Loki::DontPropagateConst
-#endif
-
-} // end namespace Loki
-
-#endif // end file guardian
diff --git a/shared/loki/DataGenerators.h b/shared/loki/DataGenerators.h
deleted file mode 100644
index 7ac697af..00000000
--- a/shared/loki/DataGenerators.h
+++ /dev/null
@@ -1,113 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Data Generator by Shannon Barber
-// This code DOES NOT accompany the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
-//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
-//
-// Code covered by the MIT License
-// 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_DATAGENERATORS_INC_
-#define LOKI_DATAGENERATORS_INC_
-
-// $Id: DataGenerators.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-#include "Typelist.h"
-
-//Reference version
-
-/************************************************************************************
-// class template GenData
-// Iteratates a Typelist, and invokes the functor GenFunc<T>
-// for each type in the list, passing a functor along the way.
-// The functor is designed to be an insertion iterator which GenFunc<T>
-// can use to output information about the types in the list.
-//
-
-Example Use
-
-template<typename T>
-struct ExtractDataType
-    {
-    some_type operator()()
-        {
-        return create_value_from_type<T>;
-        }
-    };
-
-Loki::IterateTypes<parameter_tl, ExtractDataType> gendata;
-std::vector<some_type> stuff;
-gendata(std::back_inserter(stuff));
-*******************************************************************************/
-namespace Loki
-{
-namespace TL
-{
-template<typename T>
-struct nameof_type
-{
-    const char* operator()()
-    {
-        return typeid(T).name();
-    }
-};
-template<typename T>
-struct sizeof_type
-{
-    size_t operator()()
-    {
-        return sizeof(T);
-    }
-};
-template <class TList, template <class> class GenFunc>
-struct IterateTypes;
-
-template <class T1, class T2, template <class> class GenFunc>
-struct IterateTypes<Typelist<T1, T2>, GenFunc>
-{
-    typedef IterateTypes<T1, GenFunc> head_t;
-    head_t head;
-    typedef IterateTypes<T2, GenFunc> tail_t;
-    tail_t tail;
-    template<class II>
-    void operator()(II ii)
-    {
-        head.operator()(ii);
-        tail.operator()(ii);
-    }
-};
-
-template <class AtomicType, template <class> class GenFunc>
-struct IterateTypes
-{
-    template<class II>
-    void operator()(II ii)
-    {
-        GenFunc<AtomicType> genfunc;
-        *ii = genfunc();
-        ++ii; //Is this even needed?
-    }
-};
-
-template <template <class> class GenFunc>
-struct IterateTypes<NullType, GenFunc>
-{
-    template<class II>
-    void operator()(II ii)
-    {}
-};
-
-template<typename Types, template <class> class UnitFunc, typename II>
-void iterate_types(II ii)
-{
-    Loki::TL::IterateTypes<Types, UnitFunc> it;
-    it(ii);
-}
-}//ns TL
-}//ns Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/EmptyType.h b/shared/loki/EmptyType.h
deleted file mode 100644
index 0f60c894..00000000
--- a/shared/loki/EmptyType.h
+++ /dev/null
@@ -1,49 +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_EMPTYTYPE_INC_
-#define LOKI_EMPTYTYPE_INC_
-
-// $Id: EmptyType.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class EmptyType
-// Used as a class type that doesn't hold anything
-// Useful as a strawman class
-////////////////////////////////////////////////////////////////////////////////
-
-class EmptyType {};
-
-
-inline bool operator==(const EmptyType&, const EmptyType&)
-{
-    return true;
-}
-
-inline bool operator<(const EmptyType&, const EmptyType&)
-{
-    return false;
-}
-
-inline bool operator>(const EmptyType&, const EmptyType&)
-{
-    return false;
-}
-}
-
-#endif // end file guardian
-
diff --git a/shared/loki/Factory.h b/shared/loki/Factory.h
deleted file mode 100644
index bf31afc5..00000000
--- a/shared/loki/Factory.h
+++ /dev/null
@@ -1,1084 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2001 by Andrei Alexandrescu
-// Copyright (c) 2005 by Peter Kuemmel
-// This code DOES NOT accompany the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
-//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
-//
-// Code covered by the MIT License
-// The authors make no representations about the suitability of this software
-// for any purpose. It is provided "as is" without express or implied warranty.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_FACTORYPARM_INC_
-#define LOKI_FACTORYPARM_INC_
-
-// $Id: Factory.h 788 2006-11-24 22:30:54Z clitte_bbt $
-
-
-#include "LokiTypeInfo.h"
-#include "Functor.h"
-#include "AssocVector.h"
-#include "SmallObj.h"
-#include "Sequence.h"
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4702)
-//unreachable code if OnUnknownType throws an exception
-#endif
-
-/**
- * \defgroup	FactoriesGroup Factories
- * \defgroup	FactoryGroup Factory
- * \ingroup		FactoriesGroup
- * \brief		Implements a generic object factory.
- *
- * <i>The Factory Method pattern is an object-oriented design pattern.
- * Like other creational patterns, it deals with the problem of creating objects
- * (products) without specifying the exact class of object that will be created.
- * Factory Method, one of the patterns from the Design Patterns book, handles
- * this problem by defining a separate method for creating the objects, which
- * subclasses can then override to specify the derived type of product that will
- * be created.
- * <br>
- * More generally, the term Factory Method is often used to refer to any method
- * whose main purpose is creation of objects.</i>
- * <div ALIGN="RIGHT"><a href="http://en.wikipedia.org/wiki/Factory_method_pattern">
- * Wikipedia</a></div>
- *
- * Loki proposes a generic version of the Factory. Here is a typical use.<br>
- * <code><br>
- * 1. Factory< AbstractProduct, int > aFactory;<br>
- * 2. aFactory.Register( 1, createProductNull );<br>
- * 3. aFactory.CreateObject( 1 ); <br>
- * </code><br>
- * <br>
- * - 1. The declaration<br>
- * You want a Factory that produces AbstractProduct.<br>
- * The client will refer to a creation method through an int.<br>
- * - 2.The registration<br>
- * The code that will contribute to the Factory will now need to declare its
- * ProductCreator by registering them into the Factory.<br>
- * A ProductCreator is a just a function that will return the right object. ie <br>
- * <code>
- * Product* createProductNull()<br>
- * {<br>
- *     return new Product<br>
- * }<br>
- * </code><br>
- * - 3. The use<br>
- * Now the client can create object by calling the Factory's CreateObject method
- * with the right identifier. If the ProductCreator were to have arguments
- * (<i>ie :Product* createProductParm( int a, int b )</i>)
- */
-
-namespace Loki
-{
-
-/**
- * \defgroup	FactoryErrorPoliciesGroup Factory Error Policies
- * \ingroup		FactoryGroup
- * \brief		Manages the "Unknown Type" error in an object factory
- *
- * \class DefaultFactoryError
- * \ingroup		FactoryErrorPoliciesGroup
- * \brief		Default policy that throws an exception
- *
- */
-
-template <typename IdentifierType, class AbstractProduct>
-struct DefaultFactoryError
-{
-    struct Exception : public std::exception
-    {
-        const char* what() const throw() { return "Unknown Type"; }
-    };
-
-    static AbstractProduct* OnUnknownType(IdentifierType)
-    {
-        throw Exception();
-    }
-};
-
-
-#define LOKI_ENABLE_NEW_FACTORY_CODE
-#ifdef LOKI_ENABLE_NEW_FACTORY_CODE
-
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-////////////////////////////////////////////////////////////////////////////////
-
-struct FactoryImplBase
-{
-    typedef EmptyType Parm1;
-    typedef EmptyType Parm2;
-    typedef EmptyType Parm3;
-    typedef EmptyType Parm4;
-    typedef EmptyType Parm5;
-    typedef EmptyType Parm6;
-    typedef EmptyType Parm7;
-    typedef EmptyType Parm8;
-    typedef EmptyType Parm9;
-    typedef EmptyType Parm10;
-    typedef EmptyType Parm11;
-    typedef EmptyType Parm12;
-    typedef EmptyType Parm13;
-    typedef EmptyType Parm14;
-    typedef EmptyType Parm15;
-};
-
-template <typename AP, typename Id, typename TList >
-struct FactoryImpl;
-
-template<typename AP, typename Id>
-struct FactoryImpl<AP, Id, NullType>
-        : public FactoryImplBase
-{
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id ) = 0;
-};
-template <typename AP, typename Id, typename P1 >
-struct FactoryImpl<AP, Id, Seq<P1> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1 ) = 0;
-};
-
-template<typename AP, typename Id, typename P1, typename P2 >
-struct FactoryImpl<AP, Id, Seq<P1, P2> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2 ) = 0;
-};
-
-template<typename AP, typename Id, typename P1, typename P2, typename P3 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3 ) = 0;
-};
-
-template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4 ) = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6 )
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7 )
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm9)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm9, Parm10)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm9, Parm10,
-                             Parm11)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm9, Parm10,
-                             Parm11, Parm12)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12, typename P13 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm9, Parm10,
-                             Parm11, Parm12, Parm13)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm8, Parm10,
-                             Parm11, Parm12, Parm13, Parm14)
-        = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >
-        : public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    typedef typename TypeTraits<P15>::ParameterType Parm15;
-    virtual ~FactoryImpl() {}
-    virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                             Parm6, Parm7, Parm8, Parm9, Parm10,
-                             Parm11, Parm12, Parm13, Parm14, Parm15 )
-        = 0;
-};
-
-#ifndef LOKI_DISABLE_TYPELIST_MACROS
-
-template <typename AP, typename Id, typename P1 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_1( P1 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1 ) = 0;
-};
-
-template<typename AP, typename Id, typename P1, typename P2 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_2( P1, P2 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2 ) = 0;
-};
-
-template<typename AP, typename Id, typename P1, typename P2, typename P3 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_3( P1, P2, P3 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3 ) = 0;
-};
-
-template<typename AP, typename Id, typename P1, typename P2, typename P3, typename P4 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_4( P1, P2, P3, P4 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4 ) = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_5( P1, P2, P3, P4, P5 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_6( P1, P2, P3, P4, P5, P6 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6 )
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_7( P1, P2, P3, P4, P5, P6, P7 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7 )
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_8( P1, P2, P3, P4, P5, P6, P7, P8 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_9( P1, P2, P3, P4, P5, P6, P7, P8, P9 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm9)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_10( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm9, Parm10)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_11( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm9, Parm10,
-                         Parm11)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_12( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm9, Parm10,
-                         Parm11, Parm12)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12, typename P13 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_13( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm9, Parm10,
-                         Parm11, Parm12, Parm13)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_14( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm8, Parm10,
-                         Parm11, Parm12, Parm13, Parm14)
-    = 0;
-};
-
-template < typename AP, typename Id,
-         typename P1, typename P2, typename P3, typename P4, typename P5,
-         typename P6, typename P7, typename P8, typename P9, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct FactoryImpl<AP, Id, LOKI_TYPELIST_15( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 )>
-: public FactoryImplBase
-{
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    typedef typename TypeTraits<P15>::ParameterType Parm15;
-virtual ~FactoryImpl() {}
-virtual AP* CreateObject(const Id& id, Parm1, Parm2, Parm3, Parm4, Parm5,
-                         Parm6, Parm7, Parm8, Parm9, Parm10,
-                         Parm11, Parm12, Parm13, Parm14, Parm15 )
-    = 0;
-};
-
-#endif //LOKI_DISABLE_TYPELIST_MACROS
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class Factory
-///
-///  \ingroup FactoryGroup
-///  Implements a generic object factory.
-///
-///  Create functions can have up to 15 parameters.
-///
-///  \par Singleton lifetime when used with Loki::SingletonHolder
-///  Because Factory uses internally Functors which inherits from
-///  SmallObject you must use the singleton lifetime
-///  \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode
-///  Alternatively you could suppress for Functor the inheritance
-///  from SmallObject by defining the macro:
-/// \code LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT \endcode
-////////////////////////////////////////////////////////////////////////////////
-template
-<
-class AbstractProduct,
-      typename IdentifierType,
-      typename CreatorParmTList = NullType,
-      template<typename, class> class FactoryErrorPolicy = DefaultFactoryError
-      >
-class Factory : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
-{
-    typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl;
-
-    typedef typename Impl::Parm1 Parm1;
-    typedef typename Impl::Parm2 Parm2;
-    typedef typename Impl::Parm3 Parm3;
-    typedef typename Impl::Parm4 Parm4;
-    typedef typename Impl::Parm5 Parm5;
-    typedef typename Impl::Parm6 Parm6;
-    typedef typename Impl::Parm7 Parm7;
-    typedef typename Impl::Parm8 Parm8;
-    typedef typename Impl::Parm9 Parm9;
-    typedef typename Impl::Parm10 Parm10;
-    typedef typename Impl::Parm11 Parm11;
-    typedef typename Impl::Parm12 Parm12;
-    typedef typename Impl::Parm13 Parm13;
-    typedef typename Impl::Parm14 Parm14;
-    typedef typename Impl::Parm15 Parm15;
-
-    typedef Functor<AbstractProduct*, CreatorParmTList> ProductCreator;
-
-    typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
-
-    IdToProductMap associations_;
-
-public:
-
-    Factory()
-        : associations_()
-    {
-    }
-
-    ~Factory()
-    {
-        associations_.erase(associations_.begin(), associations_.end());
-    }
-
-    bool Register(const IdentifierType& id, ProductCreator creator)
-    {
-        return associations_.insert(
-                   typename IdToProductMap::value_type(id, creator)).second != 0;
-    }
-
-    template <class PtrObj, typename CreaFn>
-    bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn)
-    {
-        ProductCreator creator( p, fn );
-        return associations_.insert(
-                   typename IdToProductMap::value_type(id, creator)).second != 0;
-    }
-
-    bool Unregister(const IdentifierType& id)
-    {
-        return associations_.erase(id) != 0;
-    }
-
-    std::vector<IdentifierType> RegisteredIds()
-    {
-        std::vector<IdentifierType> ids;
-        for (typename IdToProductMap::iterator it = associations_.begin();
-             it != associations_.end(); ++it)
-        {
-            ids.push_back(it->first);
-        }
-        return ids;
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                                  Parm6 p6)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                                  Parm6 p6, Parm7 p7 )
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                                  Parm6 p6, Parm7 p7, Parm8 p8)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                                  Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
-        return this->OnUnknownType(id);
-    }
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                                  Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1  p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5  p5,
-                                  Parm6  p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10,
-                                  Parm11 p11)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1  p1,  Parm2  p2, Parm3 p3, Parm4 p4, Parm5  p5,
-                                  Parm6  p6,  Parm7  p7, Parm8 p8, Parm9 p9, Parm10 p10,
-                                  Parm11 p11, Parm12 p12)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1  p1,  Parm2  p2,  Parm3  p3, Parm4 p4, Parm5  p5,
-                                  Parm6  p6,  Parm7  p7,  Parm8  p8, Parm9 p9, Parm10 p10,
-                                  Parm11 p11, Parm12 p12, Parm13 p13)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4, Parm5  p5,
-                                  Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9, Parm10 p10,
-                                  Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 );
-        return this->OnUnknownType(id);
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id,
-                                  Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4,  Parm5  p5,
-                                  Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9,  Parm10 p10,
-                                  Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-            return (i->second)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 );
-        return this->OnUnknownType(id);
-    }
-
-};
-
-#else
-
-template
-<
-class AbstractProduct,
-      typename IdentifierType,
-      typename ProductCreator = AbstractProduct* (*)(),
-      template<typename, class>
-      class FactoryErrorPolicy = DefaultFactoryError
-      >
-class Factory
-    : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
-{
-public:
-    bool Register(const IdentifierType& id, ProductCreator creator)
-    {
-        return associations_.insert(
-                   typename IdToProductMap::value_type(id, creator)).second != 0;
-    }
-
-    bool Unregister(const IdentifierType& id)
-    {
-        return associations_.erase(id) != 0;
-    }
-
-    AbstractProduct* CreateObject(const IdentifierType& id)
-    {
-        typename IdToProductMap::iterator i = associations_.find(id);
-        if (i != associations_.end())
-        {
-            return (i->second)();
-        }
-        return this->OnUnknownType(id);
-    }
-
-private:
-    typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
-    IdToProductMap associations_;
-};
-
-#endif //#define ENABLE_NEW_FACTORY_CODE
-
-/**
- *   \defgroup	CloneFactoryGroup Clone Factory
- *   \ingroup	FactoriesGroup
- *   \brief		Creates a copy from a polymorphic object.
- *
- *   \class		CloneFactory
- *   \ingroup	CloneFactoryGroup
- *   \brief		Creates a copy from a polymorphic object.
- */
-
-template
-<
-class AbstractProduct,
-      class ProductCreator =
-      AbstractProduct* (*)(const AbstractProduct*),
-      template<typename, class>
-      class FactoryErrorPolicy = DefaultFactoryError
-      >
-class CloneFactory
-    : public FactoryErrorPolicy<TypeInfo, AbstractProduct>
-{
-public:
-    bool Register(const TypeInfo& ti, ProductCreator creator)
-    {
-        return associations_.insert(
-                   typename IdToProductMap::value_type(ti, creator)).second != 0;
-    }
-
-    bool Unregister(const TypeInfo& id)
-    {
-        return associations_.erase(id) != 0;
-    }
-
-    AbstractProduct* CreateObject(const AbstractProduct* model)
-    {
-        if (model == NULL)
-        {
-            return NULL;
-        }
-
-        typename IdToProductMap::iterator i =
-            associations_.find(typeid(*model));
-
-        if (i != associations_.end())
-        {
-            return (i->second)(model);
-        }
-        return this->OnUnknownType(typeid(*model));
-    }
-
-private:
-    typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
-    IdToProductMap associations_;
-};
-
-} // namespace Loki
-
-
-#ifdef _MSC_VER
-#pragma warning( pop )
-#endif
-
-#endif // end file guardian
-
diff --git a/shared/loki/Function.h b/shared/loki/Function.h
deleted file mode 100644
index 5f388d3c..00000000
--- a/shared/loki/Function.h
+++ /dev/null
@@ -1,373 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2005 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_FUNCTION_INC_
-#define LOKI_FUNCTION_INC_
-
-// $Id: Function.h 841 2008-03-24 23:58:28Z rich_sposato $
-
-
-#define LOKI_ENABLE_FUNCTION
-
-#include <stdexcept>
-
-#include <loki/Functor.h>
-#include <loki/Sequence.h>
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct Function
-///
-///  \ingroup FunctorGroup
-///  Allows a boost/TR1 like usage of Functor.
-///
-///  \par Usage
-///
-///      - free functions: e.g.  \code Function<int(int,int)> f(&freeFunction);
-///                              \endcode
-///      - member functions: e.g \code Function<int()> f(&object,&ObjectType::memberFunction);
-///                              \endcode
-///
-///  see also test/Function/FunctionTest.cpp (the modified test program from boost)
-////////////////////////////////////////////////////////////////////////////////
-
-template<class R = void()>
-struct Function;
-
-
-template<class R>
-struct Function<R()> : public Functor<R>
-{
-    typedef Functor<R> FBase;
-
-    Function() : FBase() {}
-
-Function(const Function& func) : FBase()
-{
-    if ( !func.empty())
-        FBase::operator=(func);
-}
-
-// test on emptiness
-template<class R2>
-Function(Function<R2()> func) : FBase()
-{
-    if (!func.empty())
-        FBase::operator=(func);
-}
-
-// clear  by '= 0'
-Function(const int i) : FBase()
-{
-    if (i == 0)
-        FBase::clear();
-    else
-        throw std::runtime_error("Loki::Function(const int i): i!=0");
-}
-
-template<class Func>
-Function(Func func) : FBase(func) {}
-
-template<class Host, class Func>
-Function(const Host& host, const Func& func) : FBase(host, func) {}
-
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-// macros for the repetitions
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_FUNCTION_BODY                          \
-    \
-    Function() : FBase() {}                     \
-    \
-    Function(const Function& func) : FBase()    \
-    {                                           \
-        if( !func.empty())                      \
-            FBase::operator=(func);             \
-    }                                           \
-    \
-    Function(const int i) : FBase()             \
-    {                                           \
-        if(i==0)                                \
-            FBase::clear();                     \
-        else                                    \
-            throw std::runtime_error(           \
-                                                "Loki::Function(const int i): i!=0");   \
-    }                                           \
-    \
-    template<class Func>                        \
-    Function(Func func) : FBase(func) {}        \
-    \
-    template<class Host, class Func>            \
-    Function(const Host& host, const Func& func): FBase(host,func) {}
-
-
-#define LOKI_FUNCTION_R2_CTOR_BODY          \
-    \
-    : FBase()                           \
-    {                                   \
-        if(!func.empty())               \
-            FBase::operator=(func);     \
-    }
-
-
-////////////////////////////////////////////////////////////////////////////////
-// repetitions
-////////////////////////////////////////////////////////////////////////////////
-
-template<>
-struct Function<>
-        : public Loki::Functor<>
-{
-    typedef Functor<> FBase;
-
-    template<class R2>
-    Function(Function<R2()> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY // if compilation breaks here then
-    // Function.h was not included before
-    // Functor.h, check your include order
-    // or define LOKI_ENABLE_FUNCTION
-};
-
-template<class R, class P01>
-struct Function<R(P01)>
-: public Loki::Functor<R, Seq<P01> >
-{
-    typedef Functor<R, Seq<P01> > FBase;
-
-    template<class R2, class Q01>
-    Function(Function<R2(Q01)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template<class R, class P01, class P02>
-struct Function<R(P01, P02)>
-: public Functor<R, Seq<P01, P02> >
-{
-    typedef Functor<R, Seq<P01, P02> > FBase;
-
-    template<class R2, class Q01, class Q02>
-    Function(Function<R2(Q01, Q02)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template<class R, class P01, class P02, class P03>
-struct Function<R(P01, P02, P03)>
-: public Functor<R, Seq<P01, P02, P03> >
-{
-    typedef Functor<R, Seq<P01, P02, P03> > FBase;
-
-    template<class R2, class Q01, class Q02, class Q03>
-    Function(Function<R2(Q01, Q02, Q03)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template<class R, class P01, class P02, class P03, class P04>
-struct Function<R(P01, P02, P03, P04)>
-: public Functor<R, Seq<P01, P02, P03, P04> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04> > FBase;
-
-    template<class R2, class Q01, class Q02, class Q03, class Q04>
-    Function(Function<R2(Q01, Q02, Q03, Q04)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template<class R, class P01, class P02, class P03, class P04, class P05>
-struct Function<R(P01, P02, P03, P04, P05)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05> > FBase;
-
-    template<class R2, class Q01, class Q02, class Q03, class Q04, class Q05>
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06 >
-struct Function<R(P01, P02, P03, P04, P05, P06)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09    > > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09, class P10 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09, class Q10 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09, class P10,
-         class P11 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11> >FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09, class Q10,
-    class Q11 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09, class P10,
-         class P11, class P12 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09, class Q10,
-    class Q11, class Q12 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09, class P10,
-         class P11, class P12, class P13 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09, class Q10,
-    class Q11, class Q12, class Q13 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09, class P10,
-         class P11, class P12, class P13, class P14 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14> > FBase;
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09, class Q10,
-    class Q11, class Q12, class Q13, class Q14 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13, Q14)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-template < class R,    class P01, class P02, class P03, class P04, class P05,
-         class P06, class P07, class P08, class P09, class P10,
-         class P11, class P12, class P13, class P14, class P15 >
-struct Function<R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
-: public Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15> >
-{
-    typedef Functor<R, Seq<P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15> > FBase;
-
-    template < class R2,    class Q01, class Q02, class Q03, class Q04, class Q05,
-    class Q06, class Q07, class Q08, class Q09, class Q10,
-    class Q11, class Q12, class Q13, class Q14, class Q15 >
-    Function(Function<R2(Q01, Q02, Q03, Q04, Q05, Q06, Q07, Q08, Q09, Q10, Q11, Q12, Q13, Q14, Q15)> func)
-    LOKI_FUNCTION_R2_CTOR_BODY
-
-    LOKI_FUNCTION_BODY
-};
-
-}// namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/Functor.h b/shared/loki/Functor.h
deleted file mode 100644
index 664af077..00000000
--- a/shared/loki/Functor.h
+++ /dev/null
@@ -1,1790 +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_FUNCTOR_INC_
-#define LOKI_FUNCTOR_INC_
-
-// $Id: Functor.h 750 2006-10-17 19:50:02Z syntheticpp $
-
-
-#include "Typelist.h"
-#include "Sequence.h"
-#include "EmptyType.h"
-#include "SmallObj.h"
-#include "TypeTraits.h"
-#include <typeinfo>
-#include <memory>
-
-///  \defgroup FunctorGroup Function objects
-
-#ifndef LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
-//#define LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
-#endif
-
-#ifndef LOKI_FUNCTORS_ARE_COMPARABLE
-//#define LOKI_FUNCTORS_ARE_COMPARABLE
-#endif
-
-
-/// \namespace Loki
-/// All classes of Loki are in the Loki namespace
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl (internal)
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template <typename R, template <class, class> class ThreadingModel>
-struct FunctorImplBase
-#ifdef LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
-{
-#else
-        :
-    public SmallValueObject<ThreadingModel>
-{
-    inline FunctorImplBase() :
-        SmallValueObject<ThreadingModel>() {}
-    inline FunctorImplBase(const FunctorImplBase&) :
-        SmallValueObject<ThreadingModel>() {}
-#endif
-
-    typedef R ResultType;
-    typedef FunctorImplBase<R, ThreadingModel> FunctorImplBaseType;
-
-    typedef EmptyType Parm1;
-    typedef EmptyType Parm2;
-    typedef EmptyType Parm3;
-    typedef EmptyType Parm4;
-    typedef EmptyType Parm5;
-    typedef EmptyType Parm6;
-    typedef EmptyType Parm7;
-    typedef EmptyType Parm8;
-    typedef EmptyType Parm9;
-    typedef EmptyType Parm10;
-    typedef EmptyType Parm11;
-    typedef EmptyType Parm12;
-    typedef EmptyType Parm13;
-    typedef EmptyType Parm14;
-    typedef EmptyType Parm15;
-
-
-    virtual ~FunctorImplBase()
-    {}
-
-    virtual FunctorImplBase* DoClone() const = 0;
-
-    template <class U>
-    static U* Clone(U* pObj)
-    {
-        if (!pObj) return 0;
-        U* pClone = static_cast<U*>(pObj->DoClone());
-        assert(typeid(*pClone) == typeid(*pObj));
-        return pClone;
-    }
-
-
-#ifdef LOKI_FUNCTORS_ARE_COMPARABLE
-
-    virtual bool operator==(const FunctorImplBase&) const = 0;
-
-#endif
-
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// macro LOKI_DEFINE_CLONE_FUNCTORIMPL
-// Implements the DoClone function for a functor implementation
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_DEFINE_CLONE_FUNCTORIMPL(Cls) \
-    virtual Cls* DoClone() const { return new Cls(*this); }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// The base class for a hierarchy of functors. The FunctorImpl class is not used
-//     directly; rather, the Functor class manages and forwards to a pointer to
-//     FunctorImpl
-// You may want to derive your own functors from FunctorImpl.
-// Specializations of FunctorImpl for up to 15 parameters follow
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, class TList,
-         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL >
-class FunctorImpl;
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 0 (zero) parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename R, template <class, class> class ThreadingModel>
-class FunctorImpl<R, NullType, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    virtual R operator()() = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 1 parameter
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename R, typename P1, template <class, class> class ThreadingModel>
-class FunctorImpl<R, Seq<P1>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    virtual R operator()(Parm1) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 2 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, Seq<P1, P2>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    virtual R operator()(Parm1, Parm2) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 3 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, Seq<P1, P2, P3>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    virtual R operator()(Parm1, Parm2, Parm3) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 4 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, Seq<P1, P2, P3, P4>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 5 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, Seq<P1, P2, P3, P4, P5>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 6 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 7 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7>, ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 8 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R, Seq<P1, P2, P3, P4, P5, P6, P7, P8>,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 9 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9>,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 10 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 11 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 12 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 13 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12, typename P13,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 14 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12, typename P13, typename P14,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    Seq < P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
-    P14 > ,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 15 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12, typename P13, typename P14,
-         typename P15, template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    Seq < P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
-    P14, P15 > ,
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    typedef typename TypeTraits<P15>::ParameterType Parm15;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14,
-                         Parm15) = 0;
-};
-
-#ifndef LOKI_DISABLE_TYPELIST_MACROS
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 1 parameter
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename R, typename P1, template <class, class> class ThreadingModel>
-class FunctorImpl<R, LOKI_TYPELIST_1(P1), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    virtual R operator()(Parm1) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 2 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, LOKI_TYPELIST_2(P1, P2), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    virtual R operator()(Parm1, Parm2) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 3 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, LOKI_TYPELIST_3(P1, P2, P3), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    virtual R operator()(Parm1, Parm2, Parm3) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 4 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, LOKI_TYPELIST_4(P1, P2, P3, P4), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 5 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, LOKI_TYPELIST_5(P1, P2, P3, P4, P5), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 6 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, LOKI_TYPELIST_6(P1, P2, P3, P4, P5, P6), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 7 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7,
-         template <class, class> class ThreadingModel >
-class FunctorImpl<R, LOKI_TYPELIST_7(P1, P2, P3, P4, P5, P6, P7), ThreadingModel>
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 8 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R, LOKI_TYPELIST_8(P1, P2, P3, P4, P5, P6, P7, P8),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 9 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R, LOKI_TYPELIST_9(P1, P2, P3, P4, P5, P6, P7, P8, P9),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 10 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R, LOKI_TYPELIST_10(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 11 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    LOKI_TYPELIST_11(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 12 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    LOKI_TYPELIST_12(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 13 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12, typename P13,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    LOKI_TYPELIST_13(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 14 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12, typename P13, typename P14,
-         template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    LOKI_TYPELIST_14(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
-                     P14),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 15 parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template < typename R, typename P1, typename P2, typename P3, typename P4,
-         typename P5, typename P6, typename P7, typename P8, typename P9,
-         typename P10, typename P11, typename P12, typename P13, typename P14,
-         typename P15, template <class, class> class ThreadingModel >
-class FunctorImpl < R,
-    LOKI_TYPELIST_15(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
-                     P14, P15),
-    ThreadingModel >
-    : public Private::FunctorImplBase<R, ThreadingModel>
-{
-public:
-    typedef R ResultType;
-    typedef typename TypeTraits<P1>::ParameterType Parm1;
-    typedef typename TypeTraits<P2>::ParameterType Parm2;
-    typedef typename TypeTraits<P3>::ParameterType Parm3;
-    typedef typename TypeTraits<P4>::ParameterType Parm4;
-    typedef typename TypeTraits<P5>::ParameterType Parm5;
-    typedef typename TypeTraits<P6>::ParameterType Parm6;
-    typedef typename TypeTraits<P7>::ParameterType Parm7;
-    typedef typename TypeTraits<P8>::ParameterType Parm8;
-    typedef typename TypeTraits<P9>::ParameterType Parm9;
-    typedef typename TypeTraits<P10>::ParameterType Parm10;
-    typedef typename TypeTraits<P11>::ParameterType Parm11;
-    typedef typename TypeTraits<P12>::ParameterType Parm12;
-    typedef typename TypeTraits<P13>::ParameterType Parm13;
-    typedef typename TypeTraits<P14>::ParameterType Parm14;
-    typedef typename TypeTraits<P15>::ParameterType Parm15;
-    virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6,
-                         Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14,
-                         Parm15) = 0;
-};
-
-#endif //LOKI_DISABLE_TYPELIST_MACROS
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorHandler
-// Wraps functors and pointers to functions
-////////////////////////////////////////////////////////////////////////////////
-
-template <class ParentFunctor, typename Fun>
-class FunctorHandler
-    : public ParentFunctor::Impl
-{
-    typedef typename ParentFunctor::Impl Base;
-
-public:
-    typedef typename Base::ResultType ResultType;
-    typedef typename Base::Parm1 Parm1;
-    typedef typename Base::Parm2 Parm2;
-    typedef typename Base::Parm3 Parm3;
-    typedef typename Base::Parm4 Parm4;
-    typedef typename Base::Parm5 Parm5;
-    typedef typename Base::Parm6 Parm6;
-    typedef typename Base::Parm7 Parm7;
-    typedef typename Base::Parm8 Parm8;
-    typedef typename Base::Parm9 Parm9;
-    typedef typename Base::Parm10 Parm10;
-    typedef typename Base::Parm11 Parm11;
-    typedef typename Base::Parm12 Parm12;
-    typedef typename Base::Parm13 Parm13;
-    typedef typename Base::Parm14 Parm14;
-    typedef typename Base::Parm15 Parm15;
-
-    FunctorHandler(const Fun& fun) : f_(fun) {}
-
-    LOKI_DEFINE_CLONE_FUNCTORIMPL(FunctorHandler)
-
-
-#ifdef LOKI_FUNCTORS_ARE_COMPARABLE
-
-
-    bool operator==(const typename Base::FunctorImplBaseType& rhs) const
-    {
-        // there is no static information if Functor holds a member function
-        // or a free function; this is the main difference to tr1::function
-        if (typeid(*this) != typeid(rhs))
-            return false; // cannot be equal
-
-        const FunctorHandler& fh = static_cast<const FunctorHandler&>(rhs);
-        // if this line gives a compiler error, you are using a function object.
-        // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
-        return  f_ == fh.f_;
-    }
-#endif
-    // operator() implementations for up to 15 arguments
-
-    ResultType operator()()
-    { return f_(); }
-
-    ResultType operator()(Parm1 p1)
-    { return f_(p1); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2)
-    { return f_(p1, p2); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
-    { return f_(p1, p2, p3); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-    { return f_(p1, p2, p3, p4); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-    { return f_(p1, p2, p3, p4, p5); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6)
-    { return f_(p1, p2, p3, p4, p5, p6); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7)
-    { return f_(p1, p2, p3, p4, p5, p6, p7); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8)
-    { return f_(p1, p2, p3, p4, p5, p6, p7, p8); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
-    { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
-    { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
-    { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12)
-    { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13)
-    { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14)
-    {
-        return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                  p14);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
-    {
-        return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                  p14, p15);
-    }
-
-private:
-    Fun f_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorHandler
-// Wraps pointers to member functions
-////////////////////////////////////////////////////////////////////////////////
-
-template < class ParentFunctor, typename PointerToObj,
-         typename PointerToMemFn >
-class MemFunHandler : public ParentFunctor::Impl
-{
-    typedef typename ParentFunctor::Impl Base;
-
-public:
-    typedef typename Base::ResultType ResultType;
-    typedef typename Base::Parm1 Parm1;
-    typedef typename Base::Parm2 Parm2;
-    typedef typename Base::Parm3 Parm3;
-    typedef typename Base::Parm4 Parm4;
-    typedef typename Base::Parm5 Parm5;
-    typedef typename Base::Parm6 Parm6;
-    typedef typename Base::Parm7 Parm7;
-    typedef typename Base::Parm8 Parm8;
-    typedef typename Base::Parm9 Parm9;
-    typedef typename Base::Parm10 Parm10;
-    typedef typename Base::Parm11 Parm11;
-    typedef typename Base::Parm12 Parm12;
-    typedef typename Base::Parm13 Parm13;
-    typedef typename Base::Parm14 Parm14;
-    typedef typename Base::Parm15 Parm15;
-
-    MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn)
-        : pObj_(pObj), pMemFn_(pMemFn)
-    {}
-
-    LOKI_DEFINE_CLONE_FUNCTORIMPL(MemFunHandler)
-
-
-#ifdef LOKI_FUNCTORS_ARE_COMPARABLE
-
-    bool operator==(const typename Base::FunctorImplBaseType& rhs) const
-    {
-        if (typeid(*this) != typeid(rhs))
-            return false; // cannot be equal
-
-        const MemFunHandler& mfh = static_cast<const MemFunHandler&>(rhs);
-        // if this line gives a compiler error, you are using a function object.
-        // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
-        return  pObj_ == mfh.pObj_ && pMemFn_ == mfh.pMemFn_;
-    }
-#endif
-
-    ResultType operator()()
-    { return ((*pObj_).*pMemFn_)(); }
-
-    ResultType operator()(Parm1 p1)
-    { return ((*pObj_).*pMemFn_)(p1); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2)
-    { return ((*pObj_).*pMemFn_)(p1, p2); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
-    { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
-    {
-        return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
-                                   p11);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12)
-    {
-        return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
-                                   p11, p12);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13)
-    {
-        return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
-                                   p11, p12, p13);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14)
-    {
-        return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
-                                   p11, p12, p13, p14);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
-    {
-        return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
-                                   p11, p12, p13, p14, p15);
-    }
-
-private:
-    PointerToObj pObj_;
-    PointerToMemFn pMemFn_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// TR1 exception
-//////////////////////////////////////////////////////////////////////////////////
-
-#ifdef LOKI_ENABLE_FUNCTION
-
-class bad_function_call : public std::runtime_error
-{
-public:
-    bad_function_call() : std::runtime_error("bad_function_call in Loki::Functor")
-    {}
-};
-
-#define LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL if(empty()) throw bad_function_call();
-
-#else
-
-#define LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class Functor
-///
-///  \ingroup FunctorGroup
-///  A generalized functor implementation with value semantics
-///
-/// \par Macro: LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
-/// Define
-/// \code LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT \endcode
-/// to avoid static instantiation/delete
-/// order problems.
-/// It often helps against crashes when using static Functors and multi threading.
-/// Defining also removes problems when unloading Dlls which hosts
-/// static Functor objects.
-///
-/// \par Macro: LOKI_FUNCTORS_ARE_COMPARABLE
-/// To enable the operator== define the macro
-/// \code LOKI_FUNCTORS_ARE_COMPARABLE \endcode
-/// The macro is disabled by default, because it breaks compiling functor
-/// objects  which have no operator== implemented, keep in mind when you enable
-/// operator==.
-////////////////////////////////////////////////////////////////////////////////
-template < typename R = void, class TList = NullType,
-         template<class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL >
-class Functor
-{
-public:
-    // Handy type definitions for the body type
-    typedef FunctorImpl<R, TList, ThreadingModel> Impl;
-    typedef R ResultType;
-    typedef TList ParmList;
-    typedef typename Impl::Parm1 Parm1;
-    typedef typename Impl::Parm2 Parm2;
-    typedef typename Impl::Parm3 Parm3;
-    typedef typename Impl::Parm4 Parm4;
-    typedef typename Impl::Parm5 Parm5;
-    typedef typename Impl::Parm6 Parm6;
-    typedef typename Impl::Parm7 Parm7;
-    typedef typename Impl::Parm8 Parm8;
-    typedef typename Impl::Parm9 Parm9;
-    typedef typename Impl::Parm10 Parm10;
-    typedef typename Impl::Parm11 Parm11;
-    typedef typename Impl::Parm12 Parm12;
-    typedef typename Impl::Parm13 Parm13;
-    typedef typename Impl::Parm14 Parm14;
-    typedef typename Impl::Parm15 Parm15;
-
-    // Member functions
-
-    Functor() : spImpl_(0)
-    {}
-
-    Functor(const Functor& rhs) : spImpl_(Impl::Clone(rhs.spImpl_.get()))
-    {}
-
-    Functor(std::auto_ptr<Impl> spImpl) : spImpl_(spImpl)
-    {}
-
-    template <typename Fun>
-    Functor(Fun fun)
-        : spImpl_(new FunctorHandler<Functor, Fun>(fun))
-    {}
-
-    template <class PtrObj, typename MemFn>
-    Functor(const PtrObj& p, MemFn memFn)
-        : spImpl_(new MemFunHandler<Functor, PtrObj, MemFn>(p, memFn))
-    {}
-
-    typedef Impl* (std::auto_ptr<Impl>::*unspecified_bool_type)() const;
-
-    operator unspecified_bool_type() const
-    {
-        return spImpl_.get() ? &std::auto_ptr<Impl>::get : 0;
-    }
-
-    Functor& operator=(const Functor& rhs)
-    {
-        Functor copy(rhs);
-        // swap auto_ptrs by hand
-        Impl* p = spImpl_.release();
-        spImpl_.reset(copy.spImpl_.release());
-        copy.spImpl_.reset(p);
-        return *this;
-    }
-
-#ifdef LOKI_ENABLE_FUNCTION
-
-    bool empty() const
-    {
-        return spImpl_.get() == 0;
-    }
-
-    void clear()
-    {
-        spImpl_.reset(0);
-    }
-#endif
-
-#ifdef LOKI_FUNCTORS_ARE_COMPARABLE
-
-    bool operator==(const Functor& rhs) const
-    {
-        if (spImpl_.get() == 0 && rhs.spImpl_.get() == 0)
-            return true;
-        if (spImpl_.get() != 0 && rhs.spImpl_.get() != 0)
-            return *spImpl_.get() == *rhs.spImpl_.get();
-        else
-            return false;
-    }
-
-    bool operator!=(const Functor& rhs) const
-    {
-        return !(*this == rhs);
-    }
-#endif
-
-    // operator() implementations for up to 15 arguments
-
-    ResultType operator()() const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)();
-    }
-
-    ResultType operator()(Parm1 p1) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
-                          p12);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
-                          p12, p13);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
-                          p12, p13, p14);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const
-    {
-        LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL
-        return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
-                          p12, p13, p14, p15);
-    }
-
-private:
-    std::auto_ptr<Impl> spImpl_;
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-//
-//  BindersFirst and Chainer
-//
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template <class Fctor> struct BinderFirstTraits;
-
-template <typename R, class TList, template <class, class> class ThreadingModel>
-struct BinderFirstTraits< Functor<R, TList, ThreadingModel> >
-{
-    typedef Functor<R, TList, ThreadingModel> OriginalFunctor;
-
-    typedef typename TL::Erase<TList, typename TL::TypeAt<TList, 0>::Result>
-    ::Result
-    ParmList;
-
-    typedef typename TL::TypeAt<TList, 0>::Result OriginalParm1;
-
-    typedef Functor<R, ParmList, ThreadingModel> BoundFunctorType;
-
-    typedef typename BoundFunctorType::Impl Impl;
-
-};
-
-
-template<class T>
-struct BinderFirstBoundTypeStorage;
-
-template<class T>
-struct BinderFirstBoundTypeStorage
-{
-    typedef typename TypeTraits<T>::ParameterType RefOrValue;
-};
-
-template <typename R, class TList, template <class, class> class ThreadingModel>
-struct BinderFirstBoundTypeStorage< Functor<R, TList, ThreadingModel> >
-{
-    typedef Functor<R, TList, ThreadingModel> OriginalFunctor;
-    typedef const typename TypeTraits<OriginalFunctor>::ReferredType RefOrValue;
-};
-
-
-} // namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class BinderFirst
-///
-///  \ingroup FunctorGroup
-///  Binds the first parameter of a Functor object to a specific value
-////////////////////////////////////////////////////////////////////////////////
-
-template <class OriginalFunctor>
-class BinderFirst
-    : public Private::BinderFirstTraits<OriginalFunctor>::Impl
-{
-    typedef typename Private::BinderFirstTraits<OriginalFunctor>::Impl Base;
-    typedef typename OriginalFunctor::ResultType ResultType;
-
-    typedef typename OriginalFunctor::Parm1 BoundType;
-
-    typedef typename Private::BinderFirstBoundTypeStorage <
-    typename Private::BinderFirstTraits<OriginalFunctor>
-    ::OriginalParm1 >
-    ::RefOrValue
-    BoundTypeStorage;
-
-    typedef typename OriginalFunctor::Parm2 Parm1;
-    typedef typename OriginalFunctor::Parm3 Parm2;
-    typedef typename OriginalFunctor::Parm4 Parm3;
-    typedef typename OriginalFunctor::Parm5 Parm4;
-    typedef typename OriginalFunctor::Parm6 Parm5;
-    typedef typename OriginalFunctor::Parm7 Parm6;
-    typedef typename OriginalFunctor::Parm8 Parm7;
-    typedef typename OriginalFunctor::Parm9 Parm8;
-    typedef typename OriginalFunctor::Parm10 Parm9;
-    typedef typename OriginalFunctor::Parm11 Parm10;
-    typedef typename OriginalFunctor::Parm12 Parm11;
-    typedef typename OriginalFunctor::Parm13 Parm12;
-    typedef typename OriginalFunctor::Parm14 Parm13;
-    typedef typename OriginalFunctor::Parm15 Parm14;
-    typedef EmptyType Parm15;
-
-public:
-
-    BinderFirst(const OriginalFunctor& fun, BoundType bound)
-        : f_(fun), b_(bound)
-    {}
-
-    LOKI_DEFINE_CLONE_FUNCTORIMPL(BinderFirst)
-
-#ifdef LOKI_FUNCTORS_ARE_COMPARABLE
-
-    bool operator==(const typename Base::FunctorImplBaseType& rhs) const
-    {
-        if (typeid(*this) != typeid(rhs))
-            return false; // cannot be equal
-        // if this line gives a compiler error, you are using a function object.
-        // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
-        return    f_ == ((static_cast<const BinderFirst&> (rhs)).f_) &&
-                  b_ == ((static_cast<const BinderFirst&> (rhs)).b_);
-    }
-#endif
-
-    // operator() implementations for up to 15 arguments
-
-    ResultType operator()()
-    { return f_(b_); }
-
-    ResultType operator()(Parm1 p1)
-    { return f_(b_, p1); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2)
-    { return f_(b_, p1, p2); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
-    { return f_(b_, p1, p2, p3); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-    { return f_(b_, p1, p2, p3, p4); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-    { return f_(b_, p1, p2, p3, p4, p5); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6)
-    { return f_(b_, p1, p2, p3, p4, p5, p6); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13)
-    { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14)
-    {
-        return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                  p14);
-    }
-
-private:
-    OriginalFunctor f_;
-    BoundTypeStorage b_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  Binds the first parameter of a Functor object to a specific value
-///  \ingroup FunctorGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template <class Fctor>
-typename Private::BinderFirstTraits<Fctor>::BoundFunctorType
-BindFirst(
-    const Fctor& fun,
-    typename Fctor::Parm1 bound)
-{
-    typedef typename Private::BinderFirstTraits<Fctor>::BoundFunctorType
-    Outgoing;
-
-    return Outgoing(std::auto_ptr<typename Outgoing::Impl>(
-                        new BinderFirst<Fctor>(fun, bound)));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class Chainer
-///
-///  \ingroup FunctorGroup
-///   Chains two functor calls one after another
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename Fun1, typename Fun2>
-class Chainer : public Fun2::Impl
-{
-    typedef Fun2 Base;
-
-public:
-    typedef typename Base::ResultType ResultType;
-    typedef typename Base::Parm1 Parm1;
-    typedef typename Base::Parm2 Parm2;
-    typedef typename Base::Parm3 Parm3;
-    typedef typename Base::Parm4 Parm4;
-    typedef typename Base::Parm5 Parm5;
-    typedef typename Base::Parm6 Parm6;
-    typedef typename Base::Parm7 Parm7;
-    typedef typename Base::Parm8 Parm8;
-    typedef typename Base::Parm9 Parm9;
-    typedef typename Base::Parm10 Parm10;
-    typedef typename Base::Parm11 Parm11;
-    typedef typename Base::Parm12 Parm12;
-    typedef typename Base::Parm13 Parm13;
-    typedef typename Base::Parm14 Parm14;
-    typedef typename Base::Parm15 Parm15;
-
-    Chainer(const Fun1& fun1, const Fun2& fun2) : f1_(fun1), f2_(fun2) {}
-
-    LOKI_DEFINE_CLONE_FUNCTORIMPL(Chainer)
-
-#ifdef LOKI_FUNCTORS_ARE_COMPARABLE
-
-    bool operator==(const typename Base::Impl::FunctorImplBaseType& rhs) const
-    {
-        if (typeid(*this) != typeid(rhs))
-            return false; // cannot be equal
-        // if this line gives a compiler error, you are using a function object.
-        // you need to implement bool MyFnObj::operator == (const MyFnObj&) const;
-        return    f1_ == ((static_cast<const Chainer&> (rhs)).f2_) &&
-                  f2_ == ((static_cast<const Chainer&> (rhs)).f1_);
-    }
-#endif
-
-    // operator() implementations for up to 15 arguments
-
-    ResultType operator()()
-    { return f1_(), f2_(); }
-
-    ResultType operator()(Parm1 p1)
-    { return f1_(p1), f2_(p1); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2)
-    { return f1_(p1, p2), f2_(p1, p2); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
-    { return f1_(p1, p2, p3), f2_(p1, p2, p3); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-    { return f1_(p1, p2, p3, p4), f2_(p1, p2, p3, p4); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-    { return f1_(p1, p2, p3, p4, p5), f2_(p1, p2, p3, p4, p5); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6)
-    { return f1_(p1, p2, p3, p4, p5, p6), f2_(p1, p2, p3, p4, p5, p6); }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7),
-               f2_(p1, p2, p3, p4, p5, p6, p7);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                   p14),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                   p14);
-    }
-
-    ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-                          Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
-                          Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
-    {
-        return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                   p14, p15),
-               f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
-                   p14, p15);
-    }
-
-private:
-    Fun1 f1_;
-    Fun2 f2_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  Chains two functor calls one after another
-///  \ingroup FunctorGroup
-////////////////////////////////////////////////////////////////////////////////
-
-
-template <class Fun1, class Fun2>
-Fun2 Chain(
-    const Fun1& fun1,
-    const Fun2& fun2)
-{
-    return Fun2(std::auto_ptr<typename Fun2::Impl>(
-                    new Chainer<Fun1, Fun2>(fun1, fun2)));
-}
-
-} // namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/HierarchyGenerators.h b/shared/loki/HierarchyGenerators.h
deleted file mode 100644
index 126e0f3e..00000000
--- a/shared/loki/HierarchyGenerators.h
+++ /dev/null
@@ -1,291 +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_HIERARCHYGENERATORS_INC_
-#define LOKI_HIERARCHYGENERATORS_INC_
-
-// $Id: HierarchyGenerators.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-#include "Typelist.h"
-#include "TypeTraits.h"
-#include "EmptyType.h"
-
-namespace Loki
-{
-#if defined(_MSC_VER) && _MSC_VER >= 1300
-#pragma warning( push )
-// 'class1' : base-class 'class2' is already a base-class of 'class3'
-#pragma warning( disable : 4584 )
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// class template GenScatterHierarchy
-// Generates a scattered hierarchy starting from a typelist and a template
-// Invocation (TList is a typelist, Unit is a template of one arg):
-// GenScatterHierarchy<TList, Unit>
-// The generated class inherits all classes generated by instantiating the
-// template 'Unit' with the types contained in TList
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-// The following type helps to overcome subtle flaw in the original
-// implementation of GenScatterHierarchy.
-// The flaw is revealed when the input type list of GenScatterHierarchy
-// contains more then one element of the same type (e.g. LOKI_TYPELIST_2(int, int)).
-// In this case GenScatterHierarchy will contain multiple bases of the same
-// type and some of them will not be reachable (per 10.3).
-// For example before the fix the first element of Tuple<LOKI_TYPELIST_2(int, int)>
-// is not reachable in any way!
-template<class, class>
-struct ScatterHierarchyTag;
-}
-
-template <class TList, template <class> class Unit>
-class GenScatterHierarchy;
-
-template <class T1, class T2, template <class> class Unit>
-class GenScatterHierarchy<Typelist<T1, T2>, Unit>
-    : public GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit>
-    , public GenScatterHierarchy<T2, Unit>
-{
-public:
-    typedef Typelist<T1, T2> TList;
-    // Insure that LeftBase is unique and therefore reachable
-    typedef GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit> LeftBase;
-    typedef GenScatterHierarchy<T2, Unit> RightBase;
-    template <typename T> struct Rebind
-    {
-        typedef Unit<T> Result;
-    };
-};
-
-// In the middle *unique* class that resolve possible ambiguity
-template <class T1, class T2, template <class> class Unit>
-class GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit>
-    : public GenScatterHierarchy<T1, Unit>
-{
-};
-
-template <class AtomicType, template <class> class Unit>
-class GenScatterHierarchy : public Unit<AtomicType>
-{
-    typedef Unit<AtomicType> LeftBase;
-    template <typename T> struct Rebind
-    {
-        typedef Unit<T> Result;
-    };
-};
-
-template <template <class> class Unit>
-class GenScatterHierarchy<NullType, Unit>
-{
-    template <typename T> struct Rebind
-    {
-        typedef Unit<T> Result;
-    };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// function template Field
-// Accesses a field in an object of a type generated with GenScatterHierarchy
-// Invocation (obj is an object of a type H generated with GenScatterHierarchy,
-//     T is a type in the typelist used to generate H):
-// Field<T>(obj)
-// returns a reference to Unit<T>, where Unit is the template used to generate H
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class H>
-typename H::template Rebind<T>::Result& Field(H& obj)
-{
-    return obj;
-}
-
-template <class T, class H>
-const typename H::template Rebind<T>::Result& Field(const H& obj)
-{
-    return obj;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// function template TupleUnit
-// The building block of tuples
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-struct TupleUnit
-{
-    T value_;
-    operator T& () { return value_; }
-    operator const T& () const { return value_; }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Tuple
-// Implements a tuple class that holds a number of values and provides field
-//     access to them via the Field function (below)
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList>
-struct Tuple : public GenScatterHierarchy<TList, TupleUnit>
-{
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// helper class template FieldHelper
-// See Field below
-////////////////////////////////////////////////////////////////////////////////
-
-template <class H, unsigned int i> struct FieldHelper;
-
-template <class H>
-struct FieldHelper<H, 0>
-{
-    typedef typename H::TList::Head ElementType;
-    typedef typename H::template Rebind<ElementType>::Result UnitType;
-
-    enum
-    {
-        isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
-        isConst = TypeTraits<H>::isConst
-    };
-
-    typedef const typename H::LeftBase ConstLeftBase;
-
-    typedef typename Select < isConst, ConstLeftBase,
-            typename H::LeftBase >::Result LeftBase;
-
-    typedef typename Select < isTuple, ElementType,
-            UnitType >::Result UnqualifiedResultType;
-
-    typedef typename Select < isConst, const UnqualifiedResultType,
-            UnqualifiedResultType >::Result ResultType;
-
-    static ResultType& Do(H& obj)
-    {
-        LeftBase& leftBase = obj;
-        return leftBase;
-    }
-};
-
-template <class H, unsigned int i>
-struct FieldHelper
-{
-    typedef typename TL::TypeAt<typename H::TList, i>::Result ElementType;
-    typedef typename H::template Rebind<ElementType>::Result UnitType;
-
-    enum
-    {
-        isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
-        isConst = TypeTraits<H>::isConst
-    };
-
-    typedef const typename H::RightBase ConstRightBase;
-
-    typedef typename Select < isConst, ConstRightBase,
-            typename H::RightBase >::Result RightBase;
-
-    typedef typename Select < isTuple, ElementType,
-            UnitType >::Result UnqualifiedResultType;
-
-    typedef typename Select < isConst, const UnqualifiedResultType,
-            UnqualifiedResultType >::Result ResultType;
-
-    static ResultType& Do(H& obj)
-    {
-        RightBase& rightBase = obj;
-        return FieldHelper < RightBase, i - 1 >::Do(rightBase);
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// function template Field
-// Accesses a field in an object of a type generated with GenScatterHierarchy
-// Invocation (obj is an object of a type H generated with GenScatterHierarchy,
-//     i is the index of a type in the typelist used to generate H):
-// Field<i>(obj)
-// returns a reference to Unit<T>, where Unit is the template used to generate H
-//     and T is the i-th type in the typelist
-////////////////////////////////////////////////////////////////////////////////
-
-template <int i, class H>
-typename FieldHelper<H, i>::ResultType&
-Field(H& obj)
-{
-    return FieldHelper<H, i>::Do(obj);
-}
-
-//    template <int i, class H>
-//    const typename FieldHelper<H, i>::ResultType&
-//    Field(const H& obj)
-//    {
-//        return FieldHelper<H, i>::Do(obj);
-//    }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template GenLinearHierarchy
-// Generates a linear hierarchy starting from a typelist and a template
-// Invocation (TList is a typelist, Unit is a template of two args):
-// GenScatterHierarchy<TList, Unit>
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class TList,
-      template <class AtomicType, class Base> class Unit,
-      class Root = EmptyType
-      >
-class GenLinearHierarchy;
-
-template
-<
-class T1,
-      class T2,
-      template <class, class> class Unit,
-      class Root
-      >
-class GenLinearHierarchy<Typelist<T1, T2>, Unit, Root>
-    : public Unit< T1, GenLinearHierarchy<T2, Unit, Root> >
-{
-};
-
-template
-<
-class T,
-      template <class, class> class Unit,
-      class Root
-      >
-class GenLinearHierarchy<Typelist<T, NullType>, Unit, Root>
-    : public Unit<T, Root>
-{
-};
-
-template
-<
-template <class, class> class Unit,
-         class Root
-         >
-class GenLinearHierarchy<NullType , Unit, Root>
-    : public Root // is this better: Unit<NullType, Root> ?
-{
-};
-
-#if defined(_MSC_VER) && _MSC_VER >= 1300
-#pragma warning( pop )
-#endif
-}   // namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/Key.h b/shared/loki/Key.h
deleted file mode 100644
index a416d6a9..00000000
--- a/shared/loki/Key.h
+++ /dev/null
@@ -1,766 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-//
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_KEY_INC_
-#define LOKI_KEY_INC_
-
-// $Id: Key.h 771 2006-10-27 18:05:03Z clitte_bbt $
-
-
-#include <loki/Factory.h>
-
-namespace Loki
-{
-
-template <
-class Factory,
-      typename IdentifierType
-      >
-class Key;
-
-template<class F, typename I>
-bool operator==(const Key<F, I> &k1, const Key<F, I> &k2);
-
-template<class F, typename I>
-bool operator<(const Key<F, I> &k1, const Key<F, I> &k2);
-
-
-/**
- * A Key class
- */
-template <
-class Factory,
-      typename IdentifierType
-      >
-class Key
-{
-    typedef typename Factory::Parm1 Parm1;
-    typedef typename Factory::Parm2 Parm2;
-    typedef typename Factory::Parm3 Parm3;
-    typedef typename Factory::Parm4 Parm4;
-    typedef typename Factory::Parm5 Parm5;
-    typedef typename Factory::Parm6 Parm6;
-    typedef typename Factory::Parm7 Parm7;
-    typedef typename Factory::Parm8 Parm8;
-    typedef typename Factory::Parm9 Parm9;
-    typedef typename Factory::Parm10 Parm10;
-    typedef typename Factory::Parm11 Parm11;
-    typedef typename Factory::Parm12 Parm12;
-    typedef typename Factory::Parm13 Parm13;
-    typedef typename Factory::Parm14 Parm14;
-    typedef typename Factory::Parm15 Parm15;
-public:
-    // member variables
-    int count; // should be const, but constness prevent default copy ctor
-    IdentifierType id;
-    Parm1  p1;
-    Parm2  p2;
-    Parm3  p3;
-    Parm4  p4;
-    Parm5  p5;
-    Parm6  p6;
-    Parm7  p7;
-    Parm8  p8;
-    Parm9  p9;
-    Parm10 p10;
-    Parm11 p11;
-    Parm12 p12;
-    Parm13 p13;
-    Parm14 p14;
-    Parm15 p15;
-
-    // member functions
-    Key() : count(-1)
-    {
-    }
-
-    Key(const IdentifierType& id) : count(0)
-    {
-        this->id = id;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1) : count(1)
-    {
-        this->id = id;
-        this->p1 = p1;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2) : count(2)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3) : count(3)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4) : count(4)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5& p5) : count(5)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5& p5,
-        Parm6& p6) : count(6)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5& p5,
-        Parm6& p6, Parm7& p7 ) : count(7)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5& p5,
-        Parm6& p6, Parm7& p7, Parm8& p8) : count(8)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5& p5,
-        Parm6& p6, Parm7& p7, Parm8& p8, Parm9& p9) : count(9)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1& p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5& p5,
-        Parm6& p6, Parm7& p7, Parm8& p8, Parm9& p9, Parm10& p10) : count(10)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-        this->p10 = p10;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1&  p1, Parm2& p2, Parm3& p3, Parm4& p4, Parm5&  p5,
-        Parm6&  p6, Parm7& p7, Parm8& p8, Parm9& p9, Parm10& p10,
-        Parm11& p11) : count(11)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-        this->p10 = p10;
-        this->p11 = p11;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1&  p1,  Parm2&  p2, Parm3& p3, Parm4& p4, Parm5&  p5,
-        Parm6&  p6,  Parm7&  p7, Parm8& p8, Parm9& p9, Parm10& p10,
-        Parm11& p11, Parm12& p12) : count(12)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-        this->p10 = p10;
-        this->p11 = p11;
-        this->p12 = p12;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1&  p1,  Parm2&  p2,  Parm3&  p3, Parm4& p4, Parm5&  p5,
-        Parm6&  p6,  Parm7&  p7,  Parm8&  p8, Parm9& p9, Parm10& p10,
-        Parm11& p11, Parm12& p12, Parm13& p13) : count(13)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-        this->p10 = p10;
-        this->p11 = p11;
-        this->p12 = p12;
-        this->p13 = p13;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1&  p1,  Parm2&  p2,  Parm3&  p3,  Parm4&  p4, Parm5&  p5,
-        Parm6&  p6,  Parm7&  p7,  Parm8&  p8,  Parm9&  p9, Parm10& p10,
-        Parm11& p11, Parm12& p12, Parm13& p13, Parm14& p14) : count(14)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-        this->p10 = p10;
-        this->p11 = p11;
-        this->p12 = p12;
-        this->p13 = p13;
-        this->p14 = p14;
-    }
-
-    Key(const IdentifierType& id,
-        Parm1&  p1,  Parm2&  p2,  Parm3&  p3,  Parm4&  p4,  Parm5&  p5,
-        Parm6&  p6,  Parm7&  p7,  Parm8&  p8,  Parm9&  p9,  Parm10& p10,
-        Parm11& p11, Parm12& p12, Parm13& p13, Parm14& p14, Parm15& p15) : count(15)
-    {
-        this->id = id;
-        this->p1 = p1;
-        this->p2 = p2;
-        this->p3 = p3;
-        this->p4 = p4;
-        this->p5 = p5;
-        this->p6 = p6;
-        this->p7 = p7;
-        this->p8 = p8;
-        this->p9 = p9;
-        this->p10 = p10;
-        this->p11 = p11;
-        this->p12 = p12;
-        this->p13 = p13;
-        this->p14 = p14;
-        this->p15 = p15;
-    }
-
-    template<class F, typename I>
-    friend bool operator==(const Key<F, I> &k1, const Key<F, I> &k2);
-
-    template<class F, typename I>
-    friend bool operator<(const Key<F, I> &k1, const Key<F, I> &k2);
-};
-
-
-template<class F, typename I>
-bool operator==(const Key<F, I> &k1, const Key<F, I> &k2)
-{
-    if ( k1.count != k2.count )
-        return false;
-    switch (k1.count)
-    {
-        case -1:
-            return true;
-        case 0:
-            if ( k1.id == k2.id )
-                return true;
-            else
-                return false;
-        case 1:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) )
-                return true;
-            else
-                return false;
-        case 2:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) )
-                return true;
-            else
-                return false;
-        case 3:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) )
-                return true;
-            else
-                return false;
-        case 4:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) )
-                return true;
-            else
-                return false;
-        case 5:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) )
-                return true;
-            else
-                return false;
-        case 6:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) )
-                return true;
-            else
-                return false;
-        case 7:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) )
-                return true;
-            else
-                return false;
-        case 8:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) )
-                return true;
-            else
-                return false;
-        case 9:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) )
-                return true;
-            else
-                return false;
-        case 10:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) &&
-                 (k1.p10 == k2.p10) )
-                return true;
-            else
-                return false;
-        case 11:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) &&
-                 (k1.p10 == k2.p10) &&
-                 (k1.p11 == k2.p11) )
-                return true;
-            else
-                return false;
-        case 12:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) &&
-                 (k1.p10 == k2.p10) &&
-                 (k1.p11 == k2.p11) &&
-                 (k1.p12 == k2.p12) )
-                return true;
-            else
-                return false;
-        case 13:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) &&
-                 (k1.p10 == k2.p10) &&
-                 (k1.p11 == k2.p11) &&
-                 (k1.p12 == k2.p12) &&
-                 (k1.p13 == k2.p13) )
-                return true;
-            else
-                return false;
-        case 14:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) &&
-                 (k1.p10 == k2.p10) &&
-                 (k1.p11 == k2.p11) &&
-                 (k1.p12 == k2.p12) &&
-                 (k1.p13 == k2.p13) &&
-                 (k1.p14 == k2.p14) )
-                return true;
-            else
-                return false;
-        case 15:
-            if ( (k1.id == k2.id) &&
-                 (k1.p1 == k2.p1) &&
-                 (k1.p2 == k2.p2) &&
-                 (k1.p3 == k2.p3) &&
-                 (k1.p4 == k2.p4) &&
-                 (k1.p5 == k2.p5) &&
-                 (k1.p6 == k2.p6) &&
-                 (k1.p7 == k2.p7) &&
-                 (k1.p8 == k2.p8) &&
-                 (k1.p9 == k2.p9) &&
-                 (k1.p10 == k2.p10) &&
-                 (k1.p11 == k2.p11) &&
-                 (k1.p12 == k2.p12) &&
-                 (k1.p13 == k2.p13) &&
-                 (k1.p14 == k2.p14) &&
-                 (k1.p15 == k2.p15) )
-                return true;
-            else
-                return false;
-        default:
-            return false;
-    }
-}
-
-
-
-template<class F, typename I>
-bool operator<(const Key<F, I> &k1, const Key<F, I> &k2)
-{
-    if ( k1.count < k2.count )
-        return true;
-    switch (k1.count)
-    {
-        case -1:
-            return false;
-        case 0:
-            if ( k1.id < k2.id )
-                return true;
-            else
-                return false;
-        case 1:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) )
-                return true;
-            else
-                return false;
-        case 2:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) )
-                return true;
-            else
-                return false;
-        case 3:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) )
-                return true;
-            else
-                return false;
-        case 4:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) )
-                return true;
-            else
-                return false;
-        case 5:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) )
-                return true;
-            else
-                return false;
-        case 6:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) )
-                return true;
-            else
-                return false;
-        case 7:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) )
-                return true;
-            else
-                return false;
-        case 8:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) )
-                return true;
-            else
-                return false;
-        case 9:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) )
-                return true;
-            else
-                return false;
-        case 10:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) ||
-                 (k1.p10 < k2.p10) )
-                return true;
-            else
-                return false;
-        case 11:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) ||
-                 (k1.p10 < k2.p10) ||
-                 (k1.p11 < k2.p11) )
-                return true;
-            else
-                return false;
-        case 12:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) ||
-                 (k1.p10 < k2.p10) ||
-                 (k1.p11 < k2.p11) ||
-                 (k1.p12 < k2.p12) )
-                return true;
-            else
-                return false;
-        case 13:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) ||
-                 (k1.p10 < k2.p10) ||
-                 (k1.p11 < k2.p11) ||
-                 (k1.p12 < k2.p12) ||
-                 (k1.p13 < k2.p13) )
-                return true;
-            else
-                return false;
-        case 14:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) ||
-                 (k1.p10 < k2.p10) ||
-                 (k1.p11 < k2.p11) ||
-                 (k1.p12 < k2.p12) ||
-                 (k1.p13 < k2.p13) ||
-                 (k1.p14 < k2.p14) )
-                return true;
-            else
-                return false;
-        case 15:
-            if ( (k1.id < k2.id) ||
-                 (k1.p1 < k2.p1) ||
-                 (k1.p2 < k2.p2) ||
-                 (k1.p3 < k2.p3) ||
-                 (k1.p4 < k2.p4) ||
-                 (k1.p5 < k2.p5) ||
-                 (k1.p6 < k2.p6) ||
-                 (k1.p7 < k2.p7) ||
-                 (k1.p8 < k2.p8) ||
-                 (k1.p9 < k2.p9) ||
-                 (k1.p10 < k2.p10) ||
-                 (k1.p11 < k2.p11) ||
-                 (k1.p12 < k2.p12) ||
-                 (k1.p13 < k2.p13) ||
-                 (k1.p14 < k2.p14) ||
-                 (k1.p15 < k2.p15) )
-                return true;
-            else
-                return false;
-        default:
-            return false;
-    }
-}
-
-
-
-} // namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/LevelMutex.h b/shared/loki/LevelMutex.h
deleted file mode 100644
index eb01f44a..00000000
--- a/shared/loki/LevelMutex.h
+++ /dev/null
@@ -1,1211 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-//
-// LevelMutex facility for the Loki Library
-// Copyright (c) 2008 Richard 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 LevelMutex.h Defines classes and functions for LevelMutex facility.
-
-#ifndef LOKI_LEVEL_MUTEX_H_INCLUDED
-#define LOKI_LEVEL_MUTEX_H_INCLUDED
-
-
-// ----------------------------------------------------------------------------
-
-#include <vector>
-#include <assert.h>
-#include <time.h>
-
-#if defined( _MSC_VER )
-#include <Windows.h>
-#else
-#include <pthread.h>
-#endif
-
-#if !defined(_WIN32) && !defined(_WIN64)
-#include <unistd.h> // declares sleep under Linux
-#endif
-
-/** @par thread_local Keyword
- The mutexes require compilers to provide thread local storage - meaning each
- thread gets its own copy of the data.  The next version of C++ will have a
- new keyword, thread_local for that purpose.  Some existing compilers already
- provide thread local storage using different syntax, so these lines use
- thread_local to mimic that syntax.  If your compiler provides thread local
- storage but using different syntax besides "thread_local", you may want to
- modify these lines.  If your compiler does not support thread local storage,
- you can't use LevelMutex.
- */
-#ifndef LOKI_THREAD_LOCAL
-#if defined( _MSC_VER )
-#if ( _MSC_VER >= 1300 )
-#define LOKI_THREAD_LOCAL __declspec( thread )
-#else
-#error "Only Visual Studio versions 7.0 and after supported."
-#endif
-
-#elif ( __GNUC__ )
-#define LOKI_THREAD_LOCAL __thread
-
-#else
-#warning "Check if your compiler provides thread local storage."
-#define LOKI_THREAD_LOCAL thread_local
-#endif
-#endif
-
-#if defined( DEBUG ) || defined( _DEBUG )
-#define LOKI_MUTEX_DEBUG_CODE( x ) x
-#else
-#define LOKI_MUTEX_DEBUG_CODE( x )
-#endif
-
-
-namespace Loki
-{
-
-
-// ----------------------------------------------------------------------------
-
-class MutexErrors
-{
-public:
-
-    /// @enum Type Possible error conditions detected by LevelMutex functions.
-    enum Type
-    {
-        Success = 0,        ///< Operation occurred correctly.
-        NoProblem,          ///< Pre-lock and pre-unlock checks passed.
-        WrongLevel,         ///< All mutexes in container must have same level.
-        LevelTooLow,        ///< Trying to unlock a mutex lower than current level.
-        LevelTooHigh,       ///< Trying to lock a mutex higher than current level.
-        TryFailed,          ///< TryLock call failed to lock mutex.
-        NullMutexPointer,   ///< Container has a NULL pointer in it.
-        DuplicateMutex,     ///< Container must have unique pointers - no duplicates.
-        EmptyContainer,     ///< Container must have at least 1 pointer in it.
-        AlreadyLocked,      ///< TryLock call failed because mutex already locked.
-        WasntLocked,        ///< Unlock failed because mutex was not even locked.
-        NotRecentLock,      ///< Mutex in container was not recently locked by this thread.
-        NotLockedByThread,  ///< Can't unlock a mutex not locked by this thread.
-        MultiUnlockFailed,  ///< MultiUnlock can't unlock at least 1 mutex in container.
-        TimedOut,           ///< Wait time elapsed without locking mutex.
-        TooMuchRecursion,   ///< Tried to relock a PThread mutex which is not re-entrant.
-        NotInitialized,     ///< Tried to lock a PThread mutex which did not get setup.
-        AlreadyInitialized, ///< PThread mutex initialized before ctor called.
-        InvalidAttribute,   ///< PThread mutex improperly initialized.
-        InvalidAddress,     ///< Bad pointer used to initialize a PThread mutex.
-        ExceptionThrown,    ///< Exception caught in mutex operation.
-        MayDeadlock,        ///< Locking this mutex may cause a deadlock.
-        OtherError          ///< Unknown error occurred.
-    };
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class LevelMutexInfo
- This monolithic base class stores common info for a template class used to
- control mutexes.  The template class, LevelMutex, is policy-based class.
-
- @par Implementation
- Each thread has a list of mutexes it locked.  When a mutex first gets locked, it
- gets added to the head of the list.  If locked again, LevelMutex merely increments
- a count.  When unlocked, the count gets decremented until it reaches zero, and
- then it gets removed from the list.  Each mutex has a pointer to the mutex most
- recently locked by the current thread.  The current level of a thread is always
- the level of the most recently locked mutex, or UnlockedLevel if the thread does
- not have any mutexes locked now.  A mutex is considered "recently" locked if it is at
- the head of the list, or the same level as the current mutex and also locked by the
- current thread.
-
- @par Class Invariants
- This class maintains invariants for each LevelMutexInfo so that no function
- calls corrupt a mutex.  Each function makes a call to IsValid at the start so
- that LevelMutex knows it acts on valid internal data.  Many functions call
- IsValid again when they return to insure the function did not leave any data in
- an invalid state.  The exit call to IsValid occurs through a tiny helper class
- called Checker to insure all data remain valid even when exceptions occur.
- Another helper class, MutexUndoer, unlocks mutexes in a container if an
- exception occurs during calls to MultiLock.
-
- @par Error Results
- Many functions return an enum value to indicate an error status.  Many enum values
- indicate errors detected within LevelMutex, but some indicate errors found in policy
- classes, SpinLevelMutex and SleepLevelMutex.
- */
-
-class LevelMutexInfo
-{
-public:
-
-    /** Level for thread that has not locked any mutex. Maximum possible level
-     for a mutex is UnlockedLevel-1;  No mutex may have a level of UnlockedLevel.
-     */
-    static const unsigned int UnlockedLevel = 0xFFFFFFFF;
-
-    /// Container for locking multiple mutexes at once.
-    typedef ::std::vector< volatile LevelMutexInfo* > MutexContainer;
-    typedef MutexContainer::iterator LevelMutexContainerIter;
-    typedef MutexContainer::const_iterator LevelMutexContainerCIter;
-    typedef MutexContainer::reverse_iterator LevelMutexContainerRIter;
-    typedef MutexContainer::const_reverse_iterator LevelMutexContainerCRIter;
-
-    /** Locks several mutexes at once.  Requires O(m + n*n) actions where m is the
-     number of mutexes currently locked by the thread and n is the number of mutexes
-     in the container. This provides strong exception safety. If an exception occurs,
-     any mutexes that were locked during this call will get unlocked.
-     @param mutexes Container of pointers to mutexes.  Container must have at
-      least 1 mutex, all mutexes must have the same level, no NULL pointers, and all
-      mutexes must not exceed the thread's current level.  This sorts the container
-      by address order.
-     @return Enum value indicating success or error.
-     */
-    static MutexErrors::Type MultiLock( MutexContainer& mutexes );
-
-    /** Locks several mutexes at once.  Requires O(m + n*n + n*t) actions where m is
-     the number of mutexes currently locked by the thread, n is the number of mutexes
-     in the container, and t is the wait time for each mutex. This provides strong
-     exception safety.  If an exception occurs, any mutexes that were locked during
-     this call will ge unlocked.
-     @param mutexes Container of pointers to mutexes.  Container must have at
-      least 1 mutex, all mutexes must have the same level, no NULL pointers, and all
-      mutexes must not exceed the thread's current level.  This sorts the container
-      by address order.
-     @param milliSeconds Amount of time to wait for each mutex.
-     @return Enum value indicating success or error.
-     */
-    static MutexErrors::Type MultiLock( MutexContainer& mutexes,
-                                        unsigned int milliSeconds );
-
-    /** Unlocks several mutexes at once.  Requires O(m) actions where m is the number of
-     mutexes in the container. This provides strong exception safety. If an exception
-     occurs when unlocking one mutex, other mutexes in the container get unlocked anyway.
-     @param mutexes Container of pointers to mutexes.  Container must have at least 1
-      mutex, all mutexes must have the same level, no NULL pointers, and all mutexes must
-      be locked by the current thread.  This sorts the container dby address order.
-     @return Enum value indicating success or error.
-     */
-    static MutexErrors::Type MultiUnlock( MutexContainer& mutexes );
-
-    /** Gives pointer to most recently locked mutex, or NULL if nothing locked.
-     The pointer is for a const mutex so the mutex can't be modified inappropriately.
-     The pointer is for a volatile mutex so callers can call volatile member
-     functions to get info about the mutex.
-     */
-    static const volatile LevelMutexInfo* GetCurrentMutex( void );
-
-    /// Returns the level of this mutex.
-    inline unsigned int GetLevel( void ) const volatile { return m_level; }
-
-    /// Returns true if this mutex was locked at least once.
-    inline bool IsLocked( void ) const volatile { return ( 0 < m_count ); }
-
-    /// Returns count of how many times this mutex got locked.
-    inline unsigned int GetLockCount( void ) const volatile { return m_count; }
-
-    /// Returns pointer to mutex previously locked by the thread which locked this.
-    inline const volatile LevelMutexInfo* GetPrevious( void ) const volatile
-    {
-        return m_previous;
-    }
-
-    /** Tries to lock mutex, and returns immediately if mutex already locked by
-     another thread.  It will return immediately with a value of AlreadyLocked
-     if the mutex was locked by a different thread.  It may throw an exception
-     or assert when errors occur if the ErrorPolicy class implements that behavior.
-     @return An error condition if any occurred, else Success.
-     */
-    virtual MutexErrors::Type TryLock( void ) volatile = 0;
-
-    /** Blocking call will attempt to lock mutex and wait until it can lock.
-     This may throw an exception if the lock failed or an error occurred - if
-     that is what the error policy specifies.
-     @return An error condition if any occurred, else Success.
-     */
-    virtual MutexErrors::Type Lock( void ) volatile = 0;
-
-    /** Attempts to lock mutex, but only waits for a limited amount of time
-     before it gives up.  Will return quickly if an error occurs before any
-     attempt to lock.  This may throw an exception if the lock failed or an
-     error occurred - if that is what the error policy specifies.
-     @param milliSeconds How long to wait.
-     @return An error condition if any occurred, else Success.
-     */
-    virtual MutexErrors::Type Lock( unsigned int milliSeconds ) volatile = 0;
-
-    /** Unlocks the mutex, or returns an error condition.  This may throw an
-     exception if the lock failed or an error occurred - if that is what the
-     error policy specifies.
-     @return An error condition if any occurred, else Success.
-     */
-    virtual MutexErrors::Type Unlock( void ) volatile = 0;
-
-    /** Returns true if this mutex was locked by current thread, and level is the same
-     as the current thread's level.  Which means this was the most recently locked
-     mutex, or it was locked along with several others of the same level recently.
-     */
-    bool IsRecentLock( void ) const volatile;
-
-    /** Returns true if this mutex was locked within the last count mutexes.
-     @param count How many recent mutexes to look through to find this mutex.
-     */
-    bool IsRecentLock( unsigned int count ) const volatile;
-
-    /// Returns true if this was locked by current thread.
-    bool IsLockedByCurrentThread( void ) const volatile;
-
-    /// Returns true if this was locked by another thread.
-    bool IsLockedByAnotherThread( void ) const volatile;
-
-protected:
-
-    /** @class Checker Performs validity check on mutex to insure no class invariants
-     were violated inside any member function.  This class only gets used in debug
-     builds, and any instance of it gets optimized away in release builds.  A checker
-     is created inside many of member functions so that it's destructor gets called
-     when the function exits.  It determines if any class invariants were violated
-     during the function call.
-     */
-    class Checker
-    {
-    public:
-        inline explicit Checker( const volatile LevelMutexInfo* mutex ) :
-            m_mutex( mutex ) {}
-        inline ~Checker( void ) { m_mutex->IsValid(); }
-    private:
-        Checker( void );
-        Checker( const Checker& );
-        Checker& operator = ( const Checker& );
-        const volatile LevelMutexInfo* m_mutex;
-    };
-
-    /** @class MutexUndoer
-     Undoes actions by MultiLock if an exception occurs.  It keeps track of
-     which mutexes in a container got locked, and if an exception occurs, then
-     the destructor unlocks them.  If MultiLock succeeds, then it cancels the
-     undoer so nothing gets unlocked inadvertently.
-     */
-    class MutexUndoer
-    {
-    public:
-
-        explicit MutexUndoer( MutexContainer& mutexes );
-        ~MutexUndoer( void );
-        void SetPlace( LevelMutexContainerIter& here );
-        void Cancel( void );
-
-    private:
-
-        MutexUndoer( void );
-        MutexUndoer( const MutexUndoer& );
-        MutexUndoer& operator = ( const MutexUndoer& );
-
-        MutexContainer& m_mutexes;
-        LevelMutexContainerIter m_here;
-    };
-
-    /** Returns true if linked-list of locked mutexes in this thread is valid.
-     Which means the list has no loops, and each previous mutex on the list has a
-     higher or same level as the current mutex.  Called by IsValid.
-     */
-    static bool IsValidList( void );
-
-    /** This is the only available constructor, and it forces any derived class to set
-     a level for each mutex.
-     */
-    explicit LevelMutexInfo( unsigned int level );
-
-    /// The destructor only gets called by the derived class.
-    virtual ~LevelMutexInfo( void );
-
-    MutexErrors::Type PreLockCheck( bool forTryLock ) volatile;
-
-    MutexErrors::Type PreUnlockCheck( void ) volatile;
-
-    /** This gets called after each call to DoLock and DoTryLock to make sure the data
-     members in this object get set correctly.
-     */
-    void PostLock( void ) volatile;
-
-    /// Gets called just before an attempt to unlock a mutex.
-    void PreUnlock( void ) volatile;
-
-    /// Called to relock a mutex already locked by the current thread.
-    void IncrementCount( void ) volatile;
-
-    /// Called to unlock a mutex locked multiple times by the current thread.
-    void DecrementCount( void ) volatile;
-
-    /** Returns true if no class invariant broken, otherwise asserts.  This function
-    only gets called in debug builds.
-     */
-    bool IsValid( void ) const volatile;
-
-private:
-
-    /// Copy constructor is not implemented.
-    LevelMutexInfo( const LevelMutexInfo& );
-    /// Copy-assignment operator is not implemented.
-    LevelMutexInfo& operator = ( const LevelMutexInfo& );
-
-    /** Called only by MultiLock & MultiUnlock to pass a result through an
-     error checking policy.
-     @param result What error condition to check.
-     @return Result or assertion or an exception - depending on error policy.
-     */
-    virtual MutexErrors::Type DoErrorCheck( MutexErrors::Type result ) const volatile = 0;
-
-    /// Called only by MultiLock to Lock each particular mutex within a container.
-    virtual MutexErrors::Type LockThis( void ) volatile = 0;
-
-    /** Called only by MultiLock to lock each particular mutex within a container.
-     @param milliSeconds How much time to wait before giving up on locking a mutex.
-     */
-    virtual MutexErrors::Type LockThis( unsigned int milliSeconds ) volatile = 0;
-
-    /// Called only by MultiUnlock to unlock each particular mutex within a container.
-    virtual MutexErrors::Type UnlockThis( void ) volatile = 0;
-
-    /// Pointer to singly-linked list of mutexes locked by the current thread.
-    static LOKI_THREAD_LOCAL volatile LevelMutexInfo* s_currentMutex;
-
-    /// Level of this mutex.
-    const unsigned int m_level;
-
-    /// How many times this mutex got locked.
-    unsigned int m_count;
-
-    /// Pointer to mutex locked before this one.
-    volatile LevelMutexInfo* m_previous;
-
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class ThrowOnAnyMutexError
- Implements the ErrorPolicy for LevelMutex and throws an exception for any
- error condition.  Only allows MutexErrors::Success and MutexErrors::NoProblem
- to get through.  Useful for release builds.
- */
-class ThrowOnAnyMutexError
-{
-public:
-    static MutexErrors::Type CheckError( MutexErrors::Type error,
-                                         unsigned int level );
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class ThrowOnBadDesignMutexError
- Implements the ErrorPolicy for LevelMutex and throws an exception if the error
- indicates the programmer did not levelize the calls to mutexes.  Otherwise
- returns the error result.  Useful for release builds.
- */
-class ThrowOnBadDesignMutexError
-{
-public:
-    static MutexErrors::Type CheckError( MutexErrors::Type error,
-                                         unsigned int level );
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class AssertAnyMutexError
- Implements the ErrorPolicy for LevelMutex and asserts for any error condition.
- Only allows MutexErrors::Success and MutexErrors::NoProblem to get through.
- Useful for testing mutexes in debug builds.
- */
-class AssertAnyMutexError
-{
-public:
-    static inline MutexErrors::Type CheckError( MutexErrors::Type error,
-                                                unsigned int level )
-    {
-        (void)level;
-        assert( ( error == MutexErrors::Success )
-                || ( error == MutexErrors::NoProblem ) );
-        return error;
-    }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class AssertBadDesignMutexError
- Implements the ErrorPolicy for LevelMutex and asserts if the error
- indicates the programmer did not levelize the calls to mutexes.  Otherwise
- returns the error result.  Useful for testing mutexes in debug builds.
- */
-class AssertBadDesignMutexError
-{
-public:
-    static inline MutexErrors::Type CheckError( MutexErrors::Type error,
-                                                unsigned int level )
-    {
-        (void)level;
-        assert( ( error != MutexErrors::LevelTooHigh )
-                && ( error != MutexErrors::LevelTooLow  ) );
-        return error;
-    }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class JustReturnMutexError
- Implements the ErrorPolicy for LevelMutex and does nothing no matter how bad
- the error condition.  Only recommended use is for automated unit-testing of
- mutex policies.
- */
-class JustReturnMutexError
-{
-public:
-    static inline MutexErrors::Type CheckError( MutexErrors::Type error,
-                                                unsigned int level )
-    {
-        (void)level;
-        return error;
-    }
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class NoMutexWait
- Implements the WaitPolicy for LevelMutex.  Does nothing at all so it turns
- all wait loops into spin loops.  Useful for low-level mutexes.
- */
-class NoMutexWait
-{
-public:
-    static inline void Wait( void ) {}
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class MutexSleepWaits
- Implements the WaitPolicy for LevelMutex.  Sleeps for a moment so thread won't
- consume idle CPU cycles.  Useful for high-level mutexes.
- */
-class MutexSleepWaits
-{
-public:
-    static void Wait( void );
-    static unsigned int sleepTime;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class SpinLevelMutex
- Implements a spin-loop to wait for the mutex to unlock.  Since this class makes
- the thread wait in a tight spin-loop, it can cause the thread to remain busy
- while waiting and thus consume CPU cycles.  For that reason, this mutex is best
- used only for very low-level resources - especially resources which do not
- require much CPU time to exercise.  Rule of thumb: Use this only if all actions
- on the resource consume a very small number of CPU cycles.  Otherwise, use the
- SleepLevelMutex instead.
- */
-class SpinLevelMutex
-{
-public:
-
-    /// Constructs a spin-level mutex.
-    explicit SpinLevelMutex( unsigned int level );
-
-    /// Destructs the mutex.
-    virtual ~SpinLevelMutex( void );
-
-    virtual MutexErrors::Type Lock( void ) volatile;
-
-    virtual MutexErrors::Type TryLock( void ) volatile;
-
-    virtual MutexErrors::Type Unlock( void ) volatile;
-
-    inline unsigned int GetLevel( void ) const volatile { return m_level; }
-
-private:
-
-    /// Copy constructor is not implemented.
-    SpinLevelMutex( const SpinLevelMutex& );
-    /// Copy-assignment operator is not implemented.
-    SpinLevelMutex& operator = ( const SpinLevelMutex& );
-
-#if defined( _MSC_VER )
-#if ( _MSC_VER >= 1300 )
-    /// The actual mutex.
-    CRITICAL_SECTION m_mutex;
-#else
-#error "Only Visual Studio versions 7.0 and after supported."
-#endif
-
-#elif ( __GNUC__ )
-    /// The actual mutex.
-    pthread_mutex_t m_mutex;
-
-#else
-#error "Check if any mutex libraries are compatible with your compiler."
-#endif
-
-    /// Keep a copy of the mutex level around for error reporting.
-    const unsigned int m_level;
-
-}; // end class SpinLevelMutex
-
-// ----------------------------------------------------------------------------
-
-/** @class SleepLevelMutex
- Implements a sleeping loop to wait for the mutex to unlock.
-
- @par Purpose
- Since this class puts the thread to sleep for short intervals, you can use this
- class for most of your mutexes. Especially for locking any high level resources
- where any one operation on the resouce consumes many CPU cycles.  The purpose of
- this mutex is to reduce the number of CPU cycles spent in idle loops.  All
- SleepLevelMutex's should have higher levels than all your SpinLevelMutex's.
-
- @par Dependence on SpinLevelMutex
- This utilizes SpinLevelMutex so it does not have to re-implement the DoTryLock
- and DoUnlock functions the same way.  All it really needs is a DoLock function
- and the amount of time it should sleep if an attempt to lock a function fails.
- */
-class SleepLevelMutex : public SpinLevelMutex
-{
-public:
-
-    /** Constructs a levelized mutex that puts threads to sleep while they wait
-     for another thread to unlock the mutex.
-     @param level Level of this mutex.
-     */
-    explicit SleepLevelMutex( unsigned int level );
-
-    SleepLevelMutex( unsigned int level, unsigned int sleepTime );
-
-    /// Destructs the mutex.
-    virtual ~SleepLevelMutex( void );
-
-    inline unsigned int GetSleepTime( void ) const volatile { return m_sleepTime; }
-
-    inline void SetSleepTime( unsigned int sleepTime ) volatile
-    {
-        if ( 0 != sleepTime )
-            m_sleepTime = sleepTime;
-    }
-
-#if defined( _MSC_VER )
-    inline bool GetWakable( void ) const volatile { return m_wakable; }
-    inline void SetWakable( bool wakable ) volatile { m_wakable = wakable; }
-#endif
-
-    /** Attempts to lock a mutex, and if it fails, then sleeps for a while
-     before attempting again.
-     */
-    virtual MutexErrors::Type Lock( void ) volatile;
-
-private:
-
-    /// Default constructor is not implemented.
-    SleepLevelMutex( void );
-    /// Copy constructor is not implemented.
-    SleepLevelMutex( const SleepLevelMutex& );
-    /// Copy-assignment operator is not implemented.
-    SleepLevelMutex& operator = ( const SleepLevelMutex& );
-
-#if defined( _MSC_VER )
-#if ( _MSC_VER >= 1300 )
-    /// True if operating system may wake thread to respond to events.
-    bool m_wakable;
-#else
-#error "Only Visual Studio versions 7.0 and after supported."
-#endif
-#endif
-
-    /// How many milli-seconds to sleep before trying to lock mutex again.
-    unsigned int m_sleepTime;
-
-}; // end class SleepLevelMutex
-
-// ----------------------------------------------------------------------------
-
-/** @class LevelMutex
- Levelized mutex class prevents deadlocks by requiring programs to lock mutexes in
- the same order, and unlock them in reverse order.  This is accomplished by forcing
- each mutex to have a level and forcing code to lock mutexes with higher levels
- before locking mutexes at lower levels.  If you want to lock several mutexes, they
- must be locked in decreasing order by level, or if they are all of the same level,
- then locked by LevelMutex::MultiLock.
-
- @par Features
- - Immune: Very unlikely to deadlock since all mutexes are locked in the same
-   order and unlocked in reverse order.
- - Scalable: Can handle any number of mutexes.
- - Efficient: Many operations occur in constant time, and most operations require
-   no more than O(m) steps.
- - Exception safe: All operations provide strong safety or don't throw.
- - Extendable: Can work with existing mutexes through policy-based design.
- - Easily Extended: Derived classes only need to implement 5 functions and a mutex
-   to get all the features of this class.
- - Re-Entrant: Allows for re-entrancy even if mutexes in policy classes don't.
- - Cost-Free: No resource allocations occur in LevelMutex - although user-defined
-   policy classes may allocate resources.
- - Compact: Each LevelMutex object is small.
- - Portable: As long as your compiler and libraries can meet the requirements.
- - Robust: Maintains data integrity even if exceptions occur in policy classes.
- - Affording: Several functions provide information about a mutex which allows
-   client code to easily choose correct actions.
-
- @par Requirements
- - Your compiler must allow for thread-specific data.
- - You must have a threading or mutex library.
-
- @par Policy-Based Design
- This class hosts 3 policies and a default level.  The policy-based design allows
- users to write their own policies to extend the behaviors of LevelMutex.  The
- paragraphs below say how to design a class for each policy.
- - MutexPolicy The mutex policy class.
- - defaultLevel A level for existing client code that calls a default constructor.
- - ErrorPolicy How the mutex should handle error conditions.
- - WaitPolicy Whether a thread should wait, and how long in some internal loops.
-
- @par MutexPolicy
- A policy class that wraps a low-level mutex. Loki provides two policy classes
- for the actual mutex (SpinLevelMutex and SleepLevelMutex), both of which wrap
- either pthreads or the Windows CRITICAL_SECTION. If you want to use a mutex
- mechanism besides one of those, then all you have to do is provide a class
- which wraps the mutex and implements these functions.
-    explicit SpinLevelMutex( unsigned int level );
-    virtual ~SpinLevelMutex( void );
-    virtual MutexErrors::Type Lock( void ) volatile;
-    virtual MutexErrors::Type TryLock( void ) volatile;
-    virtual MutexErrors::Type Unlock( void ) volatile;
- Indeed, since the base class does most of the work, and provides all the interace
- and functionality to client classes, a derived class has very few requirements.
- It only needs to implement a single constructor, the destructor, some virtual
- functions, and whatever data members it requires.  You don't actually need to
- declare those functions as virtual if the policy class is not a base or child
- class.  In the parlance of design patterns, LevelMutex is a Template, and the
- MutexPolicy is a Strategy.
-
- @par DefaultLevel
- The template class requires a default level to use inside the default constructor.
- Some existing code calls instantiates mutexes with a default constructor, so the
- mutex must know what level to use there.  Please do not use zero or UnlockedLevel
- as the default level.
-
- @par ErrorPolicy
- This policy specifies how to handle error conditions.  The mutexes can return
- errors, assert, or throw exceptions.  I recommend that debug code use asserts,
- release code use exceptions, and unit-testing code just return errors.  The
- error policy class only needs to implement one function:
-   static MutexErrors::Type CheckError( MutexErrors::Type error, unsigned int level );
-
- @par WaitPolicy
- This states whether the mutex should wait within some tight internal loops,
- how the waiting is done, and for how long.  A wait policy class could sleep,
- do nothing, check if other objects need attention, or check if the program
- received events or notices from the operating system.  It only needs to
- implement one function:
-   static void Wait( void );
-
- @par Per-Function Usage
- If you implement a function with a static local mutex, then you have to insure
- the function is not called from a lower level via call-backs, virtual functions in
- interface classes.  If the function does get called from a lower level, you are
- setting up a potential deadlock.  LevelMutex will detect that by checking the
- current level and the local mutex's level, so it will refuse to lock the local mutex.
-
- @par Per-Object Usage
- If you use a mutex as a data member of an object to protect that object, then I
- recommend specifying which functions are volatile and which are not, and then only
- use the mutex within the volatile functions.  You may also want to provide accessor
- functions so that client code can lock and unlock the mutex either to allow for
- calling multiple operations without having to lock and unlock before and after each
- operation, or so they can lock it along with several other objects at the same
- level.
-
- @par Per-Class Usage
- If you make a static data member within a class, you can use that to lock any
- resources shared by those objects, or to require threads to act on only one object
- at a time.  You may also want to provide static accessor functions so that client
- code can lock several other resources at the same level.
- */
-
-template
-<
-class MutexPolicy,
-      unsigned int DefaultLevel,
-      class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError,
-      class WaitPolicy  = ::Loki::NoMutexWait
-      >
-class LevelMutex : public LevelMutexInfo
-{
-public:
-
-    typedef ErrorPolicy EP;
-    typedef WaitPolicy  WP;
-    typedef MutexPolicy MP;
-
-    /** This constructor allows callers to replace the default level with another
-     value.  It also acts as the default constructor for existing code which uses
-     default construction for mutexes.  This is the only time the DefaultLevel
-     template parameter gets used.
-     */
-    explicit LevelMutex( unsigned int level = DefaultLevel ) :
-        LevelMutexInfo( level ),
-        m_mutex( level )
-    {
-        assert( IsValid() );
-    }
-
-    /// The destructor.
-    ~LevelMutex( void )
-    {
-        assert( IsValid() );
-    }
-
-    /** These functions allow callers to access the mutex in case they need to
-     modify specific values in the MutexPolicy (e.g. - sleep time, functors to
-     call as tasks, etc...)  There is one function for every combination of
-     const and volatile qualifiers so callers get a reference to a MutexPolicy
-     with the proper qualifiers.
-     */
-    inline const volatile MutexPolicy& GetMutexPolicy( void ) const volatile { return m_mutex; }
-    inline       volatile MutexPolicy& GetMutexPolicy( void )       volatile { return m_mutex; }
-    inline const          MutexPolicy& GetMutexPolicy( void ) const          { return m_mutex; }
-    inline                MutexPolicy& GetMutexPolicy( void )                { return m_mutex; }
-
-    virtual MutexErrors::Type TryLock( void ) volatile
-    {
-        assert( IsValid() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-
-        MutexErrors::Type result = LevelMutexInfo::PreLockCheck( true );
-        if ( MutexErrors::Success == result )
-            return MutexErrors::Success;
-        else if ( MutexErrors::AlreadyLocked == result )
-            return result;
-        else if ( MutexErrors::NoProblem != result )
-            return EP::CheckError( result, GetLevel() );
-
-        assert( 0 == LevelMutexInfo::GetLockCount() );
-        result = m_mutex.TryLock();
-        if ( MutexErrors::Success != result )
-            return EP::CheckError( result, GetLevel() );
-        LevelMutexInfo::PostLock();
-
-        return MutexErrors::Success;
-    }
-
-    virtual MutexErrors::Type Lock( void ) volatile
-    {
-        assert( IsValid() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-
-        MutexErrors::Type result = LevelMutexInfo::PreLockCheck( false );
-        if ( MutexErrors::Success == result )
-            return MutexErrors::Success;
-        else if ( MutexErrors::NoProblem != result )
-            return EP::CheckError( result, GetLevel() );
-
-        assert( !LevelMutexInfo::IsLockedByCurrentThread() );
-        result = m_mutex.Lock();
-        if ( MutexErrors::Success != result )
-            return EP::CheckError( result, GetLevel() );
-        PostLock();
-
-        return MutexErrors::Success;
-    }
-
-    virtual MutexErrors::Type Lock( unsigned int milliSeconds ) volatile
-    {
-        assert( IsValid() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-
-        MutexErrors::Type result = LevelMutexInfo::PreLockCheck( false );
-        if ( MutexErrors::Success == result )
-            return MutexErrors::Success;
-        else if ( MutexErrors::NoProblem != result )
-            return EP::CheckError( result, GetLevel() );
-
-        assert( !LevelMutexInfo::IsLockedByCurrentThread() );
-        clock_t timeOut = clock() + milliSeconds;
-        while ( clock() < timeOut )
-        {
-            WP::Wait();
-            result = m_mutex.TryLock();
-            switch ( result )
-            {
-                case MutexErrors::Success:
-                {
-                    PostLock();
-                    return MutexErrors::Success;
-                }
-                case MutexErrors::AlreadyLocked:
-                    return MutexErrors::AlreadyLocked;
-                case MutexErrors::TryFailed:
-                    break;
-                default:
-                    return EP::CheckError( result, GetLevel() );
-            }
-        }
-
-        return MutexErrors::TimedOut;
-    }
-
-    virtual MutexErrors::Type Unlock( void ) volatile
-    {
-        assert( IsValid() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-
-        MutexErrors::Type result = LevelMutexInfo::PreUnlockCheck();
-        if ( MutexErrors::Success == result )
-            return MutexErrors::Success;
-        else if ( MutexErrors::NoProblem != result )
-            return EP::CheckError( result, GetLevel() );
-
-        LevelMutexInfo::PreUnlock();
-        result = MutexErrors::OtherError;
-        try
-        {
-            result = m_mutex.Unlock();
-            if ( MutexErrors::Success != result )
-                PostLock();
-        }
-        catch ( ... )
-        {
-            PostLock();
-            result = MutexErrors::ExceptionThrown;
-        }
-
-        return result;
-    }
-
-private:
-
-    /// Copy constructor is not implemented since mutexes don't get copied.
-    LevelMutex( const LevelMutex& );
-    /// Copy-assignment operator is not implemented since mutexes don't get copied.
-    LevelMutex& operator = ( const LevelMutex& );
-
-    virtual MutexErrors::Type DoErrorCheck( MutexErrors::Type result ) const volatile
-    {
-        return EP::CheckError( result, GetLevel() );
-    }
-
-    /** Called only by MultiLock to lock each particular mutex within a container.
-     This does not do pre-lock error checking since MultiLock does that.  Since
-     this skips the error checking, that means that callers of LevelMutex should
-     not call this function directly, and so this will not be publicly available.
-     @return Error status indicating success or reason for failure.
-     */
-    virtual MutexErrors::Type LockThis( void ) volatile
-    {
-        assert( IsValid() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-        assert( this != LevelMutexInfo::GetCurrentMutex() );
-
-        const MutexErrors::Type result = m_mutex.Lock();
-        if ( MutexErrors::Success != result )
-            return result;
-        PostLock();
-
-        return MutexErrors::Success;
-    }
-
-    /** Called only by MultiLock to lock each particular mutex within a container.
-     This does not do pre-lock error checking since MultiLock does that.  Since
-     this skips the error checking, callers of LevelMutex should not call this
-     function directly, and so this will not be publicly available.
-     @param milliSeconds How much time to wait before giving up on locking a mutex.
-     @return Error status indicating success or reason for failure.
-     */
-    virtual MutexErrors::Type LockThis( unsigned int milliSeconds ) volatile
-    {
-        assert( IsValid() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-
-        clock_t timeOut = clock() + milliSeconds;
-        while ( clock() < timeOut )
-        {
-            WP::Wait();
-            const bool locked = ( MutexErrors::Success == m_mutex.TryLock() );
-            if ( locked )
-            {
-                PostLock();
-                return MutexErrors::Success;
-            }
-        }
-
-        return MutexErrors::TimedOut;
-    }
-
-    /** Called only by MultiUnlock to unlock each mutex within a container.
-     This does not do pre-unlock error checking since MultiLock does that.  Since
-     this skips the error checking, callers of LevelMutex should not call this
-     function directly, and so this will not be publicly available.
-     @return Error status indicating success or reason for failure.
-     */
-    virtual MutexErrors::Type UnlockThis( void ) volatile
-    {
-        assert( IsValid() );
-        assert( NULL != LevelMutexInfo::GetCurrentMutex() );
-        LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; )
-
-        if ( 1 < LevelMutexInfo::GetLockCount() )
-        {
-            LevelMutexInfo::DecrementCount();
-            return MutexErrors::Success;
-        }
-
-        LevelMutexInfo::PreUnlock();
-        MutexErrors::Type result = m_mutex.Unlock();
-
-        return result;
-    }
-
-    /// An instance of an unleveled mutex wrapped to match LevelMutex's needs.
-    MutexPolicy m_mutex;
-
-}; // end class LevelMutex
-
-// ----------------------------------------------------------------------------
-
-/** Returns level of most recently locked mutex by this thread, or UnlockedLevel
- if no mutexes are locked.  Runs in constant time, and never throws exceptions.
- */
-unsigned int GetCurrentThreadsLevel( void );
-
-/** Returns count of how mutexes the current thread locked.  Requires O(m)
- actions where m is the number of mutexes in the thread.  Never throws exceptions.
- */
-unsigned int CountMutexesInCurrentThread( void );
-
-/** Returns count of how mutexes the current thread locked.  The lock count
- exceeds the number of mutexes locked by current thread if any mutex got locked
- more than once.  Requires O(m) actions where m is the number of mutexes in the
- thread.  Never throws exceptions.
- */
-unsigned int CountLocksInCurrentThread( void );
-
-/** Returns count of mutexes locked by current thread which have the same level
- as GetCurrentThreadsLevel.  Requires O(m) actions where m is the number of
- mutexes in the thread at current level.  Never throws exceptions.
- */
-unsigned int CountMutexesAtCurrentLevel( void );
-
-/** Determines if container of mutexes matches the recently locked mutexes.
- If they do match, it returns success, otherwise an error condition.
- */
-MutexErrors::Type DoMutexesMatchContainer( const LevelMutexInfo::MutexContainer& mutexes );
-
-// ----------------------------------------------------------------------------
-
-/** @class MutexException
- Exception class used to throw error statuses about LevelMutex's up to code that
- can respond to mutex problems.  This class exists because it conveys more info
- about the error condition than just ::std::exception.
- */
-class MutexException : public ::std::exception
-{
-public:
-
-    /** Constructs an exception which stores information about a mutex and the
-     reason an attempt to use a mutex failed.
-     */
-    MutexException( const char* message, unsigned int level, MutexErrors::Type reason );
-
-    /// Copy constructor performs a member-by-member copy of an exception.
-    MutexException( const MutexException& that ) throw ();
-
-    /// Copy-assignment operator performs a member-by-member copy of an exception.
-    MutexException& operator = ( const MutexException& that ) throw ();
-
-    /// Destroys the exception.
-    virtual ~MutexException( void ) throw();
-
-    /// Returns a simple message about which operation failed.
-    virtual const char* what( void ) const throw();
-
-    /// Returns level of mutex(es) used when problem occurred.
-    unsigned int GetLevel( void ) const { return m_level; }
-
-    /// Returns an error status for why operation failed.
-    MutexErrors::Type GetReason( void ) const { return m_reason; }
-
-private:
-
-    /// Default constructor is not implemented.
-    MutexException( void ) throw ();
-
-    /// Simple message about operation that failed.
-    const char* m_message;
-    /// Level of mutex(es) used when problem occurred.
-    unsigned int m_level;
-    /// Error status for why operation failed.
-    MutexErrors::Type m_reason;
-
-}; // end class MutexException
-
-// ----------------------------------------------------------------------------
-
-/** @class MutexLocker
- You can place an instance of this as a local variable inside a function to lock
- a single mutex.  It will lock the mutex if no error occurs, or throw if one
- does happen.  When the function ends, the destructor will determine if it needs
- to unlock the mutex.  This RAII technique insures the mutex gets unlocked even
- when exceptions occur.
- */
-class MutexLocker
-{
-public:
-
-    /** Creates an object to lock an unlock a mutex for a function.  This
-     will throw if an attempt to lock the mutex fails.
-     @param mutex Reference to the mutex.
-     @param lock True if function wants to lock the mutex as this gets
-      constructed.
-     */
-    explicit MutexLocker( volatile LevelMutexInfo& mutex, bool lock = true );
-
-    /** Creates an object to lock an unlock a mutex for a function.  This waits
-     a specified amount of time for another thread to unlock the mutex if it is
-     locked.  This will throw if an attempt to lock the mutex fails.
-     @param mutex Reference to the mutex.
-     @param milliSeconds Amount of time to wait for another thread to unlock
-      the mutex.
-     @param lock True if function wants to lock the mutex as this gets
-      constructed.
-     */
-    MutexLocker( volatile LevelMutexInfo& mutex, unsigned int milliSeconds,
-                 bool lock = true );
-
-    /// Destructs the locker, and determines if it needs to unlock the mutex.
-    ~MutexLocker( void );
-
-    /** You can call this to lock (or relock) a mutex.  In theory, you can lock
-     and unlock a mutex several times within a function in order to give other
-     threads access to a resource while this function does not need it.
-     @return True if mutex is locked by this, else false if not locked.
-     */
-    bool Lock( void );
-
-    /** You can call this to unlock a mutex before the destructor does it.
-     By unlocking the mutexes before returning, the function can do other
-     operations without making other threads wait too long.
-     @return True if unlocked by this, else false if not unlocked by this.
-     (Which is not the same as whether the mutex itself is locked or not by
-     another thread.)
-     */
-    bool Unlock( void );
-
-    /// Returns true if the mutex is locked by this object.
-    inline bool IsLocked( void ) const { return m_locked; }
-
-    /// Provides access to mutex controlled by this.
-    const volatile LevelMutexInfo& GetMutex( void ) const { return m_mutex; }
-
-private:
-
-    /// Default constructor is not implemented.
-    MutexLocker( void );
-    /// Copy constructor is not implemented.
-    MutexLocker( const MutexLocker& );
-    /// Copy-assignment operator is not implemented.
-    MutexLocker& operator = ( const MutexLocker& );
-
-    /// True if mutex got locked.
-    bool m_locked;
-
-    /// Reference to mutex.
-    volatile LevelMutexInfo& m_mutex;
-};
-
-// ----------------------------------------------------------------------------
-
-/** @class MultiMutexLocker
- You can place an instance of this as a local variable inside a function to lock
- a collection of mutexes.  It locks them if no error occurs, or throws an
- exception if one does happen.  When the function ends, the destructor determines
- if it needs to unlock the mutexes.  This RAII technique insures the mutexes get
- unlocked even when exceptions occur.  You will also have to construct a
- MutexContainer as a local object within the same function.
- */
-class MultiMutexLocker
-{
-public:
-
-    /** Creates an object to lock and unlock a collection of mutexes for a function.
-     This will throw if an attempt to lock any mutex fails. If an exception occurs,
-     it unlocks mutexes it previously locked.
-     @param mutex Reference to a collection of mutexes.
-     @param lock True if function wants to lock the mutex as this gets
-      constructed.
-     */
-    explicit MultiMutexLocker( LevelMutexInfo::MutexContainer& mutexes,
-                               bool lock = true );
-
-    /** Creates an object to lock and unlock a collection of mutexes for a function.
-     This waits a specified amount of time for other threads to unlock each mutex
-     that is locked.  This will throw if an attempt to lock any mutex fails. If an
-     exception occurs, it unlocks mutexes it previously locked.
-     @param mutexes Reference to a collection of mutexes.
-     @param milliSeconds Amount of time to wait for another thread to unlock
-      the mutex.
-     @param lock True if function wants to lock the mutexes as this gets
-      constructed.
-     */
-    MultiMutexLocker( LevelMutexInfo::MutexContainer& mutexes,
-                      unsigned int milliSeconds, bool lock = true );
-
-    /// Destructs the locker, and determines if it needs to unlock the mutexes.
-    ~MultiMutexLocker( void );
-
-    /** You can call this to lock (or relock) the mutexes.  In theory, you can lock
-     and unlock mutexes several times within a function in order to give other
-     threads access to resources while this function does not need them.
-     @return True if mutex is locked by this, else false if not locked.
-     */
-    bool Lock( void );
-
-    /** You can call this to unlock the mutexes before the destructor does it.
-     By unlocking the mutexes before returning, the function can do other
-     operations without making other threads wait too long.
-     @return True if unlocked by this, else false if not unlocked by this.
-     (Which is not the same as whether the mutex itself is locked or not by
-     another thread.)
-     */
-    bool Unlock( void );
-
-    /// Returns true if the mutexes are locked by this object.
-    inline bool IsLocked( void ) const { return m_locked; }
-
-    /// Provides access to the collection of mutexes controlled by this.
-    const LevelMutexInfo::MutexContainer& GetMutexes( void ) const { return m_mutexes; }
-
-private:
-
-    /// Default constructor is not implemented.
-    MultiMutexLocker( void );
-    /// Copy constructor is not implemented.
-    MultiMutexLocker( const MultiMutexLocker& );
-    /// Copy-assignment operator is not implemented.
-    MultiMutexLocker& operator = ( const MultiMutexLocker& );
-
-    /// True if mutexes got locked.
-    bool m_locked;
-
-    /// Reference to external container of mutexes;
-    LevelMutexInfo::MutexContainer& m_mutexes;
-};
-
-// ----------------------------------------------------------------------------
-
-} // end namespace Loki
-
-#endif  // end file guardian
diff --git a/shared/loki/LockingPtr.h b/shared/loki/LockingPtr.h
deleted file mode 100644
index 5482f075..00000000
--- a/shared/loki/LockingPtr.h
+++ /dev/null
@@ -1,110 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2001 by Andrei Alexandrescu
-// This code is from the article:
-//     "Generic<Programming>: volatile — Multithreaded Programmer’s Best Friend
-//     Volatile-Correctness or How to Have Your Compiler Detect Race Conditions
-//     for You" by Alexandrescu, Andrei.
-//     Published in the February 2001 issue of the C/C++ Users Journal.
-//     http://www.cuj.com/documents/s=7998/cujcexp1902alexandr/
-// 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.
-// Prepared for Loki library by Richard Sposato
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_LOCKING_PTR_INC_
-#define LOKI_LOCKING_PTR_INC_
-
-// $Id: LockingPtr.h 840 2008-03-19 19:44:38Z rich_sposato $
-
-
-#include <loki/ConstPolicy.h>
-#include <loki/Threads.h>
-
-
-namespace Loki
-{
-/** @class LockingPtr
- Locks a volatile object and casts away volatility so that the object
- can be safely used in a single-threaded region of code.
- Original version of LockingPtr had only one template - for the shared
- object, but not the mutex type.  This version allows users to specify a
- the mutex type as a LockingPolicy class.  The only requirements for a
- LockingPolicy class are to provide Lock and Unlock methods.
- */
-template < typename SharedObject, typename LockingPolicy = LOKI_DEFAULT_MUTEX,
-         template<class> class ConstPolicy = LOKI_DEFAULT_CONSTNESS >
-class LockingPtr
-{
-public:
-
-    typedef typename ConstPolicy<SharedObject>::Type ConstOrNotType;
-
-    /** Constructor locks mutex associated with an object.
-     @param object Reference to object.
-     @param mutex Mutex used to control thread access to object.
-     */
-    LockingPtr( volatile ConstOrNotType& object, LockingPolicy& mutex )
-        : pObject_( const_cast< SharedObject* >( &object ) ),
-          pMutex_( &mutex )
-    {
-        mutex.Lock();
-    }
-
-    typedef typename std::pair<volatile ConstOrNotType*, LockingPolicy*> Pair;
-
-    /** Constructor locks mutex associated with an object.
-     @param lockpair a std::pair of pointers to the object and the mutex
-     */
-    LockingPtr( Pair lockpair )
-        : pObject_( const_cast< SharedObject* >( lockpair.first ) ),
-          pMutex_( lockpair.second )
-    {
-        lockpair.second->Lock();
-    }
-
-    /// Destructor unlocks the mutex.
-    ~LockingPtr()
-    {
-        pMutex_->Unlock();
-    }
-
-    /// Star-operator dereferences pointer.
-    ConstOrNotType& operator * ()
-    {
-        return *pObject_;
-    }
-
-    /// Point-operator returns pointer to object.
-    ConstOrNotType* operator -> ()
-    {
-        return pObject_;
-    }
-
-private:
-
-    /// Default constructor is not implemented.
-    LockingPtr();
-
-    /// Copy-constructor is not implemented.
-    LockingPtr( const LockingPtr& );
-
-    /// Copy-assignment-operator is not implemented.
-    LockingPtr& operator = ( const LockingPtr& );
-
-    /// Pointer to the shared object.
-    ConstOrNotType* pObject_;
-
-    /// Pointer to the mutex.
-    LockingPolicy* pMutex_;
-
-}; // end class LockingPtr
-
-} // namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/LokiExport.h b/shared/loki/LokiExport.h
deleted file mode 100644
index eb02516b..00000000
--- a/shared/loki/LokiExport.h
+++ /dev/null
@@ -1,69 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2006 by 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_LOKIEXPORT_INC_
-#define LOKI_LOKIEXPORT_INC_
-
-// $Id: LokiExport.h 748 2006-10-17 19:49:08Z syntheticpp $
-
-
-#ifdef __GNUC__
-
-#ifdef _HAVE_GCC_VISIBILITY
-#define LOKI_EXPORT_SPEC __attribute__ ((visibility("default")))
-#define LOKI_IMPORT_SPEC
-#else
-#define LOKI_EXPORT_SPEC
-#define LOKI_IMPORT_SPEC
-#endif
-
-#else
-
-#ifdef _WIN32
-#define LOKI_EXPORT_SPEC __declspec(dllexport)
-#define LOKI_IMPORT_SPEC __declspec(dllimport)
-#else
-#define LOKI_EXPORT_SPEC
-#define LOKI_IMPORT_SPEC
-#endif
-
-#endif
-
-
-#if (defined(LOKI_MAKE_DLL) && defined(LOKI_DLL)) || \
-    (defined(LOKI_MAKE_DLL) && defined(LOKI_STATIC)) || \
-    (defined(LOKI_DLL) && defined(LOKI_STATIC))
-#error export macro error: you could not build AND use the library
-#endif
-
-#ifdef LOKI_MAKE_DLL
-#define LOKI_EXPORT LOKI_EXPORT_SPEC
-#endif
-
-#ifdef LOKI_DLL
-#define LOKI_EXPORT LOKI_IMPORT_SPEC
-#endif
-
-#ifdef LOKI_STATIC
-#define LOKI_EXPORT
-#endif
-
-#if !defined(LOKI_EXPORT) && !defined(EXPLICIT_EXPORT)
-#define LOKI_EXPORT
-#endif
-
-#ifndef LOKI_EXPORT
-#error export macro error: LOKI_EXPORT was not defined, disable EXPLICIT_EXPORT or define a export specification
-#endif
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/LokiTypeInfo.h b/shared/loki/LokiTypeInfo.h
deleted file mode 100644
index ecb657d4..00000000
--- a/shared/loki/LokiTypeInfo.h
+++ /dev/null
@@ -1,103 +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_LOKITYPEINFO_INC_
-#define LOKI_LOKITYPEINFO_INC_
-
-// $Id: LokiTypeInfo.h 748 2006-10-17 19:49:08Z syntheticpp $
-
-
-#include <typeinfo>
-#include <cassert>
-#include "Typelist.h"
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class TypeInfo
-// Purpose: offer a first-class, comparable wrapper over std::type_info
-////////////////////////////////////////////////////////////////////////////////
-
-class TypeInfo
-{
-public:
-    // Constructors
-    TypeInfo(); // needed for containers
-    TypeInfo(const std::type_info&); // non-explicit
-
-    // Access for the wrapped std::type_info
-    const std::type_info& Get() const;
-    // Compatibility functions
-    bool before(const TypeInfo& rhs) const;
-    const char* name() const;
-
-private:
-    const std::type_info* pInfo_;
-};
-
-// Implementation
-
-inline TypeInfo::TypeInfo()
-{
-    class Nil {};
-    pInfo_ = &typeid(Nil);
-    assert(pInfo_);
-}
-
-inline TypeInfo::TypeInfo(const std::type_info& ti)
-    : pInfo_(&ti)
-{ assert(pInfo_); }
-
-inline bool TypeInfo::before(const TypeInfo& rhs) const
-{
-    assert(pInfo_);
-    // type_info::before return type is int in some VC libraries
-    return pInfo_->before(*rhs.pInfo_) != 0;
-}
-
-inline const std::type_info& TypeInfo::Get() const
-{
-    assert(pInfo_);
-    return *pInfo_;
-}
-
-inline const char* TypeInfo::name() const
-{
-    assert(pInfo_);
-    return pInfo_->name();
-}
-
-// Comparison operators
-
-inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
-// type_info::operator== return type is int in some VC libraries
-{ return (lhs.Get() == rhs.Get()) != 0; }
-
-inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs)
-{ return lhs.before(rhs); }
-
-inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
-{ return !(lhs == rhs); }
-
-inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs)
-{ return rhs < lhs; }
-
-inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs)
-{ return !(lhs > rhs); }
-
-inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs)
-{ return !(lhs < rhs); }
-}
-
-#endif // end file guardian
diff --git a/shared/loki/MultiMethods.h b/shared/loki/MultiMethods.h
deleted file mode 100644
index ec5b7788..00000000
--- a/shared/loki/MultiMethods.h
+++ /dev/null
@@ -1,415 +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_MULTIMETHODS_INC_
-#define LOKI_MULTIMETHODS_INC_
-
-// $Id: MultiMethods.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-#include "Typelist.h"
-#include "LokiTypeInfo.h"
-#include "Functor.h"
-#include "AssocVector.h"
-
-////////////////////////////////////////////////////////////////////////////////
-// IMPORTANT NOTE:
-// The double dispatchers implemented below differ from the excerpts shown in
-// the book - they are simpler while respecting the same interface.
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template InvocationTraits (helper)
-// Helps implementing optional symmetry
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template < class SomeLhs, class SomeRhs,
-         class Executor, typename ResultType >
-struct InvocationTraits
-{
-    static ResultType
-    DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
-               Executor& exec, Int2Type<false>)
-    {
-        return exec.Fire(lhs, rhs);
-    }
-    static ResultType
-    DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
-               Executor& exec, Int2Type<true>)
-    {
-        return exec.Fire(rhs, lhs);
-    }
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class template StaticDispatcher
-// Implements an automatic static double dispatcher based on two typelists
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class Executor,
-      class BaseLhs,
-      class TypesLhs,
-      bool symmetric = true,
-      class BaseRhs = BaseLhs,
-      class TypesRhs = TypesLhs,
-      typename ResultType = void
-      >
-class StaticDispatcher
-{
-    template <class SomeLhs>
-    static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
-                                  Executor exec, NullType)
-    { return exec.OnError(lhs, rhs); }
-
-    template <class Head, class Tail, class SomeLhs>
-    static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
-                                  Executor exec, Typelist<Head, Tail>)
-    {
-        if (Head* p2 = dynamic_cast<Head*>(&rhs))
-        {
-            Int2Type < (symmetric &&
-                        int(TL::IndexOf<TypesRhs, Head>::value) <
-                        int(TL::IndexOf<TypesLhs, SomeLhs>::value)) > i2t;
-
-            typedef Private::InvocationTraits <
-            SomeLhs, Head, Executor, ResultType > CallTraits;
-
-            return CallTraits::DoDispatch(lhs, *p2, exec, i2t);
-        }
-        return DispatchRhs(lhs, rhs, exec, Tail());
-    }
-
-    static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
-                                  Executor exec, NullType)
-    { return exec.OnError(lhs, rhs); }
-
-    template <class Head, class Tail>
-    static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
-                                  Executor exec, Typelist<Head, Tail>)
-    {
-        if (Head* p1 = dynamic_cast<Head*>(&lhs))
-        {
-            return DispatchRhs(*p1, rhs, exec, TypesRhs());
-        }
-        return DispatchLhs(lhs, rhs, exec, Tail());
-    }
-
-public:
-    static ResultType Go(BaseLhs& lhs, BaseRhs& rhs,
-                         Executor exec)
-    { return DispatchLhs(lhs, rhs, exec, TypesLhs()); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template BasicDispatcher
-// Implements a logarithmic double dispatcher for functors (or functions)
-// Doesn't offer automated casts or symmetry
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class BaseLhs,
-      class BaseRhs = BaseLhs,
-      typename ResultType = void,
-      typename CallbackType = ResultType (*)(BaseLhs&, BaseRhs&)
-      >
-class BasicDispatcher
-{
-    typedef std::pair<TypeInfo, TypeInfo> KeyType;
-    typedef CallbackType MappedType;
-    typedef AssocVector<KeyType, MappedType> MapType;
-    MapType callbackMap_;
-
-    void DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun);
-    bool DoRemove(TypeInfo lhs, TypeInfo rhs);
-
-public:
-    template <class SomeLhs, class SomeRhs>
-    void Add(CallbackType fun)
-    {
-        DoAdd(typeid(SomeLhs), typeid(SomeRhs), fun);
-    }
-
-    template <class SomeLhs, class SomeRhs>
-    bool Remove()
-    {
-        return DoRemove(typeid(SomeLhs), typeid(SomeRhs));
-    }
-
-    ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
-};
-
-// Non-inline to reduce compile time overhead...
-template < class BaseLhs, class BaseRhs,
-         typename ResultType, typename CallbackType >
-void BasicDispatcher<BaseLhs, BaseRhs, ResultType, CallbackType>
-::DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun)
-{
-    callbackMap_[KeyType(lhs, rhs)] = fun;
-}
-
-template < class BaseLhs, class BaseRhs,
-         typename ResultType, typename CallbackType >
-bool BasicDispatcher<BaseLhs, BaseRhs, ResultType, CallbackType>
-::DoRemove(TypeInfo lhs, TypeInfo rhs)
-{
-    return callbackMap_.erase(KeyType(lhs, rhs)) == 1;
-}
-
-template < class BaseLhs, class BaseRhs,
-         typename ResultType, typename CallbackType >
-ResultType BasicDispatcher<BaseLhs, BaseRhs, ResultType, CallbackType>
-::Go(BaseLhs& lhs, BaseRhs& rhs)
-{
-    typename MapType::key_type k(typeid(lhs), typeid(rhs));
-    typename MapType::iterator i = callbackMap_.find(k);
-    if (i == callbackMap_.end())
-    {
-        throw std::runtime_error("Function not found");
-    }
-    return (i->second)(lhs, rhs);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class template StaticCaster
-// Implementation of the CastingPolicy used by FunctorDispatcher
-////////////////////////////////////////////////////////////////////////////////
-
-template <class To, class From>
-struct StaticCaster
-{
-    static To& Cast(From& obj)
-    {
-        return static_cast<To&>(obj);
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template DynamicCaster
-// Implementation of the CastingPolicy used by FunctorDispatcher
-////////////////////////////////////////////////////////////////////////////////
-
-template <class To, class From>
-struct DynamicCaster
-{
-    static To& Cast(From& obj)
-    {
-        return dynamic_cast<To&>(obj);
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Private::FnDispatcherHelper
-// Implements trampolines and argument swapping used by FnDispatcher
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template < class BaseLhs, class BaseRhs,
-         class SomeLhs, class SomeRhs,
-         typename ResultType,
-         class CastLhs, class CastRhs,
-         ResultType (*Callback)(SomeLhs&, SomeRhs&) >
-struct FnDispatcherHelper
-{
-    static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs)
-    {
-        return Callback(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
-    }
-    static ResultType TrampolineR(BaseRhs& rhs, BaseLhs& lhs)
-    {
-        return Trampoline(lhs, rhs);
-    }
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FnDispatcher
-// Implements an automatic logarithmic double dispatcher for functions
-// Features automated conversions
-////////////////////////////////////////////////////////////////////////////////
-
-template < class BaseLhs, class BaseRhs = BaseLhs,
-         typename ResultType = void,
-         template <class, class> class CastingPolicy = DynamicCaster,
-         template <class, class, class, class>
-         class DispatcherBackend = BasicDispatcher >
-class FnDispatcher
-{
-    DispatcherBackend < BaseLhs, BaseRhs, ResultType,
-                      ResultType (*)(BaseLhs&, BaseRhs&) > backEnd_;
-
-public:
-    template <class SomeLhs, class SomeRhs>
-    void Add(ResultType (*pFun)(BaseLhs&, BaseRhs&))
-    {
-        return backEnd_.template Add<SomeLhs, SomeRhs>(pFun);
-    }
-
-    template < class SomeLhs, class SomeRhs,
-             ResultType (*callback)(SomeLhs&, SomeRhs&) >
-    void Add()
-    {
-        typedef Private::FnDispatcherHelper <
-        BaseLhs, BaseRhs,
-                 SomeLhs, SomeRhs,
-                 ResultType,
-                 CastingPolicy<SomeLhs, BaseLhs>,
-                 CastingPolicy<SomeRhs, BaseRhs>,
-                 callback > Local;
-
-        Add<SomeLhs, SomeRhs>(&Local::Trampoline);
-    }
-
-    template < class SomeLhs, class SomeRhs,
-             ResultType (*callback)(SomeLhs&, SomeRhs&),
-             bool symmetric >
-    void Add(bool = true) // [gcc] dummy bool
-    {
-        typedef Private::FnDispatcherHelper <
-        BaseLhs, BaseRhs,
-                 SomeLhs, SomeRhs,
-                 ResultType,
-                 CastingPolicy<SomeLhs, BaseLhs>,
-                 CastingPolicy<SomeRhs, BaseRhs>,
-                 callback > Local;
-
-        Add<SomeLhs, SomeRhs>(&Local::Trampoline);
-        if (symmetric)
-        {
-            Add<SomeRhs, SomeLhs>(&Local::TrampolineR);
-        }
-    }
-
-    template <class SomeLhs, class SomeRhs>
-    void Remove()
-    {
-        backEnd_.template Remove<SomeLhs, SomeRhs>();
-    }
-
-    ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
-    {
-        return backEnd_.Go(lhs, rhs);
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorDispatcherAdaptor
-// permits use of FunctorDispatcher under gcc.2.95.2/3
-///////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template < class BaseLhs, class BaseRhs,
-         class SomeLhs, class SomeRhs,
-         typename ResultType,
-         class CastLhs, class CastRhs,
-         class Fun, bool SwapArgs >
-class FunctorDispatcherHelper
-{
-    Fun fun_;
-    ResultType Fire(BaseLhs& lhs, BaseRhs& rhs, Int2Type<false>)
-    {
-        return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
-    }
-    ResultType Fire(BaseLhs& rhs, BaseRhs& lhs, Int2Type<true>)
-    {
-        return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
-    }
-public:
-    FunctorDispatcherHelper(const Fun& fun) : fun_(fun) {}
-
-    ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
-    {
-        return Fire(lhs, rhs, Int2Type<SwapArgs>());
-    }
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorDispatcher
-// Implements a logarithmic double dispatcher for functors
-// Features automated casting
-////////////////////////////////////////////////////////////////////////////////
-
-template < class BaseLhs, class BaseRhs = BaseLhs,
-         typename ResultType = void,
-         template <class, class> class CastingPolicy = DynamicCaster,
-         template <class, class, class, class>
-         class DispatcherBackend = BasicDispatcher >
-class FunctorDispatcher
-{
-    typedef LOKI_TYPELIST_2(BaseLhs&, BaseRhs&) ArgsList;
-    typedef Functor<ResultType, ArgsList, LOKI_DEFAULT_THREADING> FunctorType;
-
-    DispatcherBackend<BaseLhs, BaseRhs, ResultType, FunctorType> backEnd_;
-
-public:
-    template <class SomeLhs, class SomeRhs, class Fun>
-    void Add(const Fun& fun)
-    {
-        typedef Private::FunctorDispatcherHelper <
-        BaseLhs, BaseRhs,
-                 SomeLhs, SomeRhs,
-                 ResultType,
-                 CastingPolicy<SomeLhs, BaseLhs>,
-                 CastingPolicy<SomeRhs, BaseRhs>,
-                 Fun, false > Adapter;
-
-        backEnd_.template Add<SomeLhs, SomeRhs>(FunctorType(Adapter(fun)));
-    }
-    template <class SomeLhs, class SomeRhs, bool symmetric, class Fun>
-    void Add(const Fun& fun)
-    {
-        Add<SomeLhs, SomeRhs>(fun);
-
-        if (symmetric)
-        {
-            // Note: symmetry only makes sense where BaseLhs==BaseRhs
-            typedef Private::FunctorDispatcherHelper <
-            BaseLhs, BaseLhs,
-                     SomeLhs, SomeRhs,
-                     ResultType,
-                     CastingPolicy<SomeLhs, BaseLhs>,
-                     CastingPolicy<SomeRhs, BaseLhs>,
-                     Fun, true > AdapterR;
-
-            backEnd_.template Add<SomeRhs, SomeLhs>(FunctorType(AdapterR(fun)));
-        }
-    }
-
-    template <class SomeLhs, class SomeRhs>
-    void Remove()
-    {
-        backEnd_.template Remove<SomeLhs, SomeRhs>();
-    }
-
-    ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
-    {
-        return backEnd_.Go(lhs, rhs);
-    }
-};
-} // namespace Loki
-
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/NullType.h b/shared/loki/NullType.h
deleted file mode 100644
index 8a4bb008..00000000
--- a/shared/loki/NullType.h
+++ /dev/null
@@ -1,34 +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_NULLTYPE_INC_
-#define LOKI_NULLTYPE_INC_
-
-// $Id: NullType.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class NullType
-// Used as a placeholder for "no type here"
-// Useful as an end marker in typelists
-////////////////////////////////////////////////////////////////////////////////
-
-class NullType {};
-
-}   // namespace Loki
-
-
-#endif // end file guardian
diff --git a/shared/loki/OrderedStatic.h b/shared/loki/OrderedStatic.h
deleted file mode 100644
index f0ff73c3..00000000
--- a/shared/loki/OrderedStatic.h
+++ /dev/null
@@ -1,225 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2005 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_ORDEREDSTATIC_INC_
-#define LOKI_ORDEREDSTATIC_INC_
-
-// $Id: OrderedStatic.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-#include <vector>
-#include <iostream>
-
-#include "LokiExport.h"
-#include "Singleton.h"
-#include "Typelist.h"
-#include "Sequence.h"
-
-// usage: see test/OrderedStatic
-
-namespace Loki
-{
-namespace Private
-{
-////////////////////////////////////////////////////////////////////////////////
-// polymorph base class for OrderedStatic template,
-// necessary because of the creator
-////////////////////////////////////////////////////////////////////////////////
-class LOKI_EXPORT OrderedStaticCreatorFunc
-{
-public:
-    virtual void createObject() = 0;
-
-protected:
-    OrderedStaticCreatorFunc();
-    virtual ~OrderedStaticCreatorFunc();
-
-private:
-    OrderedStaticCreatorFunc(const OrderedStaticCreatorFunc&);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// template base clase for OrderedStatic template,
-// common for all specializations
-////////////////////////////////////////////////////////////////////////////////
-template<class T>
-class OrderedStaticBase : public OrderedStaticCreatorFunc
-{
-public:
-    T& operator*()
-    {
-        return *val_;
-    }
-
-    T* operator->()
-    {
-        return val_;
-    }
-
-protected:
-
-    OrderedStaticBase(unsigned int longevity) :  val_(0), longevity_(longevity)
-    {
-    }
-
-    virtual ~OrderedStaticBase()
-    {
-    }
-
-    void SetLongevity(T* ptr)
-    {
-        val_ = ptr;
-        Loki::SetLongevity(val_, longevity_);
-    }
-
-private:
-    OrderedStaticBase();
-    OrderedStaticBase(const OrderedStaticBase&);
-    OrderedStaticBase& operator=(const OrderedStaticBase&);
-    T* val_;
-    unsigned int longevity_;
-
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// OrderedStaticManagerClass implements details
-// OrderedStaticManager is then defined as a Singleton
-////////////////////////////////////////////////////////////////////////////////
-class LOKI_EXPORT OrderedStaticManagerClass
-{
-public:
-    OrderedStaticManagerClass();
-    virtual ~OrderedStaticManagerClass();
-
-    typedef void (OrderedStaticCreatorFunc::*Creator)();
-
-    void createObjects();
-    void registerObject(unsigned int longevity, OrderedStaticCreatorFunc*, Creator);
-
-private:
-    OrderedStaticManagerClass(const OrderedStaticManagerClass&);
-    OrderedStaticManagerClass& operator=(const OrderedStaticManagerClass&);
-
-    struct Data
-    {
-        Data(unsigned int, OrderedStaticCreatorFunc*, Creator);
-        unsigned int longevity;
-        OrderedStaticCreatorFunc* object;
-        Creator creator;
-    };
-
-    std::vector<Data> staticObjects_;
-    unsigned int max_longevity_;
-    unsigned int min_longevity_;
-};
-
-}// namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-// OrderedStaticManager is only a Singleton typedef
-////////////////////////////////////////////////////////////////////////////////
-
-typedef Loki::SingletonHolder
-<
-Loki::Private::OrderedStaticManagerClass,
-     Loki::CreateUsingNew,
-     Loki::NoDestroy,
-     Loki::SingleThreaded
-     >
-     OrderedStaticManager;
-
-////////////////////////////////////////////////////////////////////////////////
-// template OrderedStatic template:
-// L        : longevity
-// T        : object type
-// TList    : creator parameters
-////////////////////////////////////////////////////////////////////////////////
-
-template<unsigned int L, class T, class TList = Loki::NullType>
-class OrderedStatic;
-
-
-////////////////////////////////////////////////////////////////////////////////
-// OrderedStatic specializations
-////////////////////////////////////////////////////////////////////////////////
-
-template<unsigned int L, class T>
-class OrderedStatic<L, T, Loki::NullType> : public Private::OrderedStaticBase<T>
-{
-public:
-    OrderedStatic() : Private::OrderedStaticBase<T>(L)
-    {
-        OrderedStaticManager::Instance().registerObject
-        (L, this, &Private::OrderedStaticCreatorFunc::createObject);
-    }
-
-    void createObject()
-    {
-        Private::OrderedStaticBase<T>::SetLongevity(new T);
-    }
-
-private:
-    OrderedStatic(const OrderedStatic&);
-    OrderedStatic& operator=(const OrderedStatic&);
-};
-
-template<unsigned int L, class T, typename P1>
-class OrderedStatic<L, T, Loki::Seq<P1> > : public Private::OrderedStaticBase<T>
-{
-public:
-    OrderedStatic(P1 p) : Private::OrderedStaticBase<T>(L), para_(p)
-    {
-        OrderedStaticManager::Instance().registerObject
-        (L, this, &Private::OrderedStaticCreatorFunc::createObject);
-    }
-
-    void createObject()
-    {
-        Private::OrderedStaticBase<T>::SetLongevity(new T(para_));
-    }
-
-private:
-    OrderedStatic();
-    OrderedStatic(const OrderedStatic&);
-    OrderedStatic& operator=(const OrderedStatic&);
-    P1 para_;
-};
-
-template<unsigned int L, class T, typename P1>
-class OrderedStatic<L, T,  P1(*)() > : public Private::OrderedStaticBase<T>
-{
-public:
-
-    typedef P1(*Func)();
-
-    OrderedStatic(Func p) : Private::OrderedStaticBase<T>(L), para_(p)
-    {
-        OrderedStaticManager::Instance().registerObject
-        (L, this, &Private::OrderedStaticCreatorFunc::createObject);
-    }
-
-    void createObject()
-    {
-        Private::OrderedStaticBase<T>::SetLongevity(new T(para_()));
-    }
-
-private:
-    OrderedStatic();
-    OrderedStatic(const OrderedStatic&);
-    OrderedStatic& operator=(const OrderedStatic&);
-    Func para_;
-};
-
-}// namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/Pimpl.h b/shared/loki/Pimpl.h
deleted file mode 100644
index 8254e3e2..00000000
--- a/shared/loki/Pimpl.h
+++ /dev/null
@@ -1,198 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_PIMPL_INC_
-#define LOKI_PIMPL_INC_
-
-// $Id: Pimpl.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-///  \defgroup PimplGroup Pimpl
-
-#ifndef LOKI_INHERITED_PIMPL_NAME
-#define LOKI_INHERITED_PIMPL_NAME d
-#endif
-
-#ifndef LOKI_INHERITED_RIMPL_NAME
-#define LOKI_INHERITED_RIMPL_NAME d
-#endif
-
-namespace Loki
-{
-
-//////////////////////////////////////////
-///  \class ConstPropPtr
-///
-///  \ingroup PimplGroup
-///   Simple const propagating smart pointer
-///   Is the default smart pointer of Pimpl.
-//////////////////////////////////////////
-
-template<class T>
-struct ConstPropPtr
-{
-    explicit ConstPropPtr(T* p) : ptr_(p) {}
-    ~ConstPropPtr() { delete  ptr_; ptr_ = 0; }
-    T* operator->()    { return  ptr_; }
-    T& operator*()    { return *ptr_; }
-    const T* operator->() const    { return  ptr_; }
-    const T& operator*()  const    { return *ptr_; }
-
-private:
-    ConstPropPtr();
-    ConstPropPtr(const ConstPropPtr&);
-    ConstPropPtr& operator=(const ConstPropPtr&);
-    T* ptr_;
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class Pimpl
-///
-///  \ingroup PimplGroup
-///
-///  Implements the Pimpl idiom. It's a wrapper for a smart pointer which
-///  automatically creates and deletes the implementation object and adds
-///  const propagation to the smart pointer.
-///
-///  \par Usage
-///  see test/Pimpl
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class T,
-      typename Pointer = ConstPropPtr<T>
-      >
-class Pimpl
-{
-public:
-
-    typedef T Impl;
-
-    Pimpl() : ptr_(new T)
-    {}
-
-    ~Pimpl()
-    {
-        // Don't compile with incomplete type
-        //
-        // If compilation breaks here make sure
-        // the compiler does not auto-generate the
-        // destructor of the class hosting the pimpl:
-        // - implement the destructor of the class
-        // - don't inline the destructor
-        typedef char T_must_be_defined[sizeof(T) ? 1 : -1 ];
-    }
-
-
-    T* operator->()
-    {
-        return ptr_.operator->();
-    }
-
-    T& operator*()
-    {
-        return ptr_.operator * ();
-    }
-
-    const T* operator->() const
-    {
-        return ptr_.operator->();
-    }
-
-    const T& operator*() const
-    {
-        return ptr_.operator * ();
-    }
-
-    Pointer& wrapped()
-    {
-        return ptr_;
-    }
-
-    const Pointer& wrapped() const
-    {
-        return ptr_;
-    }
-
-
-private:
-    Pimpl(const Pimpl&);
-    Pimpl& operator=(const Pimpl&);
-
-    Pointer ptr_;
-};
-
-
-template<class T, typename Pointer = ConstPropPtr<T> >
-struct PimplOwner
-{
-    Pimpl<T, Pointer> LOKI_INHERITED_PIMPL_NAME;
-};
-
-
-//////////////////////////////////////////
-/// \class  ImplOf
-///
-/// \ingroup PimplGroup
-/// Convenience template for the
-/// implementations which Pimpl points to.
-//////////////////////////////////////////
-
-template<class T>
-struct ImplOf;
-
-
-//////////////////////////////////////////
-/// \class  PImplOf
-///
-/// \ingroup PimplGroup
-/// Convenience template which uses ImplOf
-/// as implementation structure
-//////////////////////////////////////////
-
-
-template<class T, template<class> class Ptr = ConstPropPtr>
-struct PimplOf
-{
-    typedef T Impl;
-
-    // declare pimpl
-    typedef Pimpl<ImplOf<T>, Ptr<ImplOf<T> > > Type;
-
-    // inherit pimpl
-    typedef PimplOwner<ImplOf<T>, Ptr<ImplOf<T> > > Owner;
-};
-
-
-template<class T, class UsedPimpl = typename PimplOf<T>::Type >
-struct RimplOf
-{
-    typedef typename UsedPimpl::Impl& Type;
-
-    class Owner
-    {
-        UsedPimpl pimpl;
-
-    public:
-        Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl)
-        {}
-
-        Type LOKI_INHERITED_RIMPL_NAME;
-    };
-
-};
-
-}
-
-#endif // end file guardian
-
diff --git a/shared/loki/RefToValue.h b/shared/loki/RefToValue.h
deleted file mode 100644
index 3f7ecfef..00000000
--- a/shared/loki/RefToValue.h
+++ /dev/null
@@ -1,70 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2006 Richard Sposato
-// 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 authors make no representations about the
-//     suitability of this software for any purpose. It is provided "as is"
-//     without express or implied warranty.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_REFTOVALUE_INC_
-#define LOKI_REFTOVALUE_INC_
-
-// $Id: RefToValue.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class RefToValue
-///
-///  \ingroup SmartPointerGroup
-///  Transports a reference as a value
-///  Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-class RefToValue
-{
-public:
-
-    RefToValue(T& ref) : ref_(ref)
-    {}
-
-    RefToValue(const RefToValue& rhs) : ref_(rhs.ref_)
-    {}
-
-    operator T& () const
-    {
-        return ref_;
-    }
-
-private:
-    // Disable - not implemented
-    RefToValue();
-    RefToValue& operator=(const RefToValue&);
-
-    T& ref_;
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \ingroup ExceptionGroup
-///  RefToValue creator.
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-inline RefToValue<T> ByRef(T& t)
-{
-    return RefToValue<T>(t);
-}
-
-}
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/Register.h b/shared/loki/Register.h
deleted file mode 100644
index 2b549381..00000000
--- a/shared/loki/Register.h
+++ /dev/null
@@ -1,134 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_REGISTER_INC_
-#define LOKI_REGISTER_INC_
-
-// $Id: Register.h 776 2006-11-09 13:12:57Z syntheticpp $
-
-
-#include "TypeManip.h"
-#include "HierarchyGenerators.h"
-
-///  \defgroup RegisterGroup Register
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-//
-//  Helper classes/functions for RegisterByCreateSet
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-///  \ingroup RegisterGroup
-///  Must be specialized be the user
-////////////////////////////////////////////////////////////////////////////////
-template<class t> bool RegisterFunction();
-
-////////////////////////////////////////////////////////////////////////////////
-///  \ingroup RegisterGroup
-///  Must be specialized be the user
-////////////////////////////////////////////////////////////////////////////////
-template<class t> bool UnRegisterFunction();
-
-namespace Private
-{
-template<class T>
-struct RegisterOnCreate
-{
-    RegisterOnCreate()  { RegisterFunction<T>(); }
-};
-
-template<class T>
-struct UnRegisterOnDelete
-{
-    ~UnRegisterOnDelete() { UnRegisterFunction<T>(); }
-};
-
-template<class T>
-struct RegisterOnCreateElement
-{
-    RegisterOnCreate<T> registerObj;
-};
-
-template<class T>
-struct UnRegisterOnDeleteElement
-{
-    UnRegisterOnDelete<T> unregisterObj;
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class RegisterOnCreateSet
-///
-///  \ingroup RegisterGroup
-///  Implements a generic register class which registers classes of a typelist
-///
-///  \par Usage
-///  see test/Register
-////////////////////////////////////////////////////////////////////////////////
-
-template<typename ElementList>
-struct RegisterOnCreateSet
-        : GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement>
-{};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class UnRegisterOnDeleteSet
-///
-///  \ingroup RegisterGroup
-///  Implements a generic register class which unregisters classes of a typelist
-///
-///  \par Usage
-///  see test/Register
-////////////////////////////////////////////////////////////////////////////////
-template<typename ElementList>
-struct UnRegisterOnDeleteSet
-        : GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement>
-{};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \def  LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST )
-///
-///  \ingroup RegisterGroup
-///  Check if CLASS is in the typelist LIST.
-///
-///  \par Usage
-///  see test/Register
-////////////////////////////////////////////////////////////////////////////////
-
-
-#define LOKI_CONCATE(a,b,c,d) a ## b ## c ## d
-#define LOKI_CONCAT(a,b,c,d) LOKI_CONCATE(a,b,c,d)
-
-#define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST )                                \
-    \
-    struct LOKI_CONCAT(check_,CLASS,_isInList_,LIST)                            \
-    {                                                                           \
-        typedef int LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST);         \
-    };                                                                          \
-    typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1,           \
-    CLASS,                                                  \
-    LOKI_CONCAT(check_,CLASS,_isInList_,LIST)>              \
-    ::Result LOKI_CONCAT(CLASS,isInList,LIST,result);       \
-    typedef LOKI_CONCAT(CLASS,isInList,LIST,result)::                           \
-    LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST)      \
-    LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList__,LIST);
-
-
-} // namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/SPCachedFactory.h b/shared/loki/SPCachedFactory.h
deleted file mode 100644
index e1b8ec8c..00000000
--- a/shared/loki/SPCachedFactory.h
+++ /dev/null
@@ -1,204 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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: SPCachedFactory.h 896 2008-08-08 22:20:05Z syntheticpp $
-
-#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>
-inline const typename FunctionStorage<T>::StoredType& GetImplRef(const FunctionStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline typename FunctionStorage<T>::StoredType& GetImplRef(FunctionStorage<T>& sp)
-{ return sp.pointee_; }
-
-/**
- * \class	SmartPointer
- * \ingroup	EncapsulationPolicyCachedFactoryGroup
- * \brief	Encapsulate the object in a SmartPtr with FunctionStorage policy.
- *
- * The object will come back to the Cache as soon as no more SmartPtr are
- * referencing this object. You can customize the SmartPointer with the standard
- * SmartPtr policies (OwnershipPolicy, ConversionPolicy, CheckingPolicy,
- * ConstnessPolicy) but StoragePolicy is forced to FunctionStorage.
- */
-template
-<
-class AbstractProduct,
-      template <class> class OwnershipPolicy = RefCounted,
-      class ConversionPolicy = DisallowConversion,
-      template <class> class CheckingPolicy = AssertCheck,
-      template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
-      >
-class SmartPointer
-{
-private:
-    typedef SmartPtr < AbstractProduct, OwnershipPolicy,
-            ConversionPolicy, CheckingPolicy,
-            FunctionStorage, ConstnessPolicy > CallBackSP;
-protected:
-    typedef CallBackSP ProductReturn;
-    SmartPointer() : fun(this, &SmartPointer::smartPointerCallbackFunction) {}
-    virtual ~SmartPointer() {}
-
-    ProductReturn encapsulate(AbstractProduct* pProduct)
-    {
-        CallBackSP SP(pProduct);
-        SP.SetCallBackFunction(fun);
-        return SP;
-    }
-
-    AbstractProduct* release(ProductReturn& pProduct)
-    {
-        return GetImpl(pProduct);
-    }
-
-    const char* name() {return "smart pointer";}
-
-private:
-    SmartPointer& operator=(const SmartPointer&);
-    SmartPointer(const SmartPointer&);
-    void smartPointerCallbackFunction(void* pSP)
-    {
-        CallBackSP& SP(*reinterpret_cast<CallBackSP*>(pSP));
-        ReleaseObject(SP);
-    }
-    virtual void ReleaseObject(ProductReturn& object) = 0;
-    const typename CallBackSP::FunctorType fun;
-};
-
-} // namespace Loki
-
-#endif /*SPCACHEDFACTORY_H_*/
diff --git a/shared/loki/SafeBits.h b/shared/loki/SafeBits.h
deleted file mode 100644
index 9e160c50..00000000
--- a/shared/loki/SafeBits.h
+++ /dev/null
@@ -1,514 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2009 by Fedor Pikus & 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 claims about the suitability of this software for any
-//     purpose. It is provided "as is" without express or implied warranty.
-////////////////////////////////////////////////////////////////////////////////
-
-// $Id$
-
-
-#ifndef LOKI_INCLUDED_SAFE_BIT_FIELDS_H
-#define LOKI_INCLUDED_SAFE_BIT_FIELDS_H
-
-#include <cstdlib>
-#include <assert.h>
-#include <loki/static_check.h>
-
-
-namespace Loki
-{
-
-/*
- ==========================================================================================================================================
-   SafeBitField                    - type-safe class for bit fields.
-   SafeBitConst                    - type-safe class for bit constants.
-   SafeBitField is designed to be a [almost] drop-in replacement for integer flags and bit fields where individual bits are set and checked
-   using symbolic names for flags:
-
-      typedef unsigned long Labels_t;
-      Labels_t labels;
-      const Labels_t Label_A = 0x00000001;
-      const Labels_t Label_B = 0x00000002;
-      ...
-      labels |= Label_B;
-      if ( labels & Label_A ) { ... }
-
-   Such code offers no protection against mismatching bit constants and bit fields:
-
-      typedef unsigned long Kinds_t;
-      Kinds_t kinds;
-      const Kinds_t Kind_A = 0x00000004;
-      ...
-      if ( kinds & Label_A ) { ... } // Error but compiles
-
-   SafeBitField is a drop-in replacement which generates a unique type for each bit field. Bit fields of different types cannot be applied
-   to each other:
-
-      LOKI_BIT_FIELD( unsigned long ) Labels_t;
-      Labels_t labels;
-      LOKI_BIT_CONST( Labels_t, Label_A, 1 );                                // 0x0001 - 1st bit is set
-      LOKI_BIT_CONST( Labels_t, Label_B, 2 );                                // 0x0002 - 1st bit is set
-      ...
-      LOKI_BIT_FIELD( unsigned long ) Kinds_t;
-      Kinds_t kinds;
-      LOKI_BIT_CONST( Kinds_t, Kind_A, 3 );                                  // 0x0004 - 1st bit is set
-      ...
-      if ( kinds & Label_A ) { ... } // Does not compile
-
-   Several other kinds of bit field misuse are caught by safe bit fields:
-
-      if ( kinds & Kind_A == 0 ) { ... }
-      if ( kinds && Kind_A ) { ... }
-
-   There are few cases where drop-in replacement does not work:
-
-   1. Operations involving bit fields and unnamed integers. Usually the integer in question is 0:
-
-         Labels_t labels = 0;  // No longer compiles
-         if ( ( labels & Label_A ) == 0 ) { ... } // Also does not compile
-
-      The solution is to use named bit constants, including the one for 0:
-
-         LOKI_BIT_CONST( Labels_t, Label_None, 0 );                               // 0x0000 - No bit is set
-         Labels_t labels = Label_None; // Or just Labels_t labels; - constructor initializes to 0
-         if ( ( labels & Label_A ) == Label_None ) { ... } // // Or just if ( labels & Label_A ) { ... }
-
-   2. I/O and other operations which require integer variables and cannot be modified:
-
-         void write_to_db( unsigned int word );
-         Labels_t labels;
-         write_to_db( labels ); // No longer compiles
-
-      This problem is solved by reinterpreting the bit fields as an integer, the user is responsible for using the right
-      type of integer:
-
-         write_to_db( *((Labels_t::bit_word_t*)(&labels)) );
-
-   ==========================================================================================================================================
-*/
-
-/// @par Non-Templated Initialization.
-/// Not all compilers support template member functions where the template
-/// arguments are not deduced but explicitly specified.  For these broken
-/// compilers, a non-template make_bit_const() function is provided instead of
-/// the template one. The only downside is that instead of compile-time checking
-/// of the index argument, it does runtime checking.
-#if defined(__SUNPRO_CC) || ( defined(__GNUC__) && (__GNUC__ < 3) )
-#define LOKI_BIT_FIELD_NONTEMPLATE_INIT
-#endif
-
-/// @par Forbidding Conversions.
-/// This incomplete type prevents compilers from instantiating templates for
-/// type conversions which should not happen. This incomplete type must be a
-/// template: if the type is incomplete at the point of template definition,
-/// the  template is illegal (although the standard allows compilers to accept
-/// or reject such code, §14.6/, so some compilers will not issue diagnostics
-/// unless template is instantiated). The standard-compliant way is to defer
-/// binding to the point of instantiation by making the incomplete type itself
-/// a template.
-template < typename > struct Forbidden_conversion;  // This struct must not be defined!
-
-/// Forward declaration of the field type.
-template <
-unsigned int unique_index,
-         typename word_t = unsigned long
-         > class SafeBitField;
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class SafeBitConst Bit constants.
-///  This class defines a bit-field constant - a collection of unchanging bits
-///  used to compare to bit-fields.  Instances of this class are intended to act
-///  as labels for bit-fields.
-///
-/// \par Safety
-///  - This class provides operations used for comparisons and conversions, but
-///    no operations which may modify the value.
-///  - As a templated class, it provides type-safety so bit values and constants
-///    used for different reasons may not be unknowingly compared to each other.
-///  - The unique_index template parameter insures the unique type of each bit
-///    bit-field.  It shares the unique_index with a similar SafeBitField.
-///  - Its operations only allow comparisons to other bit-constants and
-///    bit-fields of the same type.
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-unsigned int unique_index,
-         typename word_t = unsigned long
-         >
-class SafeBitConst
-{
-public:
-
-    /// Type of the bit field is available if needed.
-    typedef word_t bit_word_t;
-    /// Corresponding field type.
-    typedef SafeBitField< unique_index, word_t > field_t;
-    /// Typedef is not allowed in friendship declaration.
-    friend class SafeBitField< unique_index, word_t >;
-
-    // Static factory constructor, creates a bit constant with one bit set. The position of the bit is given by the template parameter,
-    // bit 1 is the junior bit, i.e. make_bit_const<1>() returns 1. Bit index 0 is a special case and returns 0.
-    // This function should be used only to initialize the static bit constant objects.
-    // This function will not compile if the bit index is outside the vaild range.
-    // There is also a compile-time assert to make sure the size of the class is the same as the size of the underlaying integer type.
-    // This assert could go into the constructor, but aCC does not seem to understand sizeof(SafeBitConst) in the constructor.
-    //
-#ifndef LOKI_BIT_FIELD_NONTEMPLATE_INIT
-    template < unsigned int i > static SafeBitConst make_bit_const()
-    {
-        LOKI_STATIC_CHECK( i <= ( 8 * sizeof(word_t) ), Index_is_beyond_size_of_data );
-        LOKI_STATIC_CHECK( sizeof(SafeBitConst) == sizeof(word_t), Object_size_does_not_match_data_size );
-        // Why check for ( i > 0 ) again inside the shift if the shift
-        // can never be evaluated for i == 0? Some compilers see shift by ( i - 1 )
-        // and complain that for i == 0 the number is invalid, without
-        // checking that shift needs evaluating.
-        return SafeBitConst( ( i > 0 ) ? ( word_t(1) << ( ( i > 0 ) ? ( i - 1 ) : 0 ) ) : 0 );
-    }
-#else
-    static SafeBitConst make_bit_const( unsigned int i )
-    {
-        LOKI_STATIC_CHECK( sizeof(SafeBitConst) == sizeof(word_t), Object_size_does_not_match_data_size );
-        assert( i <= ( 8 * sizeof(word_t) ) ); // Index is beyond size of data.
-        // Why check for ( i > 0 ) again inside the shift if the shift
-        // can never be evaluated for i == 0? Some compilers see shift by ( i - 1 )
-        // and complain that for i == 0 the number is invalid, without
-        // checking that shift needs evaluating.
-        return SafeBitConst( ( i > 0 ) ? ( word_t(1) << ( ( i > 0 ) ? ( i - 1 ) : 0 ) ) : 0 );
-    }
-#endif
-
-    /// Default constructor allows client code to construct bit fields on the stack.
-    SafeBitConst() : word( 0 ) {}
-
-    /// Copy constructor.
-    SafeBitConst( const SafeBitConst& rhs ) : word( rhs.word ) {}
-
-    /// Comparison operators which take a constant bit value.
-    bool operator == ( const SafeBitConst& rhs ) const { return word == rhs.word; }
-    bool operator != ( const SafeBitConst& rhs ) const { return word != rhs.word; }
-    bool operator <  ( const SafeBitConst& rhs ) const { return word <  rhs.word; }
-    bool operator >  ( const SafeBitConst& rhs ) const { return word >  rhs.word; }
-    bool operator <= ( const SafeBitConst& rhs ) const { return word <= rhs.word; }
-    bool operator >= ( const SafeBitConst& rhs ) const { return word >= rhs.word; }
-
-    /// Comparision operators for mutable bit fields.
-    bool operator == ( const field_t& rhs ) const { return word == rhs.word; }
-    bool operator != ( const field_t& rhs ) const { return word != rhs.word; }
-    bool operator <  ( const field_t& rhs ) const { return word <  rhs.word; }
-    bool operator >  ( const field_t& rhs ) const { return word >  rhs.word; }
-    bool operator <= ( const field_t& rhs ) const { return word <= rhs.word; }
-    bool operator >= ( const field_t& rhs ) const { return word >= rhs.word; }
-
-    /// Bitwise operations.  Operation-assignment operators are not needed,
-    /// since bit constants cannot be changed after they are initialized.
-    const SafeBitConst operator | ( const SafeBitConst& rhs ) const { return SafeBitConst( word | rhs.word ); }
-    const SafeBitConst operator & ( const SafeBitConst& rhs ) const { return SafeBitConst( word & rhs.word ); }
-    const SafeBitConst operator ^ ( const SafeBitConst& rhs ) const { return SafeBitConst( word ^ rhs.word ); }
-    const SafeBitConst operator ~ ( void ) const { return SafeBitConst( ~word ); }
-
-    /// These bitwise operators return a bit-field instead of a bit-const.
-    field_t operator | ( const field_t& rhs ) const { return field_t( word | rhs.word ); }
-    field_t operator & ( const field_t& rhs ) const { return field_t( word & rhs.word ); }
-    field_t operator ^ ( const field_t& rhs ) const { return field_t( word ^ rhs.word ); }
-
-    /// The shift operators move bits inside the bit field.  These are useful in
-    /// loops which act over bit fields and increment them.
-    const SafeBitConst operator << ( unsigned int s ) const { return SafeBitConst( word << s ); }
-    const SafeBitConst operator >> ( unsigned int s ) const { return SafeBitConst( word >> s ); }
-
-    /// Word size is also the maximum number of different bit fields for a given word type.
-    static size_t size() { return ( 8 * sizeof( word_t ) ); }
-
-private:
-
-    /// Copy-assignment operator is not implemented since it does not make sense
-    /// for a constant object.
-    SafeBitConst operator = ( const SafeBitConst& rhs );
-
-    // Private constructor from an integer type.
-    explicit SafeBitConst( word_t init ) : word( init ) {}
-
-    /// This data stores a single bit value.  It is declared const to enforce
-    // constness for all functions of this class.
-    const word_t word;
-
-    // Here comes the interesting stuff: all the operators designed to
-    // trap unintended conversions and make them not compile.
-    // Operators below handle code like this:
-    //    SafeBitField<1> label1;
-    //    SafeBitField<2> label2;
-    //    if ( label1 & label2 ) { ... }
-
-    // These operators are private, and will not instantiate in any
-    // event because of the incomplete Forbidden_conversion struct.
-    template < typename T > SafeBitConst operator|( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitConst operator&( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitConst operator^( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitConst operator|=( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitConst operator&=( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitConst operator^=( T ) const { Forbidden_conversion< T > wrong; return *this; }
-
-    // And the same thing for comparisons: private and unusable.
-    //    if ( label1 == label2 ) { ... }
-    template < typename T > bool operator==( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator!=( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator<( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator>( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator<=( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator>=( const T ) const { Forbidden_conversion< T > wrong; return true; }
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class SafeBitConst Bit constants.
-///  This class defines a bit-field constant - a collection of unchanging bits
-///  used to compare to bit-fields.  Instances of this class are intended to
-///  store bit values.
-///
-/// \par Safety
-///  - This class provides operations used for comparisons and conversions, and
-///    also operations which may safely modify the value.
-///  - As a templated class, it provides type-safety so bit values and constants
-///    used for different reasons may not be unknowingly compared to each other.
-///  - The unique_index template parameter insures the unique type of each bit
-///    bit-field.  It shares the unique_index with a similar SafeBitConst.
-///  - Its operations only allow comparisons to other bit-constants and
-///    bit-fields of the same type.
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-unsigned int unique_index,
-         typename word_t
-         >
-class SafeBitField
-{
-public:
-
-    /// Type of the bit field is available if needed.
-    typedef word_t bit_word_t;
-    /// Corresponding field type.
-    typedef SafeBitConst< unique_index, word_t > const_t;
-    /// Typedef is not allowed in friendship declaration.
-    friend class SafeBitConst<unique_index, word_t>;
-
-    /// Default constructor allows client code to construct bit fields on the stack.
-    SafeBitField() : word( 0 ) {}
-
-    /// Copy constructor and assignment operators.
-    SafeBitField( const SafeBitField& rhs ) : word( rhs.word ) {}
-    SafeBitField& operator = ( const SafeBitField& rhs ) { word = rhs.word; return *this; }
-
-    /// Copy constructor and assignment operators from constant bit fields.
-    SafeBitField( const const_t& rhs ) : word( rhs.word ) {}
-    SafeBitField& operator = ( const const_t& rhs ) { word = rhs.word; return *this; }
-
-    /// These comparison operators act on bit-fields of the same type.
-    bool operator == ( const SafeBitField& rhs ) const { return word == rhs.word; }
-    bool operator != ( const SafeBitField& rhs ) const { return word != rhs.word; }
-    bool operator <  ( const SafeBitField& rhs ) const { return word <  rhs.word; }
-    bool operator >  ( const SafeBitField& rhs ) const { return word >  rhs.word; }
-    bool operator <= ( const SafeBitField& rhs ) const { return word <= rhs.word; }
-    bool operator >= ( const SafeBitField& rhs ) const { return word >= rhs.word; }
-
-    /// These comparison operators act on bit-constants of a similar type.
-    bool operator == ( const const_t& rhs ) const { return word == rhs.word; }
-    bool operator != ( const const_t& rhs ) const { return word != rhs.word; }
-    bool operator <  ( const const_t& rhs ) const { return word <  rhs.word; }
-    bool operator >  ( const const_t& rhs ) const { return word >  rhs.word; }
-    bool operator <= ( const const_t& rhs ) const { return word <= rhs.word; }
-    bool operator >= ( const const_t& rhs ) const { return word >= rhs.word; }
-
-    /// Bitwise operations that use bit-fields.
-    SafeBitField operator |  ( const SafeBitField& rhs ) const { return SafeBitField( word | rhs.word ); }
-    SafeBitField operator &  ( const SafeBitField& rhs ) const { return SafeBitField( word & rhs.word ); }
-    SafeBitField operator ^  ( const SafeBitField& rhs ) const { return SafeBitField( word ^ rhs.word ); }
-    SafeBitField operator ~  ( void ) const { return SafeBitField( ~word ); }
-    SafeBitField operator |= ( const SafeBitField& rhs ) { word |= rhs.word; return SafeBitField( *this ); }
-    SafeBitField operator &= ( const SafeBitField& rhs ) { word &= rhs.word; return SafeBitField( *this ); }
-    SafeBitField operator ^= ( const SafeBitField& rhs ) { word ^= rhs.word; return SafeBitField( *this ); }
-
-    /// Bitwise operators that use bit-constants.
-    SafeBitField operator |  ( const_t rhs ) const { return SafeBitField( word | rhs.word ); }
-    SafeBitField operator &  ( const_t rhs ) const { return SafeBitField( word & rhs.word ); }
-    SafeBitField operator ^  ( const_t rhs ) const { return SafeBitField( word ^ rhs.word ); }
-    SafeBitField operator |= ( const_t rhs ) { word |= rhs.word; return SafeBitField( *this ); }
-    SafeBitField operator &= ( const_t rhs ) { word &= rhs.word; return SafeBitField( *this ); }
-    SafeBitField operator ^= ( const_t rhs ) { word ^= rhs.word; return SafeBitField( *this ); }
-
-    // Conversion to bool.
-    // This is a major source of headaches, but it's required to support code like this:
-    //    const static SafeBitConst<1> Label_value = SafeBitConst<1>::make_bit_const<1>();
-    //    SafeBitField<1> label;
-    //    if ( label & Label_value ) { ... } // Nice...
-    //
-    // The downside is that this allows all sorts of nasty conversions. Without additional precautions, bit fields of different types
-    // can be converted to bool and then compared or operated on:
-    //    SafeBitField<1> label1;
-    //    SafeBitField<2> label2;
-    //    if ( label1 == label2 ) { ... } // Yuck!
-    //    if ( label1 & label2 ) { ... } // Blech!
-    //
-    // It is somewhat safer to convert to a pointer, at least pointers to different types cannot be readilly compared, and there are no
-    // bitwise operations on pointers, but the conversion from word_t to a pointer can have run-time cost if they are of different size.
-    //
-    operator const bool() const { return ( 0 != word ); }
-
-    // Shift operators shift bits inside the bit field. Does not make
-    // sense, most of the time, except perhaps to loop over labels and
-    // increment them.
-    SafeBitField operator <<  ( unsigned int s ) { return SafeBitField( word << s ); }
-    SafeBitField operator >>  ( unsigned int s ) { return SafeBitField( word >> s ); }
-    SafeBitField operator <<= ( unsigned int s ) { word <<= s; return *this; }
-    SafeBitField operator >>= ( unsigned int s ) { word >>= s; return *this; }
-
-    // Word size is also the maximum number of different bit fields for
-    // a given word type.
-    static size_t size( void ) { return ( 8 * sizeof( word_t ) ); }
-
-private:
-
-    /// Private constructor from an integer type. Don't put too much stock into
-    /// explicit declaration, it's better than nothing but does not solve all
-    /// problems with undesired conversions because SafeBitField coverts to bool.
-    explicit SafeBitField( word_t init ) : word( init ) {}
-
-    /// This stores the bits.
-    word_t word;
-
-    // Here comes the interesting stuff: all the operators designed to
-    // trap unintended conversions and make them not compile.
-    // Operators below handle code like this:
-    //    SafeBitField<1> label1;
-    //    SafeBitField<2> label2;
-    //    if ( label1 & label2 ) { ... }
-
-    // These operators are private, and will not instantiate in any
-    // event because of the incomplete Forbidden_conversion struct.
-    template < typename T > SafeBitField operator |  ( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitField operator &  ( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitField operator ^  ( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitField operator |= ( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitField operator &= ( T ) const { Forbidden_conversion< T > wrong; return *this; }
-    template < typename T > SafeBitField operator ^= ( T ) const { Forbidden_conversion< T > wrong; return *this; }
-
-    // And the same thing for comparisons:
-    //    if ( label1 == label2 ) { ... }
-    template < typename T > bool operator == ( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator != ( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator <  ( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator >  ( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator <= ( const T ) const { Forbidden_conversion< T > wrong; return true; }
-    template < typename T > bool operator >= ( const T ) const { Forbidden_conversion< T > wrong; return true; }
-};
-
-// The above template member operators catch errors when the first
-// argument to a binary operator is a label, but they don't work when
-// the first argument is an integer and the second one is a label: the
-// label converts to bool and the operator is performed on two integers.
-// These operators catch errors like this:
-//    SafeBitField<1> label1;
-//    SafeBitField<2> label2;
-//    if ( !label1 & label2 ) { ... }
-// where the first label is converted to bool (these errors cannot be
-// caught by member operators of SafeBitField class because the first
-// argument is not SafeBitField but bool.
-//
-// If used, these operators will not instantiate because of the
-// incomplete Forbidden_conversion struct.
-
-template < unsigned int unique_index, typename word_t >
-inline SafeBitField< unique_index, word_t > operator & ( bool, SafeBitField< unique_index, word_t > rhs )
-{
-    Forbidden_conversion<word_t> wrong;
-    return rhs;
-}
-
-template < unsigned int unique_index, typename word_t >
-inline SafeBitField< unique_index, word_t > operator | ( bool, SafeBitField< unique_index, word_t > rhs )
-{
-    Forbidden_conversion< word_t > wrong;
-    return rhs;
-}
-
-template < unsigned int unique_index, typename word_t >
-inline SafeBitField< unique_index, word_t > operator ^ ( bool, SafeBitField< unique_index, word_t > rhs )
-{
-    Forbidden_conversion< word_t > wrong;
-    return rhs;
-}
-
-template < unsigned int unique_index, typename word_t >
-inline SafeBitField< unique_index, word_t > operator == ( bool, SafeBitField< unique_index, word_t > rhs )
-{
-    Forbidden_conversion< word_t > wrong;
-    return rhs;
-}
-
-template < unsigned int unique_index, typename word_t >
-inline SafeBitField< unique_index, word_t > operator != ( bool, SafeBitField< unique_index, word_t > rhs )
-{
-    Forbidden_conversion< word_t > wrong;
-    return rhs;
-}
-
-// Finally, few macros. All macros are conditionally defined to use the SafeBitField classes if LOKI_SAFE_BIT_FIELD is defined. Otherwise,
-// the macros fall back on the use of typedefs and integer constants. This provides no addititonal safety but allows the code to support the
-// mixture of compilers which are broken to different degrees.
-#define LOKI_SAFE_BIT_FIELD
-
-// The first macro helps to declare new bit field types:
-// LOKI_BIT_FIELD( ulong ) field_t;
-// This creates a typedef field_t for SafeBitField<unique_index, ulong> where index is the current line number. Since line numbers __LINE__ are counted
-// separately for all header files, this ends up being the same type in all files using the header which defines field_t.
-#ifdef LOKI_SAFE_BIT_FIELD
-#define LOKI_BIT_FIELD( word_t ) typedef SafeBitField<__LINE__, word_t>
-#else
-#define LOKI_BIT_FIELD( word_t ) typedef word_t
-#endif // LOKI_SAFE_BIT_FIELD
-
-// The second macro helps to declare static bit constants:
-// LOKI_BIT_CONST( field_t, Label_1, 1 );
-// creates new bit field object named Label_1 of type field_t which represents the field with the 1st (junior) bit set.
-#ifdef LOKI_SAFE_BIT_FIELD
-#ifndef LOKI_BIT_FIELD_NONTEMPLATE_INIT
-#define LOKI_BIT_CONST( field_t, label, bit_index ) \
-    static const field_t::const_t label = field_t::const_t::make_bit_const<bit_index>()
-#else
-#define LOKI_BIT_CONST( field_t, label, bit_index ) \
-    static const field_t::const_t label = field_t::const_t::make_bit_const( bit_index )
-#endif // LOKI_BIT_FIELD_NONTEMPLATE_INIT
-#else
-inline size_t make_bit_const( size_t i ) { return ( i > 0 ) ? ( size_t(1) << ( ( i > 0 ) ? ( i - 1 ) : 0 ) ) : 0; }
-#define LOKI_BIT_CONST( field_t, label, bit_index ) static const field_t label = make_bit_const( bit_index )
-#endif // LOKI_SAFE_BIT_FIELD
-
-// The third macro helps to declare complex bit constants which are combination of several bits:
-// LOKI_BIT_CONSTS( field_t, Label12 ) = Label_1 | Label_2;
-#ifdef LOKI_SAFE_BIT_FIELD
-#define LOKI_BIT_CONSTS( field_t, label ) static const field_t::const_t label
-#else
-#define LOKI_BIT_CONSTS( field_t, label ) static const field_t label
-#endif // LOKI_SAFE_BIT_FIELD
-
-// The fourth macro helps to declare the maximum number of bit constants for a given type:
-// static const size_t count = LOKI_BIT_FIELD_COUNT( field_t );
-// declared a variable "count" initialized to field_t::size()
-#ifdef LOKI_SAFE_BIT_FIELD
-#define LOKI_BIT_FIELD_COUNT( field_t ) field_t::size()
-#else
-#define LOKI_BIT_FIELD_COUNT( field_t ) ( 8 * sizeof(field_t) )
-#endif // LOKI_SAFE_BIT_FIELD
-
-} // namespace Loki
-
-#endif // LOKI_INCLUDED_SAFE_BIT_FIELDS_H
diff --git a/shared/loki/SafeFormat.h b/shared/loki/SafeFormat.h
deleted file mode 100644
index bd2837f9..00000000
--- a/shared/loki/SafeFormat.h
+++ /dev/null
@@ -1,682 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright (c) 2005 by Andrei Alexandrescu
-// 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_SAFEFORMAT_INC_
-#define LOKI_SAFEFORMAT_INC_
-
-// $Id: SafeFormat.h 911 2008-12-15 20:55:24Z syntheticpp $
-
-
-////////////////////////////////////////////////////////////////////////////////
-// This file contains definitions for SafePrintf. SafeScanf coming soon (the
-//   design is similar).
-// See Alexandrescu, Andrei: Type-safe Formatting, C/C++ Users Journal, Aug 2005
-////////////////////////////////////////////////////////////////////////////////
-
-#include <cstdio>
-#include <climits>
-#include <string>
-#include <cstring>
-#include <stdexcept>
-#include <utility>
-#include <cassert>
-#include <locale>
-#include <iostream>
-
-#include <loki/LokiExport.h>
-
-
-// long is 32 bit on 64-bit Windows!
-// intptr_t used to get 64 bit on Win64
-#if defined(_WIN32) || defined(_WIN64)
-#  define LOKI_SAFEFORMAT_SIGNED_LONG intptr_t
-#  define LOKI_SAFEFORMAT_UNSIGNED_LONG uintptr_t
-#else
-#  define LOKI_SAFEFORMAT_SIGNED_LONG signed long
-#  define LOKI_SAFEFORMAT_UNSIGNED_LONG unsigned long
-#endif
-
-// Windows headers could have min/max defined
-#ifdef max
-#  undef max
-#endif
-#ifdef min
-#  undef min
-#endif
-
-namespace Loki
-{
-
-// Crude writing method: writes straight to the file, unbuffered
-// Must be combined with a buffer to work properly (and efficiently)
-LOKI_EXPORT
-void write(std::FILE* f, const char* from, const char* to);
-
-// Write to an ostream
-LOKI_EXPORT
-void write(std::ostream& f, const char* from, const char* to);
-
-// Write to a string
-LOKI_EXPORT
-void write(std::string& s, const char* from, const char* to);
-
-// Write to a fixed-size buffer
-template <class Char>
-void write(std::pair<Char*, std::size_t>& s, const Char* from, const Char* to)
-{
-    assert(from <= to);
-    if (from + s.second < to)
-        throw std::overflow_error("");
-    // s.first: position one past the final copied element
-    s.first = std::copy(from, to, s.first);
-    // remaining buffer size
-    s.second -= to - from;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// PrintfState class template
-// Holds the formatting state, and implements operator() to format stuff
-// Todo: make sure errors are handled properly
-////////////////////////////////////////////////////////////////////////////////
-
-template <class Device, class Char>
-struct PrintfState
-{
-    PrintfState(Device dev, const Char* format)
-        : device_(dev)
-        , format_(format)
-        , width_(0)
-        , prec_(0)
-        , flags_(0)
-        , result_(0)
-    {
-        Advance();
-    }
-
-    ~PrintfState()
-    {
-    }
-
-#define LOKI_PRINTF_STATE_FORWARD(type) \
-    PrintfState& operator()(type par) {\
-        return (*this)(static_cast< LOKI_SAFEFORMAT_UNSIGNED_LONG >(par)); \
-    }
-
-    LOKI_PRINTF_STATE_FORWARD(bool)
-    LOKI_PRINTF_STATE_FORWARD(char)
-    LOKI_PRINTF_STATE_FORWARD(signed char)
-    LOKI_PRINTF_STATE_FORWARD(unsigned char)
-    LOKI_PRINTF_STATE_FORWARD(signed short)
-    LOKI_PRINTF_STATE_FORWARD(unsigned short)
-    LOKI_PRINTF_STATE_FORWARD(signed int)
-    LOKI_PRINTF_STATE_FORWARD(signed long)
-#if (defined(_WIN32) || defined(_WIN64))
-    LOKI_PRINTF_STATE_FORWARD(unsigned long)
-#else
-    // on Windows already defined by uintptr_t
-    LOKI_PRINTF_STATE_FORWARD(unsigned int)
-#endif
-
-    // Print (or gobble in case of the "*" specifier) an int
-    PrintfState& operator()(LOKI_SAFEFORMAT_UNSIGNED_LONG i)
-    {
-        if (result_ == -1) return *this; // don't even bother
-        // % [flags] [width] [.prec] [modifier] type_char
-        // Fetch the flags
-        ReadFlags();
-        if (*format_ == '*')
-        {
-            // read the width and get out
-            SetWidth(static_cast<size_t>(i));
-            ++format_;
-            return *this;
-        }
-        ReadWidth();
-        // precision
-        if (*format_ == '.')
-        {
-            // deal with precision
-            if (format_[1] == '*')
-            {
-                // read the precision and get out
-                SetPrec(static_cast<size_t>(i));
-                format_ += 2;
-                return *this;
-            }
-            ReadPrecision();
-        }
-        ReadModifiers();
-        // input size modifier
-        if (ForceShort())
-        {
-            // short int
-            const Char c = *format_;
-            if (c == 'x' || c == 'X' || c == 'u' || c == 'o')
-            {
-                i = static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(static_cast<unsigned short>(i));
-            }
-        }
-        FormatWithCurrentFlags(i);
-        return *this;
-    }
-
-    PrintfState& operator()(void* n)
-    {
-        if (result_ == -1) return *this; // don't even bother
-        PrintUsing_snprintf(n, "p");
-        return *this;
-    }
-
-    PrintfState& operator()(double n)
-    {
-        if (result_ == -1) return *this; // don't even bother
-        PrintUsing_snprintf(n, "eEfgG");
-        return *this;
-    }
-
-    PrintfState& operator()(long double n)
-    {
-        if (result_ == -1) return *this; // don't even bother
-        PrintUsing_snprintf(n, "eEfgG");
-        return *this;
-    }
-
-    // Store the number of characters printed so far
-    PrintfState& operator()(int* pi)
-    {
-        return StoreCountHelper(pi);
-    }
-
-    // Store the number of characters printed so far
-    PrintfState& operator()(short* pi)
-    {
-        return StoreCountHelper(pi);
-    }
-
-    // Store the number of characters printed so far
-    PrintfState& operator()(long* pi)
-    {
-        return StoreCountHelper(pi);
-    }
-
-    PrintfState& operator()(const std::string& stdstr)
-    {
-        return operator()(stdstr.c_str());
-    }
-
-    PrintfState& operator()(const char* const s)
-    {
-        if (result_ == -1) return *this;
-        ReadLeaders();
-        const char fmt = *format_;
-        if (fmt == 'p')
-        {
-            FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(s));
-            return *this;
-        }
-        if (fmt != 's')
-        {
-            result_ = -1;
-            return *this;
-        }
-        const size_t len = std::min(std::strlen(s), prec_);
-        if (width_ > len)
-        {
-            if (LeftJustify())
-            {
-                Write(s, s + len);
-                Fill(' ', width_ - len);
-            }
-            else
-            {
-                Fill(' ', width_ - len);
-                Write(s, s + len);
-            }
-        }
-        else
-        {
-            Write(s, s + len);
-        }
-        Next();
-        return *this;
-    }
-
-    PrintfState& operator()(const void* const p)
-    {
-        return (*this)(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(p));
-    }
-
-    // read the result
-    operator int() const
-    {
-        return static_cast<int>(result_);
-    }
-
-private:
-    PrintfState& operator=(const PrintfState&);
-    template <typename T>
-    PrintfState& StoreCountHelper(T* const pi)
-    {
-        if (result_ == -1) return *this; // don't even bother
-        ReadLeaders();
-        const char fmt = *format_;
-        if (fmt == 'p')   // pointer
-        {
-            FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(pi));
-            return *this;
-        }
-        if (fmt != 'n')
-        {
-            result_ = -1;
-            return *this;
-        }
-        assert(pi != 0);
-        *pi = result_;
-        Next();
-        return *this;
-    }
-
-    void FormatWithCurrentFlags(const LOKI_SAFEFORMAT_UNSIGNED_LONG i)
-    {
-        // look at the format character
-        Char formatChar = *format_;
-        bool isSigned = formatChar == 'd' || formatChar == 'i';
-        if (formatChar == 'p')
-        {
-            formatChar = 'x'; // pointers go to hex
-            SetAlternateForm(); // printed with '0x' in front
-            isSigned = true; // that's what gcc does
-        }
-        if (!strchr("cdiuoxX", formatChar))
-        {
-            result_ = -1;
-            return;
-        }
-        Char buf[
-            sizeof(LOKI_SAFEFORMAT_UNSIGNED_LONG) * 3 // digits
-            + 1 // sign or ' '
-            + 2 // 0x or 0X
-            + 1]; // terminating zero
-        const Char* const bufEnd = buf + (sizeof(buf) / sizeof(Char));
-        Char* bufLast = buf + (sizeof(buf) / sizeof(Char) - 1);
-        Char signChar = 0;
-        unsigned int base = 10;
-
-        if (formatChar == 'c')
-        {
-            // Format only one character
-            // The 'fill with zeros' flag is ignored
-            ResetFillZeros();
-            *bufLast = static_cast<char>(i);
-        }
-        else
-        {
-            // TODO: inefficient code, refactor
-            const bool negative = isSigned && static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i) < 0;
-            if (formatChar == 'o') base = 8;
-            else if (formatChar == 'x' || formatChar == 'X') base = 16;
-            bufLast = isSigned
-                      ? RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i), bufLast, base,
-                                          formatChar == 'X')
-                      : RenderWithoutSign(i, bufLast, base,
-                                          formatChar == 'X');
-            // Add the sign
-            if (isSigned)
-            {
-                negative ? signChar = '-'
-                                      : ShowSignAlways() ? signChar = '+'
-                                                                      : Blank() ? signChar = ' '
-                                                                                             : 0;
-            }
-        }
-        // precision
-        size_t
-        countDigits = bufEnd - bufLast,
-        countZeros = prec_ != size_t(-1) && countDigits < prec_ &&
-                     formatChar != 'c'
-                     ? prec_ - countDigits
-                     : 0,
-                     countBase = base != 10 && AlternateForm() && i != 0
-                                 ? (base == 16 ? 2 : countZeros > 0 ? 0 : 1)
-                                 : 0,
-                                 countSign = (signChar != 0),
-                                 totalPrintable = countDigits + countZeros + countBase + countSign;
-        size_t countPadLeft = 0, countPadRight = 0;
-        if (width_ > totalPrintable)
-        {
-            if (LeftJustify())
-            {
-                countPadRight = width_ - totalPrintable;
-                countPadLeft = 0;
-            }
-            else
-            {
-                countPadLeft = width_ - totalPrintable;
-                countPadRight = 0;
-            }
-        }
-        if (FillZeros() && prec_ == size_t(-1))
-        {
-            // pad with zeros and no precision - transfer padding to precision
-            countZeros = countPadLeft;
-            countPadLeft = 0;
-        }
-        // ok, all computed, ready to print to device
-        Fill(' ', countPadLeft);
-        if (signChar != 0) Write(&signChar, &signChar + 1);
-        if (countBase > 0) Fill('0', 1);
-        if (countBase == 2) Fill(formatChar, 1);
-        Fill('0', countZeros);
-        Write(bufLast, bufEnd);
-        Fill(' ', countPadRight);
-        // done, advance
-        Next();
-    }
-
-    void Write(const Char* b, const Char* e)
-    {
-        if (result_ < 0) return;
-        const LOKI_SAFEFORMAT_SIGNED_LONG x = e - b;
-        write(device_, b, e);
-        result_ += x;
-    }
-
-    template <class Value>
-    void PrintUsing_snprintf(Value n, const char* check_fmt_char)
-    {
-        const Char* const fmt = format_ - 1;
-        assert(*fmt == '%');
-        // enforce format string validity
-        ReadLeaders();
-        // enforce format spec
-        if (!strchr(check_fmt_char, *format_))
-        {
-            result_ = -1;
-            return;
-        }
-        // format char validated, copy it to a temp and use legacy sprintf
-        ++format_;
-        Char fmtBuf[128], resultBuf[1024];
-        if (format_  >= fmt + sizeof(fmtBuf) / sizeof(Char))
-        {
-            result_ = -1;
-            return;
-        }
-        memcpy(fmtBuf, fmt, (format_ - fmt) * sizeof(Char));
-        fmtBuf[format_ - fmt] = 0;
-
-        const int stored =
-#ifdef _MSC_VER
-#if _MSC_VER < 1400
-            _snprintf
-#else
-            _snprintf_s
-#endif
-#else
-            snprintf
-#endif
-            (resultBuf, sizeof(resultBuf) / sizeof(Char), fmtBuf, n);
-
-        if (stored < 0)
-        {
-            result_ = -1;
-            return;
-        }
-        Write(resultBuf, resultBuf + strlen(resultBuf));
-        Advance(); // output stuff to the next format directive
-    }
-
-    void Fill(const Char c, size_t n)
-    {
-        for (; n > 0; --n)
-        {
-            Write(&c, &c + 1);
-        }
-    }
-
-    Char* RenderWithoutSign(LOKI_SAFEFORMAT_UNSIGNED_LONG n, char* bufLast,
-                            unsigned int base, bool uppercase)
-    {
-        const Char hex1st = uppercase ? 'A' : 'a';
-        for (;;)
-        {
-            const LOKI_SAFEFORMAT_UNSIGNED_LONG next = n / base;
-            Char c = static_cast<Char>(n - next * base);
-            c = static_cast<Char>(c + (c <= 9 ? '0' : static_cast<Char>(hex1st - 10)));
-            *bufLast = c;
-            n = next;
-            if (n == 0) break;
-            --bufLast;
-        }
-        return bufLast;
-    }
-
-    char* RenderWithoutSign(LOKI_SAFEFORMAT_SIGNED_LONG n, char* bufLast, unsigned int base,
-                            bool uppercase)
-    {
-        if (n != LONG_MIN)
-        {
-            return RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n < 0 ? -n : n),
-                                     bufLast, base, uppercase);
-        }
-        // annoying corner case
-        char* save = bufLast;
-        ++n;
-        bufLast = RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n),
-                                    bufLast, base, uppercase);
-        --(*save);
-        return bufLast;
-    }
-
-    void Next()
-    {
-        ++format_;
-        Advance();
-    }
-
-    void Advance()
-    {
-        ResetAll();
-        const Char* begin = format_;
-        for (;;)
-        {
-            if (*format_ == '%')
-            {
-                if (format_[1] != '%')   // It's a format specifier
-                {
-                    Write(begin, format_);
-                    ++format_;
-                    break;
-                }
-                // It's a "%%"
-                Write(begin, ++format_);
-                begin = ++format_;
-                continue;
-            }
-            if (*format_ == 0)
-            {
-                Write(begin, format_);
-                break;
-            }
-            ++format_;
-        }
-    }
-
-    void ReadFlags()
-    {
-        for (;; ++format_)
-        {
-            switch (*format_)
-            {
-                case '-':
-                    SetLeftJustify();
-                    break;
-                case '+':
-                    SetShowSignAlways();
-                    break;
-                case ' ':
-                    SetBlank();
-                    break;
-                case '#':
-                    SetAlternateForm();
-                    break;
-                case '0':
-                    SetFillZeros();
-                    break;
-                default:
-                    return;
-            }
-        }
-    }
-
-    void ParseDecimalSizeT(size_t& dest)
-    {
-        if (!std::isdigit(*format_, std::locale())) return;
-        size_t r = 0;
-        do
-        {
-            // TODO: inefficient - rewrite
-            r *= 10;
-            r += *format_ - '0';
-            ++format_;
-        }
-        while (std::isdigit(*format_, std::locale()));
-        dest = r;
-    }
-
-    void ReadWidth()
-    {
-        ParseDecimalSizeT(width_);
-    }
-
-    void ReadPrecision()
-    {
-        assert(*format_ == '.');
-        ++format_;
-        ParseDecimalSizeT(prec_);
-    }
-
-    void ReadModifiers()
-    {
-        switch (*format_)
-        {
-            case 'h':
-                SetForceShort();
-                ++format_;
-                break;
-            case 'l':
-                ++format_;
-                break;
-                // more (C99 and platform-specific modifiers) to come
-        }
-    }
-
-    void ReadLeaders()
-    {
-        ReadFlags();
-        ReadWidth();
-        if (*format_ == '.') ReadPrecision();
-        ReadModifiers();
-    }
-
-    enum
-    {
-        leftJustify = 1,
-        showSignAlways = 2,
-        blank = 4,
-        alternateForm = 8,
-        fillZeros = 16,
-        forceShort = 32
-    };
-
-    bool LeftJustify() const { return (flags_ & leftJustify) != 0; }
-    bool ShowSignAlways() const { return (flags_ & showSignAlways) != 0; }
-    void SetWidth(size_t w) { width_  = w; }
-    void SetLeftJustify() { flags_  |= leftJustify; }
-    void SetShowSignAlways() { flags_ |= showSignAlways; }
-    bool Blank() const { return (flags_ & blank) != 0; }
-    bool AlternateForm() const { return (flags_ & alternateForm) != 0; }
-    bool FillZeros() const { return (flags_ & fillZeros) != 0; }
-    bool ForceShort() const { return (flags_ & forceShort) != 0; }
-
-    void SetPrec(size_t p) { prec_ = p; }
-    void SetBlank() { flags_ |= blank; }
-    void SetAlternateForm() { flags_ |=  alternateForm; }
-    void SetFillZeros() { flags_ |= fillZeros; }
-    void ResetFillZeros() { flags_ &= ~fillZeros; }
-    void SetForceShort() { flags_ |= forceShort; }
-
-    void ResetAll()
-    {
-        assert(result_ != EOF);
-        width_ = 0;
-        prec_ = size_t(-1);
-        flags_ = 0;
-    }
-
-    // state
-    Device device_;
-    const Char* format_;
-    size_t width_;
-    size_t prec_;
-    unsigned int flags_;
-    LOKI_SAFEFORMAT_SIGNED_LONG result_;
-};
-
-LOKI_EXPORT
-PrintfState<std::FILE*, char> Printf(const char* format);
-
-LOKI_EXPORT
-PrintfState<std::FILE*, char> Printf(const std::string& format);
-
-LOKI_EXPORT
-PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const char* format);
-
-LOKI_EXPORT
-PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const std::string& format);
-
-LOKI_EXPORT
-PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const char* format);
-
-LOKI_EXPORT
-PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const std::string& format);
-
-LOKI_EXPORT
-PrintfState<std::string&, char> SPrintf(std::string& s, const char* format);
-
-LOKI_EXPORT
-PrintfState<std::string&, char> SPrintf(std::string& s, const std::string& format);
-
-template <class T, class Char>
-PrintfState<T&, Char> XPrintf(T& device, const Char* format)
-{
-    return PrintfState<T&, Char>(device, format);
-}
-
-template <class T>
-PrintfState<T&, char> XPrintf(T& device, const std::string& format)
-{
-    return PrintfState<T&, char>(device, format.c_str());
-}
-
-template <class Char, std::size_t N>
-PrintfState<std::pair<Char*, std::size_t>, Char>
-BufPrintf(Char (&buf)[N], const Char* format)
-{
-    std::pair<Char*, std::size_t> temp(buf, N);
-    return PrintfState<std::pair<Char*, std::size_t>, Char>(temp, format);
-}
-
-}// namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/ScopeGuard.h b/shared/loki/ScopeGuard.h
deleted file mode 100644
index 99ce569d..00000000
--- a/shared/loki/ScopeGuard.h
+++ /dev/null
@@ -1,669 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2000 Andrei Alexandrescu
-// Copyright (c) 2000 Petru Marginean
-// Copyright (c) 2005 Joshua Lehrer
-//
-// 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_SCOPEGUARD_INC_
-#define LOKI_SCOPEGUARD_INC_
-
-// $Id: ScopeGuard.h 799 2006-12-20 00:37:13Z rich_sposato $
-
-
-#include "RefToValue.h"
-
-/// \defgroup ExceptionGroup Exception-safe code
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImplBase
-/// \ingroup ExceptionGroup
-///
-/// Base class used by all ScopeGuard implementations.  All commonly used
-/// functions are in this class (e.g. - Dismiss and SafeExecute).
-///
-/// See Andrei's and Petru Marginean's CUJ article
-/// http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/alexandr.htm
-///
-/// Changes to the original code by Joshua Lehrer:
-/// http://www.lehrerfamily.com/scopeguard.html
-////////////////////////////////////////////////////////////////
-
-class ScopeGuardImplBase
-{
-    /// Copy-assignment operator is not implemented and private.
-    ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
-
-protected:
-
-    ~ScopeGuardImplBase()
-    {}
-
-    /// Copy-constructor takes over responsibility from other ScopeGuard.
-    ScopeGuardImplBase(const ScopeGuardImplBase& other) throw()
-        : dismissed_(other.dismissed_)
-    {
-        other.Dismiss();
-    }
-
-    template <typename J>
-    static void SafeExecute(J& j) throw()
-    {
-        if (!j.dismissed_)
-            try
-            {
-                j.Execute();
-            }
-            catch (...)
-            {}
-    }
-
-    mutable bool dismissed_;
-
-public:
-    ScopeGuardImplBase() throw() : dismissed_(false)
-    {}
-
-    void Dismiss() const throw()
-    {
-        dismissed_ = true;
-    }
-};
-
-////////////////////////////////////////////////////////////////
-///
-/// \typedef typedef const ScopeGuardImplBase& ScopeGuard
-/// \ingroup ExceptionGroup
-///
-////////////////////////////////////////////////////////////////
-
-typedef const ScopeGuardImplBase& ScopeGuard;
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImpl0
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a standalone function or class static function
-/// with no parameters.  ScopeGuard ignores any value returned from the
-/// call within the Execute function.
-///
-/// This class has a single standalone helper function, MakeGuard which
-/// creates and returns a ScopeGuard.
-///
-////////////////////////////////////////////////////////////////
-
-template <typename F>
-class ScopeGuardImpl0 : public ScopeGuardImplBase
-{
-public:
-    static ScopeGuardImpl0<F> MakeGuard(F fun)
-    {
-        return ScopeGuardImpl0<F>(fun);
-    }
-
-    ~ScopeGuardImpl0() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        fun_();
-    }
-
-protected:
-    ScopeGuardImpl0(F fun) : fun_(fun)
-    {}
-
-    F fun_;
-};
-
-template <typename F>
-inline ScopeGuardImpl0<F> MakeGuard(F fun)
-{
-    return ScopeGuardImpl0<F>::MakeGuard(fun);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImpl1
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a standalone function or class static function
-/// with one parameter.  Each parameter is copied by value - use
-/// ::Loki::ByRef if you must use a reference instead.  ScopeGuard ignores
-/// any value returned from the call within the Execute function.
-///
-/// This class has a single standalone helper function, MakeGuard which
-/// creates and returns a ScopeGuard.
-///
-////////////////////////////////////////////////////////////////
-
-template <typename F, typename P1>
-class ScopeGuardImpl1 : public ScopeGuardImplBase
-{
-public:
-    static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
-    {
-        return ScopeGuardImpl1<F, P1>(fun, p1);
-    }
-
-    ~ScopeGuardImpl1() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        fun_(p1_);
-    }
-
-protected:
-    ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1)
-    {}
-
-    F fun_;
-    const P1 p1_;
-};
-
-template <typename F, typename P1>
-inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
-{
-    return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImpl2
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a standalone function or class static function
-/// with two parameters.  Each parameter is copied by value - use
-/// ::Loki::ByRef if you must use a reference instead.  ScopeGuard ignores
-/// any value returned from the call within the Execute function.
-///
-/// This class has a single standalone helper function, MakeGuard which
-/// creates and returns a ScopeGuard.
-///
-////////////////////////////////////////////////////////////////
-
-template <typename F, typename P1, typename P2>
-class ScopeGuardImpl2: public ScopeGuardImplBase
-{
-public:
-    static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
-    {
-        return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2);
-    }
-
-    ~ScopeGuardImpl2() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        fun_(p1_, p2_);
-    }
-
-protected:
-    ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2)
-    {}
-
-    F fun_;
-    const P1 p1_;
-    const P2 p2_;
-};
-
-template <typename F, typename P1, typename P2>
-inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
-{
-    return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImpl3
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a standalone function or class static function
-/// with three parameters.  Each parameter is copied by value - use
-/// ::Loki::ByRef if you must use a reference instead.  ScopeGuard ignores
-/// any value returned from the call within the Execute function.
-///
-/// This class has a single standalone helper function, MakeGuard which
-/// creates and returns a ScopeGuard.
-///
-////////////////////////////////////////////////////////////////
-
-template <typename F, typename P1, typename P2, typename P3>
-class ScopeGuardImpl3 : public ScopeGuardImplBase
-{
-public:
-    static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
-    {
-        return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3);
-    }
-
-    ~ScopeGuardImpl3() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        fun_(p1_, p2_, p3_);
-    }
-
-protected:
-    ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3)
-    {}
-
-    F fun_;
-    const P1 p1_;
-    const P2 p2_;
-    const P3 p3_;
-};
-
-template <typename F, typename P1, typename P2, typename P3>
-inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
-{
-    return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImpl4
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a standalone function or class static function
-/// with four parameters.  Each parameter is copied by value - use
-/// ::Loki::ByRef if you must use a reference instead.  ScopeGuard ignores
-/// any value returned from the call within the Execute function.
-///
-/// This class has a single standalone helper function, MakeGuard which
-/// creates and returns a ScopeGuard.
-///
-////////////////////////////////////////////////////////////////
-
-template < typename F, typename P1, typename P2, typename P3, typename P4 >
-class ScopeGuardImpl4 : public ScopeGuardImplBase
-{
-public:
-    static ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard(
-        F fun, P1 p1, P2 p2, P3 p3, P4 p4 )
-    {
-        return ScopeGuardImpl4< F, P1, P2, P3, P4 >( fun, p1, p2, p3, p4 );
-    }
-
-    ~ScopeGuardImpl4() throw()
-    {
-        SafeExecute( *this );
-    }
-
-    void Execute()
-    {
-        fun_( p1_, p2_, p3_, p4_ );
-    }
-
-protected:
-    ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) :
-        fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 )
-    {}
-
-    F fun_;
-    const P1 p1_;
-    const P2 p2_;
-    const P3 p3_;
-    const P4 p4_;
-};
-
-template < typename F, typename P1, typename P2, typename P3, typename P4 >
-inline ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4 )
-{
-    return ScopeGuardImpl4< F, P1, P2, P3, P4 >::MakeGuard( fun, p1, p2, p3, p4 );
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ScopeGuardImpl5
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a standalone function or class static function
-/// with five parameters.  Each parameter is copied by value - use
-/// ::Loki::ByRef if you must use a reference instead.  ScopeGuard ignores
-/// any value returned from the call within the Execute function.
-///
-/// This class has a single standalone helper function, MakeGuard which
-/// creates and returns a ScopeGuard.
-///
-////////////////////////////////////////////////////////////////
-
-template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 >
-class ScopeGuardImpl5 : public ScopeGuardImplBase
-{
-public:
-    static ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard(
-        F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
-    {
-        return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >( fun, p1, p2, p3, p4, p5 );
-    }
-
-    ~ScopeGuardImpl5() throw()
-    {
-        SafeExecute( *this );
-    }
-
-    void Execute()
-    {
-        fun_( p1_, p2_, p3_, p4_, p5_ );
-    }
-
-protected:
-    ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) :
-        fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 )
-    {}
-
-    F fun_;
-    const P1 p1_;
-    const P2 p2_;
-    const P3 p3_;
-    const P4 p4_;
-    const P5 p5_;
-};
-
-template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 >
-inline ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
-{
-    return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >::MakeGuard( fun, p1, p2, p3, p4, p5 );
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ObjScopeGuardImpl0
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a class per-instance member function with no
-/// parameters.  ScopeGuard ignores any value returned from the call within
-/// the Execute function.
-///
-/// This class has 3 standalone helper functions which create a ScopeGuard.
-/// One is MakeObjGuard, which is deprecated but provided for older code.
-/// The other two are MakeGuard overloads, one which takes a pointer to an
-/// object, and the other which takes a reference.
-///
-////////////////////////////////////////////////////////////////
-
-template <class Obj, typename MemFun>
-class ObjScopeGuardImpl0 : public ScopeGuardImplBase
-{
-public:
-    static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
-    {
-        return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun);
-    }
-
-    ~ObjScopeGuardImpl0() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        (obj_.*memFun_)();
-    }
-
-protected:
-    ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun)
-    {}
-
-    Obj& obj_;
-    MemFun memFun_;
-};
-
-template <class Obj, typename MemFun>
-inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
-{
-    return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
-}
-
-template <typename Ret, class Obj1, class Obj2>
-inline ObjScopeGuardImpl0<Obj1, Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1& obj)
-{
-    return ObjScopeGuardImpl0<Obj1, Ret(Obj2::*)()>::MakeObjGuard(obj, memFun);
-}
-
-template <typename Ret, class Obj1, class Obj2>
-inline ObjScopeGuardImpl0<Obj1, Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1* obj)
-{
-    return ObjScopeGuardImpl0<Obj1, Ret(Obj2::*)()>::MakeObjGuard(*obj, memFun);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ObjScopeGuardImpl1
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a class per-instance member function with one
-/// parameter.  The parameter is copied by value - use ::Loki::ByRef if you
-/// must use a reference instead.  ScopeGuard ignores any value returned
-/// from the call within the Execute function.
-///
-/// This class has 3 standalone helper functions which create a ScopeGuard.
-/// One is MakeObjGuard, which is deprecated but provided for older code.
-/// The other two are MakeGuard overloads, one which takes a pointer to an
-/// object, and the other which takes a reference.
-///
-////////////////////////////////////////////////////////////////
-
-template <class Obj, typename MemFun, typename P1>
-class ObjScopeGuardImpl1 : public ScopeGuardImplBase
-{
-public:
-    static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
-    {
-        return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1);
-    }
-
-    ~ObjScopeGuardImpl1() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        (obj_.*memFun_)(p1_);
-    }
-
-protected:
-    ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1)
-    {}
-
-    Obj& obj_;
-    MemFun memFun_;
-    const P1 p1_;
-};
-
-template <class Obj, typename MemFun, typename P1>
-inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
-{
-    return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
-}
-
-template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b>
-inline ObjScopeGuardImpl1<Obj1, Ret(Obj2::*)(P1a), P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1& obj, P1b p1)
-{
-    return ObjScopeGuardImpl1<Obj1, Ret(Obj2::*)(P1a), P1b>::MakeObjGuard(obj, memFun, p1);
-}
-
-template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b>
-inline ObjScopeGuardImpl1<Obj1, Ret(Obj2::*)(P1a), P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1* obj, P1b p1)
-{
-    return ObjScopeGuardImpl1<Obj1, Ret(Obj2::*)(P1a), P1b>::MakeObjGuard(*obj, memFun, p1);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ObjScopeGuardImpl2
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a class per-instance member function with two
-/// parameters.  Each parameter is copied by value - use ::Loki::ByRef if you
-/// must use a reference instead.  ScopeGuard ignores any value returned
-/// from the call within the Execute function.
-///
-/// This class has 3 standalone helper functions which create a ScopeGuard.
-/// One is MakeObjGuard, which is deprecated but provided for older code.
-/// The other two are MakeGuard overloads, one which takes a pointer to an
-/// object, and the other which takes a reference.
-///
-////////////////////////////////////////////////////////////////
-
-template <class Obj, typename MemFun, typename P1, typename P2>
-class ObjScopeGuardImpl2 : public ScopeGuardImplBase
-{
-public:
-    static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
-    {
-        return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2);
-    }
-
-    ~ObjScopeGuardImpl2() throw()
-    {
-        SafeExecute(*this);
-    }
-
-    void Execute()
-    {
-        (obj_.*memFun_)(p1_, p2_);
-    }
-
-protected:
-    ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2)
-    {}
-
-    Obj& obj_;
-    MemFun memFun_;
-    const P1 p1_;
-    const P2 p2_;
-};
-
-template <class Obj, typename MemFun, typename P1, typename P2>
-inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
-{
-    return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2);
-}
-
-template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b>
-inline ObjScopeGuardImpl2<Obj1, Ret(Obj2::*)(P1a, P2a), P1b, P2b> MakeGuard(Ret(Obj2::*memFun)(P1a, P2a), Obj1& obj, P1b p1, P2b p2)
-{
-    return ObjScopeGuardImpl2<Obj1, Ret(Obj2::*)(P1a, P2a), P1b, P2b>::MakeObjGuard(obj, memFun, p1, p2);
-}
-
-template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b>
-inline ObjScopeGuardImpl2<Obj1, Ret(Obj2::*)(P1a, P2a), P1b, P2b> MakeGuard(Ret(Obj2::*memFun)(P1a, P2a), Obj1* obj, P1b p1, P2b p2)
-{
-    return ObjScopeGuardImpl2<Obj1, Ret(Obj2::*)(P1a, P2a), P1b, P2b>::MakeObjGuard(*obj, memFun, p1, p2);
-}
-
-////////////////////////////////////////////////////////////////
-///
-/// \class ObjScopeGuardImpl3
-/// \ingroup ExceptionGroup
-///
-/// Implementation class for a class per-instance member function with three
-/// parameters.  Each parameter is copied by value - use ::Loki::ByRef if you
-/// must use a reference instead.  ScopeGuard ignores any value returned
-/// from the call within the Execute function.
-///
-/// This class has 3 standalone helper functions which create a ScopeGuard.
-/// One is MakeObjGuard, which is deprecated but provided for older code.
-/// The other two are MakeGuard overloads, one which takes a pointer to an
-/// object, and the other which takes a reference.
-///
-////////////////////////////////////////////////////////////////
-
-template < class Obj, typename MemFun, typename P1, typename P2, typename P3 >
-class ObjScopeGuardImpl3 : public ScopeGuardImplBase
-{
-public:
-    static ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard(
-        Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3 )
-    {
-        return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >( obj, memFun, p1, p2, p3 );
-    }
-
-    ~ObjScopeGuardImpl3() throw()
-    {
-        SafeExecute( *this );
-    }
-
-    void Execute()
-    {
-        ( obj_.*memFun_ )( p1_, p2_, p3_ );
-    }
-
-protected:
-    ObjScopeGuardImpl3( Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) :
-        obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 )
-    {}
-
-    Obj& obj_;
-    MemFun memFun_;
-    const P1 p1_;
-    const P2 p2_;
-    const P3 p3_;
-};
-
-template < class Obj, typename MemFun, typename P1, typename P2, typename P3 >
-inline ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard(
-    Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3 )
-{
-    return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >::MakeObjGuard(
-               obj, memFun, p1, p2, p3 );
-}
-
-template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b,
-         typename P2a, typename P2b, typename P3a, typename P3b >
-inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
-MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1& obj, P1b p1, P2b p2, P3b p3 )
-{
-    return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
-           ::MakeObjGuard( obj, memFun, p1, p2, p3 );
-}
-
-template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b,
-         typename P2a, typename P2b, typename P3a, typename P3b >
-inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
-MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1* obj, P1b p1, P2b p2, P3b p3 )
-{
-    return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b >
-           ::MakeObjGuard( *obj, memFun, p1, p2, p3 );
-}
-
-} // namespace Loki
-
-#define LOKI_CONCATENATE_DIRECT(s1, s2)  s1##s2
-#define LOKI_CONCATENATE(s1, s2)         LOKI_CONCATENATE_DIRECT(s1, s2)
-#define LOKI_ANONYMOUS_VARIABLE(str)     LOKI_CONCATENATE(str, __LINE__)
-
-#define LOKI_ON_BLOCK_EXIT      ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeGuard
-#define LOKI_ON_BLOCK_EXIT_OBJ  ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeObjGuard
-
-//by ZenJu
-#define LOKI_ON_BLOCK_EXIT2(X) ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeGuard([&](){X;}); (void)LOKI_ANONYMOUS_VARIABLE(scopeGuard);
-
-#endif // end file guardian
-
diff --git a/shared/loki/Sequence.h b/shared/loki/Sequence.h
deleted file mode 100644
index 04a64174..00000000
--- a/shared/loki/Sequence.h
+++ /dev/null
@@ -1,49 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2005 by 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_SEQUENCE_INC_
-#define LOKI_SEQUENCE_INC_
-
-// $Id: Sequence.h 768 2006-10-25 20:40:40Z syntheticpp $
-
-
-#include "Typelist.h"
-
-namespace Loki
-{
-
-template
-<
-class T01 = NullType, class T02 = NullType, class T03 = NullType, class T04 = NullType, class T05 = NullType,
-      class T06 = NullType, class T07 = NullType, class T08 = NullType, class T09 = NullType, class T10 = NullType,
-      class T11 = NullType, class T12 = NullType, class T13 = NullType, class T14 = NullType, class T15 = NullType,
-      class T16 = NullType, class T17 = NullType, class T18 = NullType, class T19 = NullType, class T20 = NullType
-      >
-struct Seq
-{
-private:
-    typedef typename Seq <     T02, T03, T04, T05, T06, T07, T08, T09, T10,
-            T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 >::Type
-            TailResult;
-public:
-    typedef Typelist<T01, TailResult> Type;
-};
-
-template<>
-struct Seq<>
-{
-    typedef NullType Type;
-};
-
-}   // namespace Loki
-
-#endif // end file guardian
-
diff --git a/shared/loki/Singleton.h b/shared/loki/Singleton.h
deleted file mode 100644
index 1e479032..00000000
--- a/shared/loki/Singleton.h
+++ /dev/null
@@ -1,889 +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_SINGLETON_INC_
-#define LOKI_SINGLETON_INC_
-
-// $Id: Singleton.h 834 2007-08-02 19:36:10Z syntheticpp $
-
-
-#include "LokiExport.h"
-#include "Threads.h"
-#include <algorithm>
-#include <stdexcept>
-#include <cassert>
-#include <cstdlib>
-#include <new>
-#include <vector>
-#include <list>
-#include <memory>
-
-#ifdef _MSC_VER
-#define LOKI_C_CALLING_CONVENTION_QUALIFIER __cdecl
-#else
-#define LOKI_C_CALLING_CONVENTION_QUALIFIER
-#endif
-
-///  \defgroup  SingletonGroup Singleton
-///  \defgroup  CreationGroup Creation policies
-///  \ingroup   SingletonGroup
-///  \defgroup  LifetimeGroup Lifetime policies
-///  \ingroup   SingletonGroup
-///  The lifetimes of the singleton.
-///  \par Special lifetime for SmallObjects
-///  When the holded object is a Small(Value)Object or the holded object
-///  uses objects which are or inherit from Small(Value)Object
-///  then you can't use the default lifetime: you must use the lifetime
-///  \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode
-///  Be aware of this when you use Loki::Factory, Loki::Functor, or Loki::Function.
-
-
-
-namespace Loki
-{
-typedef void (LOKI_C_CALLING_CONVENTION_QUALIFIER* atexit_pfn_t)();
-
-namespace Private
-{
-
-#ifndef LOKI_MAKE_DLL
-void LOKI_C_CALLING_CONVENTION_QUALIFIER AtExitFn(); // declaration needed below
-#else
-void LOKI_EXPORT AtExitFn();
-#endif
-
-class LifetimeTracker;
-
-#define LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
-#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
-
-// Helper data
-// std::list because of the inserts
-typedef std::list<LifetimeTracker*> TrackerArray;
-extern LOKI_EXPORT TrackerArray* pTrackerArray;
-#else
-// Helper data
-typedef LifetimeTracker** TrackerArray;
-extern TrackerArray pTrackerArray;
-extern unsigned int elements;
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// class LifetimeTracker
-// Helper class for SetLongevity
-////////////////////////////////////////////////////////////////////////////////
-
-class LifetimeTracker
-{
-public:
-    LifetimeTracker(unsigned int x) : longevity_(x)
-    {}
-
-    virtual ~LifetimeTracker() = 0;
-
-    static bool Compare(const LifetimeTracker* lhs,
-                        const LifetimeTracker* rhs)
-    {
-        return lhs->longevity_ > rhs->longevity_;
-    }
-
-private:
-    unsigned int longevity_;
-};
-
-// Definition required
-inline LifetimeTracker::~LifetimeTracker() {}
-
-// Helper destroyer function
-template <typename T>
-struct Deleter
-{
-    typedef void (*Type)(T*);
-    static void Delete(T* pObj)
-    { delete pObj; }
-};
-
-// Concrete lifetime tracker for objects of type T
-template <typename T, typename Destroyer>
-class ConcreteLifetimeTracker : public LifetimeTracker
-{
-public:
-    ConcreteLifetimeTracker(T* p, unsigned int longevity, Destroyer d)
-        : LifetimeTracker(longevity)
-        , pTracked_(p)
-        , destroyer_(d)
-    {}
-
-    ~ConcreteLifetimeTracker()
-    { destroyer_(pTracked_); }
-
-private:
-    T* pTracked_;
-    Destroyer destroyer_;
-};
-
-} // namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-///  \ingroup LifetimeGroup
-///
-///  Assigns an object a longevity; ensures ordered destructions of objects
-///  registered thusly during the exit sequence of the application
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
-
-template <typename T, typename Destroyer>
-void SetLongevity(T* pDynObject, unsigned int longevity,
-                  Destroyer d)
-{
-    using namespace Private;
-
-    // manage lifetime of stack manually
-    if (pTrackerArray == 0)
-        pTrackerArray = new TrackerArray;
-
-    // automatically delete the ConcreteLifetimeTracker object when a exception is thrown
-    std::auto_ptr<LifetimeTracker>
-    p( new ConcreteLifetimeTracker<T, Destroyer>(pDynObject, longevity, d) );
-
-    // Find correct position
-    TrackerArray::iterator pos = std::upper_bound(
-                                     pTrackerArray->begin(),
-                                     pTrackerArray->end(),
-                                     p.get(),
-                                     LifetimeTracker::Compare);
-
-    // Insert the pointer to the ConcreteLifetimeTracker object into the queue
-    pTrackerArray->insert(pos, p.get());
-
-    // nothing has thrown: don't delete the ConcreteLifetimeTracker object
-    p.release();
-
-    // Register a call to AtExitFn
-    std::atexit(Private::AtExitFn);
-}
-
-#else
-
-template <typename T, typename Destroyer>
-void SetLongevity(T* pDynObject, unsigned int longevity,
-                  Destroyer d)
-{
-    using namespace Private;
-
-    TrackerArray pNewArray = static_cast<TrackerArray>(
-                                 std::realloc(pTrackerArray,
-                                              sizeof(*pTrackerArray) * (elements + 1)));
-    if (!pNewArray) throw std::bad_alloc();
-
-    // Delayed assignment for exception safety
-    pTrackerArray = pNewArray;
-
-    LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>(
-        pDynObject, longevity, d);
-
-    // Insert a pointer to the object into the queue
-    TrackerArray pos = std::upper_bound(
-                           pTrackerArray,
-                           pTrackerArray + elements,
-                           p,
-                           LifetimeTracker::Compare);
-    std::copy_backward(
-        pos,
-        pTrackerArray + elements,
-        pTrackerArray + elements + 1);
-    *pos = p;
-    ++elements;
-
-    // Register a call to AtExitFn
-    std::atexit(Private::AtExitFn);
-}
-
-#endif
-
-template <typename T>
-void SetLongevity(T* pDynObject, unsigned int longevity,
-                  typename Private::Deleter<T>::Type d = Private::Deleter<T>::Delete)
-{
-    SetLongevity<T, typename Private::Deleter<T>::Type>(pDynObject, longevity, d);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateUsingNew
-///
-///  \ingroup CreationGroup
-///  Implementation of the CreationPolicy used by SingletonHolder
-///  Creates objects using a straight call to the new operator
-////////////////////////////////////////////////////////////////////////////////
-template <class T> struct CreateUsingNew
-{
-    static T* Create()
-    { return new T; }
-
-    static void Destroy(T* p)
-    { delete p; }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateUsing
-///
-///  \ingroup CreationGroup
-///  Implementation of the CreationPolicy used by SingletonHolder
-///  Creates objects using a custom allocater.
-///  Usage: e.g. CreateUsing<std::allocator>::Allocator
-////////////////////////////////////////////////////////////////////////////////
-template<template<class> class Alloc>
-struct CreateUsing
-{
-    template <class T>
-    struct Allocator
-    {
-        static Alloc<T> allocator;
-
-        static T* Create()
-        {
-            return new (allocator.allocate(1)) T;
-        }
-
-        static void Destroy(T* p)
-        {
-            //allocator.destroy(p);
-            p->~T();
-            allocator.deallocate(p, 1);
-        }
-    };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateUsingMalloc
-///
-///  \ingroup CreationGroup
-///  Implementation of the CreationPolicy used by SingletonHolder
-///  Creates objects using a call to std::malloc, followed by a call to the
-///  placement new operator
-////////////////////////////////////////////////////////////////////////////////
-template <class T> struct CreateUsingMalloc
-{
-    static T* Create()
-    {
-        void* p = std::malloc(sizeof(T));
-        if (!p) return 0;
-        return new(p) T;
-    }
-
-    static void Destroy(T* p)
-    {
-        p->~T();
-        std::free(p);
-    }
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateStatic
-///
-///  \ingroup CreationGroup
-///  Implementation of the CreationPolicy used by SingletonHolder
-///  Creates an object in static memory
-///  Implementation is slightly nonportable because it uses the MaxAlign trick
-///  (an union of all types to ensure proper memory alignment). This trick is
-///  nonportable in theory but highly portable in practice.
-////////////////////////////////////////////////////////////////////////////////
-template <class T> struct CreateStatic
-{
-
-#ifdef _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4121 )
-    // alignment of a member was sensitive to packing
-#endif // _MSC_VER
-
-    union MaxAlign
-    {
-        char t_[sizeof(T)];
-        short int shortInt_;
-        int int_;
-        long int longInt_;
-        float float_;
-        double double_;
-        long double longDouble_;
-        struct Test;
-        int Test::* pMember_;
-        int (Test::*pMemberFn_)(int);
-    };
-
-#ifdef _MSC_VER
-#pragma warning( pop )
-#endif // _MSC_VER
-
-    static T* Create()
-    {
-        static MaxAlign staticMemory_;
-        return new(&staticMemory_) T;
-    }
-
-    static void Destroy(T* p)
-    {
-        p->~T();
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct DefaultLifetime
-///
-///  \ingroup LifetimeGroup
-///  Implementation of the LifetimePolicy used by SingletonHolder
-///  Schedules an object's destruction as per C++ rules
-///  Forwards to std::atexit
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-struct DefaultLifetime
-{
-    static void ScheduleDestruction(T*, atexit_pfn_t pFun)
-    { std::atexit(pFun); }
-
-    static void OnDeadReference()
-    { throw std::logic_error("Dead Reference Detected"); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct  PhoenixSingleton
-///
-///  \ingroup LifetimeGroup
-///  Implementation of the LifetimePolicy used by SingletonHolder
-///  Schedules an object's destruction as per C++ rules, and it allows object
-///  recreation by not throwing an exception from OnDeadReference
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-class PhoenixSingleton
-{
-public:
-    static void ScheduleDestruction(T*, atexit_pfn_t pFun)
-    {
-#ifndef ATEXIT_FIXED
-        if (!destroyedOnce_)
-#endif
-            std::atexit(pFun);
-    }
-
-    static void OnDeadReference()
-    {
-#ifndef ATEXIT_FIXED
-        destroyedOnce_ = true;
-#endif
-    }
-
-private:
-#ifndef ATEXIT_FIXED
-    static bool destroyedOnce_;
-#endif
-};
-
-#ifndef ATEXIT_FIXED
-template <class T> bool PhoenixSingleton<T>::destroyedOnce_ = false;
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright (c) 2004 by Curtis Krauskopf - curtis@decompile.com
-///
-///  \struct  DeletableSingleton
-///
-///  \ingroup LifetimeGroup
-///
-///  A DeletableSingleton allows the instantiated singleton to be
-///  destroyed at any time. The singleton can be reinstantiated at
-///  any time, even during program termination.
-///  If the singleton exists when the program terminates, it will
-///  be automatically deleted.
-///
-///  \par Usage:
-///  The singleton can be deleted manually:
-///
-///  DeletableSingleton<MyClass>::GracefulDelete();
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-class DeletableSingleton
-{
-public:
-
-    static void ScheduleDestruction(T*, atexit_pfn_t pFun)
-    {
-        static bool firstPass = true;
-        isDead = false;
-        deleter = pFun;
-        if (firstPass || needCallback)
-        {
-            std::atexit(atexitCallback);
-            firstPass = false;
-            needCallback = false;
-        }
-    }
-
-    static void OnDeadReference()
-    {
-    }
-    ///  delete singleton object manually
-    static void GracefulDelete()
-    {
-        if (isDead)
-            return;
-        isDead = true;
-        deleter();
-    }
-
-protected:
-    static atexit_pfn_t deleter;
-    static bool isDead;
-    static bool needCallback;
-
-    static void atexitCallback()
-    {
-#ifdef ATEXIT_FIXED
-        needCallback = true;
-#else
-        needCallback = false;
-#endif
-        GracefulDelete();
-    }
-};
-
-template <class T>
-atexit_pfn_t DeletableSingleton<T>::deleter = 0;
-
-template <class T>
-bool DeletableSingleton<T>::isDead = true;
-
-template <class T>
-bool DeletableSingleton<T>::needCallback = true;
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Adapter
-// Helper for SingletonWithLongevity below
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template <class T>
-struct Adapter
-{
-    void operator()(T*) { return pFun_(); }
-    atexit_pfn_t pFun_;
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct SingletonWithLongevity
-///
-///  \ingroup LifetimeGroup
-///  Implementation of the LifetimePolicy used by SingletonHolder
-///  Schedules an object's destruction in order of their longevities
-///  Assumes a visible function GetLongevity(T*) that returns the longevity of the
-///  object.
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-class SingletonWithLongevity
-{
-public:
-    static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun)
-    {
-        Private::Adapter<T> adapter = { pFun };
-        SetLongevity(pObj, GetLongevity(pObj), adapter);
-    }
-
-    static void OnDeadReference()
-    { throw std::logic_error("Dead Reference Detected"); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct NoDestroy
-///
-///  \ingroup LifetimeGroup
-///  Implementation of the LifetimePolicy used by SingletonHolder
-///  Never destroys the object
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-struct NoDestroy
-{
-    static void ScheduleDestruction(T*, atexit_pfn_t)
-    {}
-
-    static void OnDeadReference()
-    {}
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \defgroup LongevityLifetimeGroup LongevityLifetime
-///  \ingroup LifetimeGroup
-///
-///  \namespace LongevityLifetime
-///
-///  \ingroup LongevityLifetimeGroup
-///  \brief  In this namespace are special lifetime policies to manage lifetime
-///  dependencies.
-////////////////////////////////////////////////////////////////////////////////
-namespace LongevityLifetime
-{
-////////////////////////////////////////////////////////////////////////////////
-///  \struct  SingletonFixedLongevity
-///
-///  \ingroup LongevityLifetimeGroup
-///  Add your own lifetimes into the namespace 'LongevityLifetime'
-///  with your prefered lifetime by adding a struct like this:
-///
-///  template<class T>
-///  struct MyLifetime  : SingletonFixedLongevity< MyLifetimeNumber ,T> {}
-////////////////////////////////////////////////////////////////////////////////
-template <unsigned int Longevity, class T>
-class SingletonFixedLongevity
-{
-public:
-    virtual ~SingletonFixedLongevity() {}
-
-    static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun)
-    {
-        Private::Adapter<T> adapter = { pFun };
-        SetLongevity(pObj, Longevity , adapter);
-    }
-
-    static void OnDeadReference()
-    { throw std::logic_error("Dead Reference Detected"); }
-};
-
-///  \struct DieLast
-///  \ingroup LongevityLifetimeGroup
-///  \brief  Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF
-template <class T>
-struct DieLast  : SingletonFixedLongevity<0xFFFFFFFF , T>
-{};
-
-///  \struct DieDirectlyBeforeLast
-///  \ingroup LongevityLifetimeGroup
-///  \brief  Lifetime is a one less than DieLast: 0xFFFFFFFF-1
-template <class T>
-struct DieDirectlyBeforeLast  : SingletonFixedLongevity < 0xFFFFFFFF - 1 , T >
-{};
-
-///  \struct DieFirst
-///  \ingroup LongevityLifetimeGroup
-///  \brief  Shortest possible SingletonWithLongevity lifetime: 0
-template <class T>
-struct DieFirst : SingletonFixedLongevity<0, T>
-{};
-
-}//namespace LongevityLifetime
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class FollowIntoDeath
-///
-///  \ingroup LifetimeGroup
-///
-///  Lifetime policyfor the SingletonHolder tempalte.
-///  Followers will die after the master dies Followers will not die, if
-///    - master never dies (NoDestroy policy)
-///    - master never created
-///    - master dies not in the function registered with atexit
-///    - master dies not by a call of a the atexit registerd function (DeletableSingleton::GracefulDelete)
-///
-///  \par Usage:
-///
-///  Lifetimes of the master and the follower singletons,  e.g. with a M and a F class:
-///   \code SingletonHolder< M , FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime > MasterSingleton; \endcode
-///   \code SingletonHolder< F , CreateUsingNew, FollowIntoDeath::AfterMaster< MasterSingleton >::IsDestroyed > FollowerSingleton \endcode
-////////////////////////////////////////////////////////////////////////////////
-class FollowIntoDeath
-{
-    template<class T>
-    class Followers
-    {
-        typedef std::vector<atexit_pfn_t> Container;
-        typedef typename Container::iterator iterator;
-        static Container* followers_;
-
-    public:
-        static void Init()
-        {
-            static bool done = false;
-            if (!done)
-            {
-                followers_ = new Container;
-                done = true;
-            }
-        }
-
-        static void AddFollower(atexit_pfn_t ae)
-        {
-            Init();
-            followers_->push_back(ae);
-        }
-
-        static void DestroyFollowers()
-        {
-            Init();
-            for (iterator it = followers_->begin(); it != followers_->end(); ++it)
-                (*it)();
-            delete followers_;
-        }
-    };
-
-public:
-
-    ///  \struct With
-    ///  Template for the master
-    ///  \param Lifetime Lifetime policy for the master
-    template<template <class> class Lifetime>
-    struct With
-    {
-        ///  \struct AsMasterLifetime
-        ///  Policy for master
-        template<class Master>
-        struct AsMasterLifetime
-        {
-            static void ScheduleDestruction(Master* pObj, atexit_pfn_t pFun)
-            {
-                Followers<Master>::Init();
-                Lifetime<Master>::ScheduleDestruction(pObj, pFun);
-
-                // use same policy for the followers and force a new
-                // template instantiation,  this adds a additional atexit entry
-                // does not work with SetLonlevity, but there you can control
-                // the lifetime with the GetLongevity function.
-                Lifetime<Followers<Master> >::ScheduleDestruction(0, Followers<Master>::DestroyFollowers);
-            }
-
-            static void OnDeadReference()
-            {
-                throw std::logic_error("Dead Reference Detected");
-            }
-        };
-    };
-
-    ///  \struct AfterMaster
-    ///  Template for the follower
-    ///  \param Master Master to follow into death
-    template<class Master>
-    struct AfterMaster
-    {
-        ///  \struct IsDestroyed
-        ///  Policy for followers
-        template<class F>
-        struct IsDestroyed
-        {
-            static void ScheduleDestruction(F*, atexit_pfn_t pFun)
-            {
-                Followers<Master>::AddFollower(pFun);
-            }
-
-            static void OnDeadReference()
-            {
-                throw std::logic_error("Dead Reference Detected");
-            }
-        };
-    };
-};
-
-template<class T>
-typename FollowIntoDeath::Followers<T>::Container*
-FollowIntoDeath::Followers<T>::followers_ = 0;
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class  SingletonHolder
-///
-///  \ingroup SingletonGroup
-///
-///  Provides Singleton amenities for a type T
-///  To protect that type from spurious instantiations,
-///  you have to protect it yourself.
-///
-///  \param CreationPolicy Creation policy, default: CreateUsingNew
-///  \param LifetimePolicy Lifetime policy, default: DefaultLifetime,
-///  \param ThreadingModel Threading policy,
-///                         default: LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL
-////////////////////////////////////////////////////////////////////////////////
-template
-<
-typename T,
-         template <class> class CreationPolicy = CreateUsingNew,
-         template <class> class LifetimePolicy = DefaultLifetime,
-         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
-         class MutexPolicy = LOKI_DEFAULT_MUTEX
-         >
-class SingletonHolder
-{
-public:
-
-    ///  Type of the singleton object
-    typedef T ObjectType;
-
-    ///  Returns a reference to singleton object
-    static T& Instance();
-
-private:
-    // Helpers
-    static void MakeInstance();
-    static void LOKI_C_CALLING_CONVENTION_QUALIFIER DestroySingleton();
-
-    // Protection
-    SingletonHolder();
-
-    // Data
-    typedef typename ThreadingModel<T*, MutexPolicy>::VolatileType PtrInstanceType;
-    static PtrInstanceType pInstance_;
-    static bool destroyed_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// SingletonHolder's data
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class T,
-      template <class> class C,
-      template <class> class L,
-      template <class, class> class M,
-      class X
-      >
-typename SingletonHolder<T, C, L, M, X>::PtrInstanceType
-SingletonHolder<T, C, L, M, X>::pInstance_ = 0;
-
-template
-<
-class T,
-      template <class> class C,
-      template <class> class L,
-      template <class, class> class M,
-      class X
-      >
-bool SingletonHolder<T, C, L, M, X>::destroyed_ = false;
-
-////////////////////////////////////////////////////////////////////////////////
-// SingletonHolder::Instance
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class T,
-      template <class> class CreationPolicy,
-      template <class> class LifetimePolicy,
-      template <class, class> class ThreadingModel,
-      class MutexPolicy
-      >
-inline T& SingletonHolder < T, CreationPolicy,
-       LifetimePolicy, ThreadingModel, MutexPolicy >::Instance()
-{
-    if (!pInstance_)
-    {
-        MakeInstance();
-    }
-    return *pInstance_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// SingletonHolder::MakeInstance (helper for Instance)
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class T,
-template <class> class CreationPolicy,
-template <class> class LifetimePolicy,
-template <class, class> class ThreadingModel,
-class MutexPolicy
->
-void SingletonHolder < T, CreationPolicy,
-     LifetimePolicy, ThreadingModel, MutexPolicy >::MakeInstance()
-{
-    typename ThreadingModel<SingletonHolder, MutexPolicy>::Lock guard;
-    (void)guard;
-
-    if (!pInstance_)
-    {
-        if (destroyed_)
-        {
-            destroyed_ = false;
-            LifetimePolicy<T>::OnDeadReference();
-        }
-        pInstance_ = CreationPolicy<T>::Create();
-        LifetimePolicy<T>::ScheduleDestruction(pInstance_,
-                                               &DestroySingleton);
-    }
-}
-
-template
-<
-class T,
-template <class> class CreationPolicy,
-template <class> class L,
-template <class, class> class M,
-class X
->
-void LOKI_C_CALLING_CONVENTION_QUALIFIER
-SingletonHolder<T, CreationPolicy, L, M, X>::DestroySingleton()
-{
-    assert(!destroyed_);
-    CreationPolicy<T>::Destroy(pInstance_);
-    pInstance_ = 0;
-    destroyed_ = true;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class  Singleton
-///
-///  \ingroup SingletonGroup
-///
-///  Convenience template to implement a getter function for a singleton object.
-///  Often needed in a shared library which hosts singletons.
-///
-///  \par Usage
-///
-///  see test/SingletonDll
-///
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef LOKI_SINGLETON_EXPORT
-#define LOKI_SINGLETON_EXPORT
-#endif
-
-template<class T>
-class LOKI_SINGLETON_EXPORT Singleton
-{
-public:
-    static T& Instance();
-};
-
-} // namespace Loki
-
-
-/// \def LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER)
-/// Convenience macro for the definition of the static Instance member function
-/// Put this macro called with a SingletonHolder typedef into your cpp file.
-
-#define LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER)                     \
-    namespace Loki                                                          \
-    {                                                                        \
-    template<>                                                          \
-    SHOLDER::ObjectType&  Singleton<SHOLDER::ObjectType>::Instance()    \
-    {                                                                   \
-        return SHOLDER::Instance();                                     \
-    }                                                                    \
-    }
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/SmallObj.cpp b/shared/loki/SmallObj.cpp
deleted file mode 100644
index 1c42374f..00000000
--- a/shared/loki/SmallObj.cpp
+++ /dev/null
@@ -1,1226 +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.
-////////////////////////////////////////////////////////////////////////////////
-
-// $Id: SmallObj.cpp 823 2007-05-08 10:48:40Z lfittl $
-
-
-#include "SmallObj.h"
-
-#include <cassert>
-#include <climits>
-#include <vector>
-#include <bitset>
-
-//#define DO_EXTRA_LOKI_TESTS
-//#define USE_NEW_TO_ALLOCATE
-//#define LOKI_CHECK_FOR_CORRUPTION
-
-#ifdef DO_EXTRA_LOKI_TESTS
-#include <iostream>
-#endif
-
-namespace Loki
-{
-
-/** @struct Chunk
-    @ingroup SmallObjectGroupInternal
- Contains info about each allocated Chunk - which is a collection of
- contiguous blocks.  Each block is the same size, as specified by the
- FixedAllocator.  The number of blocks in a Chunk depends upon page size.
- This is a POD-style struct with value-semantics.  All functions and data
- are private so that they can not be changed by anything other than the
- FixedAllocator which owns the Chunk.
-
- @par Minimal Interface
- For the sake of runtime efficiency, no constructor, destructor, or
- copy-assignment operator is defined. The inline functions made by the
- compiler should be sufficient, and perhaps faster than hand-crafted
- functions.  The lack of these functions allows vector to create and copy
- Chunks as needed without overhead.  The Init and Release functions do
- what the default constructor and destructor would do.  A Chunk is not in
- a usable state after it is constructed and before calling Init.  Nor is
- a Chunk usable after Release is called, but before the destructor.
-
- @par Efficiency
- Down near the lowest level of the allocator, runtime efficiencies trump
- almost all other considerations.  Each function does the minimum required
- of it.  All functions should execute in constant time to prevent higher-
- level code from unwittingly using a version of Shlemiel the Painter's
- Algorithm.
-
- @par Stealth Indexes
- The first char of each empty block contains the index of the next empty
- block.  These stealth indexes form a singly-linked list within the blocks.
- A Chunk is corrupt if this singly-linked list has a loop or is shorter
- than blocksAvailable_.  Much of the allocator's time and space efficiency
- comes from how these stealth indexes are implemented.
- */
-class Chunk
-{
-private:
-    friend class FixedAllocator;
-
-    /** Initializes a just-constructed Chunk.
-     @param blockSize Number of bytes per block.
-     @param blocks Number of blocks per Chunk.
-     @return True for success, false for failure.
-     */
-    bool Init( std::size_t blockSize, unsigned char blocks );
-
-    /** Allocate a block within the Chunk.  Complexity is always O(1), and
-     this will never throw.  Does not actually "allocate" by calling
-     malloc, new, or any other function, but merely adjusts some internal
-     indexes to indicate an already allocated block is no longer available.
-     @return Pointer to block within Chunk.
-     */
-    void* Allocate( std::size_t blockSize );
-
-    /** Deallocate a block within the Chunk. Complexity is always O(1), and
-     this will never throw.  For efficiency, this assumes the address is
-     within the block and aligned along the correct byte boundary.  An
-     assertion checks the alignment, and a call to HasBlock is done from
-     within VicinityFind.  Does not actually "deallocate" by calling free,
-     delete, or other function, but merely adjusts some internal indexes to
-     indicate a block is now available.
-     */
-    void Deallocate( void* p, std::size_t blockSize );
-
-    /** Resets the Chunk back to pristine values. The available count is
-     set back to zero, and the first available index is set to the zeroth
-     block.  The stealth indexes inside each block are set to point to the
-     next block. This assumes the Chunk's data was already using Init.
-     */
-    void Reset( std::size_t blockSize, unsigned char blocks );
-
-    /// Releases the allocated block of memory.
-    void Release();
-
-    /** Determines if the Chunk has been corrupted.
-     @param numBlocks Total # of blocks in the Chunk.
-     @param blockSize # of bytes in each block.
-     @param checkIndexes True if caller wants to check indexes of available
-      blocks for corruption.  If false, then caller wants to skip some
-      tests tests just to run faster.  (Debug version does more checks, but
-      release version runs faster.)
-     @return True if Chunk is corrupt.
-     */
-    bool IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
-                    bool checkIndexes ) const;
-
-    /** Determines if block is available.
-     @param p Address of block managed by Chunk.
-     @param numBlocks Total # of blocks in the Chunk.
-     @param blockSize # of bytes in each block.
-     @return True if block is available, else false if allocated.
-     */
-    bool IsBlockAvailable( void* p, unsigned char numBlocks,
-                           std::size_t blockSize ) const;
-
-    /// Returns true if block at address P is inside this Chunk.
-    inline bool HasBlock( void* p, std::size_t chunkLength ) const
-    {
-        unsigned char* pc = static_cast< unsigned char* >( p );
-        return ( pData_ <= pc ) && ( pc < pData_ + chunkLength );
-    }
-
-    inline bool HasAvailable( unsigned char numBlocks ) const
-    { return ( blocksAvailable_ == numBlocks ); }
-
-    inline bool IsFilled( void ) const
-    { return ( 0 == blocksAvailable_ ); }
-
-    /// Pointer to array of allocated blocks.
-    unsigned char* pData_;
-    /// Index of first empty block.
-    unsigned char firstAvailableBlock_;
-    /// Count of empty blocks.
-    unsigned char blocksAvailable_;
-};
-
-/** @class FixedAllocator
-    @ingroup SmallObjectGroupInternal
- Offers services for allocating fixed-sized objects.  It has a container
- of "containers" of fixed-size blocks.  The outer container has all the
- Chunks.  The inner container is a Chunk which owns some blocks.
-
- @par Class Level Invariants
- - There is always either zero or one Chunk which is empty.
- - If this has no empty Chunk, then emptyChunk_ is NULL.
- - If this has an empty Chunk, then emptyChunk_ points to it.
- - If the Chunk container is empty, then deallocChunk_ and allocChunk_
-   are NULL.
- - If the Chunk container is not-empty, then deallocChunk_ and allocChunk_
-   are either NULL or point to Chunks within the container.
- - allocChunk_ will often point to the last Chunk in the container since
-   it was likely allocated most recently, and therefore likely to have an
-   available block.
- */
-class FixedAllocator
-{
-private:
-
-    /** Deallocates the block at address p, and then handles the internal
-     bookkeeping needed to maintain class invariants.  This assumes that
-     deallocChunk_ points to the correct chunk.
-     */
-    void DoDeallocate( void* p );
-
-    /** Creates an empty Chunk and adds it to the end of the ChunkList.
-     All calls to the lower-level memory allocation functions occur inside
-     this function, and so the only try-catch block is inside here.
-     @return true for success, false for failure.
-     */
-    bool MakeNewChunk( void );
-
-    /** Finds the Chunk which owns the block at address p.  It starts at
-     deallocChunk_ and searches in both forwards and backwards directions
-     from there until it finds the Chunk which owns p.  This algorithm
-     should find the Chunk quickly if it is deallocChunk_ or is close to it
-     in the Chunks container.  This goes both forwards and backwards since
-     that works well for both same-order and opposite-order deallocations.
-     (Same-order = objects are deallocated in the same order in which they
-     were allocated.  Opposite order = objects are deallocated in a last to
-     first order.  Complexity is O(C) where C is count of all Chunks.  This
-     never throws.
-     @return Pointer to Chunk that owns p, or NULL if no owner found.
-     */
-    Chunk* VicinityFind( void* p ) const;
-
-    /// Not implemented.
-    FixedAllocator(const FixedAllocator&);
-    /// Not implemented.
-    FixedAllocator& operator=(const FixedAllocator&);
-
-    /// Type of container used to hold Chunks.
-    typedef std::vector< Chunk > Chunks;
-    /// Iterator through container of Chunks.
-    typedef Chunks::iterator ChunkIter;
-    /// Iterator through const container of Chunks.
-    typedef Chunks::const_iterator ChunkCIter;
-
-    /// Fewest # of objects managed by a Chunk.
-    static unsigned char MinObjectsPerChunk_;
-
-    /// Most # of objects managed by a Chunk - never exceeds UCHAR_MAX.
-    static unsigned char MaxObjectsPerChunk_;
-
-    /// Number of bytes in a single block within a Chunk.
-    std::size_t blockSize_;
-    /// Number of blocks managed by each Chunk.
-    unsigned char numBlocks_;
-
-    /// Container of Chunks.
-    Chunks chunks_;
-    /// Pointer to Chunk used for last or next allocation.
-    Chunk* allocChunk_;
-    /// Pointer to Chunk used for last or next deallocation.
-    Chunk* deallocChunk_;
-    /// Pointer to the only empty Chunk if there is one, else NULL.
-    Chunk* emptyChunk_;
-
-public:
-    /// Create a FixedAllocator which manages blocks of 'blockSize' size.
-    FixedAllocator();
-
-    /// Destroy the FixedAllocator and release all its Chunks.
-    ~FixedAllocator();
-
-    /// Initializes a FixedAllocator by calculating # of blocks per Chunk.
-    void Initialize( std::size_t blockSize, std::size_t pageSize );
-
-    /** Returns pointer to allocated memory block of fixed size - or NULL
-     if it failed to allocate.
-     */
-    void* Allocate( void );
-
-    /** Deallocate a memory block previously allocated with Allocate.  If
-     the block is not owned by this FixedAllocator, it returns false so
-     that SmallObjAllocator can call the default deallocator.  If the
-     block was found, this returns true.
-     */
-    bool Deallocate( void* p, Chunk* hint );
-
-    /// Returns block size with which the FixedAllocator was initialized.
-    inline std::size_t BlockSize() const { return blockSize_; }
-
-    /** Releases the memory used by the empty Chunk.  This will take
-     constant time under any situation.
-     @return True if empty chunk found and released, false if none empty.
-     */
-    bool TrimEmptyChunk( void );
-
-    /** Releases unused spots from ChunkList.  This takes constant time
-     with respect to # of Chunks, but actual time depends on underlying
-     memory allocator.
-     @return False if no unused spots, true if some found and released.
-     */
-    bool TrimChunkList( void );
-
-    /** Returns count of empty Chunks held by this allocator.  Complexity
-     is O(C) where C is the total number of Chunks - empty or used.
-     */
-    std::size_t CountEmptyChunks( void ) const;
-
-    /** Determines if FixedAllocator is corrupt.  Checks data members to
-     see if any have erroneous values, or violate class invariants.  It
-     also checks if any Chunk is corrupt.  Complexity is O(C) where C is
-     the number of Chunks.  If any data is corrupt, this will return true
-     in release mode, or assert in debug mode.
-     */
-    bool IsCorrupt( void ) const;
-
-    /** Returns true if the block at address p is within a Chunk owned by
-     this FixedAllocator.  Complexity is O(C) where C is the total number
-     of Chunks - empty or used.
-     */
-    const Chunk* HasBlock( void* p ) const;
-    inline Chunk* HasBlock( void* p )
-    {
-        return const_cast< Chunk* >(
-                   const_cast< const FixedAllocator* >( this )->HasBlock( p ) );
-    }
-
-};
-
-unsigned char FixedAllocator::MinObjectsPerChunk_ = 8;
-unsigned char FixedAllocator::MaxObjectsPerChunk_ = UCHAR_MAX;
-
-// Chunk::Init ----------------------------------------------------------------
-
-bool Chunk::Init( std::size_t blockSize, unsigned char blocks )
-{
-    assert(blockSize > 0);
-    assert(blocks > 0);
-    // Overflow check
-    const std::size_t allocSize = blockSize * blocks;
-    assert( allocSize / blockSize == blocks);
-
-#ifdef USE_NEW_TO_ALLOCATE
-    // If this new operator fails, it will throw, and the exception will get
-    // caught one layer up.
-    pData_ = static_cast< unsigned char* >( ::operator new ( allocSize ) );
-#else
-    // malloc can't throw, so its only way to indicate an error is to return
-    // a NULL pointer, so we have to check for that.
-    pData_ = static_cast< unsigned char* >( ::std::malloc( allocSize ) );
-    if ( NULL == pData_ ) return false;
-#endif
-
-    Reset( blockSize, blocks );
-    return true;
-}
-
-// Chunk::Reset ---------------------------------------------------------------
-
-void Chunk::Reset(std::size_t blockSize, unsigned char blocks)
-{
-    assert(blockSize > 0);
-    assert(blocks > 0);
-    // Overflow check
-    assert((blockSize * blocks) / blockSize == blocks);
-
-    firstAvailableBlock_ = 0;
-    blocksAvailable_ = blocks;
-
-    unsigned char i = 0;
-    for ( unsigned char* p = pData_; i != blocks; p += blockSize )
-    {
-        *p = ++i;
-    }
-}
-
-// Chunk::Release -------------------------------------------------------------
-
-void Chunk::Release()
-{
-    assert( NULL != pData_ );
-#ifdef USE_NEW_TO_ALLOCATE
-    ::operator delete ( pData_ );
-#else
-    ::std::free( static_cast< void* >( pData_ ) );
-#endif
-}
-
-// Chunk::Allocate ------------------------------------------------------------
-
-void* Chunk::Allocate(std::size_t blockSize)
-{
-    if ( IsFilled() ) return NULL;
-
-    assert((firstAvailableBlock_ * blockSize) / blockSize ==
-           firstAvailableBlock_);
-    unsigned char* pResult = pData_ + (firstAvailableBlock_ * blockSize);
-    firstAvailableBlock_ = *pResult;
-    --blocksAvailable_;
-
-    return pResult;
-}
-
-// Chunk::Deallocate ----------------------------------------------------------
-
-void Chunk::Deallocate(void* p, std::size_t blockSize)
-{
-    assert(p >= pData_);
-
-    unsigned char* toRelease = static_cast<unsigned char*>(p);
-    // Alignment check
-    assert((toRelease - pData_) % blockSize == 0);
-    unsigned char index = static_cast< unsigned char >(
-                              ( toRelease - pData_ ) / blockSize);
-
-#if defined(DEBUG) || defined(_DEBUG)
-    // Check if block was already deleted.  Attempting to delete the same
-    // block more than once causes Chunk's linked-list of stealth indexes to
-    // become corrupt.  And causes count of blocksAvailable_ to be wrong.
-    if ( 0 < blocksAvailable_ )
-        assert( firstAvailableBlock_ != index );
-#endif
-
-    *toRelease = firstAvailableBlock_;
-    firstAvailableBlock_ = index;
-    // Truncation check
-    assert(firstAvailableBlock_ == (toRelease - pData_) / blockSize);
-
-    ++blocksAvailable_;
-}
-
-// Chunk::IsCorrupt -----------------------------------------------------------
-
-bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
-                       bool checkIndexes ) const
-{
-
-    if ( numBlocks < blocksAvailable_ )
-    {
-        // Contents at this Chunk corrupted.  This might mean something has
-        // overwritten memory owned by the Chunks container.
-        assert( false );
-        return true;
-    }
-    if ( IsFilled() )
-        // Useless to do further corruption checks if all blocks allocated.
-        return false;
-    unsigned char index = firstAvailableBlock_;
-    if ( numBlocks <= index )
-    {
-        // Contents at this Chunk corrupted.  This might mean something has
-        // overwritten memory owned by the Chunks container.
-        assert( false );
-        return true;
-    }
-    if ( !checkIndexes )
-        // Caller chose to skip more complex corruption tests.
-        return false;
-
-    /* If the bit at index was set in foundBlocks, then the stealth index was
-     found on the linked-list.
-     */
-    std::bitset< UCHAR_MAX > foundBlocks;
-    unsigned char* nextBlock = NULL;
-
-    /* The loop goes along singly linked-list of stealth indexes and makes sure
-     that each index is within bounds (0 <= index < numBlocks) and that the
-     index was not already found while traversing the linked-list.  The linked-
-     list should have exactly blocksAvailable_ nodes, so the for loop will not
-     check more than blocksAvailable_.  This loop can't check inside allocated
-     blocks for corruption since such blocks are not within the linked-list.
-     Contents of allocated blocks are not changed by Chunk.
-
-     Here are the types of corrupted link-lists which can be verified.  The
-     corrupt index is shown with asterisks in each example.
-
-     Type 1: Index is too big.
-      numBlocks == 64
-      blocksAvailable_ == 7
-      firstAvailableBlock_ -> 17 -> 29 -> *101*
-      There should be no indexes which are equal to or larger than the total
-      number of blocks.  Such an index would refer to a block beyond the
-      Chunk's allocated domain.
-
-     Type 2: Index is repeated.
-      numBlocks == 64
-      blocksAvailable_ == 5
-      firstAvailableBlock_ -> 17 -> 29 -> 53 -> *17* -> 29 -> 53 ...
-      No index should be repeated within the linked-list since that would
-      indicate the presence of a loop in the linked-list.
-     */
-    for ( unsigned char cc = 0; ; )
-    {
-        nextBlock = pData_ + ( index * blockSize );
-        foundBlocks.set( index, true );
-        ++cc;
-        if ( cc >= blocksAvailable_ )
-            // Successfully counted off number of nodes in linked-list.
-            break;
-        index = *nextBlock;
-        if ( numBlocks <= index )
-        {
-            /* This catches Type 1 corruptions as shown in above comments.
-             This implies that a block was corrupted due to a stray pointer
-             or an operation on a nearby block overran the size of the block.
-             */
-            assert( false );
-            return true;
-        }
-        if ( foundBlocks.test( index ) )
-        {
-            /* This catches Type 2 corruptions as shown in above comments.
-             This implies that a block was corrupted due to a stray pointer
-             or an operation on a nearby block overran the size of the block.
-             Or perhaps the program tried to delete a block more than once.
-             */
-            assert( false );
-            return true;
-        }
-    }
-    if ( foundBlocks.count() != blocksAvailable_ )
-    {
-        /* This implies that the singly-linked-list of stealth indexes was
-         corrupted.  Ideally, this should have been detected within the loop.
-         */
-        assert( false );
-        return true;
-    }
-
-    return false;
-}
-
-// Chunk::IsBlockAvailable ----------------------------------------------------
-
-bool Chunk::IsBlockAvailable( void* p, unsigned char numBlocks,
-                              std::size_t blockSize ) const
-{
-    (void) numBlocks;
-
-    if ( IsFilled() )
-        return false;
-
-    unsigned char* place = static_cast< unsigned char* >( p );
-    // Alignment check
-    assert( ( place - pData_ ) % blockSize == 0 );
-    unsigned char blockIndex = static_cast< unsigned char >(
-                                   ( place - pData_ ) / blockSize );
-
-    unsigned char index = firstAvailableBlock_;
-    assert( numBlocks > index );
-    if ( index == blockIndex )
-        return true;
-
-    /* If the bit at index was set in foundBlocks, then the stealth index was
-     found on the linked-list.
-     */
-    std::bitset< UCHAR_MAX > foundBlocks;
-    unsigned char* nextBlock = NULL;
-    for ( unsigned char cc = 0; ; )
-    {
-        nextBlock = pData_ + ( index * blockSize );
-        foundBlocks.set( index, true );
-        ++cc;
-        if ( cc >= blocksAvailable_ )
-            // Successfully counted off number of nodes in linked-list.
-            break;
-        index = *nextBlock;
-        if ( index == blockIndex )
-            return true;
-        assert( numBlocks > index );
-        assert( !foundBlocks.test( index ) );
-    }
-
-    return false;
-}
-
-// FixedAllocator::FixedAllocator ---------------------------------------------
-
-FixedAllocator::FixedAllocator()
-    : blockSize_( 0 )
-    , numBlocks_( 0 )
-    , chunks_( 0 )
-    , allocChunk_( NULL )
-    , deallocChunk_( NULL )
-    , emptyChunk_( NULL )
-{
-}
-
-// FixedAllocator::~FixedAllocator --------------------------------------------
-
-FixedAllocator::~FixedAllocator()
-{
-#ifdef DO_EXTRA_LOKI_TESTS
-    TrimEmptyChunk();
-    assert( chunks_.empty() && "Memory leak detected!" );
-#endif
-    for ( ChunkIter i( chunks_.begin() ); i != chunks_.end(); ++i )
-        i->Release();
-}
-
-// FixedAllocator::Initialize -------------------------------------------------
-
-void FixedAllocator::Initialize( std::size_t blockSize, std::size_t pageSize )
-{
-    assert( blockSize > 0 );
-    assert( pageSize >= blockSize );
-    blockSize_ = blockSize;
-
-    std::size_t numBlocks = pageSize / blockSize;
-    if ( numBlocks > MaxObjectsPerChunk_ ) numBlocks = MaxObjectsPerChunk_;
-    else if ( numBlocks < MinObjectsPerChunk_ ) numBlocks = MinObjectsPerChunk_;
-
-    numBlocks_ = static_cast<unsigned char>(numBlocks);
-    assert(numBlocks_ == numBlocks);
-}
-
-// FixedAllocator::CountEmptyChunks -------------------------------------------
-
-std::size_t FixedAllocator::CountEmptyChunks( void ) const
-{
-#ifdef DO_EXTRA_LOKI_TESTS
-    // This code is only used for specialized tests of the allocator.
-    // It is #ifdef-ed so that its O(C) complexity does not overwhelm the
-    // functions which call it.
-    std::size_t count = 0;
-    for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it )
-    {
-        const Chunk& chunk = *it;
-        if ( chunk.HasAvailable( numBlocks_ ) )
-            ++count;
-    }
-    return count;
-#else
-    return ( NULL == emptyChunk_ ) ? 0 : 1;
-#endif
-}
-
-// FixedAllocator::IsCorrupt --------------------------------------------------
-
-bool FixedAllocator::IsCorrupt( void ) const
-{
-    const bool isEmpty = chunks_.empty();
-    ChunkCIter start( chunks_.begin() );
-    ChunkCIter last( chunks_.end() );
-    const size_t emptyChunkCount = CountEmptyChunks();
-
-    if ( isEmpty )
-    {
-        if ( start != last )
-        {
-            assert( false );
-            return true;
-        }
-        if ( 0 < emptyChunkCount )
-        {
-            assert( false );
-            return true;
-        }
-        if ( NULL != deallocChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-        if ( NULL != allocChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-        if ( NULL != emptyChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-    }
-
-    else
-    {
-        const Chunk* front = &chunks_.front();
-        const Chunk* back  = &chunks_.back();
-        if ( start >= last )
-        {
-            assert( false );
-            return true;
-        }
-        if ( back < deallocChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-        if ( back < allocChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-        if ( front > deallocChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-        if ( front > allocChunk_ )
-        {
-            assert( false );
-            return true;
-        }
-
-        switch ( emptyChunkCount )
-        {
-            case 0:
-                if ( emptyChunk_ != NULL )
-                {
-                    assert( false );
-                    return true;
-                }
-                break;
-            case 1:
-                if ( emptyChunk_ == NULL )
-                {
-                    assert( false );
-                    return true;
-                }
-                if ( back < emptyChunk_ )
-                {
-                    assert( false );
-                    return true;
-                }
-                if ( front > emptyChunk_ )
-                {
-                    assert( false );
-                    return true;
-                }
-                if ( !emptyChunk_->HasAvailable( numBlocks_ ) )
-                {
-                    // This may imply somebody tried to delete a block twice.
-                    assert( false );
-                    return true;
-                }
-                break;
-            default:
-                assert( false );
-                return true;
-        }
-        for ( ChunkCIter it( start ); it != last; ++it )
-        {
-            const Chunk& chunk = *it;
-            if ( chunk.IsCorrupt( numBlocks_, blockSize_, true ) )
-                return true;
-        }
-    }
-
-    return false;
-}
-
-// FixedAllocator::HasBlock ---------------------------------------------------
-
-const Chunk* FixedAllocator::HasBlock( void* p ) const
-{
-    const std::size_t chunkLength = numBlocks_ * blockSize_;
-    for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it )
-    {
-        const Chunk& chunk = *it;
-        if ( chunk.HasBlock( p, chunkLength ) )
-            return &chunk;
-    }
-    return NULL;
-}
-
-// FixedAllocator::TrimEmptyChunk ---------------------------------------------
-
-bool FixedAllocator::TrimEmptyChunk( void )
-{
-    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
-    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
-    if ( NULL == emptyChunk_ ) return false;
-
-    // If emptyChunk_ points to valid Chunk, then chunk list is not empty.
-    assert( !chunks_.empty() );
-    // And there should be exactly 1 empty Chunk.
-    assert( 1 == CountEmptyChunks() );
-
-    Chunk* lastChunk = &chunks_.back();
-    if ( lastChunk != emptyChunk_ )
-        std::swap( *emptyChunk_, *lastChunk );
-    assert( lastChunk->HasAvailable( numBlocks_ ) );
-    lastChunk->Release();
-    chunks_.pop_back();
-
-    if ( chunks_.empty() )
-    {
-        allocChunk_ = NULL;
-        deallocChunk_ = NULL;
-    }
-    else
-    {
-        if ( deallocChunk_ == emptyChunk_ )
-        {
-            deallocChunk_ = &chunks_.front();
-            assert( deallocChunk_->blocksAvailable_ < numBlocks_ );
-        }
-        if ( allocChunk_ == emptyChunk_ )
-        {
-            allocChunk_ = &chunks_.back();
-            assert( allocChunk_->blocksAvailable_ < numBlocks_ );
-        }
-    }
-
-    emptyChunk_ = NULL;
-    assert( 0 == CountEmptyChunks() );
-
-    return true;
-}
-
-// FixedAllocator::TrimChunkList ----------------------------------------------
-
-bool FixedAllocator::TrimChunkList( void )
-{
-    if ( chunks_.empty() )
-    {
-        assert( NULL == allocChunk_ );
-        assert( NULL == deallocChunk_ );
-    }
-
-    if ( chunks_.size() == chunks_.capacity() )
-        return false;
-    // Use the "make-a-temp-and-swap" trick to remove excess capacity.
-    Chunks( chunks_ ).swap( chunks_ );
-
-    return true;
-}
-
-// FixedAllocator::MakeNewChunk -----------------------------------------------
-
-bool FixedAllocator::MakeNewChunk( void )
-{
-    bool allocated = false;
-    try
-    {
-        std::size_t size = chunks_.size();
-        // Calling chunks_.reserve *before* creating and initializing the new
-        // Chunk means that nothing is leaked by this function in case an
-        // exception is thrown from reserve.
-        if ( chunks_.capacity() == size )
-        {
-            if ( 0 == size ) size = 4;
-            chunks_.reserve( size * 2 );
-        }
-        Chunk newChunk;
-        allocated = newChunk.Init( blockSize_, numBlocks_ );
-        if ( allocated )
-            chunks_.push_back( newChunk );
-    }
-    catch ( ... )
-    {
-        allocated = false;
-    }
-    if ( !allocated ) return false;
-
-    allocChunk_ = &chunks_.back();
-    deallocChunk_ = &chunks_.front();
-    return true;
-}
-
-// FixedAllocator::Allocate ---------------------------------------------------
-
-void* FixedAllocator::Allocate( void )
-{
-    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
-    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
-    assert( CountEmptyChunks() < 2 );
-
-    if ( ( NULL == allocChunk_ ) || allocChunk_->IsFilled() )
-    {
-        if ( NULL != emptyChunk_ )
-        {
-            allocChunk_ = emptyChunk_;
-            emptyChunk_ = NULL;
-        }
-        else
-        {
-            for ( ChunkIter i( chunks_.begin() ); ; ++i )
-            {
-                if ( chunks_.end() == i )
-                {
-                    if ( !MakeNewChunk() )
-                        return NULL;
-                    break;
-                }
-                if ( !i->IsFilled() )
-                {
-                    allocChunk_ = &*i;
-                    break;
-                }
-            }
-        }
-    }
-    else if ( allocChunk_ == emptyChunk_)
-        // detach emptyChunk_ from allocChunk_, because after
-        // calling allocChunk_->Allocate(blockSize_); the chunk
-        // is no longer empty.
-        emptyChunk_ = NULL;
-
-    assert( allocChunk_ != NULL );
-    assert( !allocChunk_->IsFilled() );
-    void* place = allocChunk_->Allocate( blockSize_ );
-
-    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
-    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
-    assert( CountEmptyChunks() < 2 );
-#ifdef LOKI_CHECK_FOR_CORRUPTION
-    if ( allocChunk_->IsCorrupt( numBlocks_, blockSize_, true ) )
-    {
-        assert( false );
-        return NULL;
-    }
-#endif
-
-    return place;
-}
-
-// FixedAllocator::Deallocate -------------------------------------------------
-
-bool FixedAllocator::Deallocate( void* p, Chunk* hint )
-{
-    assert(!chunks_.empty());
-    assert(&chunks_.front() <= deallocChunk_);
-    assert(&chunks_.back() >= deallocChunk_);
-    assert( &chunks_.front() <= allocChunk_ );
-    assert( &chunks_.back() >= allocChunk_ );
-    assert( CountEmptyChunks() < 2 );
-
-    Chunk* foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint;
-    if ( NULL == foundChunk )
-        return false;
-
-    assert( foundChunk->HasBlock( p, numBlocks_ * blockSize_ ) );
-#ifdef LOKI_CHECK_FOR_CORRUPTION
-    if ( foundChunk->IsCorrupt( numBlocks_, blockSize_, true ) )
-    {
-        assert( false );
-        return false;
-    }
-    if ( foundChunk->IsBlockAvailable( p, numBlocks_, blockSize_ ) )
-    {
-        assert( false );
-        return false;
-    }
-#endif
-    deallocChunk_ = foundChunk;
-    DoDeallocate(p);
-    assert( CountEmptyChunks() < 2 );
-
-    return true;
-}
-
-// FixedAllocator::VicinityFind -----------------------------------------------
-
-Chunk* FixedAllocator::VicinityFind( void* p ) const
-{
-    if ( chunks_.empty() ) return NULL;
-    assert(deallocChunk_);
-
-    const std::size_t chunkLength = numBlocks_ * blockSize_;
-    Chunk* lo = deallocChunk_;
-    Chunk* hi = deallocChunk_ + 1;
-    const Chunk* loBound = &chunks_.front();
-    const Chunk* hiBound = &chunks_.back() + 1;
-
-    // Special case: deallocChunk_ is the last in the array
-    if (hi == hiBound) hi = NULL;
-
-    for (;;)
-    {
-        if (lo)
-        {
-            if ( lo->HasBlock( p, chunkLength ) ) return lo;
-            if ( lo == loBound )
-            {
-                lo = NULL;
-                if ( NULL == hi ) break;
-            }
-            else --lo;
-        }
-
-        if (hi)
-        {
-            if ( hi->HasBlock( p, chunkLength ) ) return hi;
-            if ( ++hi == hiBound )
-            {
-                hi = NULL;
-                if ( NULL == lo ) break;
-            }
-        }
-    }
-
-    return NULL;
-}
-
-// FixedAllocator::DoDeallocate -----------------------------------------------
-
-void FixedAllocator::DoDeallocate(void* p)
-{
-    // Show that deallocChunk_ really owns the block at address p.
-    assert( deallocChunk_->HasBlock( p, numBlocks_ * blockSize_ ) );
-    // Either of the next two assertions may fail if somebody tries to
-    // delete the same block twice.
-    assert( emptyChunk_ != deallocChunk_ );
-    assert( !deallocChunk_->HasAvailable( numBlocks_ ) );
-    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
-    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
-
-    // call into the chunk, will adjust the inner list but won't release memory
-    deallocChunk_->Deallocate(p, blockSize_);
-
-    if ( deallocChunk_->HasAvailable( numBlocks_ ) )
-    {
-        assert( emptyChunk_ != deallocChunk_ );
-        // deallocChunk_ is empty, but a Chunk is only released if there are 2
-        // empty chunks.  Since emptyChunk_ may only point to a previously
-        // cleared Chunk, if it points to something else besides deallocChunk_,
-        // then FixedAllocator currently has 2 empty Chunks.
-        if ( NULL != emptyChunk_ )
-        {
-            // If last Chunk is empty, just change what deallocChunk_
-            // points to, and release the last.  Otherwise, swap an empty
-            // Chunk with the last, and then release it.
-            Chunk* lastChunk = &chunks_.back();
-            if ( lastChunk == deallocChunk_ )
-                deallocChunk_ = emptyChunk_;
-            else if ( lastChunk != emptyChunk_ )
-                std::swap( *emptyChunk_, *lastChunk );
-            assert( lastChunk->HasAvailable( numBlocks_ ) );
-            lastChunk->Release();
-            chunks_.pop_back();
-            if ( ( allocChunk_ == lastChunk ) || allocChunk_->IsFilled() )
-                allocChunk_ = deallocChunk_;
-        }
-        emptyChunk_ = deallocChunk_;
-    }
-
-    // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
-    assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
-}
-
-// GetOffset ------------------------------------------------------------------
-/// @ingroup SmallObjectGroupInternal
-/// Calculates index into array where a FixedAllocator of numBytes is located.
-inline std::size_t GetOffset( std::size_t numBytes, std::size_t alignment )
-{
-    const std::size_t alignExtra = alignment - 1;
-    return ( numBytes + alignExtra ) / alignment;
-}
-
-// DefaultAllocator -----------------------------------------------------------
-/** @ingroup SmallObjectGroupInternal
- Calls the default allocator when SmallObjAllocator decides not to handle a
- request.  SmallObjAllocator calls this if the number of bytes is bigger than
- the size which can be handled by any FixedAllocator.
- @param numBytes number of bytes
- @param doThrow True if this function should throw an exception, or false if it
-  should indicate failure by returning a NULL pointer.
-*/
-void* DefaultAllocator( std::size_t numBytes, bool doThrow )
-{
-#ifdef USE_NEW_TO_ALLOCATE
-    return doThrow ? ::operator new( numBytes ) :
-           ::operator new( numBytes, std::nothrow_t() );
-#else
-    void* p = ::std::malloc( numBytes );
-    if ( doThrow && ( NULL == p ) )
-        throw std::bad_alloc();
-    return p;
-#endif
-}
-
-// DefaultDeallocator ---------------------------------------------------------
-/** @ingroup SmallObjectGroupInternal
- Calls default deallocator when SmallObjAllocator decides not to handle a
- request.  The default deallocator could be the global delete operator or the
- free function.  The free function is the preferred default deallocator since
- it matches malloc which is the preferred default allocator.  SmallObjAllocator
- will call this if an address was not found among any of its own blocks.
- */
-void DefaultDeallocator( void* p )
-{
-#ifdef USE_NEW_TO_ALLOCATE
-    ::operator delete( p );
-#else
-    ::std::free( p );
-#endif
-}
-
-// SmallObjAllocator::SmallObjAllocator ---------------------------------------
-
-SmallObjAllocator::SmallObjAllocator( std::size_t pageSize,
-                                      std::size_t maxObjectSize, std::size_t objectAlignSize ) :
-    pool_( NULL ),
-    maxSmallObjectSize_( maxObjectSize ),
-    objectAlignSize_( objectAlignSize )
-{
-#ifdef DO_EXTRA_LOKI_TESTS
-    std::cout << "SmallObjAllocator " << this << std::endl;
-#endif
-    assert( 0 != objectAlignSize );
-    const std::size_t allocCount = GetOffset( maxObjectSize, objectAlignSize );
-    pool_ = new FixedAllocator[ allocCount ];
-    for ( std::size_t i = 0; i < allocCount; ++i )
-        pool_[ i ].Initialize( ( i + 1 ) * objectAlignSize, pageSize );
-}
-
-// SmallObjAllocator::~SmallObjAllocator --------------------------------------
-
-SmallObjAllocator::~SmallObjAllocator( void )
-{
-#ifdef DO_EXTRA_LOKI_TESTS
-    std::cout << "~SmallObjAllocator " << this << std::endl;
-#endif
-    delete [] pool_;
-}
-
-// SmallObjAllocator::TrimExcessMemory ----------------------------------------
-
-bool SmallObjAllocator::TrimExcessMemory( void )
-{
-    bool found = false;
-    const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
-    std::size_t i = 0;
-    for ( ; i < allocCount; ++i )
-    {
-        if ( pool_[ i ].TrimEmptyChunk() )
-            found = true;
-    }
-    for ( i = 0; i < allocCount; ++i )
-    {
-        if ( pool_[ i ].TrimChunkList() )
-            found = true;
-    }
-
-    return found;
-}
-
-// SmallObjAllocator::Allocate ------------------------------------------------
-
-void* SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
-{
-    if ( numBytes > GetMaxObjectSize() )
-        return DefaultAllocator( numBytes, doThrow );
-
-    assert( NULL != pool_ );
-    if ( 0 == numBytes ) numBytes = 1;
-    const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1;
-    const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
-    (void) allocCount;
-    assert( index < allocCount );
-
-    FixedAllocator& allocator = pool_[ index ];
-    assert( allocator.BlockSize() >= numBytes );
-    assert( allocator.BlockSize() < numBytes + GetAlignment() );
-    void* place = allocator.Allocate();
-
-    if ( ( NULL == place ) && TrimExcessMemory() )
-        place = allocator.Allocate();
-
-    if ( ( NULL == place ) && doThrow )
-    {
-#ifdef _MSC_VER
-        throw std::bad_alloc( "could not allocate small object" );
-#else
-        // GCC did not like a literal string passed to std::bad_alloc.
-        // so just throw the default-constructed exception.
-        throw std::bad_alloc();
-#endif
-    }
-    return place;
-}
-
-// SmallObjAllocator::Deallocate ----------------------------------------------
-
-void SmallObjAllocator::Deallocate( void* p, std::size_t numBytes )
-{
-    if ( NULL == p ) return;
-    if ( numBytes > GetMaxObjectSize() )
-    {
-        DefaultDeallocator( p );
-        return;
-    }
-    assert( NULL != pool_ );
-    if ( 0 == numBytes ) numBytes = 1;
-    const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1;
-    const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
-    (void) allocCount;
-    assert( index < allocCount );
-    FixedAllocator& allocator = pool_[ index ];
-    assert( allocator.BlockSize() >= numBytes );
-    assert( allocator.BlockSize() < numBytes + GetAlignment() );
-    const bool found = allocator.Deallocate( p, NULL );
-    (void) found;
-    assert( found );
-}
-
-// SmallObjAllocator::Deallocate ----------------------------------------------
-
-void SmallObjAllocator::Deallocate( void* p )
-{
-    if ( NULL == p ) return;
-    assert( NULL != pool_ );
-    FixedAllocator* pAllocator = NULL;
-    const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
-    Chunk* chunk = NULL;
-
-    for ( std::size_t ii = 0; ii < allocCount; ++ii )
-    {
-        chunk = pool_[ ii ].HasBlock( p );
-        if ( NULL != chunk )
-        {
-            pAllocator = &pool_[ ii ];
-            break;
-        }
-    }
-    if ( NULL == pAllocator )
-    {
-        DefaultDeallocator( p );
-        return;
-    }
-
-    assert( NULL != chunk );
-    const bool found = pAllocator->Deallocate( p, chunk );
-    (void) found;
-    assert( found );
-}
-
-// SmallObjAllocator::IsCorrupt -----------------------------------------------
-
-bool SmallObjAllocator::IsCorrupt( void ) const
-{
-    if ( NULL == pool_ )
-    {
-        assert( false );
-        return true;
-    }
-    if ( 0 == GetAlignment() )
-    {
-        assert( false );
-        return true;
-    }
-    if ( 0 == GetMaxObjectSize() )
-    {
-        assert( false );
-        return true;
-    }
-    const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
-    for ( std::size_t ii = 0; ii < allocCount; ++ii )
-    {
-        if ( pool_[ ii ].IsCorrupt() )
-            return true;
-    }
-    return false;
-}
-
-} // end namespace Loki
-
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
-
diff --git a/shared/loki/SmartPtr.h b/shared/loki/SmartPtr.h
deleted file mode 100644
index 6f6f9996..00000000
--- a/shared/loki/SmartPtr.h
+++ /dev/null
@@ -1,1778 +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_SMARTPTR_INC_
-#define LOKI_SMARTPTR_INC_
-
-// $Id: SmartPtr.h 903 2008-11-10 05:55:12Z rich_sposato $
-
-
-///  \defgroup  SmartPointerGroup Smart pointers
-///  Policy based implementation of a smart pointer
-///  \defgroup  SmartPointerOwnershipGroup Ownership policies
-///  \ingroup   SmartPointerGroup
-///  \defgroup  SmartPointerStorageGroup Storage policies
-///  \ingroup   SmartPointerGroup
-///  \defgroup  SmartPointerConversionGroup Conversion policies
-///  \ingroup   SmartPointerGroup
-///  \defgroup  SmartPointerCheckingGroup Checking policies
-///  \ingroup   SmartPointerGroup
-
-#include "LokiExport.h"
-#include "SmallObj.h"
-#include "TypeManip.h"
-#include "static_check.h"
-#include "RefToValue.h"
-#include "ConstPolicy.h"
-
-#include <functional>
-#include <stdexcept>
-#include <cassert>
-#include <string>
-
-#if !defined(_MSC_VER)
-#  if defined(__sparc__)
-#    include <inttypes.h>
-#  else
-#    include <stdint.h>
-#  endif
-#endif
-
-#if defined(_MSC_VER) || defined(__GNUC__)
-// GCC>=4.1 must use -ffriend-injection due to a bug in GCC
-#define LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
-#endif
-
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class HeapStorage
-///
-///  \ingroup  SmartPointerStorageGroup
-///  Implementation of the StoragePolicy used by SmartPtr.  Uses explicit call
-///   to T's destructor followed by call to free.
-////////////////////////////////////////////////////////////////////////////////
-
-
-template <class T>
-class HeapStorage
-{
-public:
-    typedef T* StoredType;      /// the type of the pointee_ object
-    typedef T* InitPointerType; /// type used to declare OwnershipPolicy type.
-    typedef T* PointerType;     /// type returned by operator->
-    typedef T& ReferenceType;   /// type returned by operator*
-
-    HeapStorage() : pointee_(Default())
-    {}
-
-    // The storage policy doesn't initialize the stored pointer
-    //     which will be initialized by the OwnershipPolicy's Clone fn
-    HeapStorage(const HeapStorage&) : pointee_(0)
-    {}
-
-    template <class U>
-    HeapStorage(const HeapStorage<U>&) : pointee_(0)
-    {}
-
-    HeapStorage(const StoredType& p) : pointee_(p) {}
-
-    PointerType operator->() const { return pointee_; }
-
-    ReferenceType operator*() const { return *pointee_; }
-
-    void Swap(HeapStorage& rhs)
-    { std::swap(pointee_, rhs.pointee_); }
-
-    // Accessors
-    template <class F>
-    friend typename HeapStorage<F>::PointerType GetImpl(const HeapStorage<F>& sp);
-
-    template <class F>
-    friend const typename HeapStorage<F>::StoredType& GetImplRef(const HeapStorage<F>& sp);
-
-    template <class F>
-    friend typename HeapStorage<F>::StoredType& GetImplRef(HeapStorage<F>& sp);
-
-protected:
-    // Destroys the data stored
-    // (Destruction might be taken over by the OwnershipPolicy)
-    void Destroy()
-    {
-        if ( 0 != pointee_ )
-        {
-            pointee_->~T();
-            ::free( pointee_ );
-        }
-    }
-
-    // Default value to initialize the pointer
-    static StoredType Default()
-    { return 0; }
-
-private:
-    // Data
-    StoredType pointee_;
-};
-
-template <class T>
-inline typename HeapStorage<T>::PointerType GetImpl(const HeapStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline const typename HeapStorage<T>::StoredType& GetImplRef(const HeapStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline typename HeapStorage<T>::StoredType& GetImplRef(HeapStorage<T>& sp)
-{ return sp.pointee_; }
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DefaultSPStorage
-///
-///  \ingroup  SmartPointerStorageGroup
-///  Implementation of the StoragePolicy used by SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-
-template <class T>
-class DefaultSPStorage
-{
-public:
-    typedef T* StoredType;    // the type of the pointee_ object
-    typedef T* InitPointerType; /// type used to declare OwnershipPolicy type.
-    typedef T* PointerType;   // type returned by operator->
-    typedef T& ReferenceType; // type returned by operator*
-
-    DefaultSPStorage() : pointee_(Default())
-    {}
-
-    // The storage policy doesn't initialize the stored pointer
-    //     which will be initialized by the OwnershipPolicy's Clone fn
-    DefaultSPStorage(const DefaultSPStorage&) : pointee_(0)
-    {}
-
-    template <class U>
-    DefaultSPStorage(const DefaultSPStorage<U>&) : pointee_(0)
-    {}
-
-    DefaultSPStorage(const StoredType& p) : pointee_(p) {}
-
-    PointerType operator->() const { return pointee_; }
-
-    ReferenceType operator*() const { return *pointee_; }
-
-    void Swap(DefaultSPStorage& rhs)
-    { std::swap(pointee_, rhs.pointee_); }
-
-    // Accessors
-    template <class F>
-    friend typename DefaultSPStorage<F>::PointerType GetImpl(const DefaultSPStorage<F>& sp);
-
-    template <class F>
-    friend const typename DefaultSPStorage<F>::StoredType& GetImplRef(const DefaultSPStorage<F>& sp);
-
-    template <class F>
-    friend typename DefaultSPStorage<F>::StoredType& GetImplRef(DefaultSPStorage<F>& sp);
-
-protected:
-    // Destroys the data stored
-    // (Destruction might be taken over by the OwnershipPolicy)
-    //
-    // If your compiler gives you a warning in this area while
-    // compiling the tests, it is on purpose, please ignore it.
-    void Destroy()
-    {
-        delete pointee_;
-    }
-
-    // Default value to initialize the pointer
-    static StoredType Default()
-    { return 0; }
-
-private:
-    // Data
-    StoredType pointee_;
-};
-
-template <class T>
-inline typename DefaultSPStorage<T>::PointerType GetImpl(const DefaultSPStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline const typename DefaultSPStorage<T>::StoredType& GetImplRef(const DefaultSPStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline typename DefaultSPStorage<T>::StoredType& GetImplRef(DefaultSPStorage<T>& sp)
-{ return sp.pointee_; }
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class LockedStorage
-///
-///  \ingroup  SmartPointerStorageGroup
-///  Implementation of the StoragePolicy used by SmartPtr.
-///
-///  Each call to operator-> locks the object for the duration of a call to a
-///  member function of T.
-///
-///  \par How It Works
-///  LockedStorage has a helper class called Locker, which acts as a smart
-///  pointer with limited abilities.  LockedStorage::operator-> returns an
-///  unnamed temporary of type Locker<T> that exists for the duration of the
-///  call to a member function of T.  The unnamed temporary locks the object
-///  when it is constructed by operator-> and unlocks the object when it is
-///  destructed.
-///
-///  \note This storage policy requires class T to have member functions Lock
-///  and Unlock.  If your class does not have Lock or Unlock functions, you may
-///  either make a child class which does, or make a policy class similar to
-///  LockedStorage which calls other functions to lock the object.
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-class Locker
-{
-public:
-    Locker( const T* p ) : pointee_( const_cast< T* >( p ) )
-    {
-        if ( pointee_ != 0 )
-            pointee_->Lock();
-    }
-
-    ~Locker( void )
-    {
-        if ( pointee_ != 0 )
-            pointee_->Unlock();
-    }
-
-    operator T* ()
-    {
-        return pointee_;
-    }
-
-    T* operator->()
-    {
-        return pointee_;
-    }
-
-private:
-    Locker( void );
-    Locker& operator = ( const Locker& );
-    T* pointee_;
-};
-
-template <class T>
-class LockedStorage
-{
-public:
-
-    typedef T* StoredType;           /// the type of the pointee_ object
-    typedef T* InitPointerType;      /// type used to declare OwnershipPolicy type.
-    typedef Locker< T > PointerType; /// type returned by operator->
-    typedef T& ReferenceType;        /// type returned by operator*
-
-    LockedStorage() : pointee_( Default() ) {}
-
-    ~LockedStorage( void ) {}
-
-    LockedStorage( const LockedStorage&) : pointee_( 0 ) {}
-
-    LockedStorage( const StoredType& p ) : pointee_( p ) {}
-
-    PointerType operator->()
-    {
-        return Locker< T >( pointee_ );
-    }
-
-    void Swap(LockedStorage& rhs)
-    {
-        std::swap( pointee_, rhs.pointee_ );
-    }
-
-    // Accessors
-    template <class F>
-    friend typename LockedStorage<F>::InitPointerType GetImpl(const LockedStorage<F>& sp);
-
-    template <class F>
-    friend const typename LockedStorage<F>::StoredType& GetImplRef(const LockedStorage<F>& sp);
-
-    template <class F>
-    friend typename LockedStorage<F>::StoredType& GetImplRef(LockedStorage<F>& sp);
-
-protected:
-    // Destroys the data stored
-    // (Destruction might be taken over by the OwnershipPolicy)
-    void Destroy()
-    {
-        delete pointee_;
-    }
-
-    // Default value to initialize the pointer
-    static StoredType Default()
-    { return 0; }
-
-private:
-    /// Dereference operator is not implemented.
-    ReferenceType operator*();
-
-    // Data
-    StoredType pointee_;
-};
-
-template <class T>
-inline typename LockedStorage<T>::InitPointerType GetImpl(const LockedStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline const typename LockedStorage<T>::StoredType& GetImplRef(const LockedStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline typename LockedStorage<T>::StoredType& GetImplRef(LockedStorage<T>& sp)
-{ return sp.pointee_; }
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class ArrayStorage
-///
-///  \ingroup  SmartPointerStorageGroup
-///  Implementation of the ArrayStorage used by SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-
-template <class T>
-class ArrayStorage
-{
-public:
-    typedef T* StoredType;    // the type of the pointee_ object
-    typedef T* InitPointerType; /// type used to declare OwnershipPolicy type.
-    typedef T* PointerType;   // type returned by operator->
-    typedef T& ReferenceType; // type returned by operator*
-
-    ArrayStorage() : pointee_(Default())
-    {}
-
-    // The storage policy doesn't initialize the stored pointer
-    //     which will be initialized by the OwnershipPolicy's Clone fn
-    ArrayStorage(const ArrayStorage&) : pointee_(0)
-    {}
-
-    template <class U>
-    ArrayStorage(const ArrayStorage<U>&) : pointee_(0)
-    {}
-
-    ArrayStorage(const StoredType& p) : pointee_(p) {}
-
-    PointerType operator->() const { return pointee_; }
-
-    ReferenceType operator*() const { return *pointee_; }
-
-    void Swap(ArrayStorage& rhs)
-    { std::swap(pointee_, rhs.pointee_); }
-
-    // Accessors
-    template <class F>
-    friend typename ArrayStorage<F>::PointerType GetImpl(const ArrayStorage<F>& sp);
-
-    template <class F>
-    friend const typename ArrayStorage<F>::StoredType& GetImplRef(const ArrayStorage<F>& sp);
-
-    template <class F>
-    friend typename ArrayStorage<F>::StoredType& GetImplRef(ArrayStorage<F>& sp);
-
-protected:
-    // Destroys the data stored
-    // (Destruction might be taken over by the OwnershipPolicy)
-    void Destroy()
-    { delete [] pointee_; }
-
-    // Default value to initialize the pointer
-    static StoredType Default()
-    { return 0; }
-
-private:
-    // Data
-    StoredType pointee_;
-};
-
-template <class T>
-inline typename ArrayStorage<T>::PointerType GetImpl(const ArrayStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline const typename ArrayStorage<T>::StoredType& GetImplRef(const ArrayStorage<T>& sp)
-{ return sp.pointee_; }
-
-template <class T>
-inline typename ArrayStorage<T>::StoredType& GetImplRef(ArrayStorage<T>& sp)
-{ return sp.pointee_; }
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class RefCounted
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Provides a classic external reference counting implementation
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-class RefCounted
-{
-public:
-    RefCounted()
-        : pCount_(static_cast<uintptr_t*>(
-                      SmallObject<>::operator new(sizeof(uintptr_t))))
-    {
-        assert(pCount_ != 0);
-        *pCount_ = 1;
-    }
-
-    RefCounted(const RefCounted& rhs)
-        : pCount_(rhs.pCount_)
-    {}
-
-    // MWCW lacks template friends, hence the following kludge
-    template <typename P1>
-    RefCounted(const RefCounted<P1>& rhs)
-        : pCount_(reinterpret_cast<const RefCounted&>(rhs).pCount_)
-    {}
-
-    P Clone(const P& val)
-    {
-        ++*pCount_;
-        return val;
-    }
-
-    bool Release(const P&)
-    {
-        if (!--*pCount_)
-        {
-            SmallObject<>::operator delete(pCount_, sizeof(uintptr_t));
-            pCount_ = NULL;
-            return true;
-        }
-        return false;
-    }
-
-    void Swap(RefCounted& rhs)
-    { std::swap(pCount_, rhs.pCount_); }
-
-    enum { destructiveCopy = false };
-
-private:
-    // Data
-    uintptr_t* pCount_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct RefCountedMT
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Implements external reference counting for multithreaded programs
-///  Policy Usage: RefCountedMTAdj<ThreadingModel>::RefCountedMT
-///
-///  \par Warning
-///  There could be a race condition, see bug "Race condition in RefCountedMTAdj::Release"
-///  http://sourceforge.net/tracker/index.php?func=detail&aid=1408845&group_id=29557&atid=396644
-///  As stated in bug 1408845, the Release function is not thread safe if a
-///  SmartPtr copy-constructor tries to copy the last pointer to an object in
-///  one thread, while the destructor is acting on the last pointer in another
-///  thread.  The existence of a race between a copy-constructor and destructor
-///  implies a design flaw at a higher level.  That race condition must be
-///  fixed at a higher design level, and no change to this class could fix it.
-////////////////////////////////////////////////////////////////////////////////
-
-template < template <class, class> class ThreadingModel,
-         class MX = LOKI_DEFAULT_MUTEX >
-struct RefCountedMTAdj
-{
-    template <class P>
-    class RefCountedMT : public ThreadingModel< RefCountedMT<P>, MX >
-    {
-        typedef ThreadingModel< RefCountedMT<P>, MX > base_type;
-        typedef typename base_type::IntType       CountType;
-        typedef volatile CountType*               CountPtrType;
-
-    public:
-        RefCountedMT()
-        {
-            pCount_ = static_cast<CountPtrType>(
-                          SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator new(
-                              sizeof(*pCount_)));
-            assert(pCount_);
-            //*pCount_ = 1;
-            ThreadingModel<RefCountedMT, MX>::AtomicAssign(*pCount_, 1);
-        }
-
-        RefCountedMT(const RefCountedMT& rhs)
-            : pCount_(rhs.pCount_)
-        {}
-
-        //MWCW lacks template friends, hence the following kludge
-        template <typename P1>
-        RefCountedMT(const RefCountedMT<P1>& rhs)
-            : pCount_(reinterpret_cast<const RefCountedMT<P>&>(rhs).pCount_)
-        {}
-
-        P Clone(const P& val)
-        {
-            ThreadingModel<RefCountedMT, MX>::AtomicIncrement(*pCount_);
-            return val;
-        }
-
-        bool Release(const P&)
-        {
-            bool isZero = false;
-            ThreadingModel< RefCountedMT, MX >::AtomicDecrement( *pCount_, 0, isZero );
-            if ( isZero )
-            {
-                SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator delete(
-                    const_cast<CountType*>(pCount_),
-                    sizeof(*pCount_));
-                return true;
-            }
-            return false;
-        }
-
-        void Swap(RefCountedMT& rhs)
-        { std::swap(pCount_, rhs.pCount_); }
-
-        enum { destructiveCopy = false };
-
-    private:
-        // Data
-        CountPtrType pCount_;
-    };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class COMRefCounted
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Adapts COM intrusive reference counting to OwnershipPolicy-specific syntax
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-class COMRefCounted
-{
-public:
-    COMRefCounted()
-    {}
-
-    template <class U>
-    COMRefCounted(const COMRefCounted<U>&)
-    {}
-
-    static P Clone(const P& val)
-    {
-        if (val != 0)
-            val->AddRef();
-        return val;
-    }
-
-    static bool Release(const P& val)
-    {
-        if (val != 0)
-            val->Release();
-        return false;
-    }
-
-    enum { destructiveCopy = false };
-
-    static void Swap(COMRefCounted&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct DeepCopy
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Implements deep copy semantics, assumes existence of a Clone() member
-///  function of the pointee type
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct DeepCopy
-{
-    DeepCopy()
-    {}
-
-    template <class P1>
-    DeepCopy(const DeepCopy<P1>&)
-    {}
-
-    static P Clone(const P& val)
-    { return val->Clone(); }
-
-    static bool Release(const P&)
-    { return true; }
-
-    static void Swap(DeepCopy&)
-    {}
-
-    enum { destructiveCopy = false };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class RefLinked
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Implements reference linking
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-class LOKI_EXPORT RefLinkedBase
-{
-public:
-    RefLinkedBase()
-    { prev_ = next_ = this; }
-
-    RefLinkedBase(const RefLinkedBase& rhs);
-
-    bool Release();
-
-    void Swap(RefLinkedBase& rhs);
-
-    bool Merge( RefLinkedBase& rhs );
-
-    enum { destructiveCopy = false };
-
-private:
-    static unsigned int CountPrevCycle( const RefLinkedBase* pThis );
-    static unsigned int CountNextCycle( const RefLinkedBase* pThis );
-    bool HasPrevNode( const RefLinkedBase* p ) const;
-    bool HasNextNode( const RefLinkedBase* p ) const;
-
-    mutable const RefLinkedBase* prev_;
-    mutable const RefLinkedBase* next_;
-};
-}
-
-template <class P>
-class RefLinked : public Private::RefLinkedBase
-{
-public:
-    RefLinked()
-    {}
-
-    template <class P1>
-    RefLinked(const RefLinked<P1>& rhs)
-        : Private::RefLinkedBase(rhs)
-    {}
-
-    static P Clone(const P& val)
-    { return val; }
-
-    bool Release(const P&)
-    { return Private::RefLinkedBase::Release(); }
-
-    template < class P1 >
-    bool Merge( RefLinked< P1 > & rhs )
-    {
-        return Private::RefLinkedBase::Merge( rhs );
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DestructiveCopy
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Implements destructive copy semantics (a la std::auto_ptr)
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-class DestructiveCopy
-{
-public:
-    DestructiveCopy()
-    {}
-
-    template <class P1>
-    DestructiveCopy(const DestructiveCopy<P1>&)
-    {}
-
-    template <class P1>
-    static P Clone(P1& val)
-    {
-        P result(val);
-        val = P1();
-        return result;
-    }
-
-    static bool Release(const P&)
-    { return true; }
-
-    static void Swap(DestructiveCopy&)
-    {}
-
-    enum { destructiveCopy = true };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class NoCopy
-///
-///  \ingroup  SmartPointerOwnershipGroup
-///  Implementation of the OwnershipPolicy used by SmartPtr
-///  Implements a policy that doesn't allow copying objects
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-class NoCopy
-{
-public:
-    NoCopy()
-    {}
-
-    template <class P1>
-    NoCopy(const NoCopy<P1>&)
-    {}
-
-    static P Clone(const P&)
-    {
-        // Make it depended on template parameter
-        static const bool DependedFalse = sizeof(P*) == 0;
-
-        LOKI_STATIC_CHECK(DependedFalse, This_Policy_Disallows_Value_Copying);
-    }
-
-    static bool Release(const P&)
-    { return true; }
-
-    static void Swap(NoCopy&)
-    {}
-
-    enum { destructiveCopy = false };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct AllowConversion
-///
-///  \ingroup  SmartPointerConversionGroup
-///  Implementation of the ConversionPolicy used by SmartPtr
-///  Allows implicit conversion from SmartPtr to the pointee type
-////////////////////////////////////////////////////////////////////////////////
-
-struct AllowConversion
-{
-    enum { allow = true };
-
-    void Swap(AllowConversion&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct DisallowConversion
-///
-///  \ingroup  SmartPointerConversionGroup
-///  Implementation of the ConversionPolicy used by SmartPtr
-///  Does not allow implicit conversion from SmartPtr to the pointee type
-///  You can initialize a DisallowConversion with an AllowConversion
-////////////////////////////////////////////////////////////////////////////////
-
-struct DisallowConversion
-{
-    DisallowConversion()
-    {}
-
-    DisallowConversion(const AllowConversion&)
-    {}
-
-    enum { allow = false };
-
-    void Swap(DisallowConversion&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct NoCheck
-///
-///  \ingroup  SmartPointerCheckingGroup
-///  Implementation of the CheckingPolicy used by SmartPtr
-///  Well, it's clear what it does :o)
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct NoCheck
-{
-    NoCheck()
-    {}
-
-    template <class P1>
-    NoCheck(const NoCheck<P1>&)
-    {}
-
-    static void OnDefault(const P&)
-    {}
-
-    static void OnInit(const P&)
-    {}
-
-    static void OnDereference(const P&)
-    {}
-
-    static void Swap(NoCheck&)
-    {}
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct AssertCheck
-///
-///  \ingroup  SmartPointerCheckingGroup
-///  Implementation of the CheckingPolicy used by SmartPtr
-///  Checks the pointer before dereference
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct AssertCheck
-{
-    AssertCheck()
-    {}
-
-    template <class P1>
-    AssertCheck(const AssertCheck<P1>&)
-    {}
-
-    template <class P1>
-    AssertCheck(const NoCheck<P1>&)
-    {}
-
-    static void OnDefault(const P&)
-    {}
-
-    static void OnInit(const P&)
-    {}
-
-    static void OnDereference(P val)
-    { assert(val); (void)val; }
-
-    static void Swap(AssertCheck&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct AssertCheckStrict
-///
-///  \ingroup  SmartPointerCheckingGroup
-///  Implementation of the CheckingPolicy used by SmartPtr
-///  Checks the pointer against zero upon initialization and before dereference
-///  You can initialize an AssertCheckStrict with an AssertCheck
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct AssertCheckStrict
-{
-    AssertCheckStrict()
-    {}
-
-    template <class U>
-    AssertCheckStrict(const AssertCheckStrict<U>&)
-    {}
-
-    template <class U>
-    AssertCheckStrict(const AssertCheck<U>&)
-    {}
-
-    template <class P1>
-    AssertCheckStrict(const NoCheck<P1>&)
-    {}
-
-    static void OnDefault(P val)
-    { assert(val); }
-
-    static void OnInit(P val)
-    { assert(val); }
-
-    static void OnDereference(P val)
-    { assert(val); }
-
-    static void Swap(AssertCheckStrict&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct NullPointerException
-///
-///  \ingroup SmartPointerGroup
-///  Used by some implementations of the CheckingPolicy used by SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-struct NullPointerException : public std::runtime_error
-{
-    NullPointerException() : std::runtime_error(std::string(""))
-    { }
-    const char* what() const throw()
-    { return "Null Pointer Exception"; }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct RejectNullStatic
-///
-///  \ingroup  SmartPointerCheckingGroup
-///  Implementation of the CheckingPolicy used by SmartPtr
-///  Checks the pointer upon initialization and before dereference
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct RejectNullStatic
-{
-    RejectNullStatic()
-    {}
-
-    template <class P1>
-    RejectNullStatic(const RejectNullStatic<P1>&)
-    {}
-
-    template <class P1>
-    RejectNullStatic(const NoCheck<P1>&)
-    {}
-
-    template <class P1>
-    RejectNullStatic(const AssertCheck<P1>&)
-    {}
-
-    template <class P1>
-    RejectNullStatic(const AssertCheckStrict<P1>&)
-    {}
-
-    static void OnDefault(const P&)
-    {
-        // Make it depended on template parameter
-        static const bool DependedFalse = sizeof(P*) == 0;
-
-        LOKI_STATIC_CHECK(DependedFalse, ERROR_This_Policy_Does_Not_Allow_Default_Initialization);
-    }
-
-    static void OnInit(const P& val)
-    { if (!val) throw NullPointerException(); }
-
-    static void OnDereference(const P& val)
-    { if (!val) throw NullPointerException(); }
-
-    static void Swap(RejectNullStatic&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct RejectNull
-///
-///  \ingroup  SmartPointerCheckingGroup
-///  Implementation of the CheckingPolicy used by SmartPtr
-///  Checks the pointer before dereference
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct RejectNull
-{
-    RejectNull()
-    {}
-
-    template <class P1>
-    RejectNull(const RejectNull<P1>&)
-    {}
-
-    static void OnInit(P)
-    {}
-
-    static void OnDefault(P)
-    {}
-
-    void OnDereference(P val)
-    { if (!val) throw NullPointerException(); }
-
-    void OnDereference(P val) const
-    { if (!val) throw NullPointerException(); }
-
-    void Swap(RejectNull&)
-    {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct RejectNullStrict
-///
-///  \ingroup  SmartPointerCheckingGroup
-///  Implementation of the CheckingPolicy used by SmartPtr
-///  Checks the pointer upon initialization and before dereference
-////////////////////////////////////////////////////////////////////////////////
-
-template <class P>
-struct RejectNullStrict
-{
-    RejectNullStrict()
-    {}
-
-    template <class P1>
-    RejectNullStrict(const RejectNullStrict<P1>&)
-    {}
-
-    template <class P1>
-    RejectNullStrict(const RejectNull<P1>&)
-    {}
-
-    static void OnInit(P val)
-    { if (!val) throw NullPointerException(); }
-
-    void OnDereference(P val)
-    { OnInit(val); }
-
-    void OnDereference(P val) const
-    { OnInit(val); }
-
-    void Swap(RejectNullStrict&)
-    {}
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SmartPtr (declaration)
-// The reason for all the fuss above
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OwnershipPolicy = RefCounted,
-         class ConversionPolicy = DisallowConversion,
-         template <class> class CheckingPolicy = AssertCheck,
-         template <class> class StoragePolicy = DefaultSPStorage,
-         template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
-         >
-class SmartPtr;
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SmartPtrDef (definition)
-// this class added to unify the usage of SmartPtr
-// instead of writing SmartPtr<T,OP,CP,KP,SP> write SmartPtrDef<T,OP,CP,KP,SP>::type
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OwnershipPolicy = RefCounted,
-         class ConversionPolicy = DisallowConversion,
-         template <class> class CheckingPolicy = AssertCheck,
-         template <class> class StoragePolicy = DefaultSPStorage,
-         template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
-         >
-struct SmartPtrDef
-{
-    typedef SmartPtr
-    <
-    T,
-    OwnershipPolicy,
-    ConversionPolicy,
-    CheckingPolicy,
-    StoragePolicy,
-    ConstnessPolicy
-    >
-    type;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class SmartPtr
-///
-///  \ingroup SmartPointerGroup
-///
-///  \param OwnershipPolicy  default =  RefCounted,
-///  \param ConversionPolicy default = DisallowConversion,
-///  \param CheckingPolicy default = AssertCheck,
-///  \param StoragePolicy default = DefaultSPStorage
-///  \param ConstnessPolicy default = LOKI_DEFAULT_CONSTNESS
-///
-///  \par IMPORTANT NOTE
-///  Due to threading issues, the OwnershipPolicy has been changed as follows:
-///
-///     - Release() returns a boolean saying if that was the last release
-///        so the pointer can be deleted by the StoragePolicy
-///     - IsUnique() was removed
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OwnershipPolicy,
-         class ConversionPolicy,
-         template <class> class CheckingPolicy,
-         template <class> class StoragePolicy,
-         template <class> class ConstnessPolicy
-         >
-class SmartPtr
-    : public StoragePolicy<T>
-    , public OwnershipPolicy<typename StoragePolicy<T>::InitPointerType>
-    , public CheckingPolicy<typename StoragePolicy<T>::StoredType>
-    , public ConversionPolicy
-{
-    typedef StoragePolicy<T> SP;
-    typedef OwnershipPolicy<typename StoragePolicy<T>::InitPointerType> OP;
-    typedef CheckingPolicy<typename StoragePolicy<T>::StoredType> KP;
-    typedef ConversionPolicy CP;
-
-public:
-    typedef typename ConstnessPolicy<T>::Type* ConstPointerType;
-    typedef typename ConstnessPolicy<T>::Type& ConstReferenceType;
-
-    typedef typename SP::PointerType PointerType;
-    typedef typename SP::StoredType StoredType;
-    typedef typename SP::ReferenceType ReferenceType;
-
-    typedef typename Select<OP::destructiveCopy, SmartPtr, const SmartPtr>::Result
-    CopyArg;
-
-private:
-    struct NeverMatched {};
-
-#ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY
-    typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg;
-    typedef typename Select < !CP::allow, const StoredType&, NeverMatched >::Result ExplicitArg;
-#else
-    typedef const StoredType& ImplicitArg;
-    typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg;
-#endif
-
-public:
-
-    SmartPtr()
-    {
-        KP::OnDefault(GetImpl(*this));
-    }
-
-    explicit
-    SmartPtr(ExplicitArg p) : SP(p)
-    {
-        KP::OnInit(GetImpl(*this));
-    }
-
-    SmartPtr(ImplicitArg p) : SP(p)
-    {
-        KP::OnInit(GetImpl(*this));
-    }
-
-    SmartPtr(CopyArg& rhs) : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
-    {
-        GetImplRef(*this) = OP::Clone(GetImplRef(rhs));
-    }
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    SmartPtr(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
-        : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
-    { GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); }
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    SmartPtr(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
-        : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
-    {
-        GetImplRef(*this) = OP::Clone(GetImplRef(rhs));
-    }
-
-    SmartPtr(RefToValue<SmartPtr> rhs)
-        : SP(rhs), OP(rhs), KP(rhs), CP(rhs)
-    {}
-
-    operator RefToValue<SmartPtr>()
-    { return RefToValue<SmartPtr>(*this); }
-
-    SmartPtr& operator=(CopyArg& rhs)
-    {
-        SmartPtr temp(rhs);
-        temp.Swap(*this);
-        return *this;
-    }
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    SmartPtr& operator=(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
-    {
-        SmartPtr temp(rhs);
-        temp.Swap(*this);
-        return *this;
-    }
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    SmartPtr& operator=(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
-    {
-        SmartPtr temp(rhs);
-        temp.Swap(*this);
-        return *this;
-    }
-
-    void Swap(SmartPtr& rhs)
-    {
-        OP::Swap(rhs);
-        CP::Swap(rhs);
-        KP::Swap(rhs);
-        SP::Swap(rhs);
-    }
-
-    ~SmartPtr()
-    {
-        if (OP::Release(GetImpl(*static_cast<SP*>(this))))
-        {
-            SP::Destroy();
-        }
-    }
-
-#ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
-
-    // old non standard in class definition of friends
-    friend inline void Release(SmartPtr& sp, typename SP::StoredType& p)
-    {
-        p = GetImplRef(sp);
-        GetImplRef(sp) = SP::Default();
-    }
-
-    friend inline void Reset(SmartPtr& sp, typename SP::StoredType p)
-    { SmartPtr(p).Swap(sp); }
-
-#else
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    friend void Release(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1>& sp,
-                        typename SP1<T1>::StoredType& p);
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    friend void Reset(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1>& sp,
-                      typename SP1<T1>::StoredType p);
-#endif
-
-
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    bool Merge( SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
-    {
-        if ( GetImpl( *this ) != GetImpl( rhs ) )
-        {
-            return false;
-        }
-        return OP::template Merge( rhs );
-    }
-
-    PointerType operator->()
-    {
-        KP::OnDereference(GetImplRef(*this));
-        return SP::operator->();
-    }
-
-    ConstPointerType operator->() const
-    {
-        KP::OnDereference(GetImplRef(*this));
-        return SP::operator->();
-    }
-
-    ReferenceType operator*()
-    {
-        KP::OnDereference(GetImplRef(*this));
-        return SP::operator*();
-    }
-
-    ConstReferenceType operator*() const
-    {
-        KP::OnDereference(GetImplRef(*this));
-        return SP::operator*();
-    }
-
-    bool operator!() const // Enables "if (!sp) ..."
-    { return GetImpl(*this) == 0; }
-
-    static inline T* GetPointer( const SmartPtr& sp )
-    { return GetImpl( sp ); }
-
-    // Ambiguity buster
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    bool operator==(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const
-    { return GetImpl(*this) == GetImpl(rhs); }
-
-    // Ambiguity buster
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    bool operator!=(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const
-    { return !(*this == rhs); }
-
-    // Ambiguity buster
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    bool operator<(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const
-    { return GetImpl(*this) < GetImpl(rhs); }
-
-    // Ambiguity buster
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    inline bool operator > ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
-    {
-        return ( GetImpl( rhs ) < GetImpl( *this ) );
-    }
-
-    // Ambiguity buster
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    inline bool operator <= ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
-    {
-        return !( GetImpl( rhs ) < GetImpl( *this ) );
-    }
-
-    // Ambiguity buster
-    template
-    <
-    typename T1,
-             template <class> class OP1,
-             class CP1,
-             template <class> class KP1,
-             template <class> class SP1,
-             template <class> class CNP1
-             >
-    inline bool operator >= ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs )
-    {
-        return !( GetImpl( *this ) < GetImpl( rhs ) );
-    }
-
-private:
-    // Helper for enabling 'if (sp)'
-    struct Tester
-    {
-        Tester(int) {}
-        void dummy() {}
-    };
-
-    typedef void (Tester::*unspecified_boolean_type_)();
-
-    typedef typename Select<CP::allow, Tester, unspecified_boolean_type_>::Result
-    unspecified_boolean_type;
-
-public:
-    // enable 'if (sp)'
-    operator unspecified_boolean_type() const
-    {
-        return !*this ? 0 : &Tester::dummy;
-    }
-
-private:
-    // Helper for disallowing automatic conversion
-    struct Insipid
-    {
-        Insipid(PointerType) {}
-    };
-
-    typedef typename Select<CP::allow, PointerType, Insipid>::Result
-    AutomaticConversionResult;
-
-public:
-    operator AutomaticConversionResult() const
-    { return GetImpl(*this); }
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-// friends
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP
-         >
-inline void Release(SmartPtr<T, OP, CP, KP, SP, CNP>& sp,
-                    typename SP<T>::StoredType& p)
-{
-    p = GetImplRef(sp);
-    GetImplRef(sp) = SP<T>::Default();
-}
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP
-         >
-inline void Reset(SmartPtr<T, OP, CP, KP, SP, CNP>& sp,
-                  typename SP<T>::StoredType p)
-{ SmartPtr<T, OP, CP, KP, SP, CNP>(p).Swap(sp); }
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// free comparison operators for class template SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator== for lhs = SmartPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP1,
-         typename U
-         >
-inline bool operator==(const SmartPtr<T, OP, CP, KP, SP, CNP1 >& lhs,
-                       U* rhs)
-{ return GetImpl(lhs) == rhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator== for lhs = raw pointer, rhs = SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP1,
-         typename U
-         >
-inline bool operator==(U* lhs,
-                       const SmartPtr<T, OP, CP, KP, SP, CNP1 >& rhs)
-{ return rhs == lhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator!= for lhs = SmartPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator!=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
-                       U* rhs)
-{ return !(lhs == rhs); }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator!= for lhs = raw pointer, rhs = SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator!=(U* lhs,
-                       const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
-{ return rhs != lhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator< for lhs = SmartPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator<(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
-                      U* rhs)
-{
-    return ( GetImpl( lhs ) < rhs );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator< for lhs = raw pointer, rhs = SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator<(U* lhs,
-                      const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
-{
-    return ( GetImpl( rhs ) < lhs );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//  operator> for lhs = SmartPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator>(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
-                      U* rhs)
-{ return rhs < lhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator> for lhs = raw pointer, rhs = SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator>(U* lhs,
-                      const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
-{ return rhs < lhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator<= for lhs = SmartPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator<=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
-                       U* rhs)
-{ return !(rhs < lhs); }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator<= for lhs = raw pointer, rhs = SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator<=(U* lhs,
-                       const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
-{ return !(rhs < lhs); }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator>= for lhs = SmartPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator>=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
-                       U* rhs)
-{ return !(lhs < rhs); }
-
-////////////////////////////////////////////////////////////////////////////////
-///  operator>= for lhs = raw pointer, rhs = SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP,
-         typename U
-         >
-inline bool operator>=(U* lhs,
-                       const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs)
-{ return !(lhs < rhs); }
-
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-///  specialization of std::less for SmartPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-namespace std
-{
-template
-<
-typename T,
-         template <class> class OP,
-         class CP,
-         template <class> class KP,
-         template <class> class SP,
-         template <class> class CNP
-         >
-struct less< Loki::SmartPtr<T, OP, CP, KP, SP, CNP > >
-        : public binary_function < Loki::SmartPtr<T, OP, CP, KP, SP, CNP >,
-          Loki::SmartPtr<T, OP, CP, KP, SP, CNP >, bool >
-{
-    bool operator()(const Loki::SmartPtr<T, OP, CP, KP, SP, CNP >& lhs,
-                    const Loki::SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) const
-    { return less<T*>()(GetImpl(lhs), GetImpl(rhs)); }
-};
-}
-
-#endif // end file guardian
-
diff --git a/shared/loki/StrongPtr.h b/shared/loki/StrongPtr.h
deleted file mode 100644
index 868eb48f..00000000
--- a/shared/loki/StrongPtr.h
+++ /dev/null
@@ -1,1697 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// The Loki Library
-// Copyright (c) 2006 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.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_STRONG_PTR_INC_
-#define LOKI_STRONG_PTR_INC_
-
-// $Id: StrongPtr.h 914 2008-12-19 00:39:29Z rich_sposato $
-
-
-#include <loki/SmartPtr.h>
-#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
-#include <loki/Threads.h>
-#endif
-
-
-////////////////////////////////////////////////////////////////////////////////
-///
-///  \par Terminology
-///   These terms are used within this file's comments.
-///   -# StrongPtr : Class used to implement both strong and weak pointers. The
-///      second template parameter determines if a StrongPtr is weak or strong.
-///   -# Strong pointer : A pointer that claims ownership of a shared object.
-///      When the last strong copointer dies, the object is destroyed even if
-///      there are weak copointers.
-///   -# Weak pointer : A pointer that does not own the shared object it points
-///       to.  It only destroys the shared object if there no strong copointers
-///       exist when it dies.
-///   -# Copointers : All the pointers that refer to the same shared object.
-///      The copointers must have the same ownership policy, but the other
-///      policies may be different.
-///   -# Pointee : The shared object.
-///
-///  \par OwnershipPolicy
-///   The ownership policy has the pointer to the actual object, and it also
-///   keeps track of the strong and weak copointers so that it can know if any
-///   strong copointers remain.  The plain pointer it maintains is stored as a
-///   void pointer, which allows the ownership policy classes to be monolithic
-///   classes instead of template classes.  As monolithic classes, they reduce
-///   amount of code-bloat.
-///
-///  \par Writing Your Own OwnershipPolicy
-///   If you write your own policy, you must implement these 12 functions:
-///   -# explicit YourPolicy( bool strong )
-///   -# YourPolicy( void * p, bool strong )
-///   -# YourPolicy( const YourPolicy & rhs, bool strong )
-///   -# bool Release( bool strong )
-///   -# void Increment( bool strong )
-///   -# bool Decrement( bool strong )
-///   -# bool HasStrongPointer( void ) const
-///   -# void Swap( YourPolicy & rhs )
-///   -# void SetPointer( void * p )
-///   -# void ZapPointer( void )
-///   -# void * GetPointer( void ) const
-///   -# void * & GetPointerRef( void ) const
-///   It is strongly recommended that all 12 of these functions be protected
-///   instead of public.  These two functions are optional for single-threaded
-///   policies, but required for multi-threaded policies:
-///   -# void Lock( void ) const
-///   -# void Unlock( void ) const
-///   This function is entirely optional:
-///   -# bool Merge( TwoRefLinks & rhs )
-///
-///  \par DeletePolicy
-///   The delete policy provides a mechanism to destroy an object and a default
-///   value for an uninitialized pointer.  You can override this policy with
-///   your own when using the Singleton, NullObject, or Prototype design
-///   patterns.
-///
-///  \par Writing Your Own DeletePolicy
-///   If you write your own policy, you must implement these 3 functions:
-///   -# void static Delete( const P * p )
-///   -# static P * Default( void )
-///   -# void Swap( YourResetPolicy & )
-///
-///  \par ResetPolicy
-///   A reset policy tells the ReleaseAll and ResetAll functions whether they
-///   should release or reset the StrongPtr copointers.  These functions do
-///   not affect just one StrongPtr, but all copointers.  That is unlike
-///   SmartPtr where the Release and Reset functions only affect 1 SmartPtr,
-///   and leave all copointers untouched.  A useful trick you can do with the
-///   ResetPolicy is to not allow reset when a strong pointer exists, and then
-///   use the NoCheck policy for all strong pointers.  The reset policy
-///   guarantees the strong pointers always have a valid pointee, so checking
-///   is not required; but weak pointers may still require checking.
-///
-///  \par Writing Your Own ResetPolicy
-///   If you write your own policy, you must implement these 2 functions:
-///   -# bool OnReleaseAll( bool ) const
-///   -# bool OnResetAll( bool ) const
-///   The bool parameter means that this was called with a strong pointer or
-///   one of its copointers is strong.  The return value means the pointer
-///   can be reset or released.
-///
-///  \defgroup  StrongPointerOwnershipGroup StrongPtr Ownership policies
-///  \ingroup   SmartPointerGroup
-///  \defgroup  StrongPointerDeleteGroup Delete policies
-///  \ingroup   SmartPointerGroup
-///  \defgroup  StrongPointerResetGroup Reset policies
-///  \ingroup   SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-
-
-namespace Loki
-{
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DeleteUsingFree
-///
-///  \ingroup  StrongPointerDeleteGroup
-///  Implementation of the DeletePolicy used by StrongPtr.  Uses explicit call
-///   to T's destructor followed by call to free.  This policy is useful for
-///   managing the lifetime of pointers to structs returned by C functions.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-class DeleteUsingFree
-{
-public:
-    inline void static Delete( const P* p )
-    {
-        if ( 0 != p )
-        {
-            p->~P();
-            ::free( p );
-        }
-    }
-
-    /// Provides default value to initialize the pointer
-    inline static P* Default( void )
-    {
-        return 0;
-    }
-
-    inline void Swap( DeleteUsingFree& ) {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DeleteNothing
-///
-///  \ingroup  StrongPointerDeleteGroup
-///  Implementation of the DeletePolicy used by StrongPtr.  This will never
-///   delete anything.  You can use this policy with pointers to an undefined
-///   type or a pure interface class with a protected destructor.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-class DeleteNothing
-{
-public:
-    inline static void Delete( const P* )
-    {
-        // Do nothing at all!
-    }
-
-    inline static P* Default( void )
-    {
-        return 0;
-    }
-
-    inline void Swap( DeleteNothing& ) {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DeleteSingle
-///
-///  \ingroup  StrongPointerDeleteGroup
-///  Implementation of the DeletePolicy used by StrongPtr.  This deletes just
-///   one shared object.  This is the default class for the DeletePolicy.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-class DeleteSingle
-{
-public:
-    inline static void Delete( const P* p )
-    {
-        /** @note If you see an error message about a negative subscript, that
-         means your are attempting to use Loki to delete an incomplete type.
-         Please don't use this policy with incomplete types; you may want to
-         use DeleteNothing instead.
-         */
-        typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ];
-        delete p;
-    }
-
-    inline static P* Default( void )
-    {
-        return 0;
-    }
-
-    inline void Swap( DeleteSingle& ) {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class DeleteArray
-///
-///  \ingroup  StrongPointerDeleteGroup
-///  Implementation of the DeletePolicy used by StrongPtr.  This deletes an
-///   array of shared objects.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-class DeleteArray
-{
-public:
-    inline static void Delete( const P* p )
-    {
-        /** @note If you see an error message about a negative subscript, that
-         means your are attempting to use Loki to delete an incomplete type.
-         Please don't use this policy with incomplete types; you may want to
-         use DeleteNothing instead.
-         */
-        typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ];
-        delete [] p;
-    }
-
-    inline static P* Default( void )
-    {
-        return 0;
-    }
-
-    inline void Swap( DeleteArray& ) {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class CantResetWithStrong
-///
-///  \ingroup  StrongPointerResetGroup
-///  Implementation of the ResetPolicy used by StrongPtr.  This is the default
-///   ResetPolicy for StrongPtr.  It forbids reset and release only if a strong
-///   copointer exists.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-struct CantResetWithStrong
-{
-    inline bool OnReleaseAll( bool hasStrongPtr ) const
-    {
-        return ! hasStrongPtr;
-    }
-
-    inline bool OnResetAll( bool hasStrongPtr ) const
-    {
-        return ! hasStrongPtr;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class AllowReset
-///
-///  \ingroup  StrongPointerResetGroup
-///  Implementation of the ResetPolicy used by StrongPtr.  It allows reset and
-///   release under any circumstance.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-struct AllowReset
-{
-    inline bool OnReleaseAll( bool ) const
-    {
-        return true;
-    }
-    inline bool OnResetAll( bool ) const
-    {
-        return true;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class NeverReset
-///
-///  \ingroup  StrongPointerResetGroup
-///  Implementation of the ResetPolicy used by StrongPtr.  It forbids reset and
-///   release under any circumstance.
-////////////////////////////////////////////////////////////////////////////////
-
-template < class P >
-struct NeverReset
-{
-    inline bool OnReleaseAll( bool ) const
-    {
-        return false;
-    }
-    inline bool OnResetAll( bool ) const
-    {
-        return false;
-    }
-};
-
-// ----------------------------------------------------------------------------
-
-namespace Private
-{
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class TwoRefCountInfo
-///
-///  \ingroup  StrongPointerOwnershipGroup
-///   Implementation detail for reference counting strong and weak pointers.
-///   It maintains a void pointer and 2 reference counts.  Since it is just a
-///   class for managing implementation details, it is not intended to be used
-///   directly - which is why it is in a private namespace.  Each instance is a
-///   shared resource for all copointers, and there should be only one of these
-///   for each set of copointers.  This class is small, trivial, and inline.
-////////////////////////////////////////////////////////////////////////////////
-
-class LOKI_EXPORT TwoRefCountInfo
-{
-public:
-
-    inline explicit TwoRefCountInfo( bool strong )
-        : m_pointer( 0 )
-        , m_strongCount( strong ? 1 : 0 )
-        , m_weakCount( strong ? 0 : 1 )
-    {
-    }
-
-    inline TwoRefCountInfo( void* p, bool strong )
-        : m_pointer( p )
-        , m_strongCount( strong ? 1 : 0 )
-        , m_weakCount( strong ? 0 : 1 )
-    {
-    }
-
-    inline ~TwoRefCountInfo( void )
-    {
-        assert( 0 == m_strongCount );
-        assert( 0 == m_weakCount );
-    }
-
-    inline bool HasStrongPointer( void ) const
-    {
-        return ( 0 < m_strongCount );
-    }
-
-    inline bool HasWeakPointer( void ) const
-    {
-        return ( 0 < m_weakCount );
-    }
-
-    inline void IncStrongCount( void )
-    {
-        ++m_strongCount;
-    }
-
-    inline void IncWeakCount( void )
-    {
-        ++m_weakCount;
-    }
-
-    inline bool DecStrongCount( void )
-    {
-        assert( 0 < m_strongCount );
-        --m_strongCount;
-        const bool isZero = ( 0 == m_strongCount );
-        return isZero;
-    }
-
-    inline void DecWeakCount( void )
-    {
-        assert( 0 < m_weakCount );
-        --m_weakCount;
-    }
-
-    inline void ZapPointer( void )
-    {
-        m_pointer = 0;
-    }
-
-    void SetPointer( void* p )
-    {
-        m_pointer = p;
-    }
-
-    inline void* GetPointer( void ) const
-    {
-        return m_pointer;
-    }
-
-    inline void*& GetPointerRef( void ) const
-    {
-        return const_cast< void *& >( m_pointer );
-    }
-
-private:
-    /// Copy-constructor not implemented.
-    TwoRefCountInfo( const TwoRefCountInfo& );
-    /// Copy-assignment operator not implemented.
-    TwoRefCountInfo& operator = ( const TwoRefCountInfo& );
-
-    void* m_pointer;
-    unsigned int m_strongCount;
-    unsigned int m_weakCount;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class LockableTwoRefCountInfo
-///
-///  \ingroup  StrongPointerOwnershipGroup
-///   Implementation detail for thread-safe reference counting for strong and
-///   weak pointers.  It uses TwoRefCountInfo to manage the pointer and counts.
-///   All this does is provide a thread safety mechanism.  Since it is just a
-///   class for managing implementation details, it is not intended to be used
-///   directly - which is why it is in a private namespace.  Each instance is a
-///   shared resource for all copointers, and there should be only one of these
-///   for each set of copointers.  This class is small, trivial, and inline.
-///
-///  \note This class is not designed for use with a single-threaded model.
-///   Tests using a single-threaded model will not run properly, but tests in a
-///   multi-threaded model with either class-level-locking or object-level-locking
-///   do run properly.
-////////////////////////////////////////////////////////////////////////////////
-
-#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
-
-class LOKI_EXPORT LockableTwoRefCountInfo
-    : private Loki::Private::TwoRefCountInfo
-{
-public:
-
-    inline explicit LockableTwoRefCountInfo( bool strong )
-        : TwoRefCountInfo( strong )
-        , m_Mutex()
-    {
-    }
-
-    LockableTwoRefCountInfo( void* p, bool strong )
-        : TwoRefCountInfo( p, strong )
-        , m_Mutex()
-    {
-    }
-
-    inline ~LockableTwoRefCountInfo( void )
-    {
-    }
-
-    inline void Lock( void ) const
-    {
-        m_Mutex.Lock();
-    }
-
-    inline void Unlock( void ) const
-    {
-        m_Mutex.Unlock();
-    }
-
-    inline bool HasStrongPointer( void ) const
-    {
-        m_Mutex.Lock();
-        const bool has = TwoRefCountInfo::HasStrongPointer();
-        m_Mutex.Unlock();
-        return has;
-    }
-
-    inline bool HasWeakPointer( void ) const
-    {
-        m_Mutex.Lock();
-        const bool has = TwoRefCountInfo::HasWeakPointer();
-        m_Mutex.Unlock();
-        return has;
-    }
-
-    inline void IncStrongCount( void )
-    {
-        m_Mutex.Lock();
-        TwoRefCountInfo::IncStrongCount();
-        m_Mutex.Unlock();
-    }
-
-    inline void IncWeakCount( void )
-    {
-        m_Mutex.Lock();
-        TwoRefCountInfo::IncWeakCount();
-        m_Mutex.Unlock();
-    }
-
-    inline bool DecStrongCount( void )
-    {
-        m_Mutex.Lock();
-        const bool isZero = TwoRefCountInfo::DecStrongCount();
-        m_Mutex.Unlock();
-        return isZero;
-    }
-
-    inline void DecWeakCount( void )
-    {
-        m_Mutex.Lock();
-        TwoRefCountInfo::DecWeakCount();
-        m_Mutex.Unlock();
-    }
-
-    inline void ZapPointer( void )
-    {
-        m_Mutex.Lock();
-        TwoRefCountInfo::ZapPointer();
-        m_Mutex.Unlock();
-    }
-
-    void SetPointer( void* p )
-    {
-        m_Mutex.Lock();
-        TwoRefCountInfo::SetPointer( p );
-        m_Mutex.Unlock();
-    }
-
-    inline void* GetPointer( void ) const
-    {
-        return TwoRefCountInfo::GetPointer();
-    }
-
-    inline void*& GetPointerRef( void ) const
-    {
-        return TwoRefCountInfo::GetPointerRef();
-    }
-
-private:
-    /// Default constructor is not available.
-    LockableTwoRefCountInfo( void );
-    /// Copy constructor is not available.
-    LockableTwoRefCountInfo( const LockableTwoRefCountInfo& );
-    /// Copy-assignment operator is not available.
-    LockableTwoRefCountInfo& operator = ( const LockableTwoRefCountInfo& );
-
-    mutable LOKI_DEFAULT_MUTEX m_Mutex;
-};
-
-#endif // if object-level-locking or class-level-locking
-
-} // end namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class TwoRefCounts
-///
-///  \ingroup  StrongPointerOwnershipGroup
-///   This implementation of StrongPtr's OwnershipPolicy uses a pointer to a
-///   shared instance of TwoRefCountInfo.  This is the default policy for
-///   OwnershipPolicy.  Some functions are trivial enough to be inline, while
-///   others are implemented elsewhere.  It is not thread safe, and is intended
-///   for single-threaded environments.
-////////////////////////////////////////////////////////////////////////////////
-
-class LOKI_EXPORT TwoRefCounts
-{
-protected:
-
-    explicit TwoRefCounts( bool strong );
-
-    TwoRefCounts( const void* p, bool strong );
-
-    TwoRefCounts( const TwoRefCounts& rhs, bool strong ) :
-        m_counts( rhs.m_counts )
-    {
-        Increment( strong );
-    }
-
-    /** The destructor does not need to do anything since the call to
-     ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which
-     this dtor would have done.
-     */
-    inline ~TwoRefCounts( void ) {}
-
-    inline bool Release( bool strong )
-    {
-        return Decrement( strong );
-    }
-
-    bool HasStrongPointer( void ) const
-    {
-        return m_counts->HasStrongPointer();
-    }
-
-    void Swap( TwoRefCounts& rhs );
-
-    void SetPointer( void* p )
-    {
-        m_counts->SetPointer( p );
-    }
-
-    void ZapPointer( void );
-
-    inline void*& GetPointerRef( void ) const
-    {
-        return m_counts->GetPointerRef();
-    }
-
-    inline void* GetPointer( void ) const
-    {
-        return m_counts->GetPointer();
-    }
-
-private:
-    TwoRefCounts( void );
-    TwoRefCounts& operator = ( const TwoRefCounts& );
-
-    void Increment( bool strong );
-
-    bool Decrement( bool strong );
-
-    /// Pointer to all shared data.
-    Loki::Private::TwoRefCountInfo* m_counts;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class LockableTwoRefCounts
-///
-///  \ingroup  StrongPointerOwnershipGroup
-///   This implementation of StrongPtr's OwnershipPolicy uses a pointer to a
-///   shared instance of LockableTwoRefCountInfo.  It behaves very similarly to
-///   TwoRefCounts, except that it provides thread-safety.  Some functions are
-///   trivial enough to be inline, while others are implemented elsewhere.
-///
-///  \note This class is not designed for use with a single-threaded model.
-///   Tests using a single-threaded model will not run properly, but tests in a
-///   multi-threaded model with either class-level-locking or object-level-locking
-///   do run properly.
-////////////////////////////////////////////////////////////////////////////////
-
-#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
-
-class LOKI_EXPORT LockableTwoRefCounts
-{
-    typedef SmallValueObject< ::Loki::ClassLevelLockable > ThreadSafePointerAllocator;
-
-protected:
-
-    explicit LockableTwoRefCounts( bool strong )
-        : m_counts( NULL )
-    {
-        void* temp = ThreadSafePointerAllocator::operator new(
-                         sizeof(Loki::Private::LockableTwoRefCountInfo) );
-#ifdef DO_EXTRA_LOKI_TESTS
-        assert( temp != 0 );
-#endif
-        m_counts = new ( temp ) Loki::Private::LockableTwoRefCountInfo( strong );
-    }
-
-    LockableTwoRefCounts( const void* p, bool strong )
-        : m_counts( NULL )
-    {
-        void* temp = ThreadSafePointerAllocator::operator new(
-                         sizeof(Loki::Private::LockableTwoRefCountInfo) );
-#ifdef DO_EXTRA_LOKI_TESTS
-        assert( temp != 0 );
-#endif
-        void* p2 = const_cast< void* >( p );
-        m_counts = new ( temp )
-        Loki::Private::LockableTwoRefCountInfo( p2, strong );
-    }
-
-    LockableTwoRefCounts( const LockableTwoRefCounts& rhs, bool strong ) :
-        m_counts( rhs.m_counts )
-    {
-        Increment( strong );
-    }
-
-    /** The destructor does not need to do anything since the call to
-     ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which
-     this dtor would have done.
-     */
-    inline ~LockableTwoRefCounts( void ) {}
-
-    inline void Lock( void ) const
-    {
-        m_counts->Lock();
-    }
-
-    inline void Unlock( void ) const
-    {
-        m_counts->Unlock();
-    }
-
-    inline bool Release( bool strong )
-    {
-        return Decrement( strong );
-    }
-
-    void Increment( bool strong )
-    {
-        if ( strong )
-        {
-            m_counts->IncStrongCount();
-        }
-        else
-        {
-            m_counts->IncWeakCount();
-        }
-    }
-
-    bool Decrement( bool strong )
-    {
-        bool noStrongPointers = false;
-        if ( strong )
-        {
-            noStrongPointers = m_counts->DecStrongCount();
-        }
-        else
-        {
-            m_counts->DecWeakCount();
-            noStrongPointers = !m_counts->HasStrongPointer();
-        }
-        return noStrongPointers;
-    }
-
-    bool HasStrongPointer( void ) const
-    {
-        return m_counts->HasStrongPointer();
-    }
-
-    void Swap( LockableTwoRefCounts& rhs )
-    {
-        std::swap( m_counts, rhs.m_counts );
-    }
-
-    void SetPointer( void* p )
-    {
-        m_counts->SetPointer( p );
-    }
-
-    void ZapPointer( void )
-    {
-#ifdef DO_EXTRA_LOKI_TESTS
-        assert( !m_counts->HasStrongPointer() );
-#endif
-        if ( m_counts->HasWeakPointer() )
-        {
-            m_counts->ZapPointer();
-        }
-        else
-        {
-            ThreadSafePointerAllocator::operator delete ( m_counts,
-                                                          sizeof(Loki::Private::LockableTwoRefCountInfo) );
-            m_counts = NULL;
-        }
-    }
-
-    inline void* GetPointer( void ) const
-    {
-        return m_counts->GetPointer();
-    }
-
-    inline void*& GetPointerRef( void ) const
-    {
-        return m_counts->GetPointerRef();
-    }
-
-private:
-    LockableTwoRefCounts( void );
-    LockableTwoRefCounts& operator = ( const LockableTwoRefCounts& );
-
-    /// Pointer to all shared data.
-    Loki::Private::LockableTwoRefCountInfo* m_counts;
-};
-
-#endif // if object-level-locking or class-level-locking
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class TwoRefLinks
-///
-///  \ingroup  StrongPointerOwnershipGroup
-///   This implementation of StrongPtr's OwnershipPolicy uses a doubly-linked
-///   cycle of copointers to a shared object. Some functions are trivial enough
-///   to be inline, while others are implemented in elsewhere.  It is not thread
-///   safe, and is intended for single-threaded environments.
-////////////////////////////////////////////////////////////////////////////////
-
-class LOKI_EXPORT TwoRefLinks
-{
-protected:
-
-    inline explicit TwoRefLinks( bool strong )
-        : m_pointer( 0 )
-        , m_strong( strong )
-    {
-        m_prev = m_next = this;
-    }
-
-    TwoRefLinks( const void* p, bool strong );
-
-    TwoRefLinks( const TwoRefLinks& rhs, bool strong );
-
-    bool Release( bool strong );
-
-    void Swap( TwoRefLinks& rhs );
-
-    bool Merge( TwoRefLinks& rhs );
-
-    bool HasStrongPointer( void ) const;
-
-    inline void ZapPointer( void )
-    {
-        ZapAllNodes();
-    }
-
-    void SetPointer( void* p );
-
-    inline void* GetPointer( void ) const
-    {
-        return m_pointer;
-    }
-
-    inline void*& GetPointerRef( void ) const
-    {
-        return const_cast< void *& >( m_pointer );
-    }
-
-private:
-    static unsigned int CountPrevCycle( const TwoRefLinks* pThis );
-    static unsigned int CountNextCycle( const TwoRefLinks* pThis );
-
-    /// Not implemented.
-    TwoRefLinks( void );
-    /// Not implemented.
-    TwoRefLinks& operator = ( const TwoRefLinks& );
-
-    bool HasPrevNode( const TwoRefLinks* p ) const;
-    bool HasNextNode( const TwoRefLinks* p ) const;
-    bool AllNodesHaveSamePointer( void ) const;
-    void ZapAllNodes( void );
-
-    void* m_pointer;
-    mutable TwoRefLinks* m_prev;
-    mutable TwoRefLinks* m_next;
-    const bool m_strong;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class StrongPtr
-///
-///  \ingroup SmartPointerGroup
-///
-///  \param Strong           default = true,
-///  \param OwnershipPolicy  default = TwoRefCounts,
-///  \param ConversionPolicy default = DisallowConversion,
-///  \param CheckingPolicy   default = AssertCheck,
-///  \param ResetPolicy      default = CantResetWithStrong,
-///  \param DeletePolicy     default = DeleteSingle
-///  \param ConstnessPolicy  default = LOKI_DEFAULT_CONSTNESS
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T,
-         bool Strong = true,
-         class OwnershipPolicy = Loki::TwoRefCounts,
-         class ConversionPolicy = Loki::DisallowConversion,
-         template < class > class CheckingPolicy = Loki::AssertCheck,
-         template < class > class ResetPolicy = Loki::CantResetWithStrong,
-         template < class > class DeletePolicy = Loki::DeleteSingle,
-         template < class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
-         >
-class StrongPtr
-    : public OwnershipPolicy
-    , public ConversionPolicy
-    , public CheckingPolicy< T* >
-    , public ResetPolicy< T >
-    , public DeletePolicy< T >
-{
-    typedef ConversionPolicy CP;
-    typedef CheckingPolicy< T* > KP;
-    typedef ResetPolicy< T > RP;
-    typedef DeletePolicy< T > DP;
-
-public:
-
-    typedef OwnershipPolicy OP;
-
-    typedef T* StoredType;     // the type of the pointer
-    typedef T* PointerType;    // type returned by operator->
-    typedef T& ReferenceType;  // type returned by operator*
-
-    typedef typename ConstnessPolicy< T >::Type* ConstPointerType;
-    typedef typename ConstnessPolicy< T >::Type& ConstReferenceType;
-
-private:
-    struct NeverMatched {};
-
-#ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY
-    typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg;
-    typedef typename Select < !CP::allow, const StoredType&, NeverMatched >::Result ExplicitArg;
-#else
-    typedef const StoredType& ImplicitArg;
-    typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg;
-#endif
-
-public:
-
-    StrongPtr( void ) : OP( Strong )
-    {
-        KP::OnDefault( GetPointer() );
-    }
-
-    explicit StrongPtr( ExplicitArg p ) : OP( p, Strong )
-    {
-        KP::OnInit( GetPointer() );
-    }
-
-    StrongPtr( ImplicitArg p ) : OP( p, Strong )
-    {
-        KP::OnInit( GetPointer() );
-    }
-
-    StrongPtr( const StrongPtr& rhs )
-        : OP( rhs, Strong ), CP( rhs ), KP( rhs ), DP( rhs )
-    {
-    }
-
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    StrongPtr(
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
-        : OP( rhs, Strong )
-    {
-    }
-
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    StrongPtr(
-        StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
-        : OP( rhs, Strong )
-    {
-    }
-
-    StrongPtr( RefToValue< StrongPtr > rhs )
-        : OP( rhs, Strong ), KP( rhs ), CP( rhs ), DP( rhs )
-    {
-    }
-
-    operator RefToValue< StrongPtr >( void )
-    {
-        return RefToValue< StrongPtr >( *this );
-    }
-
-    StrongPtr& operator = ( const StrongPtr& rhs )
-    {
-        if ( GetPointer() != rhs.GetPointer() )
-        {
-            StrongPtr temp( rhs );
-            temp.Swap( *this );
-        }
-        return *this;
-    }
-
-    StrongPtr& operator = ( T* p )
-    {
-        if ( GetPointer() != p )
-        {
-            StrongPtr temp( p );
-            Swap( temp );
-        }
-        return *this;
-    }
-
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    StrongPtr& operator = (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
-    {
-        if ( !rhs.Equals( GetPointer() ) )
-        {
-            StrongPtr temp( rhs );
-            temp.Swap( *this );
-        }
-        return *this;
-    }
-
-    bool IsStrong( void ) const
-    {
-        return Strong;
-    }
-
-    void Swap( StrongPtr& rhs )
-    {
-        OP::Swap( rhs );
-        CP::Swap( rhs );
-        KP::Swap( rhs );
-        DP::Swap( rhs );
-    }
-
-    ~StrongPtr()
-    {
-        if ( OP::Release( Strong ) )
-        {
-            // Must zap the pointer before deleteing the object. Otherwise a
-            // cycle of weak pointers will lead to recursion, which leads to
-            // to deleting the shared object multiple times, which leads to
-            // undefined behavior.  Therefore, this must get pointer before
-            // zapping it, and then delete the temp pointer.
-            T* p = GetPointer();
-            OP::ZapPointer();
-            if ( p != 0 )
-            {
-                DP::Delete( p );
-            }
-        }
-    }
-
-#ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
-
-    // old non standard in class definition of friends
-    friend bool ReleaseAll( StrongPtr& sp,
-                            typename StrongPtr::StoredType& p )
-    {
-        if ( !sp.RP::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
-        {
-            return false;
-        }
-        p = sp.GetPointer();
-        sp.OP::SetPointer( sp.DP::Default() );
-        return true;
-    }
-
-    friend bool ResetAll( StrongPtr& sp,
-                          typename StrongPtr::StoredType p )
-    {
-        if ( sp.OP::GetPointer() == p )
-        {
-            return true;
-        }
-        if ( !sp.RP::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
-        {
-            return false;
-        }
-        sp.DP::Delete( sp.GetPointer() );
-        sp.OP::SetPointer( p );
-        return true;
-    }
-
-#else
-
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    friend bool ReleaseAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp,
-                            typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType& p );
-
-
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    friend bool ResetAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp,
-                          typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType p );
-
-#endif
-
-
-    /** Merges ownership of two StrongPtr's that point to same shared object
-      but are not copointers.  Requires Merge function in OwnershipPolicy.
-      \return True for success, false if not pointer to same object.
-     */
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    bool Merge( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs )
-    {
-        if ( OP::GetPointer() != rhs.OP::GetPointer() )
-        {
-            return false;
-        }
-        return OP::Merge( rhs );
-    }
-
-    /** Locks StrongPtr so other threads can't affect pointer.  Requires the
-     OwnershipPolicy to have Lock function.
-     */
-    void Lock( void )
-    {
-        OP::Lock();
-    }
-
-    /** Unlocks StrongPtr so other threads can affect pointer.  Requires the
-     OwnershipPolicy to have Unlock function.
-     */
-    void Unlock( void )
-    {
-        OP::Unlock();
-    }
-
-    PointerType operator -> ()
-    {
-        KP::OnDereference( GetPointer() );
-        return GetPointer();
-    }
-
-    ConstPointerType operator -> () const
-    {
-        KP::OnDereference( GetPointer() );
-        return GetPointer();
-    }
-
-    ReferenceType operator * ()
-    {
-        KP::OnDereference( GetPointer() );
-        return * GetPointer();
-    }
-
-    ConstReferenceType operator * () const
-    {
-        KP::OnDereference( GetPointer() );
-        return * GetPointer();
-    }
-
-    /// Helper function which can be called to avoid exposing GetPointer function.
-    template < class T1 >
-    bool Equals( const T1* p ) const
-    {
-        return ( GetPointer() == p );
-    }
-
-    /// Helper function which can be called to avoid exposing GetPointer function.
-    template < class T1 >
-    bool LessThan( const T1* p ) const
-    {
-        return ( GetPointer() < p );
-    }
-
-    /// Helper function which can be called to avoid exposing GetPointer function.
-    template < class T1 >
-    bool GreaterThan( const T1* p ) const
-    {
-        return ( GetPointer() > p );
-    }
-
-    /// Equality comparison operator is templated to handle ambiguity.
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    bool operator == (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
-    {
-        return ( rhs.Equals( GetPointer() ) );
-    }
-
-    /// Inequality comparison operator is templated to handle ambiguity.
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    bool operator != (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
-    {
-        return !( rhs.Equals( GetPointer() ) );
-    }
-
-    /// Less-than comparison operator is templated to handle ambiguity.
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    bool operator < (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
-    {
-        return ( rhs.GreaterThan( GetPointer() ) );
-    }
-
-    /// Greater-than comparison operator is templated to handle ambiguity.
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    inline bool operator > (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
-    {
-        return ( rhs.LessThan( GetPointer() ) );
-    }
-
-    /// Less-than-or-equal-to operator is templated to handle ambiguity.
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    inline bool operator <= (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
-    {
-        return !( rhs.LessThan( GetPointer() ) );
-    }
-
-    /// Greater-than-or-equal-to operator is templated to handle ambiguity.
-    template
-    <
-    typename T1,
-             bool S1,
-             class OP1,
-             class CP1,
-             template < class > class KP1,
-             template < class > class RP1,
-             template < class > class DP1,
-             template < class > class CNP1
-             >
-    inline bool operator >= (
-        const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const
-    {
-        return !( rhs.GreaterThan( GetPointer() ) );
-    }
-
-    inline bool operator ! () const // Enables "if ( !sp ) ..."
-    {
-        return ( 0 == OP::GetPointer() );
-    }
-
-protected:
-
-    inline PointerType GetPointer( void )
-    {
-        return reinterpret_cast< PointerType >( OP::GetPointer() );
-    }
-
-    inline ConstPointerType GetPointer( void ) const
-    {
-        return reinterpret_cast< ConstPointerType >( OP::GetPointer() );
-    }
-
-private:
-
-    inline ReferenceType GetPointerRef( void )
-    {
-        return reinterpret_cast< ReferenceType >( OP::GetPointerRef() );
-    }
-
-    inline ConstReferenceType GetPointerRef( void ) const
-    {
-        return reinterpret_cast< ConstReferenceType >( OP::GetPointerRef() );
-    }
-
-    // Helper for enabling 'if (sp)'
-    struct Tester
-    {
-        Tester(int) {}
-        void dummy() {}
-    };
-
-    typedef void (Tester::*unspecified_boolean_type_)();
-
-    typedef typename Select< CP::allow, Tester, unspecified_boolean_type_ >::Result
-    unspecified_boolean_type;
-
-public:
-    // enable 'if (sp)'
-    operator unspecified_boolean_type() const
-    {
-        return !*this ? 0 : &Tester::dummy;
-    }
-
-private:
-    // Helper for disallowing automatic conversion
-    struct Insipid
-    {
-        Insipid(PointerType) {}
-    };
-
-    typedef typename Select< CP::allow, PointerType, Insipid >::Result
-    AutomaticConversionResult;
-
-public:
-    operator AutomaticConversionResult() const
-    {
-        return GetPointer();
-    }
-
-};
-
-// ----------------------------------------------------------------------------
-
-// friend functions
-
-#ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND
-
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-bool ReleaseAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp,
-                 typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType& p )
-{
-    if ( !sp.RP<T>::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
-    {
-        return false;
-    }
-    p = sp.GetPointer();
-    sp.OP::SetPointer( sp.DP<T>::Default() );
-    return true;
-}
-
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-bool ResetAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp,
-               typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType p )
-{
-    if ( sp.OP::GetPointer() == p )
-    {
-        return true;
-    }
-    if ( !sp.RP<T>::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) )
-    {
-        return false;
-    }
-    sp.DP<T>::Delete( sp.GetPointer() );
-    sp.OP::SetPointer( p );
-    return true;
-}
-#endif
-
-
-// free comparison operators for class template StrongPtr
-
-///  operator== for lhs = StrongPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator == (
-    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
-{
-    return ( lhs.Equals( rhs ) );
-}
-
-///  operator== for lhs = raw pointer, rhs = StrongPtr
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator == ( U* lhs,
-                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
-{
-    return ( rhs.Equals( lhs ) );
-}
-
-///  operator!= for lhs = StrongPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator != (
-    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
-{
-    return !( lhs.Equals( rhs ) );
-}
-
-///  operator!= for lhs = raw pointer, rhs = StrongPtr
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator != ( U* lhs,
-                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
-{
-    return !( rhs.Equals( lhs ) );
-}
-
-///  operator< for lhs = StrongPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator < (
-    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
-{
-    return ( lhs.LessThan( rhs ) );
-}
-
-///  operator< for lhs = raw pointer, rhs = StrongPtr
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator < ( U* lhs,
-                         const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
-{
-    return ( rhs.GreaterThan( lhs ) );
-}
-
-//  operator> for lhs = StrongPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator > (
-    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
-{
-    return ( lhs.GreaterThan( rhs ) );
-}
-
-///  operator> for lhs = raw pointer, rhs = StrongPtr
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator > ( U* lhs,
-                         const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
-{
-    return ( rhs.LessThan( lhs ) );
-}
-
-///  operator<= for lhs = StrongPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator <= (
-    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
-{
-    return !( lhs.GreaterThan( rhs ) );
-}
-
-///  operator<= for lhs = raw pointer, rhs = StrongPtr
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator <= ( U* lhs,
-                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
-{
-    return !( rhs.LessThan( lhs ) );
-}
-
-///  operator>= for lhs = StrongPtr, rhs = raw pointer
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator >= (
-    const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U* rhs )
-{
-    return !( lhs.LessThan( rhs ) );
-}
-
-///  operator>= for lhs = raw pointer, rhs = StrongPtr
-///  \ingroup SmartPointerGroup
-template
-<
-typename U,
-         typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-inline bool operator >= ( U* lhs,
-                          const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs )
-{
-    return !( rhs.GreaterThan( lhs ) );
-}
-
-} // namespace Loki
-
-namespace std
-{
-////////////////////////////////////////////////////////////////////////////////
-///  specialization of std::less for StrongPtr
-///  \ingroup SmartPointerGroup
-////////////////////////////////////////////////////////////////////////////////
-template
-<
-typename T,
-         bool S,
-         class OP,
-         class CP,
-         template < class > class KP,
-         template < class > class RP,
-         template < class > class DP,
-         template < class > class CNP
-         >
-struct less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
-        : public binary_function <
-        Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >,
-        Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >, bool >
-{
-    bool operator () (
-        const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs,
-        const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) const
-    {
-        return ( lhs < rhs );
-    }
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // end file guardian
-
diff --git a/shared/loki/Threads.h b/shared/loki/Threads.h
deleted file mode 100644
index 690ca50f..00000000
--- a/shared/loki/Threads.h
+++ /dev/null
@@ -1,609 +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_THREADS_INC_
-#define LOKI_THREADS_INC_
-
-// $Id: Threads.h 902 2008-11-10 05:47:06Z rich_sposato $
-
-
-///  @defgroup  ThreadingGroup Threading
-///  Policies to for the threading model:
-///
-///  - SingleThreaded
-///  - ObjectLevelLockable
-///  - ClassLevelLockable
-///
-///  All classes in Loki have configurable threading model.
-///
-///  The macro LOKI_DEFAULT_THREADING selects the default
-///  threading model for certain components of Loki
-///  (it affects only default template arguments)
-///
-///  \par Usage:
-///
-///  To use a specific threading model define
-///
-///  - nothing, single-theading is default
-///  - LOKI_OBJECT_LEVEL_THREADING for object-level-threading
-///  - LOKI_CLASS_LEVEL_THREADING for class-level-threading
-///
-///  \par Supported platfroms:
-///
-///  - Windows (windows.h)
-///  - POSIX (pthread.h):
-///    No recursive mutex support with pthread.
-///    This means: calling Lock() on a Loki::Mutex twice from the
-///    same thread before unlocking the mutex deadlocks the system.
-///    To avoid this redesign your synchronization. See also:
-///    http://sourceforge.net/tracker/index.php?func=detail&aid=1516182&group_id=29557&atid=396647
-
-
-#include <cassert>
-
-#if defined(LOKI_CLASS_LEVEL_THREADING) || defined(LOKI_OBJECT_LEVEL_THREADING)
-
-#define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::ClassLevelLockable
-
-#if defined(LOKI_CLASS_LEVEL_THREADING) && !defined(LOKI_OBJECT_LEVEL_THREADING)
-#define LOKI_DEFAULT_THREADING ::Loki::ClassLevelLockable
-#else
-#define LOKI_DEFAULT_THREADING ::Loki::ObjectLevelLockable
-#endif
-
-#if defined(_WIN32) || defined(_WIN64)
-#include <windows.h>
-#define LOKI_WINDOWS_H
-#else
-#include <pthread.h>
-#define LOKI_PTHREAD_H
-#endif
-
-#else
-
-#define LOKI_DEFAULT_THREADING ::Loki::SingleThreaded
-#define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::SingleThreaded
-
-#endif
-
-#ifndef LOKI_DEFAULT_MUTEX
-#define LOKI_DEFAULT_MUTEX ::Loki::Mutex
-#endif
-
-#ifdef LOKI_WINDOWS_H
-
-#define LOKI_THREADS_MUTEX(x)           CRITICAL_SECTION (x);
-#define LOKI_THREADS_MUTEX_INIT(x)      ::InitializeCriticalSection (x)
-#define LOKI_THREADS_MUTEX_DELETE(x)    ::DeleteCriticalSection (x)
-#define LOKI_THREADS_MUTEX_LOCK(x)      ::EnterCriticalSection (x)
-#define LOKI_THREADS_MUTEX_UNLOCK(x)    ::LeaveCriticalSection (x)
-#define LOKI_THREADS_LONG               LONG
-#define LOKI_THREADS_MUTEX_CTOR(x)
-
-#define LOKI_THREADS_ATOMIC_FUNCTIONS                                   \
-    static IntType AtomicMultiply(volatile IntType& lval, const IntType val) \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        lval *= val;                                                \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicDivide(volatile IntType& lval, const IntType val)  \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        lval /= val;                                                \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicIncrement(volatile IntType& lval)          \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        ++lval;                                                     \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicDecrement(volatile IntType& lval)          \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        --lval;                                                     \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static void AtomicAssign(volatile IntType& lval, const IntType val)   \
-    { InterlockedExchange(&const_cast<IntType&>(lval), val); }      \
-    \
-    static void AtomicAssign(IntType& lval, volatile const IntType& val)  \
-    { InterlockedExchange(&lval, val); }                            \
-    \
-    static IntType AtomicIncrement(volatile IntType& lval, const IntType compare, bool & matches )  \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        ++lval;                                                     \
-        matches = ( lval == compare );                              \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicDecrement(volatile IntType& lval, const IntType compare, bool & matches )  \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        --lval;                                                     \
-        matches = ( lval == compare );                              \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicAdd(volatile IntType& lval, const IntType val, const IntType compare, bool & matches )  \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        lval += val;                                                \
-        matches = ( lval == compare );                              \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicSubtract(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        lval -= val;                                                \
-        matches = ( lval == compare );                              \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicMultiply(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                   \
-        lval *= val;                                                \
-        matches = ( lval == compare );                              \
-        ::LeaveCriticalSection( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicDivide(volatile IntType& lval, const IntType val, const IntType compare, bool & matches )   \
-    {                                                               \
-        ::EnterCriticalSection( &atomic_mutex_ );                    \
-        lval /= val;                                                \
-        matches = ( lval == compare );                              \
-        ::LeaveCriticalSection( &atomic_mutex_ );                    \
-        return lval;                                                \
-    }
-
-#elif defined(LOKI_PTHREAD_H)
-
-
-#define LOKI_THREADS_MUTEX(x)           pthread_mutex_t (x);
-
-#define LOKI_THREADS_MUTEX_INIT(x)      ::pthread_mutex_init(x, 0)
-
-// define to 1 to enable recursive mutex support
-#if 0
-// experimental recursive mutex support
-#define LOKI_THREADS_MUTEX_CTOR(x)      : x(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
-#else
-// no recursive mutex support
-#define LOKI_THREADS_MUTEX_CTOR(x)
-#endif
-
-#define LOKI_THREADS_MUTEX_DELETE(x)    ::pthread_mutex_destroy (x)
-#define LOKI_THREADS_MUTEX_LOCK(x)      ::pthread_mutex_lock (x)
-#define LOKI_THREADS_MUTEX_UNLOCK(x)    ::pthread_mutex_unlock (x)
-#define LOKI_THREADS_LONG               long
-
-#define LOKI_THREADS_ATOMIC(x)                                           \
-    pthread_mutex_lock(&atomic_mutex_);                      \
-    x;                                                       \
-    pthread_mutex_unlock(&atomic_mutex_)
-
-#define LOKI_THREADS_ATOMIC_FUNCTIONS                                \
-    private:                                                         \
-    static pthread_mutex_t atomic_mutex_;                        \
-    public:                                                          \
-    static IntType AtomicMultiply(volatile IntType& lval, const IntType val) \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        lval *= val;                                                 \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static IntType AtomicDivide(volatile IntType& lval, const IntType val) \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        lval /= val;                                                 \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static IntType AtomicIncrement(volatile IntType& lval)           \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        ++lval;                                                      \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static IntType AtomicDecrement(volatile IntType& lval)           \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        --lval;                                                      \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static void AtomicAssign(volatile IntType& lval, const IntType val) \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        lval = val;                                                  \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static void AtomicAssign(IntType& lval, volatile const IntType& val) \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        lval = val;                                                  \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static IntType AtomicIncrement(volatile IntType& lval, const IntType compare, bool & matches ) \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        ++lval;                                                      \
-        matches = ( compare == lval );                               \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    \
-    static IntType AtomicDecrement(volatile IntType& lval, const IntType compare, bool & matches ) \
-    {                                                                \
-        ::pthread_mutex_lock( &atomic_mutex_ );                      \
-        --lval;                                                      \
-        matches = ( compare == lval );                               \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                    \
-        return lval;                                                 \
-    }                                                                \
-    static IntType AtomicMultiply(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \
-    {                                                               \
-        ::pthread_mutex_lock( &atomic_mutex_ );                     \
-        lval *= val;                                                \
-        matches = ( lval == compare );                              \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }                                                               \
-    \
-    static IntType AtomicDivide(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \
-    {                                                               \
-        ::pthread_mutex_lock( &atomic_mutex_ );                     \
-        lval /= val;                                                \
-        matches = ( lval == compare );                              \
-        ::pthread_mutex_unlock( &atomic_mutex_ );                   \
-        return lval;                                                \
-    }
-
-#else // single threaded
-
-#define LOKI_THREADS_MUTEX(x)
-#define LOKI_THREADS_MUTEX_INIT(x)
-#define LOKI_THREADS_MUTEX_DELETE(x)
-#define LOKI_THREADS_MUTEX_LOCK(x)
-#define LOKI_THREADS_MUTEX_UNLOCK(x)
-#define LOKI_THREADS_LONG
-#define LOKI_THREADS_MUTEX_CTOR(x)
-
-#endif
-
-
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class Mutex
-//
-///  \ingroup ThreadingGroup
-///  A simple and portable Mutex.  A default policy class for locking objects.
-////////////////////////////////////////////////////////////////////////////////
-
-class Mutex
-{
-public:
-    Mutex() LOKI_THREADS_MUTEX_CTOR(mtx_)
-    {
-        LOKI_THREADS_MUTEX_INIT(&mtx_);
-    }
-    ~Mutex()
-    {
-        LOKI_THREADS_MUTEX_DELETE(&mtx_);
-    }
-    void Lock()
-    {
-        LOKI_THREADS_MUTEX_LOCK(&mtx_);
-    }
-    void Unlock()
-    {
-        LOKI_THREADS_MUTEX_UNLOCK(&mtx_);
-    }
-private:
-    /// Copy-constructor not implemented.
-    Mutex(const Mutex&);
-    /// Copy-assignement operator not implemented.
-    Mutex& operator = (const Mutex&);
-    LOKI_THREADS_MUTEX(mtx_)
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class SingleThreaded
-///
-///  \ingroup ThreadingGroup
-///  Implementation of the ThreadingModel policy used by various classes
-///  Implements a single-threaded model; no synchronization
-////////////////////////////////////////////////////////////////////////////////
-template <class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX>
-class SingleThreaded
-{
-public:
-    /// \struct Lock
-    /// Dummy Lock class
-    struct Lock
-    {
-        Lock() {}
-        explicit Lock(const SingleThreaded&) {}
-        explicit Lock(const SingleThreaded*) {}
-    };
-
-    typedef Host VolatileType;
-
-    typedef int IntType;
-
-    static IntType AtomicAdd(volatile IntType& lval, const IntType val)
-    { return lval += val; }
-
-    static IntType AtomicSubtract(volatile IntType& lval, const IntType val)
-    { return lval -= val; }
-
-    static IntType AtomicMultiply(volatile IntType& lval, const IntType val)
-    { return lval *= val; }
-
-    static IntType AtomicDivide(volatile IntType& lval, const IntType val)
-    { return lval /= val; }
-
-    static IntType AtomicIncrement(volatile IntType& lval)
-    { return ++lval; }
-
-    static IntType AtomicDecrement(volatile IntType& lval)
-    { return --lval; }
-
-    static void AtomicAssign(volatile IntType& lval, const IntType val)
-    { lval = val; }
-
-    static void AtomicAssign(IntType& lval, volatile IntType& val)
-    { lval = val; }
-
-    static IntType AtomicAdd(volatile IntType& lval, const IntType val, const IntType compare, bool& matches )
-    {
-        lval += val;
-        matches = ( lval == compare );
-        return lval;
-    }
-
-    static IntType AtomicSubtract(volatile IntType& lval, const IntType val, const IntType compare, bool& matches )
-    {
-        lval -= val;
-        matches = ( lval == compare );
-        return lval;
-    }
-
-    static IntType AtomicMultiply(volatile IntType& lval, const IntType val, const IntType compare, bool& matches )
-    {
-        lval *= val;
-        matches = ( lval == compare );
-        return lval;
-    }
-
-    static IntType AtomicDivide(volatile IntType& lval, const IntType val, const IntType compare, bool& matches )
-    {
-        lval /= val;
-        matches = ( lval == compare );
-        return lval;
-    }
-
-    static IntType AtomicIncrement(volatile IntType& lval, const IntType compare, bool& matches )
-    {
-        ++lval;
-        matches = ( lval == compare );
-        return lval;
-    }
-
-    static IntType AtomicDecrement(volatile IntType& lval, const IntType compare, bool& matches )
-    {
-        --lval;
-        matches = ( lval == compare );
-        return lval;
-    }
-
-};
-
-
-#if defined(LOKI_WINDOWS_H) || defined(LOKI_PTHREAD_H)
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class ObjectLevelLockable
-///
-///  \ingroup ThreadingGroup
-///  Implementation of the ThreadingModel policy used by various classes
-///  Implements a object-level locking scheme
-////////////////////////////////////////////////////////////////////////////////
-template < class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX >
-class ObjectLevelLockable
-{
-    mutable MutexPolicy mtx_;
-
-public:
-    ObjectLevelLockable() : mtx_() {}
-
-    ObjectLevelLockable(const ObjectLevelLockable&) : mtx_() {}
-
-    ~ObjectLevelLockable() {}
-
-    class Lock;
-    friend class Lock;
-
-    ///  \struct Lock
-    ///  Lock class to lock on object level
-    class Lock
-    {
-    public:
-
-        /// Lock object
-        explicit Lock(const ObjectLevelLockable& host) : host_(host)
-        {
-            host_.mtx_.Lock();
-        }
-
-        /// Lock object
-        explicit Lock(const ObjectLevelLockable* host) : host_(*host)
-        {
-            host_.mtx_.Lock();
-        }
-
-        /// Unlock object
-        ~Lock()
-        {
-            host_.mtx_.Unlock();
-        }
-
-    private:
-        /// private by design of the object level threading
-        Lock();
-        Lock(const Lock&);
-        Lock& operator=(const Lock&);
-        const ObjectLevelLockable& host_;
-    };
-
-    typedef volatile Host VolatileType;
-
-    typedef LOKI_THREADS_LONG IntType;
-
-    LOKI_THREADS_ATOMIC_FUNCTIONS
-
-};
-
-#ifdef LOKI_PTHREAD_H
-template <class Host, class MutexPolicy>
-pthread_mutex_t ObjectLevelLockable<Host, MutexPolicy>::atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER;
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class ClassLevelLockable
-///
-///  \ingroup ThreadingGroup
-///  Implementation of the ThreadingModel policy used by various classes
-///  Implements a class-level locking scheme
-////////////////////////////////////////////////////////////////////////////////
-template <class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX >
-class ClassLevelLockable
-{
-    struct Initializer
-    {
-        bool init_;
-        MutexPolicy mtx_;
-
-        Initializer() : init_(false), mtx_()
-        {
-            init_ = true;
-        }
-
-        ~Initializer()
-        {
-            assert(init_);
-        }
-    };
-
-    static Initializer initializer_;
-
-public:
-
-    class Lock;
-    friend class Lock;
-
-    ///  \struct Lock
-    ///  Lock class to lock on class level
-    class Lock
-    {
-    public:
-
-        /// Lock class
-        Lock()
-        {
-            assert(initializer_.init_);
-            initializer_.mtx_.Lock();
-        }
-
-        /// Lock class
-        explicit Lock(const ClassLevelLockable&)
-        {
-            assert(initializer_.init_);
-            initializer_.mtx_.Lock();
-        }
-
-        /// Lock class
-        explicit Lock(const ClassLevelLockable*)
-        {
-            assert(initializer_.init_);
-            initializer_.mtx_.Lock();
-        }
-
-        /// Unlock class
-        ~Lock()
-        {
-            assert(initializer_.init_);
-            initializer_.mtx_.Unlock();
-        }
-
-    private:
-        Lock(const Lock&);
-        Lock& operator=(const Lock&);
-    };
-
-    typedef volatile Host VolatileType;
-
-    typedef LOKI_THREADS_LONG IntType;
-
-    LOKI_THREADS_ATOMIC_FUNCTIONS
-
-};
-
-#ifdef LOKI_PTHREAD_H
-template <class Host, class MutexPolicy>
-pthread_mutex_t ClassLevelLockable<Host, MutexPolicy>::atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER;
-#endif
-
-template < class Host, class MutexPolicy >
-typename ClassLevelLockable< Host, MutexPolicy >::Initializer
-ClassLevelLockable< Host, MutexPolicy >::initializer_;
-
-#endif // #if defined(LOKI_WINDOWS_H) || defined(LOKI_PTHREAD_H)
-
-} // namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/Tuple.h b/shared/loki/Tuple.h
deleted file mode 100644
index ec5ae213..00000000
--- a/shared/loki/Tuple.h
+++ /dev/null
@@ -1,22 +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.
-////////////////////////////////////////////////////////////////////////////////
-
-// Last update: June 20, 2001
-
-////////////////////////////////////////////////////////////////////////////////
-// This file is intentionally left empty
-// Due to compiler limitations, its contents has been moved to
-//     HierarchyGenerators.h
-////////////////////////////////////////////////////////////////////////////////
diff --git a/shared/loki/TypeManip.h b/shared/loki/TypeManip.h
deleted file mode 100644
index 7933e340..00000000
--- a/shared/loki/TypeManip.h
+++ /dev/null
@@ -1,290 +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-Welsey 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_TYPEMANIP_INC_
-#define LOKI_TYPEMANIP_INC_
-
-// $Id: TypeManip.h 749 2006-10-17 19:49:26Z syntheticpp $
-
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template Int2Type
-// Converts each integral constant into a unique type
-// Invocation: Int2Type<v> where v is a compile-time constant integral
-// Defines 'value', an enum that evaluates to v
-////////////////////////////////////////////////////////////////////////////////
-
-template <int v>
-struct Int2Type
-{
-    enum { value = v };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Type2Type
-// Converts each type into a unique, insipid type
-// Invocation Type2Type<T> where T is a type
-// Defines the type OriginalType which maps back to T
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-struct Type2Type
-{
-    typedef T OriginalType;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Select
-// Selects one of two types based upon a boolean constant
-// Invocation: Select<flag, T, U>::Result
-// where:
-// flag is a compile-time boolean constant
-// T and U are types
-// Result evaluates to T if flag is true, and to U otherwise.
-////////////////////////////////////////////////////////////////////////////////
-
-template <bool flag, typename T, typename U>
-struct Select
-{
-    typedef T Result;
-};
-template <typename T, typename U>
-struct Select<false, T, U>
-{
-    typedef U Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template IsSameType
-// Return true iff two given types are the same
-// Invocation: SameType<T, U>::value
-// where:
-// T and U are types
-// Result evaluates to true iff U == T (types equal)
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename T, typename U>
-struct IsSameType
-{
-    enum { value = false };
-};
-
-template <typename T>
-struct IsSameType<T, T>
-{
-    enum { value = true };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Helper types Small and Big - guarantee that sizeof(Small) < sizeof(Big)
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template <class T, class U>
-struct ConversionHelper
-{
-    typedef char Small;
-    struct Big { char dummy[2]; };
-    static Big   Test(...);
-    static Small Test(U);
-    static T MakeT();
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Conversion
-// Figures out the conversion relationships between two types
-// Invocations (T and U are types):
-// a) Conversion<T, U>::exists
-// returns (at compile time) true if there is an implicit conversion from T
-// to U (example: Derived to Base)
-// b) Conversion<T, U>::exists2Way
-// returns (at compile time) true if there are both conversions from T
-// to U and from U to T (example: int to char and back)
-// c) Conversion<T, U>::sameType
-// returns (at compile time) true if T and U represent the same type
-//
-// Caveat: might not work if T and U are in a private inheritance hierarchy.
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class U>
-struct Conversion
-{
-    typedef Private::ConversionHelper<T, U> H;
-#ifndef __MWERKS__
-    enum { exists = sizeof(typename H::Small) == sizeof((H::Test(H::MakeT()))) };
-#else
-    enum { exists = false };
-#endif
-    enum { exists2Way = exists && Conversion<U, T>::exists };
-    enum { sameType = false };
-};
-
-template <class T>
-struct Conversion<T, T>
-{
-    enum { exists = 1, exists2Way = 1, sameType = 1 };
-};
-
-template <class T>
-struct Conversion<void, T>
-{
-    enum { exists = 0, exists2Way = 0, sameType = 0 };
-};
-
-template <class T>
-struct Conversion<T, void>
-{
-    enum { exists = 0, exists2Way = 0, sameType = 0 };
-};
-
-template <>
-struct Conversion<void, void>
-{
-public:
-    enum { exists = 1, exists2Way = 1, sameType = 1 };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SuperSubclass
-// Invocation: SuperSubclass<B, D>::value where B and D are types.
-// Returns true if B is a public base of D, or if B and D are aliases of the
-// same type.
-//
-// Caveat: might not work if T and U are in a private inheritance hierarchy.
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class U>
-struct SuperSubclass
-{
-    enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists &&
-                    !::Loki::Conversion<const volatile T*, const volatile void*>::sameType)
-         };
-
-    // Dummy enum to make sure that both classes are fully defined.
-    enum { dontUseWithIncompleteTypes = ( sizeof (T) == sizeof (U) ) };
-};
-
-template <>
-struct SuperSubclass<void, void>
-{
-    enum { value = false };
-};
-
-template <class U>
-struct SuperSubclass<void, U>
-{
-    enum { value = (::Loki::Conversion<const volatile U*, const volatile void*>::exists &&
-                    !::Loki::Conversion<const volatile void*, const volatile void*>::sameType)
-         };
-
-    // Dummy enum to make sure that both classes are fully defined.
-    enum { dontUseWithIncompleteTypes = ( 0 == sizeof (U) ) };
-};
-
-template <class T>
-struct SuperSubclass<T, void>
-{
-    enum { value = (::Loki::Conversion<const volatile void*, const volatile T*>::exists &&
-                    !::Loki::Conversion<const volatile T*, const volatile void*>::sameType)
-         };
-
-    // Dummy enum to make sure that both classes are fully defined.
-    enum { dontUseWithIncompleteTypes = ( sizeof (T) == 0 ) };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SuperSubclassStrict
-// Invocation: SuperSubclassStrict<B, D>::value where B and D are types.
-// Returns true if B is a public base of D.
-//
-// Caveat: might not work if T and U are in a private inheritance hierarchy.
-////////////////////////////////////////////////////////////////////////////////
-
-template<class T, class U>
-struct SuperSubclassStrict
-{
-    enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists &&
-                    !::Loki::Conversion<const volatile T*, const volatile void*>::sameType &&
-                    !::Loki::Conversion<const volatile T*, const volatile U*>::sameType)
-         };
-
-    // Dummy enum to make sure that both classes are fully defined.
-    enum { dontUseWithIncompleteTypes = ( sizeof (T) == sizeof (U) ) };
-};
-
-template<>
-struct SuperSubclassStrict<void, void>
-{
-    enum { value = false };
-};
-
-template<class U>
-struct SuperSubclassStrict<void, U>
-{
-    enum { value = (::Loki::Conversion<const volatile U*, const volatile void*>::exists &&
-                    !::Loki::Conversion<const volatile void*, const volatile void*>::sameType &&
-                    !::Loki::Conversion<const volatile void*, const volatile U*>::sameType)
-         };
-
-    // Dummy enum to make sure that both classes are fully defined.
-    enum { dontUseWithIncompleteTypes = ( 0 == sizeof (U) ) };
-};
-
-template<class T>
-struct SuperSubclassStrict<T, void>
-{
-    enum { value = (::Loki::Conversion<const volatile void*, const volatile T*>::exists &&
-                    !::Loki::Conversion<const volatile T*, const volatile void*>::sameType &&
-                    !::Loki::Conversion<const volatile T*, const volatile void*>::sameType)
-         };
-
-    // Dummy enum to make sure that both classes are fully defined.
-    enum { dontUseWithIncompleteTypes = ( sizeof (T) == 0 ) };
-};
-
-
-}   // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// macro SUPERSUBCLASS
-// Invocation: SUPERSUBCLASS(B, D) where B and D are types.
-// Returns true if B is a public base of D, or if B and D are aliases of the
-// same type.
-//
-// Caveat: might not work if T and U are in a private inheritance hierarchy.
-// Deprecated: Use SuperSubclass class template instead.
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_SUPERSUBCLASS(T, U) \
-    ::Loki::SuperSubclass<T,U>::value
-
-////////////////////////////////////////////////////////////////////////////////
-// macro SUPERSUBCLASS_STRICT
-// Invocation: SUPERSUBCLASS(B, D) where B and D are types.
-// Returns true if B is a public base of D.
-//
-// Caveat: might not work if T and U are in a private inheritance hierarchy.
-// Deprecated: Use SuperSubclassStrict class template instead.
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_SUPERSUBCLASS_STRICT(T, U) \
-    ::Loki::SuperSubclassStrict<T,U>::value
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/TypeTraits.h b/shared/loki/TypeTraits.h
deleted file mode 100644
index 28d0f0c1..00000000
--- a/shared/loki/TypeTraits.h
+++ /dev/null
@@ -1,2236 +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_TYPETRAITS_INC_
-#define LOKI_TYPETRAITS_INC_
-
-// $Id: TypeTraits.h 835 2007-08-02 19:39:02Z syntheticpp $
-
-
-#include "Typelist.h"
-#include "Sequence.h"
-
-#if (defined _MSC_VER) && (_MSC_VER < 1400)
-#include <string>
-#endif
-
-
-#ifdef _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4180 ) //qualifier applied to function type has no meaning; ignored
-#endif
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template IsCustomUnsignedInt
-// Offers a means to integrate nonstandard built-in unsigned integral types
-// (such as unsigned __int64 or unsigned long long int) with the TypeTraits
-//     class template defined below.
-// Invocation: IsCustomUnsignedInt<T> where T is any type
-// Defines 'value', an enum that is 1 iff T is a custom built-in unsigned
-//     integral type
-// Specialize this class template for nonstandard unsigned integral types
-//     and define value = 1 in those specializations
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-struct IsCustomUnsignedInt
-{
-    enum { value = 0 };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template IsCustomSignedInt
-// Offers a means to integrate nonstandard built-in unsigned integral types
-// (such as unsigned __int64 or unsigned long long int) with the TypeTraits
-//     class template defined below.
-// Invocation: IsCustomSignedInt<T> where T is any type
-// Defines 'value', an enum that is 1 iff T is a custom built-in signed
-//     integral type
-// Specialize this class template for nonstandard unsigned integral types
-//     and define value = 1 in those specializations
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-struct IsCustomSignedInt
-{
-    enum { value = 0 };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template IsCustomFloat
-// Offers a means to integrate nonstandard floating point types with the
-//     TypeTraits class template defined below.
-// Invocation: IsCustomFloat<T> where T is any type
-// Defines 'value', an enum that is 1 iff T is a custom built-in
-//     floating point type
-// Specialize this class template for nonstandard unsigned integral types
-//     and define value = 1 in those specializations
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-struct IsCustomFloat
-{
-    enum { value = 0 };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Helper types for class template TypeTraits defined below
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-#ifndef LOKI_DISABLE_TYPELIST_MACROS
-typedef LOKI_TYPELIST_4(unsigned char, unsigned short int, unsigned int, unsigned long int)
-StdUnsignedInts;
-typedef LOKI_TYPELIST_4(signed char, short int, int, long int)
-StdSignedInts;
-typedef LOKI_TYPELIST_3(bool, char, wchar_t)
-StdOtherInts;
-typedef LOKI_TYPELIST_3(float, double, long double)
-StdFloats;
-#else
-typedef Loki::Seq<unsigned char, unsigned short int, unsigned int, unsigned long int>::Type
-StdUnsignedInts;
-typedef Loki::Seq<signed char, short int, int, long int>::Type
-StdSignedInts;
-typedef Loki::Seq<bool, char, wchar_t>::Type
-StdOtherInts;
-typedef Loki::Seq<float, double, long double>::Type
-StdFloats;
-
-#endif
-template <typename U> struct AddPointer
-{
-    typedef U* Result;
-};
-
-template <typename U> struct AddPointer<U&>
-{
-    typedef U* Result;
-};
-
-template <class U> struct AddReference
-{
-    typedef U& Result;
-};
-
-template <class U> struct AddReference<U&>
-{
-    typedef U& Result;
-};
-
-template <> struct AddReference<void>
-{
-    typedef NullType Result;
-};
-
-template <class U> struct AddParameterType
-{
-    typedef const U& Result;
-};
-
-template <class U> struct AddParameterType<U&>
-{
-    typedef U& Result;
-};
-
-template <> struct AddParameterType<void>
-{
-    typedef NullType Result;
-};
-
-template <typename T>
-struct IsFunctionPointerRaw
-{enum {result = 0};};
-
-template <typename T>
-struct IsFunctionPointerRaw<T(*)()>
-{enum {result = 1};};
-
-template < typename T,
-         typename P01 >
-struct IsFunctionPointerRaw<T(*)(P01)>
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20) >
-{enum {result = 1};};
-
-template <typename T>
-struct IsFunctionPointerRaw < T(*)(
-    ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, ...) >
-{enum {result = 1};};
-
-template < typename T,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsFunctionPointerRaw < T(*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20,
-    ...) >
-{enum {result = 1};};
-
-
-template <typename T>
-struct IsMemberFunctionPointerRaw
-{enum {result = 0};};
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw<T (S::*)()>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw<T (S::*)(P01)>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20) >
-{enum {result = 1};};
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, ...) >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20,
-    ...) >
-{enum {result = 1};};
-
-// Const versions
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw<T (S::*)() const>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw<T (S::*)(P01) const>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20) const >
-{enum {result = 1};};
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, ...) const >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20,
-    ...) const >
-{enum {result = 1};};
-
-// Volatile versions
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw<T (S::*)() volatile>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw<T (S::*)(P01) volatile>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20) volatile >
-{enum {result = 1};};
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, ...) volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20,
-    ...) volatile >
-{enum {result = 1};};
-
-// Const volatile versions
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw<T (S::*)() const volatile>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw<T (S::*)(P01) const volatile>
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20) const volatile >
-{enum {result = 1};};
-
-template <typename T, typename S>
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, ...) const volatile >
-{enum {result = 1};};
-
-template < typename T, typename S,
-         typename P01, typename P02, typename P03, typename P04, typename P05,
-         typename P06, typename P07, typename P08, typename P09, typename P10,
-         typename P11, typename P12, typename P13, typename P14, typename P15,
-         typename P16, typename P17, typename P18, typename P19, typename P20 >
-struct IsMemberFunctionPointerRaw < T (S::*)(
-    P01, P02, P03, P04, P05,
-    P06, P07, P08, P09, P10,
-    P11, P12, P13, P14, P15,
-    P16, P17, P18, P19, P20,
-    ...) const volatile >
-{enum {result = 1};};
-
-}// namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-// class template TypeTraits
-//
-// Figures out at compile time various properties of any given type
-// Invocations (T is a type, TypeTraits<T>::Property):
-//
-// - isPointer       : returns true if T is a pointer type
-// - PointeeType     : returns the type to which T points if T is a pointer
-//                     type, NullType otherwise
-// - isReference     : returns true if T is a reference type
-// - ReferredType    : returns the type to which T refers if T is a reference
-//                     type, NullType otherwise
-// - isMemberPointer : returns true if T is a pointer to member type
-// - isStdUnsignedInt: returns true if T is a standard unsigned integral type
-// - isStdSignedInt  : returns true if T is a standard signed integral type
-// - isStdIntegral   : returns true if T is a standard integral type
-// - isStdFloat      : returns true if T is a standard floating-point type
-// - isStdArith      : returns true if T is a standard arithmetic type
-// - isStdFundamental: returns true if T is a standard fundamental type
-// - isUnsignedInt   : returns true if T is a unsigned integral type
-// - isSignedInt     : returns true if T is a signed integral type
-// - isIntegral      : returns true if T is a integral type
-// - isFloat         : returns true if T is a floating-point type
-// - isArith         : returns true if T is a arithmetic type
-// - isFundamental   : returns true if T is a fundamental type
-// - ParameterType   : returns the optimal type to be used as a parameter for
-//                     functions that take Ts
-// - isConst         : returns true if T is a const-qualified type
-// - NonConstType    : Type with removed 'const' qualifier from T, if any
-// - isVolatile      : returns true if T is a volatile-qualified type
-// - NonVolatileType : Type with removed 'volatile' qualifier from T, if any
-// - UnqualifiedType : Type with removed 'const' and 'volatile' qualifiers from
-//                     T, if any
-// - ParameterType   : returns the optimal type to be used as a parameter
-//                       for functions that take 'const T's
-//
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-class TypeTraits
-{
-private:
-
-    template <class U> struct ReferenceTraits
-    {
-        enum { result = false };
-        typedef U ReferredType;
-    };
-
-    template <class U> struct ReferenceTraits<U&>
-    {
-        enum { result = true };
-        typedef U ReferredType;
-    };
-
-    template <class U> struct PointerTraits
-    {
-        enum { result = false };
-        typedef NullType PointeeType;
-    };
-
-    template <class U> struct PointerTraits<U*>
-    {
-        enum { result = true };
-        typedef U PointeeType;
-    };
-
-    template <class U> struct PointerTraits<U*&>
-    {
-        enum { result = true };
-        typedef U PointeeType;
-    };
-
-    template <class U> struct PToMTraits
-    {
-        enum { result = false };
-    };
-
-    template <class U, class V> struct PToMTraits<U V::*>
-    {
-        enum { result = true };
-    };
-
-    template <class U, class V> struct PToMTraits<U V::*&>
-    {
-        enum { result = true };
-    };
-
-    template <class U> struct FunctionPointerTraits
-    {
-        enum { result = Private::IsFunctionPointerRaw<U>::result };
-    };
-
-    template <typename U> struct PToMFunctionTraits
-    {
-        enum { result = Private::IsMemberFunctionPointerRaw<U>::result };
-    };
-
-    template <class U> struct UnConst
-    {
-        typedef U Result;
-        enum { isConst = 0 };
-    };
-
-    template <class U> struct UnConst<const U>
-    {
-        typedef U Result;
-        enum { isConst = 1 };
-    };
-
-    template <class U> struct UnConst<const U&>
-    {
-        typedef U& Result;
-        enum { isConst = 1 };
-    };
-
-    template <class U> struct UnVolatile
-    {
-        typedef U Result;
-        enum { isVolatile = 0 };
-    };
-
-    template <class U> struct UnVolatile<volatile U>
-    {
-        typedef U Result;
-        enum { isVolatile = 1 };
-    };
-
-    template <class U> struct UnVolatile<volatile U&>
-    {
-        typedef U& Result;
-        enum { isVolatile = 1 };
-    };
-
-public:
-    typedef typename UnConst<T>::Result
-    NonConstType;
-    typedef typename UnVolatile<T>::Result
-    NonVolatileType;
-    typedef typename UnVolatile<typename UnConst<T>::Result>::Result
-    UnqualifiedType;
-    typedef typename PointerTraits<UnqualifiedType>::PointeeType
-    PointeeType;
-    typedef typename ReferenceTraits<T>::ReferredType
-    ReferredType;
-
-    enum { isConst          = UnConst<T>::isConst };
-    enum { isVolatile       = UnVolatile<T>::isVolatile };
-    enum { isReference      = ReferenceTraits<UnqualifiedType>::result };
-    enum { isFunction       = FunctionPointerTraits<typename Private::AddPointer<T>::Result >::result };
-    enum { isFunctionPointer = FunctionPointerTraits <
-                               typename ReferenceTraits<UnqualifiedType>::ReferredType >::result
-         };
-    enum { isMemberFunctionPointer = PToMFunctionTraits <
-                                     typename ReferenceTraits<UnqualifiedType>::ReferredType >::result
-         };
-    enum { isMemberPointer  = PToMTraits <
-                              typename ReferenceTraits<UnqualifiedType>::ReferredType >::result ||
-                              isMemberFunctionPointer
-         };
-    enum { isPointer        = PointerTraits <
-                              typename ReferenceTraits<UnqualifiedType>::ReferredType >::result ||
-                              isFunctionPointer
-         };
-
-    enum { isStdUnsignedInt = TL::IndexOf<Private::StdUnsignedInts, UnqualifiedType>::value >= 0 ||
-           TL::IndexOf < Private::StdUnsignedInts,
-           typename ReferenceTraits<UnqualifiedType>::ReferredType >::value >= 0
-         };
-    enum { isStdSignedInt   = TL::IndexOf<Private::StdSignedInts, UnqualifiedType>::value >= 0 ||
-           TL::IndexOf < Private::StdSignedInts,
-           typename ReferenceTraits<UnqualifiedType>::ReferredType >::value >= 0
-         };
-    enum { isStdIntegral    = isStdUnsignedInt || isStdSignedInt ||
-                              TL::IndexOf<Private::StdOtherInts, UnqualifiedType>::value >= 0 ||
-           TL::IndexOf < Private::StdOtherInts,
-           typename ReferenceTraits<UnqualifiedType>::ReferredType >::value >= 0
-         };
-    enum { isStdFloat       = TL::IndexOf<Private::StdFloats, UnqualifiedType>::value >= 0 ||
-           TL::IndexOf < Private::StdFloats,
-           typename ReferenceTraits<UnqualifiedType>::ReferredType >::value >= 0
-         };
-    enum { isStdArith       = isStdIntegral || isStdFloat };
-    enum { isStdFundamental = isStdArith || isStdFloat || Conversion<T, void>::sameType };
-
-    enum { isUnsignedInt    = isStdUnsignedInt || IsCustomUnsignedInt<UnqualifiedType>::value };
-    enum { isSignedInt      = isStdSignedInt || IsCustomSignedInt<UnqualifiedType>::value };
-    enum { isIntegral       = isStdIntegral || isUnsignedInt || isSignedInt };
-    enum { isFloat          = isStdFloat || IsCustomFloat<UnqualifiedType>::value };
-    enum { isArith          = isIntegral || isFloat };
-    enum { isFundamental    = isStdFundamental || isArith };
-
-    typedef typename Select < isStdArith || isPointer || isMemberPointer, T,
-            typename Private::AddParameterType<T>::Result >::Result
-            ParameterType;
-};
-}
-
-#ifdef _MSC_VER
-#pragma warning( pop )
-#endif // _MSC_VER
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/Typelist.h b/shared/loki/Typelist.h
deleted file mode 100644
index e512ac83..00000000
--- a/shared/loki/Typelist.h
+++ /dev/null
@@ -1,459 +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-Welsey 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_TYPELIST_INC_
-#define LOKI_TYPELIST_INC_
-
-// $Id: Typelist.h 749 2006-10-17 19:49:26Z syntheticpp $
-
-
-#include "NullType.h"
-#include "TypeManip.h"
-#include "TypelistMacros.h"
-
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template Typelist
-// The building block of typelists of any length
-// Use it through the LOKI_TYPELIST_NN macros
-// Defines nested types:
-//     Head (first element, a non-typelist type by convention)
-//     Tail (second element, can be another typelist)
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class U>
-struct Typelist
-{
-    typedef T Head;
-    typedef U Tail;
-};
-
-// Typelist utility algorithms
-
-namespace TL
-{
-
-////////////////////////////////////////////////////////////////////////////////
-// class template MakeTypelist
-// Takes a number of arguments equal to its numeric suffix
-// The arguments are type names.
-// MakeTypelist<T1, T2, ...>::Result
-// returns a typelist that is of T1, T2, ...
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename T1  = NullType, typename T2  = NullType, typename T3  = NullType,
-         typename T4  = NullType, typename T5  = NullType, typename T6  = NullType,
-         typename T7  = NullType, typename T8  = NullType, typename T9  = NullType,
-         typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
-         typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
-         typename T16 = NullType, typename T17 = NullType, typename T18 = NullType
-         >
-struct MakeTypelist
-{
-private:
-    typedef typename MakeTypelist
-    <
-    T2 , T3 , T4 ,
-       T5 , T6 , T7 ,
-       T8 , T9 , T10,
-       T11, T12, T13,
-       T14, T15, T16,
-       T17, T18
-       >
-       ::Result TailResult;
-
-public:
-    typedef Typelist<T1, TailResult> Result;
-};
-
-template<>
-struct MakeTypelist<>
-{
-    typedef NullType Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Length
-// Computes the length of a typelist
-// Invocation (TList is a typelist):
-// Length<TList>::value
-// returns a compile-time constant containing the length of TList, not counting
-//     the end terminator (which by convention is NullType)
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList> struct Length;
-template <> struct Length<NullType>
-{
-    enum { value = 0 };
-};
-
-template <class T, class U>
-struct Length< Typelist<T, U> >
-{
-    enum { value = 1 + Length<U>::value };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template TypeAt
-// Finds the type at a given index in a typelist
-// Invocation (TList is a typelist and index is a compile-time integral
-//     constant):
-// TypeAt<TList, index>::Result
-// returns the type in position 'index' in TList
-// If you pass an out-of-bounds index, the result is a compile-time error
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, unsigned int index> struct TypeAt;
-
-template <class Head, class Tail>
-struct TypeAt<Typelist<Head, Tail>, 0>
-{
-    typedef Head Result;
-};
-
-template <class Head, class Tail, unsigned int i>
-struct TypeAt<Typelist<Head, Tail>, i>
-{
-    typedef typename TypeAt < Tail, i - 1 >::Result Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template TypeAtNonStrict
-// Finds the type at a given index in a typelist
-// Invocations (TList is a typelist and index is a compile-time integral
-//     constant):
-// a) TypeAt<TList, index>::Result
-// returns the type in position 'index' in TList, or NullType if index is
-//     out-of-bounds
-// b) TypeAt<TList, index, D>::Result
-// returns the type in position 'index' in TList, or D if index is out-of-bounds
-////////////////////////////////////////////////////////////////////////////////
-
-template < class TList, unsigned int index,
-         typename DefaultType = NullType >
-struct TypeAtNonStrict
-{
-    typedef DefaultType Result;
-};
-
-template <class Head, class Tail, typename DefaultType>
-struct TypeAtNonStrict<Typelist<Head, Tail>, 0, DefaultType>
-{
-    typedef Head Result;
-};
-
-template <class Head, class Tail, unsigned int i, typename DefaultType>
-struct TypeAtNonStrict<Typelist<Head, Tail>, i, DefaultType>
-{
-    typedef typename
-    TypeAtNonStrict < Tail, i - 1, DefaultType >::Result Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template IndexOf
-// Finds the index of a type in a typelist
-// Invocation (TList is a typelist and T is a type):
-// IndexOf<TList, T>::value
-// returns the position of T in TList, or NullType if T is not found in TList
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T> struct IndexOf;
-
-template <class T>
-struct IndexOf<NullType, T>
-{
-    enum { value = -1 };
-};
-
-template <class T, class Tail>
-struct IndexOf<Typelist<T, Tail>, T>
-{
-    enum { value = 0 };
-};
-
-template <class Head, class Tail, class T>
-struct IndexOf<Typelist<Head, Tail>, T>
-{
-private:
-    enum { temp = IndexOf<Tail, T>::value };
-public:
-    enum { value = (temp == -1 ? -1 : 1 + temp) };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Append
-// Appends a type or a typelist to another
-// Invocation (TList is a typelist and T is either a type or a typelist):
-// Append<TList, T>::Result
-// returns a typelist that is TList followed by T and NullType-terminated
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T> struct Append;
-
-template <> struct Append<NullType, NullType>
-{
-    typedef NullType Result;
-};
-
-template <class T> struct Append<NullType, T>
-{
-    typedef Typelist<T, NullType> Result;
-};
-
-template <class Head, class Tail>
-struct Append<NullType, Typelist<Head, Tail> >
-{
-    typedef Typelist<Head, Tail> Result;
-};
-
-template <class Head, class Tail, class T>
-struct Append<Typelist<Head, Tail>, T>
-{
-    typedef Typelist < Head,
-            typename Append<Tail, T>::Result >
-            Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Erase
-// Erases the first occurence, if any, of a type in a typelist
-// Invocation (TList is a typelist and T is a type):
-// Erase<TList, T>::Result
-// returns a typelist that is TList without the first occurence of T
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T> struct Erase;
-
-template <class T>                         // Specialization 1
-struct Erase<NullType, T>
-{
-    typedef NullType Result;
-};
-
-template <class T, class Tail>             // Specialization 2
-struct Erase<Typelist<T, Tail>, T>
-{
-    typedef Tail Result;
-};
-
-template <class Head, class Tail, class T> // Specialization 3
-struct Erase<Typelist<Head, Tail>, T>
-{
-    typedef Typelist < Head,
-            typename Erase<Tail, T>::Result >
-            Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template EraseAll
-// Erases all first occurences, if any, of a type in a typelist
-// Invocation (TList is a typelist and T is a type):
-// EraseAll<TList, T>::Result
-// returns a typelist that is TList without any occurence of T
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T> struct EraseAll;
-template <class T>
-struct EraseAll<NullType, T>
-{
-    typedef NullType Result;
-};
-template <class T, class Tail>
-struct EraseAll<Typelist<T, Tail>, T>
-{
-    // Go all the way down the list removing the type
-    typedef typename EraseAll<Tail, T>::Result Result;
-};
-template <class Head, class Tail, class T>
-struct EraseAll<Typelist<Head, Tail>, T>
-{
-    // Go all the way down the list removing the type
-    typedef Typelist < Head,
-            typename EraseAll<Tail, T>::Result >
-            Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template NoDuplicates
-// Removes all duplicate types in a typelist
-// Invocation (TList is a typelist):
-// NoDuplicates<TList, T>::Result
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList> struct NoDuplicates;
-
-template <> struct NoDuplicates<NullType>
-{
-    typedef NullType Result;
-};
-
-template <class Head, class Tail>
-struct NoDuplicates< Typelist<Head, Tail> >
-{
-private:
-    typedef typename NoDuplicates<Tail>::Result L1;
-    typedef typename Erase<L1, Head>::Result L2;
-public:
-    typedef Typelist<Head, L2> Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Replace
-// Replaces the first occurence of a type in a typelist, with another type
-// Invocation (TList is a typelist, T, U are types):
-// Replace<TList, T, U>::Result
-// returns a typelist in which the first occurence of T is replaced with U
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T, class U> struct Replace;
-
-template <class T, class U>
-struct Replace<NullType, T, U>
-{
-    typedef NullType Result;
-};
-
-template <class T, class Tail, class U>
-struct Replace<Typelist<T, Tail>, T, U>
-{
-    typedef Typelist<U, Tail> Result;
-};
-
-template <class Head, class Tail, class T, class U>
-struct Replace<Typelist<Head, Tail>, T, U>
-{
-    typedef Typelist < Head,
-            typename Replace<Tail, T, U>::Result >
-            Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template ReplaceAll
-// Replaces all occurences of a type in a typelist, with another type
-// Invocation (TList is a typelist, T, U are types):
-// Replace<TList, T, U>::Result
-// returns a typelist in which all occurences of T is replaced with U
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T, class U> struct ReplaceAll;
-
-template <class T, class U>
-struct ReplaceAll<NullType, T, U>
-{
-    typedef NullType Result;
-};
-
-template <class T, class Tail, class U>
-struct ReplaceAll<Typelist<T, Tail>, T, U>
-{
-    typedef Typelist<U, typename ReplaceAll<Tail, T, U>::Result> Result;
-};
-
-template <class Head, class Tail, class T, class U>
-struct ReplaceAll<Typelist<Head, Tail>, T, U>
-{
-    typedef Typelist < Head,
-            typename ReplaceAll<Tail, T, U>::Result >
-            Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Reverse
-// Reverses a typelist
-// Invocation (TList is a typelist):
-// Reverse<TList>::Result
-// returns a typelist that is TList reversed
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList> struct Reverse;
-
-template <>
-struct Reverse<NullType>
-{
-    typedef NullType Result;
-};
-
-template <class Head, class Tail>
-struct Reverse< Typelist<Head, Tail> >
-{
-    typedef typename Append <
-    typename Reverse<Tail>::Result, Head >::Result Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template MostDerived
-// Finds the type in a typelist that is the most derived from a given type
-// Invocation (TList is a typelist, T is a type):
-// MostDerived<TList, T>::Result
-// returns the type in TList that's the most derived from T
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, class T> struct MostDerived;
-
-template <class T>
-struct MostDerived<NullType, T>
-{
-    typedef T Result;
-};
-
-template <class Head, class Tail, class T>
-struct MostDerived<Typelist<Head, Tail>, T>
-{
-private:
-    typedef typename MostDerived<Tail, T>::Result Candidate;
-public:
-    typedef typename Select <
-    SuperSubclass<Candidate, Head>::value,
-                  Head, Candidate >::Result Result;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template DerivedToFront
-// Arranges the types in a typelist so that the most derived types appear first
-// Invocation (TList is a typelist):
-// DerivedToFront<TList>::Result
-// returns the reordered TList
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList> struct DerivedToFront;
-
-template <>
-struct DerivedToFront<NullType>
-{
-    typedef NullType Result;
-};
-
-template <class Head, class Tail>
-struct DerivedToFront< Typelist<Head, Tail> >
-{
-private:
-    typedef typename MostDerived<Tail, Head>::Result
-    TheMostDerived;
-    typedef typename Replace < Tail,
-            TheMostDerived, Head >::Result Temp;
-    typedef typename DerivedToFront<Temp>::Result L;
-public:
-    typedef Typelist<TheMostDerived, L> Result;
-};
-
-}   // namespace TL
-}   // namespace Loki
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/TypelistMacros.h b/shared/loki/TypelistMacros.h
deleted file mode 100644
index 4bd34cb7..00000000
--- a/shared/loki/TypelistMacros.h
+++ /dev/null
@@ -1,353 +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-Welsey 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_TYPELISTMACROS_INC_
-#define LOKI_TYPELISTMACROS_INC_
-
-// $Id: TypelistMacros.h 749 2006-10-17 19:49:26Z syntheticpp $
-
-
-//#define LOKI_DISABLE_TYPELIST_MACROS
-#ifndef LOKI_DISABLE_TYPELIST_MACROS
-
-////////////////////////////////////////////////////////////////////////////////
-// macros LOKI_TYPELIST_1, LOKI_TYPELIST_2, ... LOKI_TYPELIST_50
-// Each takes a number of arguments equal to its numeric suffix
-// The arguments are type names. LOKI_TYPELIST_NN generates a typelist containing
-//     all types passed as arguments, in that order.
-// Example: LOKI_TYPELIST_2(char, int) generates a type containing char and int.
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_TYPELIST_1(T1) ::Loki::Typelist<T1, ::Loki::NullType>
-
-#define LOKI_TYPELIST_2(T1, T2) ::Loki::Typelist<T1, LOKI_TYPELIST_1(T2) >
-
-#define LOKI_TYPELIST_3(T1, T2, T3) ::Loki::Typelist<T1, LOKI_TYPELIST_2(T2, T3) >
-
-#define LOKI_TYPELIST_4(T1, T2, T3, T4) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_3(T2, T3, T4) >
-
-#define LOKI_TYPELIST_5(T1, T2, T3, T4, T5) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_4(T2, T3, T4, T5) >
-
-#define LOKI_TYPELIST_6(T1, T2, T3, T4, T5, T6) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_5(T2, T3, T4, T5, T6) >
-
-#define LOKI_TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_6(T2, T3, T4, T5, T6, T7) >
-
-#define LOKI_TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
-
-#define LOKI_TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
-
-#define LOKI_TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >
-
-#define LOKI_TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
-
-#define LOKI_TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                          T11, T12) >
-
-#define LOKI_TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \
-    ::Loki::Typelist<T1, LOKI_TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                          T11, T12, T13) >
-
-#define LOKI_TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14) \
-::Loki::Typelist<T1, LOKI_TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14) >
-
-#define LOKI_TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15) \
-::Loki::Typelist<T1, LOKI_TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15) >
-
-#define LOKI_TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16) \
-::Loki::Typelist<T1, LOKI_TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16) >
-
-#define LOKI_TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17) \
-::Loki::Typelist<T1, LOKI_TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17) >
-
-#define LOKI_TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18) \
-::Loki::Typelist<T1, LOKI_TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18) >
-
-#define LOKI_TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19) \
-::Loki::Typelist<T1, LOKI_TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19) >
-
-#define LOKI_TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) \
-::Loki::Typelist<T1, LOKI_TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) >
-
-#define LOKI_TYPELIST_21(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) \
-::Loki::Typelist<T1, LOKI_TYPELIST_20(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) >
-
-#define LOKI_TYPELIST_22(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) \
-::Loki::Typelist<T1, LOKI_TYPELIST_21(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) >
-
-#define LOKI_TYPELIST_23(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) \
-::Loki::Typelist<T1, LOKI_TYPELIST_22(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) >
-
-#define LOKI_TYPELIST_24(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) \
-::Loki::Typelist<T1, LOKI_TYPELIST_23(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) >
-
-#define LOKI_TYPELIST_25(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) \
-::Loki::Typelist<T1, LOKI_TYPELIST_24(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25) >
-
-#define LOKI_TYPELIST_26(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26) \
-::Loki::Typelist<T1, LOKI_TYPELIST_25(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26) >
-
-#define LOKI_TYPELIST_27(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27) \
-::Loki::Typelist<T1, LOKI_TYPELIST_26(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27) >
-
-#define LOKI_TYPELIST_28(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28) \
-::Loki::Typelist<T1, LOKI_TYPELIST_27(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28) >
-
-#define LOKI_TYPELIST_29(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29) \
-::Loki::Typelist<T1, LOKI_TYPELIST_28(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29) >
-
-#define LOKI_TYPELIST_30(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) \
-::Loki::Typelist<T1, LOKI_TYPELIST_29(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) >
-
-#define LOKI_TYPELIST_31(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) \
-::Loki::Typelist<T1, LOKI_TYPELIST_30(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) >
-
-#define LOKI_TYPELIST_32(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) \
-::Loki::Typelist<T1, LOKI_TYPELIST_31(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) >
-
-#define LOKI_TYPELIST_33(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) \
-::Loki::Typelist<T1, LOKI_TYPELIST_32(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) >
-
-#define LOKI_TYPELIST_34(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) \
-::Loki::Typelist<T1, LOKI_TYPELIST_33(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) >
-
-#define LOKI_TYPELIST_35(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35) \
-::Loki::Typelist<T1, LOKI_TYPELIST_34(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35) >
-
-#define LOKI_TYPELIST_36(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36) \
-::Loki::Typelist<T1, LOKI_TYPELIST_35(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36) >
-
-#define LOKI_TYPELIST_37(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37) \
-::Loki::Typelist<T1, LOKI_TYPELIST_36(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37) >
-
-#define LOKI_TYPELIST_38(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38) \
-::Loki::Typelist<T1, LOKI_TYPELIST_37(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38) >
-
-#define LOKI_TYPELIST_39(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39) \
-::Loki::Typelist<T1, LOKI_TYPELIST_38(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39) >
-
-#define LOKI_TYPELIST_40(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) \
-::Loki::Typelist<T1, LOKI_TYPELIST_39(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) >
-
-#define LOKI_TYPELIST_41(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) \
-::Loki::Typelist<T1, LOKI_TYPELIST_40(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) >
-
-#define LOKI_TYPELIST_42(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) \
-::Loki::Typelist<T1, LOKI_TYPELIST_41(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) >
-
-#define LOKI_TYPELIST_43(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) \
-::Loki::Typelist<T1, LOKI_TYPELIST_42(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) >
-
-#define LOKI_TYPELIST_44(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) \
-::Loki::Typelist<T1, LOKI_TYPELIST_43(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) >
-
-#define LOKI_TYPELIST_45(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                         T41, T42, T43, T44, T45) \
-::Loki::Typelist<T1, LOKI_TYPELIST_44(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                                      T41, T42, T43, T44, T45) >
-
-#define LOKI_TYPELIST_46(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                         T41, T42, T43, T44, T45, T46) \
-::Loki::Typelist<T1, LOKI_TYPELIST_45(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                                      T41, T42, T43, T44, T45, T46) >
-
-#define LOKI_TYPELIST_47(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                         T41, T42, T43, T44, T45, T46, T47) \
-::Loki::Typelist<T1, LOKI_TYPELIST_46(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                                      T41, T42, T43, T44, T45, T46, T47) >
-
-#define LOKI_TYPELIST_48(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                         T41, T42, T43, T44, T45, T46, T47, T48) \
-::Loki::Typelist<T1, LOKI_TYPELIST_47(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                                      T41, T42, T43, T44, T45, T46, T47, T48) >
-
-#define LOKI_TYPELIST_49(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                         T41, T42, T43, T44, T45, T46, T47, T48, T49) \
-::Loki::Typelist<T1, LOKI_TYPELIST_48(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                                      T41, T42, T43, T44, T45, T46, T47, T48, T49) >
-
-#define LOKI_TYPELIST_50(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                         T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                         T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                         T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                         T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) \
-::Loki::Typelist<T1, LOKI_TYPELIST_49(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-                                      T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
-                                      T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
-                                      T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
-                                      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) >
-
-#endif //LOKI_DISABLE_TYPELIST_MACROS
-
-#endif // end file guardian
-
diff --git a/shared/loki/Visitor.h b/shared/loki/Visitor.h
deleted file mode 100644
index 85b8acd2..00000000
--- a/shared/loki/Visitor.h
+++ /dev/null
@@ -1,355 +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_VISITOR_INC_
-#define LOKI_VISITOR_INC_
-
-// $Id: Visitor.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-///  \defgroup VisitorGroup Visitor
-
-#include "Typelist.h"
-#include "HierarchyGenerators.h"
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class BaseVisitor
-///
-/// \ingroup VisitorGroup
-/// The base class of any Acyclic Visitor
-////////////////////////////////////////////////////////////////////////////////
-
-class BaseVisitor
-{
-public:
-    virtual ~BaseVisitor() {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class Visitor
-///
-/// \ingroup VisitorGroup
-/// The building block of Acyclic Visitor
-///
-/// \par Usage
-///
-/// Defining the visitable class:
-///
-/// \code
-/// class RasterBitmap : public BaseVisitable<>
-/// {
-/// public:
-///     LOKI_DEFINE_VISITABLE()
-/// };
-/// \endcode
-///
-/// Way 1 to define a visitor:
-/// \code
-/// class SomeVisitor :
-///     public BaseVisitor // required
-///     public Visitor<RasterBitmap>,
-///     public Visitor<Paragraph>
-/// {
-/// public:
-///     void Visit(RasterBitmap&); // visit a RasterBitmap
-///     void Visit(Paragraph &);   // visit a Paragraph
-/// };
-/// \endcode
-///
-/// Way 2 to define the visitor:
-/// \code
-/// class SomeVisitor :
-///     public BaseVisitor // required
-///     public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
-/// {
-/// public:
-///     void Visit(RasterBitmap&); // visit a RasterBitmap
-///     void Visit(Paragraph &);   // visit a Paragraph
-/// };
-/// \endcode
-///
-/// Way 3 to define the visitor:
-/// \code
-/// class SomeVisitor :
-///     public BaseVisitor // required
-///     public Visitor<Seq<RasterBitmap, Paragraph>::Type>
-/// {
-/// public:
-///     void Visit(RasterBitmap&); // visit a RasterBitmap
-///     void Visit(Paragraph &);   // visit a Paragraph
-/// };
-/// \endcode
-///
-/// \par Using const visit functions:
-///
-/// Defining the visitable class (true for const):
-///
-/// \code
-/// class RasterBitmap : public BaseVisitable<void, DefaultCatchAll, true>
-/// {
-/// public:
-///     LOKI_DEFINE_CONST_VISITABLE()
-/// };
-/// \endcode
-///
-/// Defining the visitor which only calls const member functions:
-/// \code
-/// class SomeVisitor :
-///     public BaseVisitor // required
-///     public Visitor<RasterBitmap, void, true>,
-/// {
-/// public:
-///     void Visit(const RasterBitmap&); // visit a RasterBitmap by a const member function
-/// };
-/// \endcode
-///
-/// \par Example:
-///
-/// test/Visitor/main.cpp
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, typename R = void, bool ConstVisit = false>
-class Visitor;
-
-template <class T, typename R>
-class Visitor<T, R, false>
-{
-public:
-    typedef R ReturnType;
-    typedef T ParamType;
-    virtual ~Visitor() {}
-    virtual ReturnType Visit(ParamType&) = 0;
-};
-
-template <class T, typename R>
-class Visitor<T, R, true>
-{
-public:
-    typedef R ReturnType;
-    typedef const T ParamType;
-    virtual ~Visitor() {}
-    virtual ReturnType Visit(ParamType&) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Visitor (specialization)
-// This specialization is not present in the book. It makes it easier to define
-// Visitors for multiple types in a shot by using a typelist. Example:
-//
-// class SomeVisitor :
-//     public BaseVisitor // required
-//     public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
-// {
-// public:
-//     void Visit(RasterBitmap&); // visit a RasterBitmap
-//     void Visit(Paragraph &);   // visit a Paragraph
-// };
-////////////////////////////////////////////////////////////////////////////////
-
-template <class Head, class Tail, typename R>
-class Visitor<Typelist<Head, Tail>, R, false>
-    : public Visitor<Head, R, false>, public Visitor<Tail, R, false>
-{
-public:
-    typedef R ReturnType;
-    // using Visitor<Head, R>::Visit;
-    // using Visitor<Tail, R>::Visit;
-};
-
-template <class Head, typename R>
-class Visitor<Typelist<Head, NullType>, R, false> : public Visitor<Head, R, false>
-{
-public:
-    typedef R ReturnType;
-    using Visitor<Head, R, false>::Visit;
-};
-
-template <class Head, class Tail, typename R>
-class Visitor<Typelist<Head, Tail>, R, true>
-    : public Visitor<Head, R, true>, public Visitor<Tail, R, true>
-{
-public:
-    typedef R ReturnType;
-    // using Visitor<Head, R>::Visit;
-    // using Visitor<Tail, R>::Visit;
-};
-
-template <class Head, typename R>
-class Visitor<Typelist<Head, NullType>, R, true> : public Visitor<Head, R, true>
-{
-public:
-    typedef R ReturnType;
-    using Visitor<Head, R, true>::Visit;
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-// class template BaseVisitorImpl
-// Implements non-strict visitation (you can implement only part of the Visit
-//     functions)
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TList, typename R = void> class BaseVisitorImpl;
-
-template <class Head, class Tail, typename R>
-class BaseVisitorImpl<Typelist<Head, Tail>, R>
-    : public Visitor<Head, R>
-    , public BaseVisitorImpl<Tail, R>
-{
-public:
-    // using BaseVisitorImpl<Tail, R>::Visit;
-
-    virtual R Visit(Head&)
-    { return R(); }
-};
-
-template <class Head, typename R>
-class BaseVisitorImpl<Typelist<Head, NullType>, R>
-    : public Visitor<Head, R>
-{
-public:
-    virtual R Visit(Head&)
-    { return R(); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template BaseVisitable
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename R, typename Visited>
-struct DefaultCatchAll
-{
-    static R OnUnknownVisitor(Visited&, BaseVisitor&)
-    { return R(); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// class template BaseVisitable
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-typename R = void,
-         template <typename, class> class CatchAll = DefaultCatchAll,
-         bool ConstVisitable = false
-         >
-class BaseVisitable;
-
-template<typename R, template <typename, class> class CatchAll>
-class BaseVisitable<R, CatchAll, false>
-{
-public:
-    typedef R ReturnType;
-    virtual ~BaseVisitable() {}
-    virtual ReturnType Accept(BaseVisitor&) = 0;
-
-protected: // give access only to the hierarchy
-    template <class T>
-    static ReturnType AcceptImpl(T& visited, BaseVisitor& guest)
-    {
-        // Apply the Acyclic Visitor
-        if (Visitor<T, R>* p = dynamic_cast<Visitor<T, R>*>(&guest))
-        {
-            return p->Visit(visited);
-        }
-        return CatchAll<R, T>::OnUnknownVisitor(visited, guest);
-    }
-};
-
-template<typename R, template <typename, class> class CatchAll>
-class BaseVisitable<R, CatchAll, true>
-{
-public:
-    typedef R ReturnType;
-    virtual ~BaseVisitable() {}
-    virtual ReturnType Accept(BaseVisitor&) const = 0;
-
-protected: // give access only to the hierarchy
-    template <class T>
-    static ReturnType AcceptImpl(const T& visited, BaseVisitor& guest)
-    {
-        // Apply the Acyclic Visitor
-        if (Visitor<T, R, true>* p = dynamic_cast<Visitor<T, R, true>*>(&guest))
-        {
-            return p->Visit(visited);
-        }
-        return CatchAll<R, T>::OnUnknownVisitor(const_cast<T&>(visited), guest);
-    }
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-/// \def LOKI_DEFINE_VISITABLE()
-/// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable
-/// (in addition to deriving it from BaseVisitable<R>)
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_DEFINE_VISITABLE() \
-    virtual ReturnType Accept(::Loki::BaseVisitor& guest) \
-    { return AcceptImpl(*this, guest); }
-
-////////////////////////////////////////////////////////////////////////////////
-/// \def LOKI_DEFINE_CONST_VISITABLE()
-/// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable by const member
-/// functions (in addition to deriving it from BaseVisitable<R>)
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_DEFINE_CONST_VISITABLE() \
-    virtual ReturnType Accept(::Loki::BaseVisitor& guest) const \
-    { return AcceptImpl(*this, guest); }
-
-////////////////////////////////////////////////////////////////////////////////
-/// \class CyclicVisitor
-///
-/// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable (in addition to
-/// deriving it from BaseVisitable<R>
-////////////////////////////////////////////////////////////////////////////////
-
-template <typename R, class TList>
-class CyclicVisitor : public Visitor<TList, R>
-{
-public:
-    typedef R ReturnType;
-    // using Visitor<TList, R>::Visit;
-
-    template <class Visited>
-    ReturnType GenericVisit(Visited& host)
-    {
-        Visitor<Visited, ReturnType>& subObj = *this;
-        return subObj.Visit(host);
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-/// \def LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor)
-/// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable by a cyclic visitor
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor) \
-    virtual SomeVisitor::ReturnType Accept(SomeVisitor& guest) \
-    { return guest.GenericVisit(*this); }
-
-} // namespace Loki
-
-
-
-#endif // end file guardian
-
diff --git a/shared/loki/readme.txt b/shared/loki/readme.txt
deleted file mode 100644
index a35cf387..00000000
--- a/shared/loki/readme.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-// $Id: readme.txt 753 2006-10-17 19:54:22Z syntheticpp $
-
-The Golden Code
-KEEPEN DER DAMDDEN FUGGERMUTTENS OTTEN DIS CODDEN FIL
-
-A compliant C++ compiler will compile all of this code as is.
-See the respective vendor directories for code that actually compiles & runs.
-
-Note: Right now, this code contains CodeWarrior & gcc modifications, 
-which may be removed at a future point in time 
-(by moving them to a vendor specific implementation).
-MKH
\ No newline at end of file
diff --git a/shared/loki/static_check.h b/shared/loki/static_check.h
deleted file mode 100644
index b4c455c9..00000000
--- a/shared/loki/static_check.h
+++ /dev/null
@@ -1,45 +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_STATIC_CHECK_INC_
-#define LOKI_STATIC_CHECK_INC_
-
-// $Id: static_check.h 752 2006-10-17 19:52:18Z syntheticpp $
-
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// Helper structure for the STATIC_CHECK macro
-////////////////////////////////////////////////////////////////////////////////
-
-template<int> struct CompileTimeError;
-template<> struct CompileTimeError<true> {};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// macro STATIC_CHECK
-// Invocation: STATIC_CHECK(expr, id)
-// where:
-// expr is a compile-time integral or pointer expression
-// id is a C++ identifier that does not need to be defined
-// If expr is zero, id will appear in a compile-time error message.
-////////////////////////////////////////////////////////////////////////////////
-
-#define LOKI_STATIC_CHECK(expr, msg) \
-    { Loki::CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; }
-
-
-#endif // end file guardian
-