diff --git a/include/loki/AbstractFactory.h b/include/loki/AbstractFactory.h
index 846b60c..34e084c 100644
--- a/include/loki/AbstractFactory.h
+++ b/include/loki/AbstractFactory.h
@@ -2,14 +2,14 @@
 // The Loki Library
 // Copyright (c) 2001 by Andrei Alexandrescu
 // This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+// 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 to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author or Addison-Wesley Longman make no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author or Addison-Wesley Longman make no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_ABSTRACTFACTORY_INC_
@@ -18,10 +18,10 @@
 // $Id$
 
 
-#include "Typelist.h"
-#include "Sequence.h"
-#include "TypeManip.h"
-#include "HierarchyGenerators.h"
+#include <loki/Typelist.h>
+#include <loki/Sequence.h>
+#include <loki/TypeManip.h>
+#include <loki/HierarchyGenerators.h>
 
 #include <cassert>
 
@@ -31,7 +31,7 @@
  * \ingroup		FactoriesGroup
  * \brief		Implements an abstract object factory.
  */
- 
+
 /**
  * \class		AbstractFactory
  * \ingroup		AbstractFactoryGroup
@@ -68,14 +68,14 @@ namespace Loki
     {
     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
@@ -85,10 +85,10 @@ namespace Loki
     class OpNewFactoryUnit : public Base
     {
         typedef typename Base::ProductList BaseProductList;
-    
+
     protected:
         typedef typename BaseProductList::Tail ProductList;
-    
+
     public:
         typedef typename BaseProductList::Head AbstractProduct;
         ConcreteProduct* DoCreate(Type2Type<AbstractProduct>)
@@ -101,7 +101,7 @@ namespace Loki
 // 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 
+//     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.
@@ -111,7 +111,7 @@ namespace Loki
     class PrototypeFactoryUnit : public Base
     {
         typedef typename Base::ProductList BaseProductList;
-    
+
     protected:
         typedef typename BaseProductList::Tail ProductList;
 
@@ -133,17 +133,17 @@ namespace Loki
         template <class U>
         void GetPrototype(U*& p)
         { return DoGetPrototype(*this, p); }
-        
+
         template <class U>
         void SetPrototype(U* pObj)
         { DoSetPrototype(*this, pObj); }
-        
+
         AbstractProduct* DoCreate(Type2Type<AbstractProduct>)
         {
             assert(pPrototype_);
             return pPrototype_->Clone();
         }
-        
+
     private:
         AbstractProduct* pPrototype_;
     };
diff --git a/include/loki/DataGenerators.h b/include/loki/DataGenerators.h
index 9839676..c57d56a 100644
--- a/include/loki/DataGenerators.h
+++ b/include/loki/DataGenerators.h
@@ -2,7 +2,7 @@
 // The Loki Library
 // Data Generator by Shannon Barber
 // This code DOES NOT accompany the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
 //     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
 //
 // Code covered by the MIT License
@@ -15,7 +15,7 @@
 // $Id$
 
 
-#include "Typelist.h"
+#include <loki/Typelist.h>
 
 //Reference version
 
@@ -64,7 +64,7 @@ namespace Loki
             };
     template <class TList, template <class> class GenFunc>
     struct IterateTypes;
-     
+
     template <class T1, class T2, template <class> class GenFunc>
     struct IterateTypes<Typelist<T1, T2>, GenFunc>
     {
@@ -79,7 +79,7 @@ namespace Loki
         tail.operator()(ii);
         }
     };
-     
+
     template <class AtomicType, template <class> class GenFunc>
     struct IterateTypes
     {
@@ -91,7 +91,7 @@ namespace Loki
         ++ii; //Is this even needed?
         }
     };
-    
+
     template <template <class> class GenFunc>
     struct IterateTypes<NullType, GenFunc>
     {
@@ -99,7 +99,7 @@ namespace Loki
     void operator()(II ii)
         {}
     };
-    
+
     template<typename Types, template <class> class UnitFunc, typename II>
     void iterate_types(II ii)
         {
diff --git a/include/loki/Factory.h b/include/loki/Factory.h
index 74734e0..fb912be 100644
--- a/include/loki/Factory.h
+++ b/include/loki/Factory.h
@@ -16,11 +16,11 @@
 // $Id$
 
 
-#include "LokiTypeInfo.h"
-#include "Functor.h"
-#include "AssocVector.h"
-#include "SmallObj.h"
-#include "Sequence.h"
+#include <loki/LokiTypeInfo.h>
+#include <loki/Functor.h>
+#include <loki/AssocVector.h>
+#include <loki/SmallObj.h>
+#include <loki/Sequence.h>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -33,7 +33,7 @@
  * \defgroup	FactoryGroup Factory
  * \ingroup		FactoriesGroup
  * \brief		Implements a generic object factory.
- * 
+ *
  * <i>The Factory Method pattern is an object-oriented design pattern.
  * Like other creational patterns, it deals with the problem of creating objects
  * (products) without specifying the exact class of object that will be created.
@@ -46,7 +46,7 @@
  * whose main purpose is creation of objects.</i>
  * <div ALIGN="RIGHT"><a href="http://en.wikipedia.org/wiki/Factory_method_pattern">
  * Wikipedia</a></div>
- * 
+ *
  * Loki proposes a generic version of the Factory. Here is a typical use.<br>
  * <code><br>
  * 1. Factory< AbstractProduct, int > aFactory;<br>
@@ -62,7 +62,7 @@
  * ProductCreator by registering them into the Factory.<br>
  * A ProductCreator is a just a function that will return the right object. ie <br>
  * <code>
- * Product* createProductNull()<br>             
+ * Product* createProductNull()<br>
  * {<br>
  *     return new Product<br>
  * }<br>
@@ -80,11 +80,11 @@ namespace Loki
  * \defgroup	FactoryErrorPoliciesGroup Factory Error Policies
  * \ingroup		FactoryGroup
  * \brief		Manages the "Unknown Type" error in an object factory
- * 
+ *
  * \class DefaultFactoryError
  * \ingroup		FactoryErrorPoliciesGroup
- * \brief		Default policy that throws an exception		
- * 
+ * \brief		Default policy that throws an exception
+ *
  */
 
     template <typename IdentifierType, class AbstractProduct>
@@ -1065,9 +1065,9 @@ template <typename AP, typename Id, typename P1 >
             	return NULL;
             }
 
-            typename IdToProductMap::iterator i = 
+            typename IdToProductMap::iterator i =
             	associations_.find(typeid(*model));
-            	
+
             if (i != associations_.end())
             {
                 return (i->second)(model);
@@ -1079,7 +1079,7 @@ template <typename AP, typename Id, typename P1 >
         typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
         IdToProductMap associations_;
     };
-        
+
 } // namespace Loki
 
 
diff --git a/include/loki/Functor.h b/include/loki/Functor.h
index d05d466..2cbd912 100644
--- a/include/loki/Functor.h
+++ b/include/loki/Functor.h
@@ -18,11 +18,11 @@
 // $Id$
 
 
-#include "Typelist.h"
-#include "Sequence.h"
-#include "EmptyType.h"
-#include "SmallObj.h"
-#include "TypeTraits.h"
+#include <loki/Typelist.h>
+#include <loki/Sequence.h>
+#include <loki/EmptyType.h>
+#include <loki/SmallObj.h>
+#include <loki/TypeTraits.h>
 #include <typeinfo>
 #include <memory>
 
