First blush

git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@6 7ec92016-0320-0410-acc4-a06ded1c099a

AbstractFactory.h

@@ -0,0 +1,159 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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 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
+
+#endif // ABSTRACTFACTORY_INC_

AssocVector.h

@@ -0,0 +1,324 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 2001
+
+#ifndef ASSOCVECTOR_INC_
+#define ASSOCVECTOR_INC_
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <utility>
+#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(*this).swap(*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>
+        iterator 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 namespace std;
+            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;
+        } 
+
+        friend bool operator<(const AssocVector& lhs, const AssocVector& rhs)
+        {
+            const Base& me = lhs;
+            return me < rhs;
+        } 
+
+        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
+
+#endif // ASSOCVECTOR_INC_

EmptyType.h

@@ -0,0 +1,32 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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 {};
+}
+
+#endif // EMPTYTYPE_INC_

Factory.h

@@ -0,0 +1,137 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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 { 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::const_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::const_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
+
+#endif // FACTORY_INC_

HierarchyGenerators.h

@@ -0,0 +1,233 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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 <class T> struct Rebind
+        { typedef Unit<T> Result; };   
+    };
+     
+     template <class AtomicType, template <class> class Unit>
+     class GenScatterHierarchy : public Unit<AtomicType>
+     {
+        typedef Unit<AtomicType> LeftBase;
+
+        template <class T> struct Rebind
+        { typedef Unit<T> Result; };   
+     };
+     
+     template <template <class> class Unit>
+     class GenScatterHierarchy<NullType, Unit>
+     {
+        template <class 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;
+     }
+     
+////////////////////////////////////////////////////////////////////////////////
+// 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 Select<isConst, const H::LeftBase, 
+            H::LeftBase>::Result LeftBase;
+            
+        typedef Select<isTuple, ElementType, UnitType>::Result 
+            UnqualifiedResultType;
+        typedef 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 Select<isConst, const H::RightBase, 
+            H::RightBase>::Result RightBase;
+
+        typedef Select<isTuple, ElementType, UnitType>::Result 
+            UnqualifiedResultType;
+        typedef Select<isConst,
+                const UnqualifiedResultType,
+                UnqualifiedResultType>::Result
+            ResultType;
+            
+        static ResultType& Do(H& obj)
+        {
+            typename H::RightBase& rightBase = obj;
+            return FieldHelper<typename H::RightBase, i - 1>::Do(obj);
+        }
+    };
+
+////////////////////////////////////////////////////////////////////////////////
+// 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);
+    }
+        
+////////////////////////////////////////////////////////////////////////////////
+// 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_1(T), Unit, Root>
+        : public Unit<T, Root>
+    {
+    };
+
+}   // namespace Loki
+
+
+#endif // HIERARCHYGENERATORS_INC_

Mappings.h

@@ -0,0 +1,31 @@
+#ifndef MAPPINGS_H_
+#define MAPPINGS_H_
+
+namespace Loki
+{
+    template <int v>
+    struct Int2Type
+    {
+        enum { value = v };
+    };
+    
+    template <typename T>
+    struct Type2Type
+    {
+        typedef T OriginalType;
+    };
+    
+    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;
+    };
+
+}
+
+#endif

MultiMethods.h

