diff --git a/AbstractFactory.h b/AbstractFactory.h
index fb5ed93..4a0644b 100644
--- a/AbstractFactory.h
+++ b/AbstractFactory.h
@@ -1,164 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////
+//Generated header: AbstractFactory.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-#ifndef ABSTRACTFACTORY_INC_
-#define ABSTRACTFACTORY_INC_
-
-#include "Typelist.h"
-#include "TypeManip.h"
-#include "HierarchyGenerators.h"
-
-#include <cassert>
-
-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)
-        {}
-        
-        friend void DoGetPrototype(const PrototypeFactoryUnit& me,
-            AbstractProduct*& pPrototype)
-        { pPrototype = me.pPrototype_; }
-        
-        friend void DoSetPrototype(PrototypeFactoryUnit& me, 
-            AbstractProduct* pObj)
-        { me.pPrototype_ = pObj; }
-        
-        template <class U>
-        void GetPrototype(AbstractProduct*& 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_;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// 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
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // ABSTRACTFACTORY_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\AbstractFactory.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\AbstractFactory.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\AbstractFactory.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\AbstractFactory.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\AbstractFactory.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/AssocVector.h b/AssocVector.h
index 2b4386e..0dc51c5 100644
--- a/AssocVector.h
+++ b/AssocVector.h
@@ -1,335 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////
+//Generated header: AssocVector.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-#ifndef ASSOCVECTOR_INC_
-#define ASSOCVECTOR_INC_
 
-#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() || operator()(val.first, i->first))
-            {
-                i = Base::insert(i, val);
-                found = false;
-            }
-            return std::make_pair(i, !found);
-        }
-
-        iterator insert(iterator pos, const value_type& val)
-        {
-            if (pos != end() && operator()(*pos, val) && 
-                (pos == end() - 1 ||
-                    !operator()(val, pos[1]) &&
-                        operator()(pos[1], val)))
-            {
-                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)
-        {
-            using std::swap;
-            Base::swap(other);
-            MyCompare& me = *this;
-            MyCompare& rhs = other;
-            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() && 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() && 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);
-        }
-        
-        friend bool operator==(const AssocVector& lhs, const AssocVector& rhs)
-        {
-            const Base& me = lhs;
-            return me == rhs;
-        } 
-
-        bool operator<(const AssocVector& rhs) const
-        {
-            const Base& me = *this;
-            const Base& yo = rhs;
-            return me < yo;
-        } 
-
-        friend bool operator!=(const AssocVector& lhs, const AssocVector& rhs)
-        { return !(lhs == rhs); } 
-
-        friend bool operator>(const AssocVector& lhs, const AssocVector& rhs)
-        { return rhs < lhs; }
-
-        friend bool operator>=(const AssocVector& lhs, const AssocVector& rhs)
-        { return !(lhs < rhs); } 
-
-        friend bool operator<=(const AssocVector& lhs, const AssocVector& 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
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// May 20, 2001: change operator= - credit due to Cristoph Koegl
-// June 11, 2001: remove paren in equal_range - credit due to Cristoph Koegl
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// January 22, 2002: fixed operator= - credit due to Tom Hyer
-// June 25, 2002: fixed template insert() - credit due to Robert Minsk
-// June 27, 2002: fixed member swap() - credit due to David Brookman
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // ASSOCVECTOR_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\AssocVector.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\AssocVector.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\AssocVector.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\AssocVector.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\AssocVector.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/EmptyType.h b/EmptyType.h
index e8ffb17..dfc21f6 100644
--- a/EmptyType.h
+++ b/EmptyType.h
@@ -1,37 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////
+//Generated header: EmptyType.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-#ifndef EMPTYTYPE_INC_
-#define EMPTYTYPE_INC_
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class EmptyType
-// Used as a class type that doesn't hold anything
-// Useful as a strawman class
-////////////////////////////////////////////////////////////////////////////////
-
-    class EmptyType {};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // EMPTYTYPE_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\EmptyType.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\EmptyType.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\EmptyType.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\EmptyType.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\EmptyType.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Factory.h b/Factory.h
index 475c956..c1bd4ca 100644
--- a/Factory.h
+++ b/Factory.h
@@ -1,145 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////
+//Generated header: Factory.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-#ifndef FACTORY_INC_
-#define FACTORY_INC_
-
-#include "TypeInfo.h"
-#include "AssocVector.h"
-#include <exception>
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-// class template DefaultFactoryError
-// Manages the "Unknown Type" error in an object factory
-////////////////////////////////////////////////////////////////////////////////
-
-    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();
-        }
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Factory
-// Implements a generic object factory
-////////////////////////////////////////////////////////////////////////////////
-
-    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(
-                IdToProductMap::value_type(id, creator)).second;
-        }
-        
-        bool Unregister(const IdentifierType& id)
-        {
-            return associations_.erase(id) == 1;
-        }
-        
-        AbstractProduct* CreateObject(const IdentifierType& id)
-        {
-            typename IdToProductMap::iterator i = associations_.find(id);
-            if (i != associations_.end())
-            {
-                return (i->second)();
-            }
-            return OnUnknownType(id);
-        }
-        
-    private:
-        typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
-        IdToProductMap associations_;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template CloneFactory
-// Implements a generic cloning factory
-////////////////////////////////////////////////////////////////////////////////
-
-    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(
-                IdToProductMap::value_type(ti, creator)).second;
-        }
-        
-        bool Unregister(const TypeInfo& id)
-        {
-            return associations_.erase(id) == 1;
-        }
-        
-        AbstractProduct* CreateObject(const AbstractProduct* model)
-        {
-            if (model == 0) return 0;
-            
-            typename IdToProductMap::iterator i = 
-                associations_.find(typeid(*model));
-            if (i != associations_.end())
-            {
-                return (i->second)(model);
-            }
-            return OnUnknownType(typeid(*model));
-        }
-        
-    private:
-        typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
-        IdToProductMap associations_;
-    };
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// May 08, 2002: replaced const_iterator with iterator so that self-modifying
-//      ProductCreators are supported. Also, added a throw() spec to what().
-//      Credit due to Jason Fischl.
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // FACTORY_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Factory.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Factory.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Factory.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Factory.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Factory.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Functor.h b/Functor.h
index 2300b61..a91ea17 100644
--- a/Functor.h
+++ b/Functor.h
@@ -1,1144 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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
-
-#ifndef FUNCTOR_INC_
-#define FUNCTOR_INC_
-
-#include "Typelist.h"
-#include "EmptyType.h"
-#include "SmallObj.h"
-#include "TypeTraits.h"
-#include <typeinfo>
-#include <memory>
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl (internal)
-////////////////////////////////////////////////////////////////////////////////
-
-    namespace Private
-    {
-        template <typename R, template <class> class ThreadingModel>
-        struct FunctorImplBase : public SmallObject<ThreadingModel>
-        {
-            typedef R ResultType;
-            
-            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* 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;
-            }
-        };
-    }
-    
-////////////////////////////////////////////////////////////////////////////////
-// macro DEFINE_CLONE_FUNCTORIMPL
-// Implements the DoClone function for a functor implementation
-////////////////////////////////////////////////////////////////////////////////
-
-#define 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 ThreadingModel = DEFAULT_THREADING>
-    class FunctorImpl;
-
-////////////////////////////////////////////////////////////////////////////////
-// class template FunctorImpl
-// Specialization for 0 (zero) parameters
-////////////////////////////////////////////////////////////////////////////////
-
-    template <typename R, template <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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R, 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 ThreadingModel>
-    class FunctorImpl<R,
-            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 ThreadingModel>
-    class FunctorImpl<R,
-            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 ThreadingModel>
-    class FunctorImpl<R,
-            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 ThreadingModel>
-    class FunctorImpl<R,
-            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 ThreadingModel>
-    class FunctorImpl<R,
-            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;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// 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) {}
-        
-        DEFINE_CLONE_FUNCTORIMPL(FunctorHandler)
-
-        // 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)
-        {}
-        
-        DEFINE_CLONE_FUNCTORIMPL(MemFunHandler)
-        
-        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_;
-    };
-        
-////////////////////////////////////////////////////////////////////////////////
-// class template Functor
-// A generalized functor implementation with value semantics
-////////////////////////////////////////////////////////////////////////////////
-       
-    template <typename R, class TList = NullType,
-        template<class> class ThreadingModel = DEFAULT_THREADING>
-    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))
-        {}
-
-        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;
-        }
-        
-        ResultType operator()()
-        { return (*spImpl_)(); }
-
-        ResultType operator()(Parm1 p1)
-        { return (*spImpl_)(p1); }
-        
-        ResultType operator()(Parm1 p1, Parm2 p2)
-        { return (*spImpl_)(p1, p2); }
-        
-        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
-        { return (*spImpl_)(p1, p2, p3); }
-        
-        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
-        { return (*spImpl_)(p1, p2, p3, p4); }
-        
-        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
-        { return (*spImpl_)(p1, p2, p3, p4, p5); }
-        
-        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-            Parm6 p6)
-        { return (*spImpl_)(p1, p2, p3, p4, p5, p6); }
-        
-        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
-            Parm6 p6, Parm7 p7)
-        { 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)
-        { 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)
-        { 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)
-        { 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)
-        { 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)
-        {
-            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)
-        {
-            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)
-        {
-            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)
-        {
-            return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, 
-                p12, p13, p14, p15);
-        }
-
-    private:
-        std::auto_ptr<Impl> spImpl_;
-    };
-    
-    namespace Private
-    {
-        template <class Fctor> struct BinderFirstTraits;
-
-        template <typename R, class TList, template <class> class ThreadingModel>
-        struct BinderFirstTraits< Functor<R, TList, ThreadingModel> >
-        {
-            typedef typename TL::Erase<TList, 
-                    typename TL::TypeAt<TList, 0>::Result>::Result
-                ParmList;
-            typedef Functor<R, ParmList, ThreadingModel> BoundFunctorType;
-            typedef typename BoundFunctorType::Impl Impl;
-        };        
-    }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template BinderFirst
-// 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 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)
-        {}
-        
-        DEFINE_CLONE_FUNCTORIMPL(BinderFirst)
-        
-        // 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_;
-        BoundType b_;
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// function template BindFirst
-// Binds the first parameter of a Functor object to a specific value
-////////////////////////////////////////////////////////////////////////////////
-
-    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 template Chainer
-// 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) {}
-
-        DEFINE_CLONE_FUNCTORIMPL(Chainer)
-
-        // 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_;
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// function template Chain
-// Chains two functor calls one after another
-////////////////////////////////////////////////////////////////////////////////
-
-
-    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
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif  // FUNCTOR_INC_
+//////////////////////////////
+//Generated header: Functor.h
+//Forwards to the appropriate code
+// that works on the detected compiler
+
+
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Functor.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Functor.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Functor.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Functor.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Functor.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/HierarchyGenerators.h b/HierarchyGenerators.h
index ed76530..32ee788 100644
--- a/HierarchyGenerators.h
+++ b/HierarchyGenerators.h
@@ -1,254 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////
+//Generated header: HierarchyGenerators.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: March 05, 2001
 