diff --git a/include/loki/HierarchyGenerators.h b/include/loki/HierarchyGenerators.h
index 7bf1229..1b8b00e 100644
--- a/include/loki/HierarchyGenerators.h
+++ b/include/loki/HierarchyGenerators.h
@@ -2,14 +2,14 @@
 // The Loki Library
 // Copyright (c) 2001 by Andrei Alexandrescu
 // This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+// 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 to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author or Addison-Wesley Longman make no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author or Addison-Wesley Longman make no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_HIERARCHYGENERATORS_INC_
@@ -18,14 +18,14 @@
 // $Id$
 
 
-#include "Typelist.h"
-#include "TypeTraits.h"
-#include "EmptyType.h"
+#include <loki/Typelist.h>
+#include <loki/TypeTraits.h>
+#include <loki/EmptyType.h>
 
 namespace Loki
 {
 #if defined(_MSC_VER) && _MSC_VER >= 1300
-#pragma warning( push ) 
+#pragma warning( push )
  // 'class1' : base-class 'class2' is already a base-class of 'class3'
 #pragma warning( disable : 4584 )
 #endif // _MSC_VER
@@ -35,27 +35,27 @@ namespace Loki
 // Generates a scattered hierarchy starting from a typelist and a template
 // Invocation (TList is a typelist, Unit is a template of one arg):
 // GenScatterHierarchy<TList, Unit>
-// The generated class inherits all classes generated by instantiating the 
-// template 'Unit' with the types contained in TList 
+// The generated class inherits all classes generated by instantiating the
+// template 'Unit' with the types contained in TList
 ////////////////////////////////////////////////////////////////////////////////
 
     namespace Private
     {
-        // The following type helps to overcome subtle flaw in the original 
-        // implementation of GenScatterHierarchy. 
-        // The flaw is revealed when the input type list of GenScatterHierarchy 
-        // contains more then one element of the same type (e.g. LOKI_TYPELIST_2(int, int)). 
-        // In this case GenScatterHierarchy will contain multiple bases of the same 
+        // The following type helps to overcome subtle flaw in the original
+        // implementation of GenScatterHierarchy.
+        // The flaw is revealed when the input type list of GenScatterHierarchy
+        // contains more then one element of the same type (e.g. LOKI_TYPELIST_2(int, int)).
+        // In this case GenScatterHierarchy will contain multiple bases of the same
         // type and some of them will not be reachable (per 10.3).
         // For example before the fix the first element of Tuple<LOKI_TYPELIST_2(int, int)>
         // is not reachable in any way!
-        template<class, class> 
+        template<class, class>
         struct ScatterHierarchyTag;
     }
 
     template <class TList, template <class> class Unit>
     class GenScatterHierarchy;
-     
+
     template <class T1, class T2, template <class> class Unit>
     class GenScatterHierarchy<Typelist<T1, T2>, Unit>
         : public GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit>
@@ -71,10 +71,10 @@ namespace Loki
             typedef Unit<T> Result;
         };
     };
-     
+
     // In the middle *unique* class that resolve possible ambiguity
     template <class T1, class T2, template <class> class Unit>
-    class GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit> 
+    class GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit>
         : public GenScatterHierarchy<T1, Unit>
     {
     };
@@ -88,7 +88,7 @@ namespace Loki
             typedef Unit<T> Result;
         };
     };