@@ -0,0 +1,320 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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 <bool swapArgs, class SomeLhs, class SomeRhs, class Executor,
+            typename ResultType>
+        struct InvocationTraits
+        {
+            static ResultType DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
+                Executor& exec)
+            {
+                return exec.Fire(lhs, rhs);
+            }
+        };
+        
+        template <class SomeLhs, class SomeRhs, class Executor, 
+            typename ResultType>
+        struct InvocationTraits<true, SomeLhs, SomeRhs, Executor, ResultType>
+        {
+            static ResultType DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
+                Executor& exec)
+            {
+                return exec.Fire(rhs, lhs); // swap arguments
+            }
+        };
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+// class template StaticDispatcher
+// Implements an automatic static double dispatcher based on two typelists
+////////////////////////////////////////////////////////////////////////////////
+
+    template
+    <
+        class Executor,
+        bool symmetric,
+        class BaseLhs, 
+        class TypesLhs,
+        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))
+            {
+                enum { swapArgs = symmetric &&
+                    TL::IndexOf<TypesRhs, Head>::value <
+                    TL::IndexOf<TypesLhs, SomeLhs>::value };
+                typedef Private::InvocationTraits<swapArgs, 
+                        SomeLhs, Head, Executor, ResultType>
+                    CallTraits;
+                    
+                return CallTraits::DoDispatch(lhs, *p2, exec);
+            }
+            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_;
+        
+    public:
+        void DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun)
+        {
+            callbackMap_[KeyType(lhs, rhs)] = fun;
+        }
+        
+        bool DoRemove(TypeInfo lhs, TypeInfo rhs)
+        {
+            return callbackMap_.erase(KeyType(lhs, rhs)) == 1;
+        }
+        
+        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)
+        {
+            MapType::iterator i = callbackMap_.find(
+                KeyType(typeid(lhs), typeid(rhs)));
+            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 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 ConcreteLhs, class ConcreteRhs>
+        void Add(ResultType (*pFun)(BaseLhs&, BaseRhs&))
+        {
+            return backEnd_.Add<ConcreteLhs, ConcreteRhs>(pFun);
+        }        
+        
+        template <class ConcreteLhs, class ConcreteRhs,
+            ResultType (*callback)(ConcreteLhs&, ConcreteRhs&),
+            bool symmetric>
+        void Add()
+        {
+            struct Local
+            {
+                static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs)
+                {
+                    return callback(
+                        CastingPolicy<ConcreteLhs, BaseLhs>::Cast(lhs),
+                        CastingPolicy<ConcreteRhs, BaseRhs>::Cast(rhs));
+                }
+                static ResultType TrampolineR(BaseRhs& rhs, BaseLhs& lhs)
+                {
+                    return Trampoline(lhs, rhs);
+                }
+            };
+            Add<ConcreteLhs, ConcreteRhs>(&Local::Trampoline);
+            if (symmetric)
+            {
+                Add<ConcreteRhs, ConcreteLhs>(&Local::TrampolineR);
+            }
+        }
+        
+        ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
+        {
+            return backEnd_.Go(lhs, rhs);
+        }
+    };
+
+////////////////////////////////////////////////////////////////////////////////
+// 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;
+            
+        typedef DispatcherBackend<BaseLhs, BaseRhs, ResultType, FunctorType>
+            BackEndType;
+        BackEndType backEnd_;
+
+    public:
+        template <class SomeLhs, class SomeRhs, class Fun>
+        void Add(const Fun& fun)
+        {
+            typedef FunctorImpl<ResultType, TYPELIST_2(BaseLhs, BaseRhs)>
+                FunctorImplType;
+            class Adapter : public FunctorImplType
+            {
+                Fun fun_;
+                virtual ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
+                {
+                    return fun_(
+                        CastingPolicy<ConcreteLhs, BaseLhs>::Cast(lhs),
+                        CastingPolicy<ConcreteRhs, BaseRhs>::Cast(rhs));
+                }
+                virtual FunctorImplType* DoClone() const
+                { return new Adapter(*this); }
+            public:
+                Adapter(const Fun& fun) : fun_(fun) {}
+            };
+            backEnd_.Add<SomeLhs, SomeRhs>(
+                Functor<ResultType, ArgsList, DEFAULT_THREADING>(new Adapter(fun)));
+        }
+        
+        ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
+        {
+            return backEnd_.Go(lhs, rhs);
+        }
+    };
+} // namespace Loki
+
+
+#endif

NullType.h

@@ -0,0 +1,32 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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 {};
+}
+
+#endif // NULLTYPE_INC_

Singleton.cpp

@@ -0,0 +1,42 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 2001
+
+#include "Singleton.h"
+
+using namespace Loki::Private;
+
+extern TrackerArray Loki::Private::pTrackerArray = 0;
+extern 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, --elements));
+    // Destroy the element
+    delete pTop;
+}

Singleton.h