-#ifndef HIERARCHYGENERATORS_INC_
-#define HIERARCHYGENERATORS_INC_
-
-#include "Typelist.h"
-#include "TypeTraits.h"
-#include "EmptyType.h"
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template GenScatterHierarchy
-// Generates a scattered hierarchy starting from a typelist and a template
-// Invocation (TList is a typelist, Model is a template of one arg):
-// GenScatterHierarchy<TList, Model>
-// The generated class inherits all classes generated by instantiating the 
-// template 'Model' with the types contained in TList 
-////////////////////////////////////////////////////////////////////////////////
-
-    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<T1, Unit>
-        , public GenScatterHierarchy<T2, Unit>
-    {
-    public:
-        typedef Typelist<T1, T2> TList;
-        typedef GenScatterHierarchy<T1, Unit> LeftBase;
-        typedef GenScatterHierarchy<T2, Unit> RightBase;
-        template <typename T> struct Rebind
-        {
-            typedef Unit<T> Result;
-        };
-    };
-     
-    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::Rebind<T>::Result& Field(H& obj)
-    {
-        return obj;
-    }
-     
-    template <class T, class H>
-    const typename H::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::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::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, Model is a template of two args):
-// GenScatterHierarchy<TList, Model>
-////////////////////////////////////////////////////////////////////////////////
-
-    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>
-    {
-    };
-
-}   // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // HIERARCHYGENERATORS_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\HierarchyGenerators.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\HierarchyGenerators.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\HierarchyGenerators.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\HierarchyGenerators.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\HierarchyGenerators.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/MultiMethods.h b/MultiMethods.h
index 8331da3..ee37dce 100644
--- a/MultiMethods.h
+++ b/MultiMethods.h
@@ -1,423 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////
+//Generated header: MultiMethods.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
-
-#ifndef MULTIMETHODS_INC_
-#define MULTIMETHODS_INC_
-
-#include "Typelist.h"
-#include "TypeInfo.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 TList, class SomeLhs>
-        static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
-            Executor exec, TList)
-        {
-            typedef typename TList::Head Head;
-            typedef typename TList::Tail 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 TList>
-        static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
-            Executor exec, TList)
-        {
-            typedef typename TList::Head Head;
-            typedef typename TList::Tail 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_.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()
-        {
-	    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_.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 TYPELIST_2(BaseLhs&, BaseRhs&) ArgsList;
-        typedef Functor<ResultType, ArgsList, 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_.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_.Add<SomeRhs, SomeLhs>(FunctorType(AdapterR(fun)));
-	    }
-        }
-        
-        template <class SomeLhs, class SomeRhs>
-        void Remove()
-        {
-            backEnd_.Remove<SomeLhs, SomeRhs>();
-        }
-
-        ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
-        {
-            return backEnd_.Go(lhs, rhs);
-        }
-    };
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
 
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\MultiMethods.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\MultiMethods.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\MultiMethods.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\MultiMethods.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\MultiMethods.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
 #endif
diff --git a/NullType.h b/NullType.h
index c2f31be..a9ae1ab 100644
--- a/NullType.h
+++ b/NullType.h
@@ -1,39 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////
+//Generated header: NullType.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: November 22, 2001
 