-    
+
     template <template <class> class Unit>
     class GenScatterHierarchy<NullType, Unit>
     {
@@ -97,14 +97,14 @@ namespace Loki
             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 
+// returns a reference to Unit<T>, where Unit is the template used to generate H
 ////////////////////////////////////////////////////////////////////////////////
 
     template <class T, class H>
@@ -112,16 +112,16 @@ namespace Loki
     {
         return obj;
     }
-     
+
     template <class T, class H>
     const typename H::template Rebind<T>::Result& Field(const H& obj)
     {
         return obj;
     }
-     
+
 ////////////////////////////////////////////////////////////////////////////////
 // function template TupleUnit
-// The building block of tuples 
+// The building block of tuples
 ////////////////////////////////////////////////////////////////////////////////
 
     template <class T>
@@ -134,8 +134,8 @@ namespace Loki
 
 ////////////////////////////////////////////////////////////////////////////////
 // class template Tuple
-// Implements a tuple class that holds a number of values and provides field 
-//     access to them via the Field function (below) 
+// Implements a tuple class that holds a number of values and provides field
+//     access to them via the Field function (below)
 ////////////////////////////////////////////////////////////////////////////////
 
     template <class TList>
@@ -149,13 +149,13 @@ namespace Loki
 ////////////////////////////////////////////////////////////////////////////////
 
     template <class H, unsigned int i> struct FieldHelper;
-    
+
     template <class H>
     struct FieldHelper<H, 0>
     {
         typedef typename H::TList::Head ElementType;
         typedef typename H::template Rebind<ElementType>::Result UnitType;
-        
+
         enum
         {
             isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
@@ -163,16 +163,16 @@ namespace Loki
         };
 
         typedef const typename H::LeftBase ConstLeftBase;
-        
-        typedef typename Select<isConst, ConstLeftBase, 
+
+        typedef typename Select<isConst, ConstLeftBase,
             typename H::LeftBase>::Result LeftBase;
-            
-        typedef typename Select<isTuple, ElementType, 
+
+        typedef typename Select<isTuple, ElementType,
             UnitType>::Result UnqualifiedResultType;
 
         typedef typename Select<isConst, const UnqualifiedResultType,
                         UnqualifiedResultType>::Result ResultType;
-            
+
         static ResultType& Do(H& obj)
         {
             LeftBase& leftBase = obj;
@@ -185,7 +185,7 @@ namespace Loki
     {
         typedef typename TL::TypeAt<typename H::TList, i>::Result ElementType;
         typedef typename H::template Rebind<ElementType>::Result UnitType;
-        
+
         enum
         {
             isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
@@ -193,16 +193,16 @@ namespace Loki
         };
 
         typedef const typename H::RightBase ConstRightBase;
-        
-        typedef typename Select<isConst, ConstRightBase, 
+
+        typedef typename Select<isConst, ConstRightBase,
             typename H::RightBase>::Result RightBase;
 
-        typedef typename Select<isTuple, ElementType, 
+        typedef typename Select<isTuple, ElementType,
             UnitType>::Result UnqualifiedResultType;
 
         typedef typename Select<isConst, const UnqualifiedResultType,
                         UnqualifiedResultType>::Result ResultType;
-            
+
         static ResultType& Do(H& obj)
         {
             RightBase& rightBase = obj;
@@ -217,7 +217,7 @@ namespace Loki
 //     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 
+//     and T is the i-th type in the typelist
 ////////////////////////////////////////////////////////////////////////////////
 
     template <int i, class H>
@@ -226,14 +226,14 @@ namespace Loki
     {
         return FieldHelper<H, i>::Do(obj);
     }
-        
+
 //    template <int i, class H>
 //    const typename FieldHelper<H, i>::ResultType&
 //    Field(const H& obj)
 //    {
 //        return FieldHelper<H, i>::Do(obj);
 //    }
-        
+
 ////////////////////////////////////////////////////////////////////////////////
 // class template GenLinearHierarchy
 // Generates a linear hierarchy starting from a typelist and a template
@@ -248,7 +248,7 @@ namespace Loki
         class Root = EmptyType
     >
     class GenLinearHierarchy;
-    
+
     template
     <
         class T1,
@@ -283,7 +283,7 @@ namespace Loki
     };
 
 #if defined(_MSC_VER) && _MSC_VER >= 1300
-#pragma warning( pop ) 
+#pragma warning( pop )
 #endif
 }   // namespace Loki
 
diff --git a/include/loki/LokiTypeInfo.h b/include/loki/LokiTypeInfo.h
index 14df506..eb8f9bc 100644
--- a/include/loki/LokiTypeInfo.h
+++ b/include/loki/LokiTypeInfo.h
@@ -2,14 +2,14 @@
 // The Loki Library
 // Copyright (c) 2001 by Andrei Alexandrescu
 // This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+// 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 to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author or Addison-Wesley Longman make no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author or Addison-Wesley Longman make no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_LOKITYPEINFO_INC_
@@ -20,7 +20,7 @@
 
 #include <typeinfo>
 #include <cassert>
-#include "Typelist.h"
+#include <loki/Typelist.h>
 
 namespace Loki
 {
@@ -45,24 +45,24 @@ namespace Loki
     private:
         const std::type_info* pInfo_;
     };
-    
+
 // Implementation
-    
+
     inline TypeInfo::TypeInfo()
     {
         class Nil {};
         pInfo_ = &typeid(Nil);
         assert(pInfo_);
     }
-    
+
     inline TypeInfo::TypeInfo(const std::type_info& ti)
     : pInfo_(&ti)
     { assert(pInfo_); }
-    
+
     inline bool TypeInfo::before(const TypeInfo& rhs) const
     {
         assert(pInfo_);
-        // type_info::before return type is int in some VC libraries 
+        // type_info::before return type is int in some VC libraries
         return pInfo_->before(*rhs.pInfo_) != 0;
     }
 
@@ -71,7 +71,7 @@ namespace Loki
         assert(pInfo_);
         return *pInfo_;
     }
-    
+
     inline const char* TypeInfo::name() const
     {
         assert(pInfo_);
@@ -79,7 +79,7 @@ namespace Loki
     }
 
 // Comparison operators
-    
+
     inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
     // type_info::operator== return type is int in some VC libraries
     { return (lhs.Get() == rhs.Get()) != 0; }
@@ -88,14 +88,14 @@ namespace Loki
     { return lhs.before(rhs); }
 
     inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
-    { return !(lhs == 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); }
 }
diff --git a/include/loki/MultiMethods.h b/include/loki/MultiMethods.h
index f41b2e0..b8ade1b 100644
--- a/include/loki/MultiMethods.h
+++ b/include/loki/MultiMethods.h
@@ -18,10 +18,10 @@
 // $Id$
 
 
-#include "Typelist.h"
-#include "LokiTypeInfo.h"
-#include "Functor.h"
-#include "AssocVector.h"
+#include <loki/Typelist.h>
+#include <loki/LokiTypeInfo.h>
+#include <loki/Functor.h>
+#include <loki/AssocVector.h>
 
 ////////////////////////////////////////////////////////////////////////////////
 // IMPORTANT NOTE:
diff --git a/include/loki/OrderedStatic.h b/include/loki/OrderedStatic.h
index b1b6b15..8c52434 100644
--- a/include/loki/OrderedStatic.h
+++ b/include/loki/OrderedStatic.h
@@ -1,12 +1,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 // The Loki Library
 // Copyright (c) 2005 Peter Kümmel
-// Permission to use, copy, modify, distribute and sell this software for any 
-//     purpose is hereby granted without fee, provided that the above copyright 
-//     notice appear in all copies and that both that copyright notice and this 
+// Permission to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author makes no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author makes no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_ORDEREDSTATIC_INC_
@@ -18,10 +18,10 @@
 #include <vector>
 #include <iostream>
 
-#include "LokiExport.h"
-#include "Singleton.h"
-#include "Typelist.h"
-#include "Sequence.h"
+#include <loki/LokiExport.h>
+#include <loki/Singleton.h>
+#include <loki/Typelist.h>
+#include <loki/Sequence.h>
 
 // usage: see test/OrderedStatic
 
@@ -37,17 +37,17 @@ namespace Loki
         {
         public:
             virtual void createObject() = 0;
-        
+
         protected:
             OrderedStaticCreatorFunc();
             virtual ~OrderedStaticCreatorFunc();
-        
+
         private:
             OrderedStaticCreatorFunc(const OrderedStaticCreatorFunc&);
         };
 
         ////////////////////////////////////////////////////////////////////////////////
-        // template base clase for OrderedStatic template, 
+        // template base clase for OrderedStatic template,
         // common for all specializations
         ////////////////////////////////////////////////////////////////////////////////
         template<class T>
@@ -69,11 +69,11 @@ namespace Loki
             OrderedStaticBase(unsigned int longevity) :  val_(0), longevity_(longevity)
             {
             }
-            
+
             virtual ~OrderedStaticBase()
             {
             }
-            
+
             void SetLongevity(T* ptr)
             {
                 val_=ptr;
@@ -86,11 +86,11 @@ namespace Loki
             OrderedStaticBase& operator=(const OrderedStaticBase&);
             T* val_;
             unsigned int longevity_;
-            
+
         };
 
         ////////////////////////////////////////////////////////////////////////////////
-        // OrderedStaticManagerClass implements details 
+        // OrderedStaticManagerClass implements details
         // OrderedStaticManager is then defined as a Singleton
         ////////////////////////////////////////////////////////////////////////////////
         class LOKI_EXPORT OrderedStaticManagerClass
@@ -107,7 +107,7 @@ namespace Loki
         private:
             OrderedStaticManagerClass(const OrderedStaticManagerClass&);
             OrderedStaticManagerClass& operator=(const OrderedStaticManagerClass&);
-            
+
             struct Data
             {
                 Data(unsigned int,OrderedStaticCreatorFunc*, Creator);
@@ -129,7 +129,7 @@ namespace Loki
 
     typedef Loki::SingletonHolder
     <
-        Loki::Private::OrderedStaticManagerClass, 
+        Loki::Private::OrderedStaticManagerClass,
         Loki::CreateUsingNew,
         Loki::NoDestroy,
         Loki::SingleThreaded
@@ -137,7 +137,7 @@ namespace Loki
     OrderedStaticManager;
 
     ////////////////////////////////////////////////////////////////////////////////
-    // template OrderedStatic template: 
+    // template OrderedStatic template:
     // L        : longevity
     // T        : object type
     // TList    : creator parameters
@@ -154,7 +154,7 @@ namespace Loki
     template<unsigned int L, class T>
     class OrderedStatic<L, T, Loki::NullType> : public Private::OrderedStaticBase<T>
     {
-    public:    
+    public:
         OrderedStatic() : Private::OrderedStaticBase<T>(L)
         {
             OrderedStaticManager::Instance().registerObject
@@ -180,7 +180,7 @@ namespace Loki
             OrderedStaticManager::Instance().registerObject
                                 (L,this,&Private::OrderedStaticCreatorFunc::createObject);
         }
-        
+
         void createObject()
         {
             Private::OrderedStaticBase<T>::SetLongevity(new T(para_));
diff --git a/include/loki/Register.h b/include/loki/Register.h
index 6f1228e..1842799 100644
--- a/include/loki/Register.h
+++ b/include/loki/Register.h
@@ -1,12 +1,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 // The Loki Library
 // Copyright (c) 2006 Peter Kümmel
-// Permission to use, copy, modify, distribute and sell this software for any 
-//     purpose is hereby granted without fee, provided that the above copyright 
-//     notice appear in all copies and that both that copyright notice and this 
+// Permission to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author makes no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author makes no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_REGISTER_INC_
@@ -15,12 +15,12 @@
 // $Id$
 
 
-#include "TypeManip.h"
-#include "HierarchyGenerators.h"
-#include "ForEachType.h"
+#include <loki/TypeManip.h>
+#include <loki/HierarchyGenerators.h>
+#include <loki/ForEachType.h>
 
 
-///  \defgroup RegisterGroup Register 
+///  \defgroup RegisterGroup Register
 
 namespace Loki
 {
@@ -35,14 +35,14 @@ namespace Loki
     ///  \ingroup RegisterGroup
     ///  Must be specialized be the user
     ////////////////////////////////////////////////////////////////////////////////
-    template<class T> 
+    template<class T>
     bool RegisterFunction();
 
     ////////////////////////////////////////////////////////////////////////////////
     ///  \ingroup RegisterGroup
     ///  Must be specialized be the user
     ////////////////////////////////////////////////////////////////////////////////
-    template<class T> 
+    template<class T>
     bool UnRegisterFunction();
 
     namespace Private
@@ -52,7 +52,7 @@ namespace Loki
             template< int Index, typename T >
             void operator()()
             {
-                RegisterFunction<T>(); 
+                RegisterFunction<T>();
             }
         };
 
@@ -118,8 +118,8 @@ namespace Loki
     ///  see test/Register
     ////////////////////////////////////////////////////////////////////////////////
 
-    
-#define LOKI_CONCATE(a,b,c,d) a ## b ## c ## d 
+
+#define LOKI_CONCATE(a,b,c,d) a ## b ## c ## d
 #define LOKI_CONCAT(a,b,c,d) LOKI_CONCATE(a,b,c,d)
 
 #define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST )                                \
diff --git a/include/loki/Sequence.h b/include/loki/Sequence.h
index 3d9359c..91cf0a3 100644
--- a/include/loki/Sequence.h
+++ b/include/loki/Sequence.h
@@ -15,7 +15,7 @@
 // $Id$
 
 
-#include "Typelist.h"
+#include <loki/Typelist.h>
 
 namespace Loki
 {
diff --git a/include/loki/Singleton.h b/include/loki/Singleton.h
index e028372..195da98 100644
--- a/include/loki/Singleton.h
+++ b/include/loki/Singleton.h
@@ -18,8 +18,8 @@
 // $Id$
 
 
-#include "LokiExport.h"
-#include "Threads.h"
+#include <loki/LokiExport.h>
+#include <loki/Threads.h>
 #include <algorithm>
 #include <stdexcept>
 #include <cassert>
diff --git a/include/loki/SmallObj.h b/include/loki/SmallObj.h
index 1f0f584..dc77827 100644
--- a/include/loki/SmallObj.h
+++ b/include/loki/SmallObj.h
@@ -18,9 +18,9 @@
 // $Id$
 
 
-#include "LokiExport.h"
-#include "Threads.h"
-#include "Singleton.h"
+#include <loki/LokiExport.h>
+#include <loki/Threads.h>
+#include <loki/Singleton.h>
 #include <cstddef>
 #include <new> // needed for std::nothrow_t parameter.
 
diff --git a/include/loki/SmartPtr.h b/include/loki/SmartPtr.h
index 4bd14a0..3806ce2 100644
--- a/include/loki/SmartPtr.h
+++ b/include/loki/SmartPtr.h
@@ -29,12 +29,12 @@
 ///  \defgroup  SmartPointerCheckingGroup Checking policies
 ///  \ingroup   SmartPointerGroup
 
-#include "LokiExport.h"
-#include "SmallObj.h"
-#include "TypeManip.h"
-#include "static_check.h"
-#include "RefToValue.h"
-#include "ConstPolicy.h"
+#include <loki/LokiExport.h>
+#include <loki/SmallObj.h>
+#include <loki/TypeManip.h>
+#include <loki/static_check.h>
+#include <loki/RefToValue.h>
+#include <loki/ConstPolicy.h>
 
 #include <functional>
 #include <stdexcept>
diff --git a/include/loki/TypeTraits.h b/include/loki/TypeTraits.h
index b2499fa..33a08c1 100644
--- a/include/loki/TypeTraits.h
+++ b/include/loki/TypeTraits.h
@@ -2,14 +2,14 @@
 // The Loki Library
 // Copyright (c) 2001 by Andrei Alexandrescu
 // This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+// 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 to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author or Addison-Wesley Longman make no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author or Addison-Wesley Longman make no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_TYPETRAITS_INC_
@@ -18,8 +18,8 @@
 // $Id$
 
 
-#include "Typelist.h"
-#include "Sequence.h"
+#include <loki/Typelist.h>
+#include <loki/Sequence.h>
 
 #if (defined _MSC_VER) && (_MSC_VER < 1400)
 #include <string>
@@ -27,7 +27,7 @@
 
 
 #ifdef _MSC_VER
-#pragma warning( push ) 
+#pragma warning( push )
 #pragma warning( disable : 4180 ) //qualifier applied to function type has no meaning; ignored
 #endif
 
@@ -36,7 +36,7 @@ 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 
+// (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
@@ -49,12 +49,12 @@ namespace Loki
     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 
+// (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
@@ -67,7 +67,7 @@ namespace Loki
     struct IsCustomSignedInt
     {
         enum { value = 0 };
-    };        
+    };
 
 ////////////////////////////////////////////////////////////////////////////////
 // class template IsCustomFloat
@@ -84,7 +84,7 @@ namespace Loki
     struct IsCustomFloat
     {
         enum { value = 0 };
-    };        
+    };
 
 ////////////////////////////////////////////////////////////////////////////////
 // Helper types for class template TypeTraits defined below
@@ -92,14 +92,14 @@ namespace Loki
 
     namespace Private
     {
-#ifndef LOKI_DISABLE_TYPELIST_MACROS    
-        typedef LOKI_TYPELIST_4(unsigned char, unsigned short int,unsigned int, unsigned long int) 
+#ifndef LOKI_DISABLE_TYPELIST_MACROS
+        typedef LOKI_TYPELIST_4(unsigned char, unsigned short int,unsigned int, unsigned long int)
             StdUnsignedInts;
-        typedef LOKI_TYPELIST_4(signed char, short int,int, long int) 
+        typedef LOKI_TYPELIST_4(signed char, short int,int, long int)
             StdSignedInts;
-        typedef LOKI_TYPELIST_3(bool, char, wchar_t) 
+        typedef LOKI_TYPELIST_3(bool, char, wchar_t)
             StdOtherInts;
-        typedef LOKI_TYPELIST_3(float, double, long double) 
+        typedef LOKI_TYPELIST_3(float, double, long double)
             StdFloats;
 #else
         typedef Loki::Seq<unsigned char, unsigned short int,unsigned int, unsigned long int>::Type
@@ -111,7 +111,7 @@ namespace Loki
         typedef Loki::Seq<float, double, long double>::Type
             StdFloats;
 
-#endif            
+#endif
         template <typename U> struct AddPointer
         {
             typedef U* Result;
@@ -151,312 +151,312 @@ namespace Loki
         {
             typedef NullType Result;
         };
-    
+
         template <typename T>
         struct IsFunctionPointerRaw
         {enum{result = 0};};
 
         template <typename T>
-        struct IsFunctionPointerRaw<T(*)()> 
+        struct IsFunctionPointerRaw<T(*)()>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01>
-        struct IsFunctionPointerRaw<T(*)(P01)> 
+        struct IsFunctionPointerRaw<T(*)(P01)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02)> 
+            P01, P02)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03)> 
+            P01, P02, P03)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04)> 
+            P01, P02, P03, P04)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05)> 
+            P01, P02, P03, P04, P05)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06)> 
+            P01, P02, P03, P04, P05,
+            P06)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07)> 
+            P06, P07)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08)> 
+            P06, P07, P08)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09)> 
+            P06, P07, P08, P09)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, P10)> 
+            P06, P07, P08, P09, P10)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11)> 
+            P11)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12)> 
+            P11, P12)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13)> 
+            P11, P12, P13)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14)> 
+            P11, P12, P13, P14)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, P15)> 
+            P11, P12, P13, P14, P15)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16)> 
+            P16)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17)> 
+            P16, P17)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18)> 
+            P16, P17, P18)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19)> 
+            P16, P17, P18, P19)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, P20)> 
+            P16, P17, P18, P19, P20)>
         {enum {result = 1};};
 
         template <typename T>
         struct IsFunctionPointerRaw<T(*)(
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01>
         struct IsFunctionPointerRaw<T(*)(
-            P01, ...)> 
+            P01, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, ...)> 
+            P01, P02, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, ...)> 
+            P01, P02, P03, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, ...)> 
+            P01, P02, P03, P04, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, ...)> 
+            P01, P02, P03, P04, P05,
+            P06, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07, ...)> 
+            P06, P07, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, ...)> 
+            P06, P07, P08, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, ...)> 
+            P06, P07, P08, P09, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, ...)> 
+            P11, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, ...)> 
+            P11, P12, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, ...)> 
+            P11, P12, P13, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsFunctionPointerRaw<T(*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, ...)> 
+            P11, P12, P13, P14, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
@@ -464,376 +464,376 @@ namespace Loki
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, ...)> 
+            P16, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, ...)> 
+            P16, P17, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, ...)> 
+            P16, P17, P18, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, ...)> 
+            P16, P17, P18, P19, ...)>
         {enum {result = 1};};
 