@@ -0,0 +1,421 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 2001
+
+#ifndef SINGLETON_INC_
+#define SINGLETON_INC_
+
+#include "Threads.h"
+#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;
+            
+            friend inline bool Compare(unsigned int longevity,
+                const LifetimeTracker* p)
+            {
+                return p->longevity_ > 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, elements + 1));
+        if (!pNewArray) throw std::bad_alloc();
+        
+        LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>(
+            pDynObject, longevity, d);
+        
+        // Delayed assignment for exception safety
+        pTrackerArray = pNewArray;
+        
+        // Insert a pointer to the object into the queue
+        TrackerArray pos = std::upper_bound(
+            pTrackerArray, pTrackerArray + elements, longevity, Compare);
+        std::copy_backward(pos, pTrackerArray + elements,
+            pTrackerArray + elements + 1);
+        *pos = p;
+        ++elements;
+        
+        // Register a call to AtExitFn
+        std::atexit(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_)
+#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 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)())
+        {
+            struct Adapter
+            {
+                void operator()(T*) { return pFun_(); }
+                void (*pFun_)();
+            };
+        
+            Adapter 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 ThreadingModel<T>::VolatileType InstanceType;
+        static InstanceType* 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>::InstanceType*
+        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;
+        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
+
+#endif // SINGLETON_INC_

SmallObj.cpp

@@ -0,0 +1,408 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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)
+    , deallocChunk_(0)
+    , allocChunk_(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_.push_back(Chunk());
+                Chunk& newChunk = chunks_.back();
+                newChunk.Init(blockSize_, numBlocks_);
+                allocChunk_ = &newChunk;
+                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;
+
+    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);
+}

SmallObj.h

@@ -0,0 +1,176 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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> >
+    {
+        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)
+            Lock lock;
+            lock; // get rid of warning
+            
+            return SingletonHolder<MySmallObjAllocator, CreateStatic, 
+                PhoenixSingleton>::Instance().Allocate(size);
+#else
+            return ::operator new(size);
+#endif
+        }
+        static void operator delete(void* p, std::size_t size)
+        {
+#if (MAX_SMALL_OBJECT_SIZE != 0) && (DEFAULT_CHUNK_SIZE != 0)
+            Lock lock;
+            lock; // get rid of warning
+            
+            SingletonHolder<MySmallObjAllocator, CreateStatic, 
+                PhoenixSingleton>::Instance().Deallocate(p, size);
+#else
+            ::operator delete(p, size);
+#endif
+        }
+        virtual ~SmallObject() {}
+    };
+} // namespace Loki
+
+#endif // SMALLOBJ_INC_

Threads.h

@@ -0,0 +1,195 @@
+#ifndef THREADS_H_
+#define THREADS_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// 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
+////////////////////////////////////////////////////////////////////////////////
+
+#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; }
+        
+        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    
+}
+
+#endif

Tuple.h

@@ -0,0 +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: February 19, 2001
+
+////////////////////////////////////////////////////////////////////////////////
+// This file is intentionally left empty
+// Due to compiler limitations, its contents has been moved to
+//     HierarchyGenerators.h 
+////////////////////////////////////////////////////////////////////////////////

TypeInfo.h

@@ -0,0 +1,101 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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); }
+}
+
+#endif // TYPEINFO_INC_

TypeManip.h

@@ -0,0 +1,165 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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
+    {
+        typedef char Small;
+        class Big { char dummy[2]; };
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+// 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>
+    class Conversion
+    {
+        static Private::Big Test(...);
+        static Private::Small Test(U);
+        static T MakeT();
+
+    public:
+        enum { exists = sizeof(Test(MakeT())) == sizeof(Private::Small) };
+        enum { exists2Way = exists && 
+            Conversion<U, T>::exists };
+        enum { sameType = false };
+    };
+    
+    template <class T>
+    class Conversion<T, T>    
+    {
+    public:
+        enum { exists = 1, exists2Way = 1,sameType = 1 };
+    };
+    
+    template <class T>
+    class Conversion<void, T>    
+    {
+    public:
+        enum { exists = 1, exists2Way = 0,sameType = 0 };
+    };
+    
+    template <class T>
+    class Conversion<T, void>    
+    {
+    public:
+        enum { exists = 1, exists2Way = 0,sameType = 0 };
+    };
+    
+    template <>
+    class Conversion<void, void>    
+    {
+    public:
+        enum { exists = 1, exists2Way = 1,sameType = 1 };
+    };    
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 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 U*, const T*>::exists && \
+    !::Loki::Conversion<const T*, const 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 T, const U>::sameType)
+
+
+#endif // TYPEMANIP_INC_

TypeTraits.h