-#ifndef NULLTYPE_INC_
-#define NULLTYPE_INC_
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class NullType
-// Used as a placeholder for "no type here"
-// Useful as an end marker in typelists 
-////////////////////////////////////////////////////////////////////////////////
-
-    class NullType {};
-    
-}   // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// November 22, 2001: minor change to support porting to boost
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // NULLTYPE_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\NullType.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\NullType.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\NullType.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\NullType.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\NullType.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Singleton.cpp b/Singleton.cpp
index 8cb69c2..15a530d 100644
--- a/Singleton.cpp
+++ b/Singleton.cpp
@@ -1,50 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////
+//Generated header: Singleton.cpp
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-#include "Singleton.h"
-
-using namespace Loki::Private;
-
-Loki::Private::TrackerArray Loki::Private::pTrackerArray = 0;
-unsigned int Loki::Private::elements = 0;
-
-////////////////////////////////////////////////////////////////////////////////
-// function AtExitFn
-// Ensures proper destruction of objects with longevity
-////////////////////////////////////////////////////////////////////////////////
-
-void Loki::Private::AtExitFn()
-{
-    assert(elements > 0 && pTrackerArray != 0);
-    // Pick the element at the top of the stack
-    LifetimeTracker* pTop = pTrackerArray[elements - 1];
-    // Remove that object off the stack
-    // Don't check errors - realloc with less memory 
-    //     can't fail
-    pTrackerArray = static_cast<TrackerArray>(std::realloc(
-        pTrackerArray, sizeof(*pTrackerArray) * --elements));
-    // Destroy the element
-    delete pTop;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// January 10, 2002: Fixed bug in call to realloc - credit due to Nigel Gent and
-//      Eike Petersen
-// May 08, 2002: Refixed bug in call to realloc
-////////////////////////////////////////////////////////////////////////////////
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Singleton.cpp"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Singleton.cpp"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Singleton.cpp"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Singleton.cpp"
+#elif (__BORLANDC__)
+#		include ".\Borland\Singleton.cpp"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Singleton.h b/Singleton.h
index 3bbb2c9..5ace6c5 100644
--- a/Singleton.h
+++ b/Singleton.h
@@ -1,448 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////
+//Generated header: Singleton.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-#ifndef SINGLETON_INC_
-#define SINGLETON_INC_
 
-#include "Threads.h"
-#include <algorithm>
-#include <stdexcept>
-#include <cassert>
-#include <cstdlib>
-#include <new>
-
-namespace Loki
-{
-    namespace Private
-    {
-////////////////////////////////////////////////////////////////////////////////
-// 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 data
-        typedef LifetimeTracker** TrackerArray;
-        extern TrackerArray pTrackerArray;
-        extern unsigned int elements;
-
-        // Helper destroyer function
-        template <typename T>
-        struct Deleter
-        {
-            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_;
-        };
-
-        void AtExitFn(); // declaration needed below
-    
-    } // namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-// function template SetLongevity
-// Assigns an object a longevity; ensures ordered destructions of objects 
-//     registered thusly during the exit sequence of the application
-////////////////////////////////////////////////////////////////////////////////
-
-    template <typename T, typename Destroyer>
-    void SetLongevity(T* pDynObject, unsigned int longevity,
-        Destroyer d = Private::Deleter<T>::Delete)
-    {
-        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);
-    }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template CreateUsingNew
-// 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; }
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template CreateUsingNew
-// 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);
-        }
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template CreateStatic
-// 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
-    {
-        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);
-        };
-        
-        static T* Create()
-        {
-            static MaxAlign staticMemory_;
-            return new(&staticMemory_) T;
-        }
-        
-        static void Destroy(T* p)
-        {
-            p->~T();
-        }
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template DefaultLifetime
-// 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*, void (*pFun)())
-        { std::atexit(pFun); }
-        
-        static void OnDeadReference()
-        { throw std::logic_error("Dead Reference Detected"); }
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template PhoenixSingleton
-// 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*, void (*pFun)())
-        {
-#ifndef ATEXIT_FIXED
-            if (!destroyedOnce_)
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Singleton.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Singleton.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Singleton.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Singleton.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Singleton.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
 #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
-        
-////////////////////////////////////////////////////////////////////////////////
-// class template Adapter
-// Helper for SingletonWithLongevity below
-////////////////////////////////////////////////////////////////////////////////
-
-    namespace Private
-    {
-        template <class T>
-        struct Adapter
-        {
-            void operator()(T*) { return pFun_(); }
-            void (*pFun_)();
-        };
-    }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SingletonWithLongevity
-// 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, void (*pFun)())
-        {
-            Private::Adapter<T> adapter = { pFun };
-            SetLongevity(pObj, GetLongevity(pObj), adapter);
-        }
-        
-        static void OnDeadReference()
-        { throw std::logic_error("Dead Reference Detected"); }
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template NoDestroy
-// Implementation of the LifetimePolicy used by SingletonHolder
-// Never destroys the object
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class T>
-    struct NoDestroy
-    {
-        static void ScheduleDestruction(T*, void (*)())
-        {}
-        
-        static void OnDeadReference()
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SingletonHolder
-// Provides Singleton amenities for a type T
-// To protect that type from spurious instantiations, you have to protect it
-//     yourself.
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class CreationPolicy = CreateUsingNew,
-        template <class> class LifetimePolicy = DefaultLifetime,
-        template <class> class ThreadingModel = SingleThreaded
-    >
-    class SingletonHolder
-    {
-    public:
-        static T& Instance();
-        
-    private:
-        // Helpers
-        static void MakeInstance();
-        static void DestroySingleton();
-        
-        // Protection
-        SingletonHolder();
-        
-        // Data
-        typedef typename ThreadingModel<T*>::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 M
-    >
-    typename SingletonHolder<T, C, L, M>::PtrInstanceType
-        SingletonHolder<T, C, L, M>::pInstance_;
-
-    template
-    <
-        class T,
-        template <class> class C,
-        template <class> class L,
-        template <class> class M
-    >
-    bool SingletonHolder<T, C, L, M>::destroyed_;
-
-////////////////////////////////////////////////////////////////////////////////
-// SingletonHolder::Instance
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        class T,
-        template <class> class CreationPolicy,
-        template <class> class LifetimePolicy,
-        template <class> class ThreadingModel
-    >
-    inline T& SingletonHolder<T, CreationPolicy, 
-        LifetimePolicy, ThreadingModel>::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 ThreadingModel
-    >
-    void SingletonHolder<T, CreationPolicy, 
-        LifetimePolicy, ThreadingModel>::MakeInstance()
-    {
-        typename ThreadingModel<T>::Lock guard;
-        (void)guard;
-        
-        if (!pInstance_)
-        {
-            if (destroyed_)
-            {
-                LifetimePolicy<T>::OnDeadReference();
-                destroyed_ = false;
-            }
-            pInstance_ = CreationPolicy<T>::Create();
-            LifetimePolicy<T>::ScheduleDestruction(pInstance_, 
-                &DestroySingleton);
-        }
-    }
-
-    template
-    <
-        class T,
-        template <class> class CreationPolicy,
-        template <class> class L,
-        template <class> class M
-    >
-    void SingletonHolder<T, CreationPolicy, L, M>::DestroySingleton()
-    {
-        assert(!destroyed_);
-        CreationPolicy<T>::Destroy(pInstance_);
-        pInstance_ = 0;
-        destroyed_ = true;
-    }
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// May 21, 2001: Correct the volatile qualifier - credit due to Darin Adler
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// January 08, 2002: Fixed bug in call to realloc - credit due to Nigel Gent and
-//      Eike Petersen
-// March 08, 2002: moved the assignment to pTrackerArray in SetLongevity to fix
-//      exception safety issue. Credit due to Kari Hoijarvi
-// May 09, 2002: Fixed bug in Compare that caused longevities to act backwards.
-//      Credit due to Scott McDonald.
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // SINGLETON_INC_
diff --git a/SmallObj.cpp b/SmallObj.cpp
index 382d726..8d906cf 100644
--- a/SmallObj.cpp
+++ b/SmallObj.cpp
@@ -1,420 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////
+//Generated header: SmallObj.cpp
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: March 20, 2001
 
-#include "SmallObj.h"
-#include <cassert>
-#include <algorithm>
-
-using namespace Loki;
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Chunk::Init
-// Initializes a chunk object
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::Chunk::Init(std::size_t blockSize, unsigned char blocks)
-{
-    assert(blockSize > 0);
-    assert(blocks > 0);
-    // Overflow check
-    assert((blockSize * blocks) / blockSize == blocks);
-    
-    pData_ = new unsigned char[blockSize * blocks];
-    Reset(blockSize, blocks);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Chunk::Reset
-// Clears an already allocated chunk
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::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;
-    unsigned char* p = pData_;
-    for (; i != blocks; p += blockSize)
-    {
-        *p = ++i;
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Chunk::Release
-// Releases the data managed by a chunk
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::Chunk::Release()
-{
-    delete[] pData_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Chunk::Allocate
-// Allocates a block from a chunk
-////////////////////////////////////////////////////////////////////////////////
-
-void* FixedAllocator::Chunk::Allocate(std::size_t blockSize)
-{
-    if (!blocksAvailable_) return 0;
-    
-    assert((firstAvailableBlock_ * blockSize) / blockSize == 
-        firstAvailableBlock_);
-
-    unsigned char* pResult =
-        pData_ + (firstAvailableBlock_ * blockSize);
-    firstAvailableBlock_ = *pResult;
-    --blocksAvailable_;
-    
-    return pResult;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Chunk::Deallocate
-// Dellocates a block from a chunk
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::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);
-
-    *toRelease = firstAvailableBlock_;
-    firstAvailableBlock_ = static_cast<unsigned char>(
-        (toRelease - pData_) / blockSize);
-    // Truncation check
-    assert(firstAvailableBlock_ == (toRelease - pData_) / blockSize);
-
-    ++blocksAvailable_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::FixedAllocator
-// Creates a FixedAllocator object of a fixed block size
-////////////////////////////////////////////////////////////////////////////////
-
-FixedAllocator::FixedAllocator(std::size_t blockSize)
-    : blockSize_(blockSize)
-    , allocChunk_(0)
-    , deallocChunk_(0)
-{
-    assert(blockSize_ > 0);
-    
-    prev_ = next_ = this;
-
-    std::size_t numBlocks = DEFAULT_CHUNK_SIZE / blockSize;
-    if (numBlocks > UCHAR_MAX) numBlocks = UCHAR_MAX;
-    else if (numBlocks == 0) numBlocks = 8 * blockSize;
-    
-    numBlocks_ = static_cast<unsigned char>(numBlocks);
-    assert(numBlocks_ == numBlocks);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::FixedAllocator(const FixedAllocator&)
-// Creates a FixedAllocator object of a fixed block size
-////////////////////////////////////////////////////////////////////////////////
-
-FixedAllocator::FixedAllocator(const FixedAllocator& rhs)
-    : blockSize_(rhs.blockSize_)
-    , numBlocks_(rhs.numBlocks_)
-    , chunks_(rhs.chunks_)
-{
-    prev_ = &rhs;
-    next_ = rhs.next_;
-    rhs.next_->prev_ = this;
-    rhs.next_ = this;
-    
-    allocChunk_ = rhs.allocChunk_
-        ? &chunks_.front() + (rhs.allocChunk_ - &rhs.chunks_.front())
-        : 0;
-
-    deallocChunk_ = rhs.deallocChunk_
-        ? &chunks_.front() + (rhs.deallocChunk_ - &rhs.chunks_.front())
-        : 0;
-}
-
-FixedAllocator& FixedAllocator::operator=(const FixedAllocator& rhs)
-{
-    FixedAllocator copy(rhs);
-    copy.Swap(*this);
-    return *this;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::~FixedAllocator
-////////////////////////////////////////////////////////////////////////////////
-
-FixedAllocator::~FixedAllocator()
-{
-    if (prev_ != this)
-    {
-        prev_->next_ = next_;
-        next_->prev_ = prev_;
-        return;
-    }
-    
-    assert(prev_ == next_);
-    Chunks::iterator i = chunks_.begin();
-    for (; i != chunks_.end(); ++i)
-    {
-       assert(i->blocksAvailable_ == numBlocks_);
-       i->Release();
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Swap
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::Swap(FixedAllocator& rhs)
-{
-    using namespace std;
-    
-    swap(blockSize_, rhs.blockSize_);
-    swap(numBlocks_, rhs.numBlocks_);
-    chunks_.swap(rhs.chunks_);
-    swap(allocChunk_, rhs.allocChunk_);
-    swap(deallocChunk_, rhs.deallocChunk_);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Allocate
-// Allocates a block of fixed size
-////////////////////////////////////////////////////////////////////////////////
-
-void* FixedAllocator::Allocate()
-{
-    if (allocChunk_ == 0 || allocChunk_->blocksAvailable_ == 0)
-    {
-        Chunks::iterator i = chunks_.begin();
-        for (;; ++i)
-        {
-            if (i == chunks_.end())
-            {
-                // Initialize
-                chunks_.reserve(chunks_.size() + 1);
-                Chunk newChunk;
-                newChunk.Init(blockSize_, numBlocks_);
-                chunks_.push_back(newChunk);
-                allocChunk_ = &chunks_.back();
-                deallocChunk_ = &chunks_.front();
-                break;
-            }
-            if (i->blocksAvailable_ > 0)
-            {
-                allocChunk_ = &*i;
-                break;
-            }
-        }
-    }
-    assert(allocChunk_ != 0);
-    assert(allocChunk_->blocksAvailable_ > 0);
-    
-    return allocChunk_->Allocate(blockSize_);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::Deallocate
-// Deallocates a block previously allocated with Allocate
-// (undefined behavior if called with the wrong pointer)
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::Deallocate(void* p)
-{
-    assert(!chunks_.empty());
-    assert(&chunks_.front() <= deallocChunk_);
-    assert(&chunks_.back() >= deallocChunk_);
-    
-    deallocChunk_  = VicinityFind(p);
-    assert(deallocChunk_);
-
-    DoDeallocate(p);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::VicinityFind (internal)
-// Finds the chunk corresponding to a pointer, using an efficient search
-////////////////////////////////////////////////////////////////////////////////
-
-FixedAllocator::Chunk* FixedAllocator::VicinityFind(void* p)
-{
-    assert(!chunks_.empty());
-    assert(deallocChunk_);
-
-    const std::size_t chunkLength = numBlocks_ * blockSize_;
-
-    Chunk* lo = deallocChunk_;
-    Chunk* hi = deallocChunk_ + 1;
-    Chunk* loBound = &chunks_.front();
-    Chunk* hiBound = &chunks_.back() + 1;
-	
-	// Special case: deallocChunk_ is the last in the array
-	if (hi == hiBound) hi = 0;
-
-    for (;;)
-    {
-        if (lo)
-        {
-            if (p >= lo->pData_ && p < lo->pData_ + chunkLength)
-            {
-                return lo;
-            }
-            if (lo == loBound) lo = 0;
-            else --lo;
-        }
-        
-        if (hi)
-        {
-            if (p >= hi->pData_ && p < hi->pData_ + chunkLength)
-            {
-                return hi;
-            }
-            if (++hi == hiBound) hi = 0;
-        }
-    }
-    assert(false);
-    return 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FixedAllocator::DoDeallocate (internal)
-// Performs deallocation. Assumes deallocChunk_ points to the correct chunk
-////////////////////////////////////////////////////////////////////////////////
-
-void FixedAllocator::DoDeallocate(void* p)
-{
-    assert(deallocChunk_->pData_ <= p);
-    assert(deallocChunk_->pData_ + numBlocks_ * blockSize_ > p);
-
-    // call into the chunk, will adjust the inner list but won't release memory
-    deallocChunk_->Deallocate(p, blockSize_);
-
-    if (deallocChunk_->blocksAvailable_ == numBlocks_)
-    {
-        // deallocChunk_ is completely free, should we release it? 
-        
-        Chunk& lastChunk = chunks_.back();
-        
-        if (&lastChunk == deallocChunk_)
-        {
-            // check if we have two last chunks empty
-            
-            if (chunks_.size() > 1 && 
-                deallocChunk_[-1].blocksAvailable_ == numBlocks_)
-            {
-                // Two free chunks, discard the last one
-                lastChunk.Release();
-                chunks_.pop_back();
-                allocChunk_ = deallocChunk_ = &chunks_.front();
-            }
-            return;
-        }
-        
-        if (lastChunk.blocksAvailable_ == numBlocks_)
-        {
-            // Two free blocks, discard one
-            lastChunk.Release();
-            chunks_.pop_back();
-            allocChunk_ = deallocChunk_;
-        }
-        else
-        {
-            // move the empty chunk to the end
-            std::swap(*deallocChunk_, lastChunk);
-            allocChunk_ = &chunks_.back();
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// SmallObjAllocator::SmallObjAllocator
-// Creates an allocator for small objects given chunk size and maximum 'small'
-//     object size
-////////////////////////////////////////////////////////////////////////////////
-
-SmallObjAllocator::SmallObjAllocator(
-        std::size_t chunkSize, 
-        std::size_t maxObjectSize)
-    : pLastAlloc_(0), pLastDealloc_(0)
-    , chunkSize_(chunkSize), maxObjectSize_(maxObjectSize) 
-{   
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// SmallObjAllocator::Allocate
-// Allocates 'numBytes' memory
-// Uses an internal pool of FixedAllocator objects for small objects  
-////////////////////////////////////////////////////////////////////////////////
-
-void* SmallObjAllocator::Allocate(std::size_t numBytes)
-{
-    if (numBytes > maxObjectSize_) return operator new(numBytes);
-    
-    if (pLastAlloc_ && pLastAlloc_->BlockSize() == numBytes)
-    {
-        return pLastAlloc_->Allocate();
-    }
-    Pool::iterator i = std::lower_bound(pool_.begin(), pool_.end(), numBytes);
-    if (i == pool_.end() || i->BlockSize() != numBytes)
-    {
-        i = pool_.insert(i, FixedAllocator(numBytes));
-        pLastDealloc_ = &*pool_.begin();
-    }
-    pLastAlloc_ = &*i;
-    return pLastAlloc_->Allocate();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// SmallObjAllocator::Deallocate
-// Deallocates memory previously allocated with Allocate
-// (undefined behavior if you pass any other pointer)
-////////////////////////////////////////////////////////////////////////////////
-
-void SmallObjAllocator::Deallocate(void* p, std::size_t numBytes)
-{
-    if (numBytes > maxObjectSize_) return operator delete(p);
-
-    if (pLastDealloc_ && pLastDealloc_->BlockSize() == numBytes)
-    {
-        pLastDealloc_->Deallocate(p);
-        return;
-    }
-    Pool::iterator i = std::lower_bound(pool_.begin(), pool_.end(), numBytes);
-    assert(i != pool_.end());
-    assert(i->BlockSize() == numBytes);
-    pLastDealloc_ = &*i;
-    pLastDealloc_->Deallocate(p);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// March 20: fix exception safety issue in FixedAllocator::Allocate 
-//     (thanks to Chris Udazvinis for pointing that out)
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// Aug 02, 2002: Fix in VicinityFind sent by Pavel Vozenilek
-////////////////////////////////////////////////////////////////////////////////
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\SmallObj.cpp"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\SmallObj.cpp"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\SmallObj.cpp"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\SmallObj.cpp"
+#elif (__BORLANDC__)
+#		include ".\Borland\SmallObj.cpp"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/SmallObj.h b/SmallObj.h
index 4a90c33..c21d90b 100644
--- a/SmallObj.h
+++ b/SmallObj.h
@@ -1,184 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////
+//Generated header: SmallObj.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-#ifndef SMALLOBJ_INC_
-#define SMALLOBJ_INC_
-
-#include "Threads.h"
-#include "Singleton.h"
-#include <cstddef>
-#include <vector>
-
-#ifndef DEFAULT_CHUNK_SIZE
-#define DEFAULT_CHUNK_SIZE 4096
-#endif
-
-#ifndef MAX_SMALL_OBJECT_SIZE
-#define MAX_SMALL_OBJECT_SIZE 64
-#endif
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class FixedAllocator
-// Offers services for allocating fixed-sized objects
-////////////////////////////////////////////////////////////////////////////////
-
-    class FixedAllocator
-    {
-    private:
-        struct Chunk
-        {
-            void Init(std::size_t blockSize, unsigned char blocks);
-            void* Allocate(std::size_t blockSize);
-            void Deallocate(void* p, std::size_t blockSize);
-            void Reset(std::size_t blockSize, unsigned char blocks);
-            void Release();
-            unsigned char* pData_;
-            unsigned char
-                firstAvailableBlock_,
-                blocksAvailable_;
-        };
-        
-        // Internal functions        
-        void DoDeallocate(void* p);
-        Chunk* VicinityFind(void* p);
-        
-        // Data 
-        std::size_t blockSize_;
-        unsigned char numBlocks_;
-        typedef std::vector<Chunk> Chunks;
-        Chunks chunks_;
-        Chunk* allocChunk_;
-        Chunk* deallocChunk_;
-        // For ensuring proper copy semantics
-        mutable const FixedAllocator* prev_;
-        mutable const FixedAllocator* next_;
-        
-    public:
-        // Create a FixedAllocator able to manage blocks of 'blockSize' size
-        explicit FixedAllocator(std::size_t blockSize = 0);
-        FixedAllocator(const FixedAllocator&);
-        FixedAllocator& operator=(const FixedAllocator&);
-        ~FixedAllocator();
-        
-        void Swap(FixedAllocator& rhs);
-        
-        // Allocate a memory block
-        void* Allocate();
-        // Deallocate a memory block previously allocated with Allocate()
-        // (if that's not the case, the behavior is undefined)
-        void Deallocate(void* p);
-        // Returns the block size with which the FixedAllocator was initialized
-        std::size_t BlockSize() const
-        { return blockSize_; }
-        // Comparison operator for sorting 
-        bool operator<(std::size_t rhs) const
-        { return BlockSize() < rhs; }
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class SmallObjAllocator
-// Offers services for allocating small-sized objects
-////////////////////////////////////////////////////////////////////////////////
-
-    class SmallObjAllocator
-    {
-    public:
-        SmallObjAllocator(
-            std::size_t chunkSize, 
-            std::size_t maxObjectSize);
-    
-        void* Allocate(std::size_t numBytes);
-        void Deallocate(void* p, std::size_t size);
-    
-    private:
-        SmallObjAllocator(const SmallObjAllocator&);
-        SmallObjAllocator& operator=(const SmallObjAllocator&);
-        
-        typedef std::vector<FixedAllocator> Pool;
-        Pool pool_;
-        FixedAllocator* pLastAlloc_;
-        FixedAllocator* pLastDealloc_;
-        std::size_t chunkSize_;
-        std::size_t maxObjectSize_;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class SmallObject
-// Base class for polymorphic small objects, offers fast
-//     allocations/deallocations
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        template <class> class ThreadingModel = DEFAULT_THREADING,
-        std::size_t chunkSize = DEFAULT_CHUNK_SIZE,
-        std::size_t maxSmallObjectSize = MAX_SMALL_OBJECT_SIZE
-    >
-    class SmallObject : public ThreadingModel< 
-        SmallObject<ThreadingModel, chunkSize, maxSmallObjectSize> >
-    {
-    	typedef ThreadingModel< SmallObject<ThreadingModel, 
-    			chunkSize, maxSmallObjectSize> > MyThreadingModel;
-    			
-        struct MySmallObjAllocator : public SmallObjAllocator
-        {
-            MySmallObjAllocator() 
-            : SmallObjAllocator(chunkSize, maxSmallObjectSize)
-            {}
-        };
-        // The typedef below would make things much simpler, 
-        //     but MWCW won't like it
-        // typedef SingletonHolder<MySmallObjAllocator/*, CreateStatic, 
-        //        DefaultLifetime, ThreadingModel*/> MyAllocator;
-        
-    public:
-        static void* operator new(std::size_t size)
-        {
-#if (MAX_SMALL_OBJECT_SIZE != 0) && (DEFAULT_CHUNK_SIZE != 0)
-            typename MyThreadingModel::Lock lock;
-            (void)lock; // get rid of warning
-            
-            return SingletonHolder<MySmallObjAllocator, CreateStatic, 
-                PhoenixSingleton>::Instance().Allocate(size);
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\SmallObj.h"
 #else
-            return ::operator new(size);
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\SmallObj.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\SmallObj.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\SmallObj.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\SmallObj.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
 #endif
-        }
-        static void operator delete(void* p, std::size_t size)
-        {
-#if (MAX_SMALL_OBJECT_SIZE != 0) && (DEFAULT_CHUNK_SIZE != 0)
-            typename MyThreadingModel::Lock lock;
-            (void)lock; // get rid of warning
-            
-            SingletonHolder<MySmallObjAllocator, CreateStatic, 
-                PhoenixSingleton>::Instance().Deallocate(p, size);
-#else
-            ::operator delete(p, size);
-#endif
-        }
-        virtual ~SmallObject() {}
-    };
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // SMALLOBJ_INC_
diff --git a/SmartPtr.h b/SmartPtr.h
index a8d4840..e717aa4 100644
--- a/SmartPtr.h
+++ b/SmartPtr.h
@@ -1,1195 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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
-
-#ifndef SMARTPTR_INC_
-#define SMARTPTR_INC_
-
-////////////////////////////////////////////////////////////////////////////////
-// 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
-////////////////////////////////////////////////////////////////////////////////
-
-
-#include "SmallObj.h"
-#include "TypeManip.h"
-#include "static_check.h"
-#include <functional>
-#include <stdexcept>
-#include <cassert>
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-// class template DefaultSPStorage
-// Implementation of the StoragePolicy used by SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class T>
-    class DefaultSPStorage
-    {
-    protected:
-        typedef T* StoredType;    // the type of the pointee_ object
-        typedef T* PointerType;   // type returned by operator->
-        typedef T& ReferenceType; // type returned by operator*
-        
-    public:
-        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&)
-        {}
-
-        template <class U>
-        DefaultSPStorage(const DefaultSPStorage<U>&) 
-        {}
-        
-        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
-        friend inline PointerType GetImpl(const DefaultSPStorage& sp)
-        { return sp.pointee_; }
-        
-    	friend inline const StoredType& GetImplRef(const DefaultSPStorage& sp)
-    	{ return sp.pointee_; }
-
-    	friend inline StoredType& GetImplRef(DefaultSPStorage& sp)
-    	{ return sp.pointee_; }
-
-    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_;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template RefCounted
-// Implementation of the OwnershipPolicy used by SmartPtr
-// Provides a classic external reference counting implementation
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class P>
-    class RefCounted
-    {
-    public:
-        RefCounted() 
-        {
-            pCount_ = static_cast<unsigned int*>(
-                SmallObject<>::operator new(sizeof(unsigned int)));
-            assert(pCount_);
-            *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(unsigned int));
-                return true;
-            }
-            return false;
-        }
-        
-        void Swap(RefCounted& rhs)
-        { std::swap(pCount_, rhs.pCount_); }
-    
-        enum { destructiveCopy = false };
-
-    private:
-        // Data
-        unsigned int* pCount_;
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template RefCountedMT
-// Implementation of the OwnershipPolicy used by SmartPtr
-// Implements external reference counting for multithreaded programs
-////////////////////////////////////////////////////////////////////////////////
-    template <class P,
-        template <class> class ThreadingModel>
-    class RefCountedMT : public ThreadingModel< RefCountedMT<P, ThreadingModel> >
-    {
-    public:
-        RefCountedMT() 
-        {
-            pCount_ = static_cast<unsigned int*>(
-                SmallObject<ThreadingModel>::operator new(
-                    sizeof(unsigned int)));
-            assert(pCount_);
-            *pCount_ = 1;
-        }
-        
-        RefCountedMT(const RefCountedMT& rhs) 
-        : pCount_(rhs.pCount_)
-        {}
-        
-        // MWCW lacks template friends, hence the following kludge
-        template <typename P1>
-        RefCountedMT(const RefCountedMT<P1, ThreadingModel>& rhs) 
-        : pCount_(reinterpret_cast<const RefCounted<P>&>(rhs).pCount_)
-        {}
-        
-        P Clone(const P& val)
-        {
-            ThreadingModel<RefCountedMT>::AtomicIncrement(*pCount_);
-            return val;
-        }
-        
-        bool Release(const P&)
-        {
-            if (!ThreadingModel<RefCountedMT>::AtomicDecrement(*pCount_))
-            {
-                SmallObject<ThreadingModel>::operator delete(pCount_, 
-                    sizeof(unsigned int));
-                return true;
-            }
-            return false;
-        }
-        
-        void Swap(RefCountedMT& rhs)
-        { std::swap(pCount_, rhs.pCount_); }
-    
-        enum { destructiveCopy = false };
-
-    private:
-        // Data
-        volatile unsigned int* pCount_;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template COMRefCounted
-// 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)
-        {
-            val->AddRef();
-            return val;
-        }
-        
-        static bool Release(const P& val)
-        { val->Release(); return false; }
-        
-        enum { destructiveCopy = false };
-        
-        static void Swap(COMRefCounted&)
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template DeepCopy
-// 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& val)
-        { return true; }
-        
-        static void Swap(DeepCopy&)
-        {}
-        
-        enum { destructiveCopy = false };
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template RefLinked
-// Implementation of the OwnershipPolicy used by SmartPtr
-// Implements reference linking
-////////////////////////////////////////////////////////////////////////////////
-
-    namespace Private
-    {
-        class RefLinkedBase
-        {
-        public:
-            RefLinkedBase() 
-            { prev_ = next_ = this; }
-            
-            RefLinkedBase(const RefLinkedBase& rhs) 
-            {
-                prev_ = &rhs;
-                next_ = rhs.next_;
-                prev_->next_ = this;
-                next_->prev_ = this;
-            }
-            
-            bool Release()
-            {
-                if (next_ == this)
-                {   
-                    assert(prev_ == this);
-                    return true;
-                }
-                prev_->next_ = next_;
-                next_->prev_ = prev_;
-                return false;
-            }
-            
-            void Swap(RefLinkedBase& rhs)
-            {
-                if (next_ == this)
-                {
-                    assert(prev_ == this);
-                    if (rhs.next_ == &rhs)
-                    {
-                        assert(rhs.prev_ == &rhs);
-                        // both lists are empty, nothing 2 do
-                        return;
-                    }
-                    prev_ = rhs.prev_;
-                    next_ = rhs.next_;
-                    prev_->next_ = next_->prev_ = this;
-                    rhs.next_ = rhs.prev_ = &rhs;
-                    return;
-                }
-                if (rhs.next_ == &rhs)
-                {
-                    rhs.Swap(*this);
-                    return;
-                }
-                std::swap(prev_, rhs.prev_);
-                std::swap(next_, rhs.next_);
-                std::swap(prev_->next_, rhs.prev_->next_);
-                std::swap(next_->prev_, rhs.next_->prev_);
-            }
-                
-            enum { destructiveCopy = false };
-
-        private:
-            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(); }
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template DestructiveCopy
-// 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 template NoCopy
-// 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&)
-        {
-            CT_ASSERT(false, This_Policy_Disallows_Value_Copying);
-        }
-        
-        static bool Release(const P&)
-        { return true; }
-        
-        static void Swap(NoCopy&)
-        {}
-        
-        enum { destructiveCopy = false };
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template AllowConversion
-// Implementation of the ConversionPolicy used by SmartPtr
-// Allows implicit conversion from SmartPtr to the pointee type
-////////////////////////////////////////////////////////////////////////////////
-
-    struct AllowConversion
-    {
-        enum { allow = true };
-
-        void Swap(AllowConversion&)
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template DisallowConversion
-// 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&)
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template NoCheck
-// 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&)
-        {}
-    };
-
-
-////////////////////////////////////////////////////////////////////////////////
-// class template AssertCheck
-// 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); }
-
-        static void Swap(AssertCheck&)
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template AssertCheckStrict
-// 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&)
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class NullPointerException
-// Used by some implementations of the CheckingPolicy used by SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    struct NullPointerException : public std::runtime_error
-    {
-        NullPointerException() : std::runtime_error("")
-        { }
-        const char* what() const
-        { return "Null Pointer Exception"; }
-    };
-        
-////////////////////////////////////////////////////////////////////////////////
-// class template RejectNullStatic
-// 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&)
-        {
-            CompileTimeError<false>
-                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&)
-        {}
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template RejectNull
-// 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 val)
-        { if (!val) throw NullPointerException(); }
-
-        static void OnDefault(P val)
-        { OnInit(val); }
-        
-        void OnDereference(P val)
-        { OnInit(val); }
-        
-        void Swap(RejectNull&)
-        {}        
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template RejectNullStrict
-// 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 Swap(RejectNullStrict&)
-        {}        
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// class template ByRef
-// Transports a reference as a value
-// Serves to implement the Colvin/Gibbons trick for SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class T>
-    class ByRef
-    {
-    public:
-        ByRef(T& v) : value_(v) {}
-        operator T&() { return value_; }
-        // gcc doesn't like this:
-        // operator const T&() const { return value_; }
-    private:
-        T& value_;
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// 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
-    >
-    class SmartPtr;
-
-////////////////////////////////////////////////////////////////////////////////
-// class template SmartPtr (definition)
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OwnershipPolicy,
-        class ConversionPolicy,
-        template <class> class CheckingPolicy,
-        template <class> class StoragePolicy
-    >
-    class SmartPtr
-        : public StoragePolicy<T>
-        , public OwnershipPolicy<typename StoragePolicy<T>::PointerType>
-        , public CheckingPolicy<typename StoragePolicy<T>::StoredType>
-        , public ConversionPolicy
-    {
-        typedef StoragePolicy<T> SP;
-        typedef OwnershipPolicy<typename StoragePolicy<T>::PointerType> OP;
-        typedef CheckingPolicy<typename StoragePolicy<T>::StoredType> KP;
-        typedef ConversionPolicy CP;
-        
-    public:
-        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;
-    
-        SmartPtr()
-        { KP::OnDefault(GetImpl(*this)); }
-    	
-        SmartPtr(const StoredType& 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
-        >
-    	SmartPtr(const SmartPtr<T1, OP1, CP1, KP1, SP1>& 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
-        >
-    	SmartPtr(SmartPtr<T1, OP1, CP1, KP1, SP1>& rhs)
-    	: SP(rhs), OP(rhs), KP(rhs), CP(rhs)
-    	{ GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); }
-
-        SmartPtr(ByRef<SmartPtr> rhs)
-    	: SP(rhs), OP(rhs), KP(rhs), CP(rhs)
-        {}
-        
-        operator ByRef<SmartPtr>()
-        { return ByRef<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
-        >
-    	SmartPtr& operator=(const SmartPtr<T1, OP1, CP1, KP1, SP1>& 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
-        >
-    	SmartPtr& operator=(SmartPtr<T1, OP1, CP1, KP1, SP1>& 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();
-    	    }
-    	}
-    	
-    	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); }
-
-        PointerType operator->()
-        {
-            KP::OnDereference(GetImplRef(*this));
-            return SP::operator->();
-        }
-
-        PointerType operator->() const
-        {
-            KP::OnDereference(GetImplRef(*this));
-            return SP::operator->();
-        }
-
-        ReferenceType operator*()
-        {
-            KP::OnDereference(GetImplRef(*this));
-            return SP::operator*();
-        }
-    	
-        ReferenceType operator*() const
-        {
-            KP::OnDereference(GetImplRef(*this));
-            return SP::operator*();
-        }
-    	
-        bool operator!() const // Enables "if (!sp) ..."
-        { return GetImpl(*this) == 0; }
-        
-        inline friend bool operator==(const SmartPtr& lhs,
-            const T* rhs)
-        { return GetImpl(lhs) == rhs; }
-        
-        inline friend bool operator==(const T* lhs,
-            const SmartPtr& rhs)
-        { return rhs == lhs; }
-        
-        inline friend bool operator!=(const SmartPtr& lhs,
-            const T* rhs)
-        { return !(lhs == rhs); }
-        
-        inline friend bool operator!=(const T* lhs,
-            const SmartPtr& rhs)
-        { return rhs != lhs; }
-
-        // Ambiguity buster
-        template
-        <
-            typename T1,
-            template <class> class OP1,
-            class CP1,
-            template <class> class KP1,
-            template <class> class SP1
-        >
-        bool operator==(const SmartPtr<T1, OP1, CP1, KP1, SP1>& rhs) const
-        { return *this == GetImpl(rhs); }
-
-        // Ambiguity buster
-        template
-        <
-            typename T1,
-            template <class> class OP1,
-            class CP1,
-            template <class> class KP1,
-            template <class> class SP1
-        >
-        bool operator!=(const SmartPtr<T1, OP1, CP1, KP1, SP1>& rhs) const
-        { return !(*this == rhs); }
-
-        // Ambiguity buster
-        template
-        <
-            typename T1,
-            template <class> class OP1,
-            class CP1,
-            template <class> class KP1,
-            template <class> class SP1
-        >
-        bool operator<(const SmartPtr<T1, OP1, CP1, KP1, SP1>& rhs) const
-        { return *this < GetImpl(rhs); }
-
-    private:
-        // Helper for enabling 'if (sp)'
-        struct Tester
-        {
-            Tester() {}
-        private:
-            void operator delete(void*);
-        };
-        
-    public:
-        // enable 'if (sp)'
-        operator Tester*() const
-        {
-            if (!*this) return 0;
-            static Tester t;
-            return &t;
-        }
-
-    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); }
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// free comparison operators for class template SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// operator== for lhs = SmartPtr, rhs = raw pointer
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator==(const SmartPtr<T, OP, CP, KP, SP>& lhs,
-        const U* rhs)
-    { return GetImpl(lhs) == rhs; }
-    
-////////////////////////////////////////////////////////////////////////////////
-// operator== for lhs = raw pointer, rhs = SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator==(const U* lhs,
-        const SmartPtr<T, OP, CP, KP, SP>& rhs)
-    { return rhs == lhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-// operator!= for lhs = SmartPtr, rhs = raw pointer
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator!=(const SmartPtr<T, OP, CP, KP, SP>& lhs,
-        const U* rhs)
-    { return !(lhs == rhs); }
-    
-////////////////////////////////////////////////////////////////////////////////
-// operator!= for lhs = raw pointer, rhs = SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator!=(const U* lhs,
-        const SmartPtr<T, OP, CP, KP, SP>& rhs)
-    { return rhs != lhs; }
-
-////////////////////////////////////////////////////////////////////////////////
-// operator< for lhs = SmartPtr, rhs = raw pointer -- NOT DEFINED
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator<(const SmartPtr<T, OP, CP, KP, SP>& lhs,
-        const U* rhs);
-        
-////////////////////////////////////////////////////////////////////////////////
-// operator< for lhs = raw pointer, rhs = SmartPtr -- NOT DEFINED
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator<(const U* lhs,
-        const SmartPtr<T, OP, CP, KP, SP>& rhs);
-        
-////////////////////////////////////////////////////////////////////////////////
-// operator> for lhs = SmartPtr, rhs = raw pointer -- NOT DEFINED
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator>(const SmartPtr<T, OP, CP, KP, SP>& lhs,
-        const U* rhs)
-    { return rhs < lhs; }
-        
-////////////////////////////////////////////////////////////////////////////////
-// operator> for lhs = raw pointer, rhs = SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator>(const U* lhs,
-        const SmartPtr<T, OP, CP, KP, SP>& rhs)
-    { return rhs < lhs; }
-  
-////////////////////////////////////////////////////////////////////////////////
-// operator<= for lhs = SmartPtr, rhs = raw pointer
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator<=(const SmartPtr<T, OP, CP, KP, SP>& lhs,
-        const U* rhs)
-    { return !(rhs < lhs); }
-        
-////////////////////////////////////////////////////////////////////////////////
-// operator<= for lhs = raw pointer, rhs = SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator<=(const U* lhs,
-        const SmartPtr<T, OP, CP, KP, SP>& rhs)
-    { return !(rhs < lhs); }
-
-////////////////////////////////////////////////////////////////////////////////
-// operator>= for lhs = SmartPtr, rhs = raw pointer
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator>=(const SmartPtr<T, OP, CP, KP, SP>& lhs,
-        const U* rhs)
-    { return !(lhs < rhs); }
-        
-////////////////////////////////////////////////////////////////////////////////
-// operator>= for lhs = raw pointer, rhs = SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP,
-        typename U
-    >
-    inline bool operator>=(const U* lhs,
-        const SmartPtr<T, OP, CP, KP, SP>& rhs)
-    { return !(lhs < rhs); }
-
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// specialization of std::less for SmartPtr
-////////////////////////////////////////////////////////////////////////////////
-
-namespace std
-{
-    template
-    <
-        typename T,
-        template <class> class OP,
-        class CP,
-        template <class> class KP,
-        template <class> class SP
-    >
-    struct less< Loki::SmartPtr<T, OP, CP, KP, SP> >
-        : public binary_function<Loki::SmartPtr<T, OP, CP, KP, SP>,
-            Loki::SmartPtr<T, OP, CP, KP, SP>, bool>
-    {
-        bool operator()(const Loki::SmartPtr<T, OP, CP, KP, SP>& lhs,
-            const Loki::SmartPtr<T, OP, CP, KP, SP>& rhs) const
-        { return less<T*>()(GetImpl(lhs), GetImpl(rhs)); }
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// December 09, 2001: Included <cassert>
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // SMARTPTR_INC_
+///////////////////////////////
+//Generated header: SmartPtr.h
+//Forwards to the appropriate code
+// that works on the detected compiler
+
+
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\SmartPtr.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\SmartPtr.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\SmartPtr.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\SmartPtr.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\SmartPtr.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Threads.h b/Threads.h
index b9a6729..5fff44f 100644
--- a/Threads.h
+++ b/Threads.h
@@ -1,203 +1,22 @@
-#ifndef THREADS_H_
-#define THREADS_H_
+//////////////////////////////
+//Generated header: Threads.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-////////////////////////////////////////////////////////////////////////////////
-// macro DEFAULT_THREADING
-// Selects the default threading model for certain components of Loki
-// If you don't define it, it defaults to single-threaded
-// All classes in Loki have configurable threading model; DEFAULT_THREADING
-// affects only default template arguments
-////////////////////////////////////////////////////////////////////////////////
-
-// Last update: June 20, 2001
-
-#ifndef DEFAULT_THREADING
-#define DEFAULT_THREADING /**/ ::Loki::SingleThreaded
-#endif
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template SingleThreaded
-// Implementation of the ThreadingModel policy used by various classes
-// Implements a single-threaded model; no synchronization
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class Host>
-    class SingleThreaded
-    {
-    public:
-        struct Lock
-        {
-            Lock() {}
-            Lock(const Host&) {}
-        };
-        
-        typedef Host VolatileType;
-
-        typedef int IntType; 
-
-        static IntType AtomicAdd(volatile IntType& lval, IntType val)
-        { return lval += val; }
-        
-        static IntType AtomicSubtract(volatile IntType& lval, IntType val)
-        { return lval -= val; }
-
-        static IntType AtomicMultiply(volatile IntType& lval, IntType val)
-        { return lval *= val; }
-        
-        static IntType AtomicDivide(volatile IntType& lval, IntType val)
-        { return lval /= val; }
-        
-        static IntType AtomicIncrement(volatile IntType& lval)
-        { return ++lval; }
-        
-        static IntType AtomicDivide(volatile IntType& lval)
-        { return lval /= val; }
-        
-        static void AtomicAssign(volatile IntType & lval, IntType val)
-        { lval = val; }
-        
-        static void AtomicAssign(IntType & lval, volatile IntType & val)
-        { lval = val; }
-    };
-    
-#ifdef _WINDOWS_
-
-////////////////////////////////////////////////////////////////////////////////
-// class template ObjectLevelLockable
-// Implementation of the ThreadingModel policy used by various classes
-// Implements a object-level locking scheme
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class Host>
-    class ObjectLevelLockable
-    {
-        CRITICAL_SECTION mtx_;
-
-    public:
-        ObjectLevelLockable()
-        {
-            ::InitializeCriticalSection(&mtx_);
-        }
-
-        ~ObjectLevelLockable()
-        {
-            ::DeleteCriticalSection(&mtx_);
-        }
-
-        class Lock;
-        friend class Lock;
-        
-        class Lock
-        {
-            ObjectLevelLockable& host_;
-            
-            Lock(const Lock&);
-            Lock& operator=(const Lock&);
-        public:
-            Lock(Host& host) : host_(host)
-            {
-                ::EnterCriticalSection(&host_.mtx_);
-            }
-            ~Lock()
-            {
-                ::LeaveCriticalSection(&host_.mtx_);
-            }
-        };
-
-        typedef volatile Host VolatileType;
-
-        typedef LONG IntType; 
-
-        static IntType AtomicIncrement(volatile IntType& lval)
-        { return InterlockedIncrement(&const_cast<IntType&>(lval)); }
-        
-        static IntType AtomicDivide(volatile IntType& lval)
-        { return InterlockedDecrement(&const_cast<IntType&>(lval)); }
-        
-        static void AtomicAssign(volatile IntType& lval, IntType val)
-        { InterlockedExchange(&const_cast<IntType&>(lval), val); }
-        
-        static void AtomicAssign(IntType& lval, volatile IntType& val)
-        { InterlockedExchange(&lval, val); }
-    };
-    
-    template <class Host>
-    class ClassLevelLockable
-    {
-        static CRITICAL_SECTION mtx_;
-
-        struct Initializer;
-        friend struct Initializer;
-        struct Initializer
-        {
-            Initializer()
-            {
-                ::InitializeCriticalSection(&mtx_);
-            }
-            ~Initializer()
-            {
-                ::DeleteCriticalSection(&mtx_);
-            }
-        };
-        
-        static Initializer initializer_;
-
-    public:
-        class Lock;
-        friend class Lock;
-        
-        class Lock
-        {
-            Lock(const Lock&);
-            Lock& operator=(const Lock&);
-        public:
-            Lock()
-            {
-                ::EnterCriticalSection(&mtx_);
-            }
-            Lock(Host&)
-            {
-                ::EnterCriticalSection(&mtx_);
-            }
-            ~Lock()
-            {
-                ::LeaveCriticalSection(&mtx_);
-            }
-        };
-
-        typedef volatile Host VolatileType;
-
-        typedef LONG IntType; 
-
-        static IntType AtomicIncrement(volatile IntType& lval)
-        { return InterlockedIncrement(&const_cast<IntType&>(lval)); }
-        
-        static IntType AtomicDivide(volatile IntType& lval)
-        { return InterlockedDecrement(&const_cast<IntType&>(lval)); }
-        
-        static void AtomicAssign(volatile IntType& lval, IntType val)
-        { InterlockedExchange(&const_cast<IntType&>(lval), val); }
-        
-        static void AtomicAssign(IntType& lval, volatile IntType& val)
-        { InterlockedExchange(&lval, val); }
-    };
-    
-    template <class Host>
-    CRITICAL_SECTION ClassLevelLockable<Host>::mtx_;
-    
-    template <class Host>
-    typename ClassLevelLockable<Host>::Initializer 
-    ClassLevelLockable<Host>::initializer_;
-    
-#endif    
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// January 10, 2002: Fixed bug in AtomicDivide - credit due to Jordi Guerrero
-////////////////////////////////////////////////////////////////////////////////
 
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Threads.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Threads.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Threads.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Threads.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Threads.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
 #endif
diff --git a/Tuple.h b/Tuple.h
index 47fc19e..9c629f2 100644
--- a/Tuple.h
+++ b/Tuple.h
@@ -1,22 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+////////////////////////////
+//Generated header: Tuple.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-////////////////////////////////////////////////////////////////////////////////
-// This file is intentionally left empty
-// Due to compiler limitations, its contents has been moved to
-//     HierarchyGenerators.h 
-////////////////////////////////////////////////////////////////////////////////
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Tuple.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Tuple.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Tuple.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Tuple.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Tuple.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/TypeInfo.h b/TypeInfo.h
index f9ed1a5..3f27100 100644
--- a/TypeInfo.h
+++ b/TypeInfo.h
@@ -1,106 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////
+//Generated header: TypeInfo.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
 
-#ifndef TYPEINFO_INC_
-#define TYPEINFO_INC_
-
-#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_);
-        return pInfo_->before(*rhs.pInfo_);
-    }
-
-    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)
-    { return lhs.Get() == rhs.Get(); }
-
-    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); }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // TYPEINFO_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\TypeInfo.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\TypeInfo.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\TypeInfo.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\TypeInfo.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\TypeInfo.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/TypeManip.h b/TypeManip.h
index 931c8ab..f930546 100644
--- a/TypeManip.h
+++ b/TypeManip.h
@@ -1,177 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////
+//Generated header: TypeManip.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: November 22, 2001
 
-#ifndef TYPEMANIP_INC_
-#define TYPEMANIP_INC_
-
-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;
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// 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())) };
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\TypeManip.h"
 #else
-        enum { exists = false };
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\TypeManip.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\TypeManip.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\TypeManip.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\TypeManip.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
 #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 = 1, exists2Way = 0, sameType = 0 };
-    };
-    
-    template <>
-    class Conversion<void, void>    
-    {
-    public:
-        enum { exists = 1, exists2Way = 1, sameType = 1 };
-    };
-}   // 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.
-////////////////////////////////////////////////////////////////////////////////
-
-#define SUPERSUBCLASS(T, U) \
-    (::Loki::Conversion<const volatile U*, const volatile T*>::exists && \
-    !::Loki::Conversion<const volatile T*, const volatile void*>::sameType)
-
-////////////////////////////////////////////////////////////////////////////////
-// macro SUPERSUBCLASS
-// 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.
-////////////////////////////////////////////////////////////////////////////////
-
-#define SUPERSUBCLASS_STRICT(T, U) \
-    (SUPERSUBCLASS(T, U) && \
-    !::Loki::Conversion<const volatile T, const volatile U>::sameType)
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// November 22, 2001: minor change to support porting to boost
-// November 22, 2001: fixed bug in Conversion<void, T>
-//      (credit due to Brad Town)
-// November 23, 2001: (well it's 12:01 am) fixed bug in SUPERSUBCLASS - added
-//      the volatile qualifier to be 100% politically correct
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // TYPEMANIP_INC_
diff --git a/TypeTraits.h b/TypeTraits.h
index c2a7948..8ad16f5 100644
--- a/TypeTraits.h
+++ b/TypeTraits.h
@@ -1,236 +1,22 @@
-#ifndef TYPETRAITS_INC_
-#define TYPETRAITS_INC_
+/////////////////////////////////
+//Generated header: TypeTraits.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-#include "Typelist.h"
 
-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
-    {
-        typedef TYPELIST_4(unsigned char, unsigned short int,
-           unsigned int, unsigned long int) StdUnsignedInts;
-        typedef TYPELIST_4(signed char, short int,
-           int, long int) StdSignedInts;
-        typedef TYPELIST_3(bool, char, wchar_t) StdOtherInts;
-        typedef TYPELIST_3(float, double, long double) StdFloats;
-    }
-        
-////////////////////////////////////////////////////////////////////////////////
-// class template TypeTraits
-// Figures out various properties of any given type
-// Invocations (T is a type):
-// a) TypeTraits<T>::isPointer
-// returns (at compile time) true if T is a pointer type
-// b) TypeTraits<T>::PointeeType
-// returns the type to which T points is T is a pointer type, NullType otherwise
-// a) TypeTraits<T>::isReference
-// returns (at compile time) true if T is a reference type
-// b) TypeTraits<T>::ReferredType
-// returns the type to which T refers is T is a reference type, NullType
-// otherwise
-// c) TypeTraits<T>::isMemberPointer
-// returns (at compile time) true if T is a pointer to member type
-// d) TypeTraits<T>::isStdUnsignedInt
-// returns (at compile time) true if T is a standard unsigned integral type
-// e) TypeTraits<T>::isStdSignedInt
-// returns (at compile time) true if T is a standard signed integral type
-// f) TypeTraits<T>::isStdIntegral
-// returns (at compile time) true if T is a standard integral type
-// g) TypeTraits<T>::isStdFloat
-// returns (at compile time) true if T is a standard floating-point type
-// h) TypeTraits<T>::isStdArith
-// returns (at compile time) true if T is a standard arithmetic type
-// i) TypeTraits<T>::isStdFundamental
-// returns (at compile time) true if T is a standard fundamental type
-// j) TypeTraits<T>::isUnsignedInt
-// returns (at compile time) true if T is a unsigned integral type
-// k) TypeTraits<T>::isSignedInt
-// returns (at compile time) true if T is a signed integral type
-// l) TypeTraits<T>::isIntegral
-// returns (at compile time) true if T is a integral type
-// m) TypeTraits<T>::isFloat
-// returns (at compile time) true if T is a floating-point type
-// n) TypeTraits<T>::isArith
-// returns (at compile time) true if T is a arithmetic type
-// o) TypeTraits<T>::isFundamental
-// returns (at compile time) true if T is a fundamental type
-// p) TypeTraits<T>::ParameterType
-// returns the optimal type to be used as a parameter for functions that take Ts
-// q) TypeTraits<T>::isConst
-// returns (at compile time) true if T is a const-qualified type
-// r) TypeTraits<T>::NonConstType
-// removes the 'const' qualifier from T, if any
-// s) TypeTraits<T>::isVolatile
-// returns (at compile time) true if T is a volatile-qualified type
-// t) TypeTraits<T>::NonVolatileType
-// removes the 'volatile' qualifier from T, if any
-// u) TypeTraits<T>::UnqualifiedType
-// removes both the 'const' and 'volatile' qualifiers from T, if any
-////////////////////////////////////////////////////////////////////////////////
-
-    template <typename T>
-    class TypeTraits
-    {
-    private:
-        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 ReferenceTraits
-        {
-            enum { result = false };
-            typedef U ReferredType;
-        };
-        
-        template <class U> struct ReferenceTraits<U&>
-        {
-            enum { result = true };
-            typedef U ReferredType;
-        };
-        
-        template <class U> struct PToMTraits
-        {
-            enum { result = false };
-        };
-        
-        template <class U, class V>
-        struct PToMTraits<U V::*>
-        {
-            enum { result = true };
-        };
-
-        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 UnVolatile
-        {
-            typedef U Result;
-            enum { isVolatile = 0 };
-        };
-        
-        template <class U> struct UnVolatile<volatile U>
-        {
-            typedef U Result;
-            enum { isVolatile = 1 };
-        };
-
-    public:
-        enum { isPointer = PointerTraits<T>::result };
-        typedef typename PointerTraits<T>::PointeeType PointeeType;
-
-        enum { isReference = ReferenceTraits<T>::result };
-        typedef typename ReferenceTraits<T>::ReferredType ReferredType;
-        
-        enum { isMemberPointer = PToMTraits<T>::result };
-    
-        enum { isStdUnsignedInt = 
-            TL::IndexOf<Private::StdUnsignedInts, T>::value >= 0 };
-        enum { isStdSignedInt = 
-            TL::IndexOf<Private::StdSignedInts, T>::value >= 0 };
-        enum { isStdIntegral = isStdUnsignedInt || isStdSignedInt ||
-            TL::IndexOf<Private::StdOtherInts, T>::value >= 0 };
-        enum { isStdFloat = TL::IndexOf<Private::StdFloats, T>::value >= 0 };
-        enum { isStdArith = isStdIntegral || isStdFloat };
-        enum { isStdFundamental = isStdArith || isStdFloat || 
-            Conversion<T, void>::sameType };
-            
-        enum { isUnsignedInt = isStdUnsignedInt || IsCustomUnsignedInt<T>::value };
-        enum { isSignedInt = isStdSignedInt || IsCustomSignedInt<T>::value };
-        enum { isIntegral = isStdIntegral || isUnsignedInt || isSignedInt };
-        enum { isFloat = isStdFloat || IsCustomFloat<T>::value };
-        enum { isArith = isIntegral || isFloat };
-        enum { isFundamental = isStdFundamental || isArith || isFloat };
-        
-        typedef typename Select<isStdArith || isPointer || isMemberPointer,
-                T, ReferredType&>::Result
-            ParameterType;
-        
-        enum { isConst = UnConst<T>::isConst };
-        typedef typename UnConst<T>::Result NonConstType;
-        enum { isVolatile = UnVolatile<T>::isVolatile };
-        typedef typename UnVolatile<T>::Result NonVolatileType;
-        typedef typename UnVolatile<typename UnConst<T>::Result>::Result 
-            UnqualifiedType;
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // TYPETRAITS_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\TypeTraits.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\TypeTraits.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\TypeTraits.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\TypeTraits.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\TypeTraits.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Typelist.h b/Typelist.h
index 2248edd..7e23218 100644
--- a/Typelist.h
+++ b/Typelist.h
@@ -1,754 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
-
-// Last update: November 22, 2001
-
-#ifndef TYPELIST_INC_
-#define TYPELIST_INC_
-
-#include "NullType.h"
-#include "TypeManip.h"
-
-////////////////////////////////////////////////////////////////////////////////
-// macros TYPELIST_1, TYPELIST_2, ... TYPELIST_50
-// Each takes a number of arguments equal to its numeric suffix
-// The arguments are type names. TYPELIST_NN generates a typelist containing 
-//     all types passed as arguments, in that order.
-// Example: TYPELIST_2(char, int) generates a type containing char and int.
-////////////////////////////////////////////////////////////////////////////////
-
-#define TYPELIST_1(T1) ::Loki::Typelist<T1, ::Loki::NullType>
-
-#define TYPELIST_2(T1, T2) ::Loki::Typelist<T1, TYPELIST_1(T2) >
-
-#define TYPELIST_3(T1, T2, T3) ::Loki::Typelist<T1, TYPELIST_2(T2, T3) >
-
-#define TYPELIST_4(T1, T2, T3, T4) \
-    ::Loki::Typelist<T1, TYPELIST_3(T2, T3, T4) >
-
-#define TYPELIST_5(T1, T2, T3, T4, T5) \
-    ::Loki::Typelist<T1, TYPELIST_4(T2, T3, T4, T5) >
-
-#define TYPELIST_6(T1, T2, T3, T4, T5, T6) \
-    ::Loki::Typelist<T1, TYPELIST_5(T2, T3, T4, T5, T6) >
-
-#define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \
-    ::Loki::Typelist<T1, TYPELIST_6(T2, T3, T4, T5, T6, T7) >
-
-#define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \
-    ::Loki::Typelist<T1, TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
-
-#define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \
-    ::Loki::Typelist<T1, TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
-
-#define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
-    ::Loki::Typelist<T1, TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >
-
-#define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \
-    ::Loki::Typelist<T1, TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
-
-#define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \
-    ::Loki::Typelist<T1, TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12) >
-
-#define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \
-    ::Loki::Typelist<T1, TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13) >
-
-#define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14) \
-    ::Loki::Typelist<T1, TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14) >
-
-#define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15) \
-    ::Loki::Typelist<T1, TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15) >
-
-#define TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16) \
-    ::Loki::Typelist<T1, TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16) >
-
-#define TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17) \
-    ::Loki::Typelist<T1, TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17) >
-
-#define TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18) \
-    ::Loki::Typelist<T1, TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18) >
-
-#define TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18, T19) \
-    ::Loki::Typelist<T1, TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18, T19) >
-
-#define 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, TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) >
-
-#define 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, TYPELIST_20(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) >
-
-#define 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, TYPELIST_21(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
-        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) >
-
-#define 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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) >
-
-namespace Loki
-{
-////////////////////////////////////////////////////////////////////////////////
-// class template Typelist
-// The building block of typelists of any length
-// Use it through the 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 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_1(T) 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 <class T>
-        struct Reverse< TYPELIST_1(T) >
-        {
-            typedef TYPELIST_1(T) 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),
-                    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 ReplaceAll<Tail, 
-                TheMostDerived, Head>::Result Temp;
-            typedef typename DerivedToFront<Temp>::Result L;
-        public:
-            typedef Typelist<TheMostDerived, L> Result;
-        };
-        
-    }   // namespace TL
-}   // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// June 09, 2001: Fix bug in parameter list of macros TYPELIST_23 to TYPELIST_27
-//      (credit due to Dave Taylor)
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-// November 22, 2001: fixed bug in DerivedToFront
-//      (credit due to Gianni Luciani who noticed the bug first;
-//          Adam Wilkshire;
-//          Friedrik Hedman who fixed the bug but didn't send the fix;
-//          Kevin Cline who sent the first actual fix)
-// May 13, 2002: TYPELIST_46 called TYPELIST_45 with only 44 parameters.
-//      Credit due to Robert Minsk     
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // TYPELIST_INC_
-
+///////////////////////////////
+//Generated header: Typelist.h
+//Forwards to the appropriate code
+// that works on the detected compiler
+
+
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Typelist.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Typelist.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Typelist.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Typelist.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Typelist.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/Visitor.h b/Visitor.h
index 2b29f0e..a7d66ba 100644
--- a/Visitor.h
+++ b/Visitor.h
@@ -1,203 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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.
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////
+//Generated header: Visitor.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
-// Last update: June 20, 2001
-
-#ifndef VISITOR_INC_
-#define VISITOR_INC_
-
-#include "Typelist.h"
-#include "HierarchyGenerators.h"
-
-namespace Loki
-{
-
-////////////////////////////////////////////////////////////////////////////////
-// class template BaseVisitor
-// The base class of any Acyclic Visitor
-////////////////////////////////////////////////////////////////////////////////
-
-    class BaseVisitor
-    {
-    public:
-        virtual ~BaseVisitor() {}
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// class template Visitor
-// The building block of Acyclic Visitor
-////////////////////////////////////////////////////////////////////////////////
-
-    template <class T, typename R = void>
-    class Visitor
-    {
-    public:
-        typedef R ReturnType;
-        virtual ReturnType Visit(T&) = 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<TYPELIST_2(RasterBitmap, Paragraph)>, 
-//     public Visitor<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>
-        : public Visitor<Head, R>, public Visitor<Tail, R>
-    {
-    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> : public Visitor<Head, R>
-    {
-    public:
-        typedef R ReturnType;
-        using Visitor<Head, R>::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
-    >
-    class BaseVisitable
-    {
-    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>* p = dynamic_cast<Visitor<T>*>(&guest))
-            {
-                return p->Visit(visited);
-            }
-            return CatchAll<R, T>::OnUnknownVisitor(visited, guest);
-        }
-    };
-
-////////////////////////////////////////////////////////////////////////////////
-// macro DEFINE_VISITABLE
-// Put it in every class that you want to make visitable (in addition to 
-//     deriving it from BaseVisitable<R>
-////////////////////////////////////////////////////////////////////////////////
-
-#define DEFINE_VISITABLE() \
-    virtual ReturnType Accept(BaseVisitor& guest) \
-    { return AcceptImpl(*this, guest); }
-
-////////////////////////////////////////////////////////////////////////////////
-// class template CyclicVisitor
-// 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);
-        }
-    };
-    
-////////////////////////////////////////////////////////////////////////////////
-// macro DEFINE_CYCLIC_VISITABLE
-// Put it in every class that you want to make visitable by a cyclic visitor
-////////////////////////////////////////////////////////////////////////////////
-
-#define DEFINE_CYCLIC_VISITABLE(SomeVisitor) \
-    virtual SomeVisitor::ReturnType Accept(SomeVisitor& guest) \
-    { return guest.GenericVisit(*this); }
-
-} // namespace Loki
-
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// March 20: add default argument DefaultCatchAll to BaseVisitable
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // VISITOR_INC_
 
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\Visitor.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\Visitor.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\Visitor.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\Visitor.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\Visitor.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif
diff --git a/readme.txt b/readme.txt
index 901db1a..784fde9 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,4 +1,4 @@
-Last update: June 20, 2001
+Last update: Aug 14, 2002
 
 Directions:
 
@@ -12,9 +12,14 @@ Compatibility:
 
 Loki has been tested with Metrowerks CodeWarrior Pro 6 under Windows. CodeWarrior has a problem with the Conversion template (see TypeManip.h) and, though it compiles it, it doesn't provide correct results. Consequently, the DerivedToFront algorithm in Typelist.h does not function. This affects the static dispatcher in Multimethods.h. As a fix, you must order the types (putting the most derived ones in the front) when providing the typelist argument to StaticDispatcher.
 
-Also, Loki has been ported to gcc 2.95.3 by Nick Thurn.
+Also, Loki has been ported to gcc 2.95.3 and to MSVC7.
+A port to Borland C++ BUilder is in progress.
+Typelist have been ported to MSVC6.
 
 
 More info:
 
 http://moderncppdesign.com
+http://sourceforge.net/projects/loki-lib/
+
+
diff --git a/static_check.h b/static_check.h
index b8a07b0..945be4f 100644
--- a/static_check.h
+++ b/static_check.h
@@ -1,51 +1,22 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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
-
-#ifndef STATIC_CHECK_INC_
-#define STATIC_CHECK_INC_
-
-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 STATIC_CHECK(expr, msg) \
-    { Loki::CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; } 
+///////////////////////////////////
+//Generated header: static_check.h
+//Forwards to the appropriate code
+// that works on the detected compiler
 
 
-////////////////////////////////////////////////////////////////////////////////
-// Change log:
-// March 20, 2001: add extra parens to STATIC_CHECK - it looked like a fun 
-//     definition
-// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // STATIC_CHECK_INC_
+#ifdef LOKI_USE_REFERENCE
+#	include ".\Reference\static_check.h"
+#else
+#	if (_MSC_VER >= 1300)
+#		include ".\MSVC\1300\static_check.h"
+#elif (_MSC_VER >= 1200)
+#		include ".\MSVC\1200\static_check.h"
+#elif ( (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 1)) )
+#		include ".\Reference\static_check.h"
+#elif (__BORLANDC__)
+#		include ".\Borland\static_check.h"
+#	else
+		//Define LOKI_USE_REFERENCE and get back to us on the results
+#		error Compiler not tested with Loki, #define LOKI_USE_REFERENCE
+#	endif
+#endif