-        template <typename T, 
+        template <typename T,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsFunctionPointerRaw<T(*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
             P16, P17, P18, P19, P20,
-            ...)> 
+            ...)>
         {enum {result = 1};};
-        
-        
+
+
         template <typename T>
         struct IsMemberFunctionPointerRaw
         {enum{result = 0};};
 
         template <typename T, typename S>
-        struct IsMemberFunctionPointerRaw<T (S::*)()> 
+        struct IsMemberFunctionPointerRaw<T (S::*)()>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
-        struct IsMemberFunctionPointerRaw<T (S::*)(P01)> 
+        struct IsMemberFunctionPointerRaw<T (S::*)(P01)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02)> 
+            P01, P02)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03)> 
+            P01, P02, P03)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04)> 
+            P01, P02, P03, P04)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05)> 
+            P01, P02, P03, P04, P05)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06)> 
+            P01, P02, P03, P04, P05,
+            P06)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07)> 
+            P06, P07)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08)> 
+            P06, P07, P08)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09)> 
+            P06, P07, P08, P09)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, P10)> 
+            P06, P07, P08, P09, P10)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11)> 
+            P11)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12)> 
+            P11, P12)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13)> 
+            P11, P12, P13)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14)> 
+            P11, P12, P13, P14)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, P15)> 
+            P11, P12, P13, P14, P15)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16)> 
+            P16)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17)> 
+            P16, P17)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18)> 
+            P16, P17, P18)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19)> 
+            P16, P17, P18, P19)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, P20)> 
+            P16, P17, P18, P19, P20)>
         {enum {result = 1};};
 
         template <typename T, typename S>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, ...)> 