@@ -0,0 +1,230 @@
+#ifndef TYPETRAITS_INC_
+#define TYPETRAITS_INC_
+
+#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 PointerTraits<T>::PointeeType PointeeType;
+
+        enum { isReference = ReferenceTraits<T>::result };
+        typedef 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 Select<isStdArith || isPointer || isMemberPointer,
+                T, ReferredType&>::Result
+            ParameterType;
+        
+        enum { isConst = UnConst<T>::isConst };
+        typedef UnConst<T>::Result NonConstType;
+        enum { isVolatile = UnVolatile<T>::isVolatile };
+        typedef UnVolatile<T>::Result NonVolatileType;
+        typedef UnVolatile<UnConst<T>::Result>::Result UnqualifiedType;
+    };
+}
+
+#endif // TYPETRAITS_INC_

Typelist.h

@@ -0,0 +1,734 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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, 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, 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, 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, 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, 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) >
+
+#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;
+    };
+
+    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 Tail, class T>
+        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):
+// Replace<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 Replace<Tail, 
+                TheMostDerived, Head>::Result L;
+        public:
+            typedef Typelist<TheMostDerived, L> Result;
+        };
+        
+    }   // namespace TL
+}   // namespace Loki
+
+#endif // TYPELIST_INC_

Visitor.h