+            P01, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, ...)> 
+            P01, P02, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, ...)> 
+            P01, P02, P03, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, ...)> 
+            P01, P02, P03, P04, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, ...)> 
+            P01, P02, P03, P04, P05,
+            P06, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, ...)> 
+            P06, P07, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, ...)> 
+            P06, P07, P08, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, ...)> 
+            P06, P07, P08, P09, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, ...)> 
+            P11, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, ...)> 
+            P11, P12, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, ...)> 
+            P11, P12, P13, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, ...)> 
+            P11, P12, P13, P14, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
@@ -841,373 +841,373 @@ namespace Loki
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, ...)> 
+            P16, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, ...)> 
+            P16, P17, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, ...)> 
+            P16, P17, P18, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, ...)> 
+            P16, P17, P18, P19, ...)>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
             P16, P17, P18, P19, P20,
-            ...)> 
+            ...)>
         {enum {result = 1};};
 
         // Const versions
 
         template <typename T, typename S>
-        struct IsMemberFunctionPointerRaw<T (S::*)() const> 
+        struct IsMemberFunctionPointerRaw<T (S::*)() const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
-        struct IsMemberFunctionPointerRaw<T (S::*)(P01) const> 
+        struct IsMemberFunctionPointerRaw<T (S::*)(P01) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02) const> 
+            P01, P02) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03) const> 
+            P01, P02, P03) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04) const> 
+            P01, P02, P03, P04) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05) const> 
+            P01, P02, P03, P04, P05) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06) const> 
+            P01, P02, P03, P04, P05,
+            P06) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07) const> 
+            P06, P07) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08) const> 
+            P06, P07, P08) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09) const> 
+            P06, P07, P08, P09) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, P10) const> 
+            P06, P07, P08, P09, P10) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11) const> 
+            P11) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12) const> 
+            P11, P12) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13) const> 
+            P11, P12, P13) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14) const> 
+            P11, P12, P13, P14) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, P15) const> 
+            P11, P12, P13, P14, P15) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16) const> 
+            P16) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17) const> 
+            P16, P17) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18) const> 
+            P16, P17, P18) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19) const> 
+            P16, P17, P18, P19) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, P20) const> 
+            P16, P17, P18, P19, P20) const>
         {enum {result = 1};};
 
         template <typename T, typename S>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            ...) const> 
+            ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, ...) const> 
+            P01, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, ...) const> 
+            P01, P02, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, ...) const> 
+            P01, P02, P03, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, ...) const> 
+            P01, P02, P03, P04, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            ...) const> 
+            ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, ...) const> 
+            P01, P02, P03, P04, P05,
+            P06, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, ...) const> 
+            P06, P07, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, ...) const> 
+            P06, P07, P08, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, ...) const> 
+            P06, P07, P08, P09, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            ...) const> 
+            ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, ...) const> 
+            P11, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, ...) const> 
+            P11, P12, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, ...) const> 
+            P11, P12, P13, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, ...) const> 
+            P11, P12, P13, P14, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
@@ -1215,373 +1215,373 @@ namespace Loki
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            ...) const> 
+            ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, ...) const> 
+            P16, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, ...) const> 
+            P16, P17, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, ...) const> 
+            P16, P17, P18, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, ...) const> 
+            P16, P17, P18, P19, ...) const>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
             P16, P17, P18, P19, P20,
-            ...) const> 
+            ...) const>
         {enum {result = 1};};
 
         // Volatile versions
 
         template <typename T, typename S>
-        struct IsMemberFunctionPointerRaw<T (S::*)() volatile> 
+        struct IsMemberFunctionPointerRaw<T (S::*)() volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
-        struct IsMemberFunctionPointerRaw<T (S::*)(P01) volatile> 
+        struct IsMemberFunctionPointerRaw<T (S::*)(P01) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02) volatile> 
+            P01, P02) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03) volatile> 
+            P01, P02, P03) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04) volatile> 
+            P01, P02, P03, P04) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05) volatile> 
+            P01, P02, P03, P04, P05) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06) volatile> 
+            P01, P02, P03, P04, P05,
+            P06) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07) volatile> 
+            P06, P07) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08) volatile> 
+            P06, P07, P08) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09) volatile> 
+            P06, P07, P08, P09) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, P10) volatile> 
+            P06, P07, P08, P09, P10) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11) volatile> 
+            P11) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12) volatile> 
+            P11, P12) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13) volatile> 
+            P11, P12, P13) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14) volatile> 
+            P11, P12, P13, P14) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, P15) volatile> 
+            P11, P12, P13, P14, P15) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16) volatile> 
+            P16) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17) volatile> 
+            P16, P17) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18) volatile> 
+            P16, P17, P18) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19) volatile> 
+            P16, P17, P18, P19) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, P20) volatile> 
+            P16, P17, P18, P19, P20) volatile>
         {enum {result = 1};};
 
         template <typename T, typename S>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            ...) volatile> 
+            ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, ...) volatile> 
+            P01, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, ...) volatile> 
+            P01, P02, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, ...) volatile> 
+            P01, P02, P03, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, ...) volatile> 
+            P01, P02, P03, P04, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            ...) volatile> 
+            ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, ...) volatile> 
+            P01, P02, P03, P04, P05,
+            P06, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, ...) volatile> 
+            P06, P07, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, ...) volatile> 
+            P06, P07, P08, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, ...) volatile> 
+            P06, P07, P08, P09, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            ...) volatile> 
+            ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, ...) volatile> 
+            P11, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, ...) volatile> 
+            P11, P12, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, ...) volatile> 
+            P11, P12, P13, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, ...) volatile> 
+            P11, P12, P13, P14, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
@@ -1589,373 +1589,373 @@ namespace Loki
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            ...) volatile> 
+            ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, ...) volatile> 
+            P16, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, ...) volatile> 
+            P16, P17, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, ...) volatile> 
+            P16, P17, P18, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, ...) volatile> 
+            P16, P17, P18, P19, ...) volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
             P16, P17, P18, P19, P20,
-            ...) volatile> 
+            ...) volatile>
         {enum {result = 1};};
 
         // Const volatile versions
 
         template <typename T, typename S>
-        struct IsMemberFunctionPointerRaw<T (S::*)() const volatile> 
+        struct IsMemberFunctionPointerRaw<T (S::*)() const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
-        struct IsMemberFunctionPointerRaw<T (S::*)(P01) const volatile> 
+        struct IsMemberFunctionPointerRaw<T (S::*)(P01) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02) const volatile> 
+            P01, P02) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03) const volatile> 
+            P01, P02, P03) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04) const volatile> 
+            P01, P02, P03, P04) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05) const volatile> 
+            P01, P02, P03, P04, P05) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06) const volatile> 
+            P01, P02, P03, P04, P05,
+            P06) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07) const volatile> 
+            P06, P07) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08) const volatile> 
+            P06, P07, P08) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09) const volatile> 
+            P06, P07, P08, P09) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, P10) const volatile> 
+            P06, P07, P08, P09, P10) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11) const volatile> 
+            P11) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12) const volatile> 
+            P11, P12) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13) const volatile> 
+            P11, P12, P13) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14) const volatile> 
+            P11, P12, P13, P14) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, P15) const volatile> 
+            P11, P12, P13, P14, P15) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16) const volatile> 
+            P16) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17) const volatile> 
+            P16, P17) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18) const volatile> 
+            P16, P17, P18) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19) const volatile> 
+            P16, P17, P18, P19) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, P20) const volatile> 
+            P16, P17, P18, P19, P20) const volatile>
         {enum {result = 1};};
 
         template <typename T, typename S>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            ...) const volatile> 
+            ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, ...) const volatile> 
+            P01, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, ...) const volatile> 
+            P01, P02, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, ...) const volatile> 
+            P01, P02, P03, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, ...) const volatile> 
+            P01, P02, P03, P04, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            ...) const volatile> 
+            ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, ...) const volatile> 
+            P01, P02, P03, P04, P05,
+            P06, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, ...) const volatile> 
+            P06, P07, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, ...) const volatile> 
+            P06, P07, P08, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
-            P06, P07, P08, P09, ...) const volatile> 
+            P06, P07, P08, P09, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            ...) const volatile> 
+            ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, ...) const volatile> 
+            P11, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, ...) const volatile> 
+            P11, P12, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, ...) const volatile> 
+            P11, P12, P13, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14>
         struct IsMemberFunctionPointerRaw<T (S::*)(
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
-            P11, P12, P13, P14, ...) const volatile> 
+            P11, P12, P13, P14, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15>
@@ -1963,72 +1963,72 @@ namespace Loki
             P01, P02, P03, P04, P05,
             P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            ...) const volatile> 
+            ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, ...) const volatile> 
+            P16, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, ...) const volatile> 
+            P16, P17, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, ...) const volatile> 
+            P16, P17, P18, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
-            P16, P17, P18, P19, ...) const volatile> 
+            P16, P17, P18, P19, ...) const volatile>
         {enum {result = 1};};
 
-        template <typename T, typename S, 
+        template <typename T, typename S,
             typename P01, typename P02, typename P03, typename P04, typename P05,
             typename P06, typename P07, typename P08, typename P09, typename P10,
             typename P11, typename P12, typename P13, typename P14, typename P15,
             typename P16, typename P17, typename P18, typename P19, typename P20>
         struct IsMemberFunctionPointerRaw<T (S::*)(
-            P01, P02, P03, P04, P05, 
-            P06, P07, P08, P09, P10, 
+            P01, P02, P03, P04, P05,
+            P06, P07, P08, P09, P10,
             P11, P12, P13, P14, P15,
             P16, P17, P18, P19, P20,
-            ...) const volatile> 
+            ...) const volatile>
         {enum {result = 1};};
-               
+
       }// namespace Private
-        
+
 ////////////////////////////////////////////////////////////////////////////////
 // class template TypeTraits
 //