@@ -0,0 +1,211 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 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>, public Visitor<Tail>
+    {
+    public:
+        typedef R ReturnType;
+        using Visitor<Head>::Visit;
+        using Visitor<Tail>::Visit;
+    };
+    
+    template <class Head, typename R>
+    class Visitor<Typelist<Head, NullType>, R> : public Visitor<Head>
+    {
+    public:
+        typedef R ReturnType;
+        using Visitor<Head>::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>
+    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 VisitorBinder
+// Helper for CyclicVisitor below
+////////////////////////////////////////////////////////////////////////////////
+
+    namespace Private
+    {
+        template <typename R>
+        struct VisitorBinder
+        {
+            template <class T>
+            struct Result : public Visitor<T, R>
+            {
+            };
+        };
+    }
+    
+////////////////////////////////////////////////////////////////////////////////
+// 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 GenScatterHierarchy<TList, Private::VisitorBinder<R>::Result>
+    {
+    public:
+        typedef R ReturnType;
+        
+        // this is GenericVisit and not Visit to avoid the compiler warning 
+        // "Visit hides virtual function in base class" 
+        template <class Visited>
+        ReturnType GenericVisit(Visited& host)
+        {
+            Visitor<Visited>& 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
+
+#endif // VISITOR_INC_

main.cpp

@@ -0,0 +1,301 @@
+//#include <windows.h>
+//#include "Threads.h"
+#include "MultiMethods.h"
+#include "Visitor.h"
+#include "AbstractFactory.h"
+#include "SmartPtr.h"
+#include "static_check.h"
+#include "TypeManip.h"
+#include "TypeInfo.h"
+#include "TypeTraits.h"
+#include "HierarchyGenerators.h"
+#include "SmallObj.h"
+#include "Functor.h"
+#include "Singleton.h"
+#include "Factory.h"
+#include "SmallObj.h"
+#include "Factory.h"
+
+#include <cassert>
+
+using namespace Loki;
+
+class Base
+{
+public:
+    int Fun(const char*)
+    {
+        return 0;
+    }
+};
+class Derived : public Base {};
+
+class Base1
+{
+public:
+    int Fun(const char*)
+    {
+        return 0;
+    }
+};
+class Derived1 : public Base1 {};
+
+unsigned int GetLongevity(Base*) { return 1; }
+
+template <class T>
+struct Holder
+{
+    T value_;
+}; 
+
+template <class T, class Base>
+struct Holder2 : public Base
+{
+};
+
+int Fun(double)
+{
+    return 0;
+}
+
+template class SmartPtr< Base >;
+
+template class Factory< Base, int, Base* (*)(), DefaultFactoryError >;
+
+template class CloneFactory< Base, Base* (*)(const Base*), DefaultFactoryError>;
+
+template class AbstractFactory<TYPELIST_2(Base, Derived)>;
+
+class DocElement;
+class Paragraph;
+class RasterBitmap;
+
+typedef CyclicVisitor
+<
+    void, // return type
+    TYPELIST_3(DocElement, Paragraph, RasterBitmap)
+>
+MyVisitor;
+
+class DocElement
+{
+public:
+    virtual void Accept(MyVisitor&) = 0;
+};
+
+class Paragraph : public DocElement
+{
+public:
+    DEFINE_CYCLIC_VISITABLE(MyVisitor)
+};
+
+class MyConcreteVisitor : public MyVisitor
+{
+    void Visit(DocElement&)
+    {}
+    
+    void Visit(Paragraph&)
+    {}
+    
+    void Visit(RasterBitmap&)
+    {}
+};
+
+extern void TestMultiMethods();
+extern void TestThreads();
+extern void TestAbstractFactory();
+extern void TestFactory();
+extern void TestFunctor();
+extern void TestAssocVector();
+
+int main()
+{
+    TestAbstractFactory();
+    TestAssocVector();
+    TestFactory();
+    TestFunctor();
+    TestMultiMethods();
+    TestThreads();
+    
+    {
+        MyConcreteVisitor vis;
+        Paragraph par;
+        DocElement& docElem = par;
+        
+        docElem.Accept(vis);
+    }
+
+    {
+        typedef AbstractFactory<TYPELIST_2(Base, Base1)> Fact;
+        typedef ConcreteFactory<Fact, OpNewFactoryUnit, 
+            TYPELIST_2(Derived, Derived1)> CFact;
+            
+        CFact factory;
+        factory.Create<Base>();
+    }
+
+    STATIC_CHECK(sizeof(int) == 4, Int_Too_Small);
+	
+	{
+	    Int2Type<3> i2t;
+	    i2t;
+	}
+	
+	{
+	    Type2Type<int> t2t;
+	    t2t;
+	}
+	
+	{
+	    Select<true, int, char*>::Result test = 9;
+	}
+
+	{
+	    Select<false, int, char*>::Result test = "9";
+	}
+
+    {
+        //STATIC_CHECK(X<int>::a, zzz);
+        //STATIC_CHECK((Conversion<Derived, Base>::exists == 4), X);
+        /*STATIC_CHECK((Conversion<int, char>::exists2Way), X);
+        STATIC_CHECK((!Conversion<int, char>::sameType), X);
+        STATIC_CHECK(!Conversion<int, char*>::exists, X);
+        STATIC_CHECK(Conversion<int, char*>::exists2Way;
+        Conversion<int, char*>::sameType;
+        Conversion<char*, char*>::exists;
+        Conversion<char*, char*>::exists2Way;
+        Conversion<char*, char*>::sameType;
+        
+        SUPERSUBCLASS(int, char*);*/
+    }
+    
+    {   
+        TypeInfo ti1;
+        TypeInfo ti2(typeid(int));
+        TypeInfo ti3(ti1);
+        ti2 = ti1;
+        
+        ti1.name();
+        ti1 == ti2;
+        ti1 != ti2;
+        ti1 < ti2;
+        ti1 > ti2;
+        ti1.before(ti2);
+        
+    }
+    
+    {
+        STATIC_CHECK(TypeTraits<char*>::isPointer, TypeTraits_Broken);
+        STATIC_CHECK(!TypeTraits<char>::isPointer, TypeTraits_Broken);
+
+        STATIC_CHECK(TypeTraits<char&>::isReference, TypeTraits_Broken);
+        STATIC_CHECK(!TypeTraits<char*>::isReference, TypeTraits_Broken);
+        
+        STATIC_CHECK(TypeTraits<int>::isStdSignedInt &&
+            !TypeTraits<int>::isStdUnsignedInt &&
+            TypeTraits<int>::isStdIntegral &&
+            !TypeTraits<int>::isStdFloat &&
+            TypeTraits<int>::isStdArith &&
+            TypeTraits<int>::isStdFundamental, TypeTraits_Broken);
+    }
+ 
+    {
+        typedef TYPELIST_5(int, long int, char*, char, short int)
+            TList;
+        STATIC_CHECK(TL::Length<TList>::value == 5, Typelist_Broken);
+        TL::TypeAt<TList, 2>::Result x = "oo";
+        
+        typedef TL::Append<TList, int>::Result TList2;
+        STATIC_CHECK(TL::Length<TList2>::value == 6, Typelist_Broken);
+        
+        typedef TL::Erase<TList2, int>::Result TList3;
+        STATIC_CHECK(TL::Length<TList3>::value == 5, Typelist_Broken);
+        TL::TypeAt<TList3, 1>::Result y = "d";        
+        
+        typedef TL::EraseAll<TList2, int>::Result TList4;
+        STATIC_CHECK(TL::Length<TList4>::value == 4, Typelist_Broken);
+        TL::TypeAt<TList3, 1>::Result z = "f";        
+        
+        typedef TL::Append<TList2, long int>::Result TList5;
+        STATIC_CHECK(TL::Length<TList5>::value == 7, Typelist_Broken);
+        typedef TL::NoDuplicates<TList5>::Result TList6;
+        STATIC_CHECK(TL::Length<TList6>::value == 5, Typelist_Broken);
+        TL::TypeAt<TList6, 2>::Result c = "d";        
+        
+        typedef TL::Replace<TList, char*, int>::Result TList7;
+        TL::TypeAt<TList7, 2>::Result d = 44;
+        
+        typedef TL::ReplaceAll<TList2, int, char*>::Result TList8;
+        TL::TypeAt<TList8, 5>::Result e = "44";
+    }
+    
+    {
+        //GenScatterHierarchy<TYPELIST_2(char*, int), Holder> obj1;
+        //obj1;
+        GenLinearHierarchy<TYPELIST_2(char*, int), Holder2> obj2;
+        obj2;
+        //Field<char*>(obj1).value_ = "hello";
+        //Field<int>(obj1).value_ = 3;
+
+        //Field<0>(obj1).value_ = "hello";
+        //Field<1>(obj1).value_ = 3;
+
+        //const GenScatterHierarchy<TYPELIST_2(char*, int), Holder> obj3;
+        //obj3;
+        //char*& p1 = Field<0>(obj3).value_;
+        //char*& p2 = Field<0>(obj1).value_;
+    }
+    
+    {
+        Functor<int, TYPELIST_1(double)> fn(Fun);
+        fn(4.5);
+        Base b;
+        Functor<int, TYPELIST_1(char*)> fn2(&b, &Base::Fun);
+        fn2("a");
+        
+        char* ddd = "aaa";
+        Functor<int> fn3 = BindFirst(fn2, "ddd");
+        fn3();
+        
+        Functor<int> fn4 = Chain(fn3, fn3);
+        fn4();
+    }
+    
+    {
+        typedef SingletonHolder<Base> TheBase;
+        TheBase::Instance();
+    }
+
+    {
+        typedef SingletonHolder<Base, CreateUsingNew, SingletonWithLongevity> TheBase;
+        TheBase::Instance();
+    }
+    
+    {
+        SmartPtr<int> sp1, sp2;
+        GetImpl(sp1);
+        sp1 = sp2;
+     
+        SmartPtr<Base, RefLinked> sp3;
+        SmartPtr<Derived, RefLinked> sp4(new Derived);
+        
+        sp3 = sp4;
+        
+        SmartPtr<Derived, RefCounted, AllowConversion> sp5;
+        
+        if (!!sp5)
+        {}
+        
+        //Derived* p = sp5;
+        
+        //delete sp5;
+    }
+    
+    {
+        class MyClass : public SmallObject<> {};
+        MyClass* p1 = new MyClass;
+        MyClass* p2 = new MyClass;
+        delete p1;
+        delete p2;
+    }
+}        

readme.txt

@@ -0,0 +1,17 @@
+Last update: February 19, 2001
+
+Directions:
+
+To use Loki, simply extract the files from the archive, give your compiler access to their path, and include them appropriately in your code via #include.
+
+If you use the small object allocator directly or indirectly (through the Functor class) you must add SmallObj.cpp to your project/makefile.
+
+If you use Singletons with longevity you must add Singleton.cpp to your project/makefile.
+
+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.
+
+More info:
+
+http://moderncppdesign.com

static_check.h

@@ -0,0 +1,50 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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: February 19, 2001
+
+#ifndef STATIC_CHECK_INC_
+#define STATIC_CHECK_INC_
+
+namespace Loki
+{
+////////////////////////////////////////////////////////////////////////////////
+// Helper structure for the STATIC_CHECK macro
+////////////////////////////////////////////////////////////////////////////////
+
+    template<bool> struct CompileTimeChecker
+    {
+        CompileTimeChecker(...); 
+    };
+
+    template<> struct CompileTimeChecker<false> {};
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 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) \
+    {\
+        class ERROR_##msg {}; \
+        (void)sizeof(::Loki::CompileTimeChecker<(expr) != 0>(ERROR_##msg()));\
+    }
+
+#endif // STATIC_CHECK_INC_