@@ -2036,10 +2036,10 @@ namespace Loki
 // Invocations (T is a type, TypeTraits<T>::Property):
 //
 // - isPointer       : returns true if T is a pointer type
-// - PointeeType     : returns the type to which T points if T is a pointer 
+// - PointeeType     : returns the type to which T points if T is a pointer
 //                     type, NullType otherwise
 // - isReference     : returns true if T is a reference type
-// - ReferredType    : returns the type to which T refers if T is a reference 
+// - ReferredType    : returns the type to which T refers if T is a reference
 //                     type, NullType otherwise
 // - isMemberPointer : returns true if T is a pointer to member type
 // - isStdUnsignedInt: returns true if T is a standard unsigned integral type
@@ -2054,15 +2054,15 @@ namespace Loki
 // - isFloat         : returns true if T is a floating-point type
 // - isArith         : returns true if T is a arithmetic type
 // - isFundamental   : returns true if T is a fundamental type
-// - ParameterType   : returns the optimal type to be used as a parameter for 
+// - ParameterType   : returns the optimal type to be used as a parameter for
 //                     functions that take Ts
 // - isConst         : returns true if T is a const-qualified type
 // - NonConstType    : Type with removed 'const' qualifier from T, if any
 // - isVolatile      : returns true if T is a volatile-qualified type
 // - NonVolatileType : Type with removed 'volatile' qualifier from T, if any
-// - UnqualifiedType : Type with removed 'const' and 'volatile' qualifiers from 
+// - UnqualifiedType : Type with removed 'const' and 'volatile' qualifiers from
 //                     T, if any
-// - ParameterType   : returns the optimal type to be used as a parameter 
+// - ParameterType   : returns the optimal type to be used as a parameter
 //                       for functions that take 'const T's
 //
 ////////////////////////////////////////////////////////////////////////////////
@@ -2071,68 +2071,68 @@ namespace Loki
     class TypeTraits
     {
     private:
-    
+
         template <class U> struct ReferenceTraits
         {
             enum { result = false };
             typedef U ReferredType;
         };
-        
+
         template <class U> struct ReferenceTraits<U&>
         {
             enum { result = true };
             typedef U ReferredType;
         };
-               
+
         template <class U> struct PointerTraits
         {
             enum { result = false };
             typedef NullType PointeeType;
         };
-        
+
         template <class U> struct PointerTraits<U*>
         {
             enum { result = true };
             typedef U PointeeType;
         };
-        
+
         template <class U> struct PointerTraits<U*&>
         {
             enum { result = true };
             typedef U PointeeType;
         };
-          
+
         template <class U> struct PToMTraits
         {
             enum { result = false };
         };
-        
+
         template <class U, class V> struct PToMTraits<U V::*>
         {
             enum { result = true };
         };
-        
+
         template <class U, class V> struct PToMTraits<U V::*&>
         {
             enum { result = true };
         };
-        
+
         template <class U> struct FunctionPointerTraits
         {
             enum{ result = Private::IsFunctionPointerRaw<U>::result };
         };
-        
+
         template <typename U> struct PToMFunctionTraits
         {
             enum{ result = Private::IsMemberFunctionPointerRaw<U>::result };
         };
-         
+
         template <class U> struct UnConst
         {
             typedef U Result;
             enum { isConst = 0 };
         };
-        
+
         template <class U> struct UnConst<const U>
         {
             typedef U Result;
@@ -2144,13 +2144,13 @@ namespace Loki
             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;
@@ -2162,17 +2162,17 @@ namespace Loki
             typedef U& Result;
             enum { isVolatile = 1 };
         };
-        
+
     public:
-        typedef typename UnConst<T>::Result 
+        typedef typename UnConst<T>::Result
             NonConstType;
-        typedef typename UnVolatile<T>::Result 
+        typedef typename UnVolatile<T>::Result
             NonVolatileType;
-        typedef typename UnVolatile<typename UnConst<T>::Result>::Result 
+        typedef typename UnVolatile<typename UnConst<T>::Result>::Result
             UnqualifiedType;
-        typedef typename PointerTraits<UnqualifiedType>::PointeeType 
+        typedef typename PointerTraits<UnqualifiedType>::PointeeType
             PointeeType;
-        typedef typename ReferenceTraits<T>::ReferredType 
+        typedef typename ReferenceTraits<T>::ReferredType
             ReferredType;
 
         enum { isConst          = UnConst<T>::isConst };
@@ -2189,32 +2189,32 @@ namespace Loki
         enum { isPointer        = PointerTraits<
                                         typename ReferenceTraits<UnqualifiedType>::ReferredType >::result ||
                                         isFunctionPointer };
-        
+
         enum { isStdUnsignedInt = TL::IndexOf<Private::StdUnsignedInts, UnqualifiedType>::value >= 0 ||
-                                  TL::IndexOf<Private::StdUnsignedInts, 
+                                  TL::IndexOf<Private::StdUnsignedInts,
                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
         enum { isStdSignedInt   = TL::IndexOf<Private::StdSignedInts, UnqualifiedType>::value >= 0 ||
-                                  TL::IndexOf<Private::StdSignedInts, 
+                                  TL::IndexOf<Private::StdSignedInts,
                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
         enum { isStdIntegral    = isStdUnsignedInt || isStdSignedInt ||
                                   TL::IndexOf<Private::StdOtherInts, UnqualifiedType>::value >= 0 ||
-                                  TL::IndexOf<Private::StdOtherInts, 
+                                  TL::IndexOf<Private::StdOtherInts,
                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
         enum { isStdFloat       = TL::IndexOf<Private::StdFloats, UnqualifiedType>::value >= 0 ||
-                                  TL::IndexOf<Private::StdFloats, 
+                                  TL::IndexOf<Private::StdFloats,
                                         typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0};
         enum { isStdArith       = isStdIntegral || isStdFloat };
         enum { isStdFundamental = isStdArith || isStdFloat || Conversion<T, void>::sameType };
-            
+
         enum { isUnsignedInt    = isStdUnsignedInt || IsCustomUnsignedInt<UnqualifiedType>::value };
         enum { isSignedInt      = isStdSignedInt || IsCustomSignedInt<UnqualifiedType>::value };
         enum { isIntegral       = isStdIntegral || isUnsignedInt || isSignedInt };
         enum { isFloat          = isStdFloat || IsCustomFloat<UnqualifiedType>::value };
         enum { isArith          = isIntegral || isFloat };
         enum { isFundamental    = isStdFundamental || isArith };
-        
-        typedef typename Select<isStdArith || isPointer || isMemberPointer, T, 
-                typename Private::AddParameterType<T>::Result>::Result 
+
+        typedef typename Select<isStdArith || isPointer || isMemberPointer, T,
+                typename Private::AddParameterType<T>::Result>::Result
             ParameterType;
     };
 }
diff --git a/include/loki/Typelist.h b/include/loki/Typelist.h
index 7c6cdfa..81d153f 100644
--- a/include/loki/Typelist.h
+++ b/include/loki/Typelist.h
@@ -18,9 +18,9 @@
 // $Id$
 
 
-#include "NullType.h"
-#include "TypeManip.h"
-#include "TypelistMacros.h"
+#include <loki/NullType.h>
+#include <loki/TypeManip.h>
+#include <loki/TypelistMacros.h>
 
 
 namespace Loki
diff --git a/include/loki/Visitor.h b/include/loki/Visitor.h
index f737e51..c6a089a 100644
--- a/include/loki/Visitor.h
+++ b/include/loki/Visitor.h
@@ -2,14 +2,14 @@
 // The Loki Library
 // Copyright (c) 2001 by Andrei Alexandrescu
 // This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+// 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 to use, copy, modify, distribute and sell this software for any
+//     purpose is hereby granted without fee, provided that the above copyright
+//     notice appear in all copies and that both that copyright notice and this
 //     permission notice appear in supporting documentation.
-// The author or Addison-Wesley Longman make no representations about the 
-//     suitability of this software for any purpose. It is provided "as is" 
+// The author or Addison-Wesley Longman make no representations about the
+//     suitability of this software for any purpose. It is provided "as is"
 //     without express or implied warranty.
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef LOKI_VISITOR_INC_
@@ -20,15 +20,15 @@
 
 ///  \defgroup VisitorGroup Visitor
 
-#include "Typelist.h"
-#include "HierarchyGenerators.h"
+#include <loki/Typelist.h>
+#include <loki/HierarchyGenerators.h>
 
 namespace Loki
 {
 
 ////////////////////////////////////////////////////////////////////////////////
 /// \class BaseVisitor
-///  
+///
 /// \ingroup VisitorGroup
 /// The base class of any Acyclic Visitor
 ////////////////////////////////////////////////////////////////////////////////
@@ -38,7 +38,7 @@ namespace Loki
     public:
         virtual ~BaseVisitor() {}
     };
-    
+
 ////////////////////////////////////////////////////////////////////////////////
 /// \class Visitor
 ///
@@ -48,7 +48,7 @@ namespace Loki
 /// \par Usage
 ///
 /// Defining the visitable class:
-/// 
+///
 /// \code
 /// class RasterBitmap : public BaseVisitable<>
 /// {
@@ -59,7 +59,7 @@ namespace Loki
 ///
 /// Way 1 to define a visitor:
 /// \code
-/// class SomeVisitor : 
+/// class SomeVisitor :
 ///     public BaseVisitor // required
 ///     public Visitor<RasterBitmap>,
 ///     public Visitor<Paragraph>
@@ -72,7 +72,7 @@ namespace Loki
 ///
 /// Way 2 to define the visitor:
 /// \code
-/// class SomeVisitor : 
+/// class SomeVisitor :
 ///     public BaseVisitor // required
 ///     public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
 /// {
@@ -84,7 +84,7 @@ namespace Loki
 ///
 /// Way 3 to define the visitor:
 /// \code
-/// class SomeVisitor : 
+/// class SomeVisitor :
 ///     public BaseVisitor // required
 ///     public Visitor<Seq<RasterBitmap, Paragraph>::Type>
 /// {
@@ -97,7 +97,7 @@ namespace Loki
 /// \par Using const visit functions:
 ///
 /// Defining the visitable class (true for const):
-/// 
+///
 /// \code
 /// class RasterBitmap : public BaseVisitable<void, DefaultCatchAll, true>
 /// {
@@ -108,7 +108,7 @@ namespace Loki
 ///
 /// Defining the visitor which only calls const member functions:
 /// \code
-/// class SomeVisitor : 
+/// class SomeVisitor :
 ///     public BaseVisitor // required
 ///     public Visitor<RasterBitmap, void, true>,
 /// {
@@ -119,7 +119,7 @@ namespace Loki
 ///
 /// \par Example:
 ///
-/// test/Visitor/main.cpp 
+/// test/Visitor/main.cpp
 ////////////////////////////////////////////////////////////////////////////////
 
     template <class T, typename R = void, bool ConstVisit = false>
@@ -150,7 +150,7 @@ namespace Loki
 // 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 : 
+// class SomeVisitor :
 //     public BaseVisitor // required
 //     public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
 // {
@@ -169,7 +169,7 @@ namespace Loki
        // using Visitor<Head, R>::Visit;
        // using Visitor<Tail, R>::Visit;
     };
-    
+
     template <class Head, typename R>
     class Visitor<Typelist<Head, NullType>, R, false> : public Visitor<Head, R, false>
     {
@@ -187,7 +187,7 @@ namespace Loki
        // using Visitor<Head, R>::Visit;
        // using Visitor<Tail, R>::Visit;
     };
-    
+
     template <class Head, typename R>
     class Visitor<Typelist<Head, NullType>, R, true> : public Visitor<Head, R, true>
     {
@@ -216,7 +216,7 @@ namespace Loki
         virtual R Visit(Head&)
         { return R(); }
     };
-    
+
     template <class Head, typename R>
     class BaseVisitorImpl<Typelist<Head, NullType>, R>
         : public Visitor<Head, R>
@@ -225,7 +225,7 @@ namespace Loki
         virtual R Visit(Head&)
         { return R(); }
     };
-    
+
 ////////////////////////////////////////////////////////////////////////////////
 // class template BaseVisitable
 ////////////////////////////////////////////////////////////////////////////////
@@ -241,9 +241,9 @@ struct DefaultCatchAll
 // class template BaseVisitable
 ////////////////////////////////////////////////////////////////////////////////
 
-    template 
+    template
     <
-        typename R = void, 
+        typename R = void,
         template <typename, class> class CatchAll = DefaultCatchAll,
         bool ConstVisitable = false
     >
@@ -256,7 +256,7 @@ struct DefaultCatchAll
         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)
@@ -277,7 +277,7 @@ struct DefaultCatchAll
         typedef R ReturnType;
         virtual ~BaseVisitable() {}
         virtual ReturnType Accept(BaseVisitor&) const = 0;
-        
+
     protected: // give access only to the hierarchy
         template <class T>
         static ReturnType AcceptImpl(const T& visited, BaseVisitor& guest)
@@ -295,7 +295,7 @@ struct DefaultCatchAll
 ////////////////////////////////////////////////////////////////////////////////
 /// \def LOKI_DEFINE_VISITABLE()
 /// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable 
+/// Put it in every class that you want to make visitable
 /// (in addition to deriving it from BaseVisitable<R>)
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -306,7 +306,7 @@ struct DefaultCatchAll
 ////////////////////////////////////////////////////////////////////////////////
 /// \def LOKI_DEFINE_CONST_VISITABLE()
 /// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable by const member 
+/// Put it in every class that you want to make visitable by const member
 /// functions (in addition to deriving it from BaseVisitable<R>)
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -318,7 +318,7 @@ struct DefaultCatchAll
 /// \class CyclicVisitor
 ///
 /// \ingroup VisitorGroup
-/// Put it in every class that you want to make visitable (in addition to 
+/// Put it in every class that you want to make visitable (in addition to
 /// deriving it from BaseVisitable<R>
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -328,7 +328,7 @@ struct DefaultCatchAll
     public:
         typedef R ReturnType;
         // using Visitor<TList, R>::Visit;
-        
+
         template <class Visited>
         ReturnType GenericVisit(Visited& host)
         {
@@ -336,7 +336,7 @@ struct DefaultCatchAll
             return subObj.Visit(host);
         }
     };
-    
+
 ////////////////////////////////////////////////////////////////////////////////
 /// \def LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor)
 /// \ingroup VisitorGroup