From df8f4eb7c035c786b86143acf08c76b4a800ab2e Mon Sep 17 00:00:00 2001
From: aleks-f <alex@pocoproject.org>
Date: Mon, 12 Nov 2012 20:45:16 -0600
Subject: [PATCH] Replaced space indentations with tabs

Replaced intermittent space indentations with tabs; removed test.txt
file
---
 Foundation/include/Poco/DigestEngine.h       |   12 +-
 Foundation/include/Poco/FIFOBufferStream.h   |    2 +-
 Foundation/include/Poco/MetaObject.h         |    2 +-
 Foundation/include/Poco/NamedTuple.h         | 6526 +++++++++---------
 Foundation/include/Poco/StreamCopier.h       |   12 +-
 Foundation/include/Poco/Thread_POSIX.h       |    6 +-
 Foundation/include/Poco/Thread_WIN32.h       |    2 +-
 Foundation/include/Poco/TypeList.h           |    4 +-
 Foundation/src/Debugger.cpp                  |    6 +-
 Foundation/src/File.cpp                      |   10 +-
 Foundation/src/Thread_WIN32.cpp              |    2 +-
 Foundation/src/Timestamp.cpp                 |   54 +-
 Foundation/src/UTF8String.cpp                |   44 +-
 Foundation/testsuite/src/DateTimeTest.cpp    |  698 +-
 Foundation/testsuite/src/FileChannelTest.cpp |   20 +-
 Foundation/testsuite/src/FileChannelTest.h   |   14 +-
 Foundation/testsuite/src/NamedTuplesTest.cpp |  558 +-
 Foundation/testsuite/src/URITest.cpp         |   42 +-
 Foundation/testsuite/test.txt                |    3 -
 19 files changed, 4007 insertions(+), 4010 deletions(-)
 delete mode 100644 Foundation/testsuite/test.txt

diff --git a/Foundation/include/Poco/DigestEngine.h b/Foundation/include/Poco/DigestEngine.h
index 0b1b09100..0b7400785 100644
--- a/Foundation/include/Poco/DigestEngine.h
+++ b/Foundation/include/Poco/DigestEngine.h
@@ -82,15 +82,15 @@ public:
 		/// The returned reference is valid until the next
 		/// time digest() is called, or the engine object is destroyed.
 
-        static std::string digestToHex(const Digest& bytes);
-                /// Converts a message digest into a string of hexadecimal numbers.
+	static std::string digestToHex(const Digest& bytes);
+		/// Converts a message digest into a string of hexadecimal numbers.
 
-        static Digest digestFromHex(const std::string& digest);
-                /// Converts a string created by digestToHex back to its Digest presentation
+	static Digest digestFromHex(const std::string& digest);
+		/// Converts a string created by digestToHex back to its Digest presentation
 
 protected:
-        virtual void updateImpl(const void* data, std::size_t length) = 0;
-                /// Updates the digest with the given data. Must be implemented
+	virtual void updateImpl(const void* data, std::size_t length) = 0;
+		/// Updates the digest with the given data. Must be implemented
 		/// by subclasses.
 		
 private:
diff --git a/Foundation/include/Poco/FIFOBufferStream.h b/Foundation/include/Poco/FIFOBufferStream.h
index f36d9c3bf..b75c86537 100644
--- a/Foundation/include/Poco/FIFOBufferStream.h
+++ b/Foundation/include/Poco/FIFOBufferStream.h
@@ -132,7 +132,7 @@ class Foundation_API FIFOBufferStream: public FIFOIOS, public std::iostream
 	/// An output stream for writing to a FIFO.
 {
 public:
-    Poco::BasicEvent<bool>& readable;
+	Poco::BasicEvent<bool>& readable;
 	Poco::BasicEvent<bool>& writable;
 
 	explicit FIFOBufferStream(FIFOBuffer& buffer);
diff --git a/Foundation/include/Poco/MetaObject.h b/Foundation/include/Poco/MetaObject.h
index 643ee573b..971828295 100644
--- a/Foundation/include/Poco/MetaObject.h
+++ b/Foundation/include/Poco/MetaObject.h
@@ -206,7 +206,7 @@ public:
 	{
 		return *_object.get();
 	}
-      
+
 	bool isAutoDelete(B* pObject) const
 	{
 		return true;
diff --git a/Foundation/include/Poco/NamedTuple.h b/Foundation/include/Poco/NamedTuple.h
index 1fd8b8393..da9513c2a 100644
--- a/Foundation/include/Poco/NamedTuple.h
+++ b/Foundation/include/Poco/NamedTuple.h
@@ -52,167 +52,167 @@ namespace Poco {
 
 
 template<class T0, 
-    class T1 = NullTypeList,
-    class T2 = NullTypeList,
-    class T3 = NullTypeList,
-    class T4 = NullTypeList,
-    class T5 = NullTypeList,
-    class T6 = NullTypeList,
-    class T7 = NullTypeList, 
-    class T8 = NullTypeList,
-    class T9 = NullTypeList,
-    class T10 = NullTypeList,
-    class T11 = NullTypeList,
-    class T12 = NullTypeList,
-    class T13 = NullTypeList,
-    class T14 = NullTypeList,
-    class T15 = NullTypeList,
-    class T16 = NullTypeList,
-    class T17 = NullTypeList,
-    class T18 = NullTypeList,
-    class T19 = NullTypeList>
+	class T1 = NullTypeList,
+	class T2 = NullTypeList,
+	class T3 = NullTypeList,
+	class T4 = NullTypeList,
+	class T5 = NullTypeList,
+	class T6 = NullTypeList,
+	class T7 = NullTypeList, 
+	class T8 = NullTypeList,
+	class T9 = NullTypeList,
+	class T10 = NullTypeList,
+	class T11 = NullTypeList,
+	class T12 = NullTypeList,
+	class T13 = NullTypeList,
+	class T14 = NullTypeList,
+	class T15 = NullTypeList,
+	class T16 = NullTypeList,
+	class T17 = NullTypeList,
+	class T18 = NullTypeList,
+	class T19 = NullTypeList>
 struct NamedTuple: public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::Type Type;
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames)
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
-        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
-        typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
-        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
-        typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
-        const std::string& n14 = "O",
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
-        const std::string& n15 = "P",
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
-        const std::string& n16 = "Q",
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
-        const std::string& n17 = "R",
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
-        const std::string& n18 = "S",
-        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18),
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		const std::string& n17 = "R",
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
+		const std::string& n18 = "S",
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18),
 		const std::string& n19 = "T",
-        typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
@@ -223,41 +223,41 @@ struct NamedTuple: public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T1
 					case 17: return TupleType::template get<17>();
 					case 18: return TupleType::template get<18>();
 					case 19: return TupleType::template get<19>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
-        throw NotFoundException("Name not found: " + name);
-    }
+		throw NotFoundException("Name not found: " + name);
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
 	void setName(std::size_t index, const std::string& name)
 	{
@@ -275,61 +275,61 @@ struct NamedTuple: public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T1
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N",
-        const std::string& n14 = "O",
-        const std::string& n15 = "P",
-        const std::string& n16 = "Q",
-        const std::string& n17 = "R",
-        const std::string& n18 = "S",
-        const std::string& n19 = "T")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q",
+		const std::string& n17 = "R",
+		const std::string& n18 = "S",
+		const std::string& n19 = "T")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
@@ -340,171 +340,171 @@ private:
 			_pNames->push_back(n17); 
 			_pNames->push_back(n18); 
 			_pNames->push_back(n19); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12,
-    class T13,
-    class T14,
-    class T15,
-    class T16,
-    class T17,
-    class T18>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::Type Type;
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
-        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
-        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
-        const std::string& n14 = "O",
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
-        const std::string& n15 = "P",
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
-        const std::string& n16 = "Q",
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
-        const std::string& n17 = "R",
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
-        const std::string& n18 = "S",
-        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		const std::string& n17 = "R",
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
+		const std::string& n18 = "S",
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
@@ -514,43 +514,43 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,
 					case 16: return TupleType::template get<16>();
 					case 17: return TupleType::template get<17>();
 					case 18: return TupleType::template get<18>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -566,60 +566,60 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N",
-        const std::string& n14 = "O",
-        const std::string& n15 = "P",
-        const std::string& n16 = "Q",
-        const std::string& n17 = "R",
-        const std::string& n18 = "S")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q",
+		const std::string& n17 = "R",
+		const std::string& n18 = "S")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
@@ -629,166 +629,166 @@ private:
 			_pNames->push_back(n16); 
 			_pNames->push_back(n17); 
 			_pNames->push_back(n18); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12,
-    class T13,
-    class T14,
-    class T15,
-    class T16,
-    class T17>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::Type Type;
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames)
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
-        const std::string& n14 = "O",
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
-        const std::string& n15 = "P",
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
-        const std::string& n16 = "Q",
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
-        const std::string& n17 = "R",
-        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		const std::string& n17 = "R",
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
@@ -797,43 +797,43 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,
 					case 15: return TupleType::template get<15>();
 					case 16: return TupleType::template get<16>();
 					case 17: return TupleType::template get<17>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -849,59 +849,59 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N",
-        const std::string& n14 = "O",
-        const std::string& n15 = "P",
-        const std::string& n16 = "Q",
-        const std::string& n17 = "R")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q",
+		const std::string& n17 = "R")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
@@ -910,161 +910,161 @@ private:
 			_pNames->push_back(n15); 
 			_pNames->push_back(n16); 
 			_pNames->push_back(n17); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12,
-    class T13,
-    class T14,
-    class T15,
-    class T16>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::Type Type;
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
-        const std::string& n14 = "O",
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
-        const std::string& n15 = "P",
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
-        const std::string& n16 = "Q",
-        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
@@ -1072,43 +1072,43 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,Null
 					case 14: return TupleType::template get<14>();
 					case 15: return TupleType::template get<15>();
 					case 16: return TupleType::template get<16>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -1124,58 +1124,58 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,Null
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N",
-        const std::string& n14 = "O",
-        const std::string& n15 = "P",
-        const std::string& n16 = "Q")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
@@ -1183,200 +1183,200 @@ private:
 			_pNames->push_back(n14); 
 			_pNames->push_back(n15); 
 			_pNames->push_back(n16); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12,
-    class T13,
-    class T14,
-    class T15>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
-        const std::string& n14 = "O",
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
-        const std::string& n15 = "P",
-        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
 					case 13: return TupleType::template get<13>();
 					case 14: return TupleType::template get<14>();
 					case 15: return TupleType::template get<15>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -1392,251 +1392,251 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullType
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N",
-        const std::string& n14 = "O",
-        const std::string& n15 = "P")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
 			_pNames->push_back(n13); 
 			_pNames->push_back(n14); 
 			_pNames->push_back(n15); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12,
-    class T13,
-    class T14>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
-        const std::string& n14 = "O",
-        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
 					case 13: return TupleType::template get<13>();
 					case 14: return TupleType::template get<14>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -1652,243 +1652,243 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N",
-        const std::string& n14 = "O")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
 			_pNames->push_back(n13); 
 			_pNames->push_back(n14); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12,
-    class T13>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
-        const std::string& n13 = "N",
-        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
 					case 13: return TupleType::template get<13>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -1904,234 +1904,234 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M",
-        const std::string& n13 = "N")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
 			_pNames->push_back(n13); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11,
-    class T12>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
-        const std::string& n12 = "M",
-        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
-    TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), _pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12);
-    }
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
 					case 12: return TupleType::template get<12>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -2147,227 +2147,227 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L",
-        const std::string& n12 = "M")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
 			_pNames->push_back(n12); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10,
-    class T11>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
-        const std::string& n11 = "L",
-        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
 					case 11: return TupleType::template get<11>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -2383,218 +2383,218 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K",
-        const std::string& n11 = "L")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
 			_pNames->push_back(n11); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9,
-    class T10>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
-        const std::string& n10 = "K",
-        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
-    TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), _pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10);
-    }
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
 					case 10: return TupleType::template get<10>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -2610,211 +2610,211 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J",
-        const std::string& n10 = "K")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
 			_pNames->push_back(n10); 
-        }
-    }
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8,
-    class T9>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
-        const std::string& n9 = "J",
-        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    case 9: return TupleType::template get<9>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -2830,203 +2830,203 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I",
-        const std::string& n9 = "J")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-            _pNames->push_back(n9); 
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7, 
-    class T8>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
-        const std::string& n8 = "I",
-        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7,n8);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    case 8: return TupleType::template get<8>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -3042,195 +3042,195 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H",
-        const std::string& n8 = "I")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-            _pNames->push_back(n8);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6,
-    class T7>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
-        const std::string& n7 = "H",
-        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
 		TupleType(t0,t1,t2,t3,t4,t5,t6,t7), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6,n7);
-    }
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    case 7: return TupleType::template get<7>(); 
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -3246,185 +3246,185 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G",
-        const std::string& n7 = "H")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-            _pNames->push_back(n7);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5,
-    class T6>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5,T6>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
-
-        _pNames = rNames;
-    }
-
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
-    TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0)
-    {
-        init();
-    }
-
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
-    TupleType(t0,t1,t2,t3,t4,t5,t6)
-    {
+	NamedTuple(const NameVecPtr& rNames) 
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
-        const std::string& n6 = "G",
-        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
-    TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5,n6);
-    }
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0)
+	{
+		init();
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    case 6: return TupleType::template get<6>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -3440,177 +3440,177 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F", 
-        const std::string& n6 = "G")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-            _pNames->push_back(n6);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4,
-    class T5>
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5>
 struct NamedTuple<T0,T1,T2,T3,T4,T5,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4,T5>
 {
 	typedef Tuple<T0,T1,T2,T3,T4,T5> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4,T5>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
-
-        _pNames = rNames;
-    }
-
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
-    TupleType(t0,t1,t2,t3,t4,t5), _pNames(0)
-    {
-        init();
-    }
-
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
-    TupleType(t0,t1,t2,t3,t4,t5)
-    {
+	NamedTuple(const NameVecPtr& rNames) 
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
-        const std::string& n5 = "F",
-        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
-    TupleType(t0,t1,t2,t3,t4,t5), _pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4,n5);
-    }
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
+	TupleType(t0,t1,t2,t3,t4,t5), _pNames(0)
+	{
+		init();
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
+	TupleType(t0,t1,t2,t3,t4,t5)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    case 5: return TupleType::template get<5>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
+	TupleType(t0,t1,t2,t3,t4,t5), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -3626,171 +3626,171 @@ struct NamedTuple<T0,T1,T2,T3,T4,T5,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E",
-        const std::string& n5 = "F")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-            _pNames->push_back(n5);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3,
-    class T4>
+	class T1,
+	class T2,
+	class T3,
+	class T4>
 struct NamedTuple<T0,T1,T2,T3,T4,NullTypeList>:
 	public Tuple<T0,T1,T2,T3,T4>
 {
 	typedef Tuple<T0,T1,T2,T3,T4> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3,T4>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
 		TupleType(t0,t1,t2,t3,t4), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
 		TupleType(t0,t1,t2,t3,t4)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
-        const std::string& n4 = "E",
-        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
 		TupleType(t0,t1,t2,t3,t4), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2,n3,n4);
-    }
+	{
+		init(n0,n1,n2,n3,n4);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    case 4: return TupleType::template get<4>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -3806,162 +3806,162 @@ struct NamedTuple<T0,T1,T2,T3,T4,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D",
-        const std::string& n4 = "E")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-            _pNames->push_back(n4);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2,
-    class T3>
+	class T1,
+	class T2,
+	class T3>
 struct NamedTuple<T0,T1,T2,T3,NullTypeList>:
 	public Tuple<T0,T1,T2,T3>
 {
 	typedef Tuple<T0,T1,T2,T3> TupleType;
 	typedef typename Tuple<T0,T1,T2,T3>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
 		TupleType(t0,t1,t2,t3), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
 		TupleType(t0,t1,t2,t3)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
-        const std::string& n3 = "D",
-        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
-    TupleType(t0,t1,t2,t3), _pNames(0) 
-    {
-        init(n0,n1,n2,n3);
-    }
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
+	TupleType(t0,t1,t2,t3), _pNames(0) 
+	{
+		init(n0,n1,n2,n3);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    case 3: return TupleType::template get<3>(); 
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -3977,155 +3977,155 @@ struct NamedTuple<T0,T1,T2,T3,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C",
-        const std::string& n3 = "D")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-            _pNames->push_back(n3); 
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1,
-    class T2>
+	class T1,
+	class T2>
 struct NamedTuple<T0,T1,T2,NullTypeList>:
 	public Tuple<T0,T1,T2>
 {
 	typedef Tuple<T0,T1,T2> TupleType;
 	typedef typename Tuple<T0,T1,T2>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
 		TupleType(t0,t1,t2), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
 		TupleType(t0,t1,t2)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
-        const std::string& n2 = "C",
-        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
 		TupleType(t0,t1,t2), 
 		_pNames(0) 
-    {
-        init(n0,n1,n2);
-    }
+	{
+		init(n0,n1,n2);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    case 2: return TupleType::template get<2>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -4141,147 +4141,147 @@ struct NamedTuple<T0,T1,T2,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B",
-        const std::string& n2 = "C")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-            _pNames->push_back(n2);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
 template<class T0, 
-    class T1>
+	class T1>
 struct NamedTuple<T0,T1,NullTypeList>:
 	public Tuple<T0,T1>
 {
 	typedef Tuple<T0,T1> TupleType;
 	typedef typename Tuple<T0,T1>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
 		TupleType(t0,t1), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0,
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
 		TupleType(t0,t1)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0,
-        typename TypeWrapper<T0>::CONSTTYPE& t0, 
-        const std::string& n1 = "B",
-        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
 		TupleType(t0,t1), 
 		_pNames(0) 
-    {
-        init(n0,n1);
-    }
+	{
+		init(n0,n1);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    case 1: return TupleType::template get<1>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -4297,39 +4297,39 @@ struct NamedTuple<T0,T1,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A",
-        const std::string& n1 = "B")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-            _pNames->push_back(n1);
-        }
-    }
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
@@ -4340,95 +4340,95 @@ struct NamedTuple<T0,NullTypeList>:
 	typedef Tuple<T0> TupleType;
 	typedef typename Tuple<T0>::Type Type;
 
-    typedef std::vector<std::string> NameVec; 
-    typedef SharedPtr<NameVec> NameVecPtr; 
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
 
-    NamedTuple(): _pNames(0)
-    {
-        init();
-    }
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames) 
-    {
-        if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0): 
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0): 
 		TupleType(t0), 
 		_pNames(0)
-    {
-        init();
-    }
+	{
+		init();
+	}
 
-    NamedTuple(const NameVecPtr& rNames, 
-        typename TypeWrapper<T0>::CONSTTYPE& t0): 
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0): 
 		TupleType(t0)
-    {
+	{
 		if (rNames->size() != TupleType::length)
-            throw InvalidArgumentException("Wrong names vector length."); 
+			throw InvalidArgumentException("Wrong names vector length."); 
 
-        _pNames = rNames;
-    }
+		_pNames = rNames;
+	}
 
-    NamedTuple(const std::string& n0, typename TypeWrapper<T0>::CONSTTYPE& t0): 
+	NamedTuple(const std::string& n0, typename TypeWrapper<T0>::CONSTTYPE& t0): 
 		TupleType(t0), 
 		_pNames(0) 
-    {
-        init(n0);
-    }
+	{
+		init(n0);
+	}
 
-    const DynamicAny get(const std::string& name) const
-    {
-        NameVec::const_iterator it = _pNames->begin(); 
-        NameVec::const_iterator itEnd = _pNames->end();
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
 
-        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
-        {
-            if (name == *it)
-            {
-                switch (counter)
-                { 
-                    case 0: return TupleType::template get<0>();
-                    default: throw RangeException();
-                }
-            }
-        } 
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					default: throw RangeException();
+				}
+			}
+		} 
 
 		throw NotFoundException("Name not found: " + name);
-    }
+	}
 
-    const DynamicAny operator [] (const std::string& name) const
-    {
-        return get(name);
-    }
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::ConstHeadType& get() const 
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    typename TypeGetter<N, Type>::HeadType& get()
-    {
-        return TupleType::template get<N>();
-    }
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
 
-    template<int N>
-    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
-    {
-        return TupleType::template set<N>(val);
-    }
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
 
-    const NameVecPtr& names()
-    {
-        return _pNames; 
-    }
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
 
-    void setName(std::size_t index, const std::string& name)
+	void setName(std::size_t index, const std::string& name)
 	{
 		if (index >= _pNames->size())
 			throw InvalidArgumentException(format("Invalid index: %z", index));
@@ -4444,37 +4444,37 @@ struct NamedTuple<T0,NullTypeList>:
 		return (*_pNames)[index];
 	}
 
-    bool operator == (const NamedTuple& other) const
-    {
-        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
-    }
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
 
-    bool operator != (const NamedTuple& other) const 
-    {
-        return !(*this == other);
-    }
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
 
-    bool operator < (const NamedTuple& other) const
-    {
-        TupleType th(*this);
-        TupleType oth(other); 
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
 
-        return (th < oth && _pNames == other._pNames) || 
-            (th == oth && _pNames < other._pNames) ||
-            (th < oth && _pNames < other._pNames);
-    }
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
 
 private:
-    void init(const std::string& n0 = "A")
-    { 
-        if (!_pNames)
-        {
-            _pNames = new NameVec;
-            _pNames->push_back(n0);
-        }
-    }
+	void init(const std::string& n0 = "A")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+		}
+	}
 
-    NameVecPtr _pNames;
+	NameVecPtr _pNames;
 };
 
 
diff --git a/Foundation/include/Poco/StreamCopier.h b/Foundation/include/Poco/StreamCopier.h
index 9067f76a9..4924b5c18 100644
--- a/Foundation/include/Poco/StreamCopier.h
+++ b/Foundation/include/Poco/StreamCopier.h
@@ -54,13 +54,13 @@ class Foundation_API StreamCopier
 	/// into another.
 {
 public:
-    static std::streamsize copyStream(std::istream& istr, std::ostream& ostr, std::size_t bufferSize = 8192);
+	static std::streamsize copyStream(std::istream& istr, std::ostream& ostr, std::size_t bufferSize = 8192);
 		/// Writes all bytes readable from istr to ostr, using an internal buffer.
 		///
 		/// Returns the number of bytes copied.
 
 #if defined(POCO_HAVE_INT64)
-    static Poco::UInt64 copyStream64(std::istream& istr, std::ostream& ostr, std::size_t bufferSize = 8192);
+	static Poco::UInt64 copyStream64(std::istream& istr, std::ostream& ostr, std::size_t bufferSize = 8192);
 		/// Writes all bytes readable from istr to ostr, using an internal buffer.
 		///
 		/// Returns the number of bytes copied as a 64-bit unsigned integer.
@@ -69,13 +69,13 @@ public:
 		/// integer is used to count the number of bytes copied.
 #endif
 
-    static std::streamsize copyStreamUnbuffered(std::istream& istr, std::ostream& ostr);
+	static std::streamsize copyStreamUnbuffered(std::istream& istr, std::ostream& ostr);
 		/// Writes all bytes readable from istr to ostr.
 		///
 		/// Returns the number of bytes copied.
 
 #if defined(POCO_HAVE_INT64)
-    static Poco::UInt64 copyStreamUnbuffered64(std::istream& istr, std::ostream& ostr);
+	static Poco::UInt64 copyStreamUnbuffered64(std::istream& istr, std::ostream& ostr);
 		/// Writes all bytes readable from istr to ostr.
 		///
 		/// Returns the number of bytes copied as a 64-bit unsigned integer.
@@ -84,13 +84,13 @@ public:
 		/// integer is used to count the number of bytes copied.
 #endif
 
-    static std::streamsize copyToString(std::istream& istr, std::string& str, std::size_t bufferSize = 8192);
+	static std::streamsize copyToString(std::istream& istr, std::string& str, std::size_t bufferSize = 8192);
 		/// Appends all bytes readable from istr to the given string, using an internal buffer.
 		///
 		/// Returns the number of bytes copied.
 
 #if defined(POCO_HAVE_INT64)
-    static Poco::UInt64 copyToString64(std::istream& istr, std::string& str, std::size_t bufferSize = 8192);
+	static Poco::UInt64 copyToString64(std::istream& istr, std::string& str, std::size_t bufferSize = 8192);
 		/// Appends all bytes readable from istr to the given string, using an internal buffer.
 		///
 		/// Returns the number of bytes copied as a 64-bit unsigned integer.
diff --git a/Foundation/include/Poco/Thread_POSIX.h b/Foundation/include/Poco/Thread_POSIX.h
index e9da535b1..d24b5808a 100644
--- a/Foundation/include/Poco/Thread_POSIX.h
+++ b/Foundation/include/Poco/Thread_POSIX.h
@@ -64,7 +64,7 @@ namespace Poco {
 class Foundation_API ThreadImpl
 {
 public:	
-    typedef pthread_t TIDImpl;
+	typedef pthread_t TIDImpl;
 	typedef void (*Callable)(void*);
 
 	enum Priority
@@ -91,9 +91,9 @@ public:
 		void*     pData; 
 	};
 
-	ThreadImpl();				
+	ThreadImpl();
 	~ThreadImpl();
-    
+
 	TIDImpl tidImpl() const;
 	void setPriorityImpl(int prio);
 	int getPriorityImpl() const;
diff --git a/Foundation/include/Poco/Thread_WIN32.h b/Foundation/include/Poco/Thread_WIN32.h
index 3c863c9bb..9f58e4f3a 100644
--- a/Foundation/include/Poco/Thread_WIN32.h
+++ b/Foundation/include/Poco/Thread_WIN32.h
@@ -51,7 +51,7 @@ namespace Poco {
 class Foundation_API ThreadImpl
 {
 public:	
-    typedef DWORD TIDImpl;
+	typedef DWORD TIDImpl;
 	typedef void (*Callable)(void*);
 
 #if defined(_DLL)
diff --git a/Foundation/include/Poco/TypeList.h b/Foundation/include/Poco/TypeList.h
index 12383eebf..645883549 100644
--- a/Foundation/include/Poco/TypeList.h
+++ b/Foundation/include/Poco/TypeList.h
@@ -173,10 +173,10 @@ struct TypeListType
 	/// typeList is a TypeList of T0, T1, ... , Tn
 {
 private:
-    typedef typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType TailType;
+	typedef typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType TailType;
 
 public:
-    typedef TypeList<T0, TailType> HeadType;
+	typedef TypeList<T0, TailType> HeadType;
 };
 
 
diff --git a/Foundation/src/Debugger.cpp b/Foundation/src/Debugger.cpp
index fb1582c94..28d84629c 100644
--- a/Foundation/src/Debugger.cpp
+++ b/Foundation/src/Debugger.cpp
@@ -66,9 +66,9 @@ bool Debugger::isAvailable()
 	#if defined(POCO_OS_FAMILY_WINDOWS)
 		#if defined(_WIN32_WCE)
 			#if (_WIN32_WCE >= 0x600)
-			    BOOL isDebuggerPresent;
-			    if (CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent))
-			    {
+				BOOL isDebuggerPresent;
+				if (CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent))
+				{
 					return isDebuggerPresent ? true : false;
 				}
 				return false;
diff --git a/Foundation/src/File.cpp b/Foundation/src/File.cpp
index 8e7dc77a1..5c17858b5 100644
--- a/Foundation/src/File.cpp
+++ b/Foundation/src/File.cpp
@@ -193,7 +193,7 @@ Timestamp File::getLastModified() const
 File& File::setLastModified(const Timestamp& ts)
 {
 	setLastModifiedImpl(ts);
-    return *this;
+	return *this;
 }
 
 	
@@ -206,28 +206,28 @@ File::FileSize File::getSize() const
 File& File::setSize(FileSizeImpl size)
 {
 	setSizeImpl(size);
-    return *this;
+	return *this;
 }
 
 	
 File& File::setWriteable(bool flag)
 {
 	setWriteableImpl(flag);
-    return *this;
+	return *this;
 }
 
 
 File& File::setReadOnly(bool flag)
 {
 	setWriteableImpl(!flag);
-    return *this;
+	return *this;
 }
 
 
 File& File::setExecutable(bool flag)
 {
 	setExecutableImpl(flag);
-    return *this;
+	return *this;
 }
 
 	
diff --git a/Foundation/src/Thread_WIN32.cpp b/Foundation/src/Thread_WIN32.cpp
index cdb071b50..cd402fe0e 100644
--- a/Foundation/src/Thread_WIN32.cpp
+++ b/Foundation/src/Thread_WIN32.cpp
@@ -226,7 +226,7 @@ ThreadImpl* ThreadImpl::currentImpl()
 
 ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
 {
-    return GetCurrentThreadId();
+	return GetCurrentThreadId();
 }
 
 
diff --git a/Foundation/src/Timestamp.cpp b/Foundation/src/Timestamp.cpp
index 1d72726de..8fb50dc32 100644
--- a/Foundation/src/Timestamp.cpp
+++ b/Foundation/src/Timestamp.cpp
@@ -78,47 +78,47 @@ public:
 		std::memset(&st1, 0, sizeof(SYSTEMTIME));
 		std::memset(&st2, 0, sizeof(SYSTEMTIME));
 		GetSystemTime(&st1);
-        while (true)
-        {
-            GetSystemTime(&st2);
+		while (true)
+		{
+			GetSystemTime(&st2);
 
-            // wait for a rollover
+			// wait for a rollover
 			if (st1.wSecond != st2.wSecond)
-            {
-                _offset = GetTickCount() % 1000;
-                break;
-            }
-        }
+			{
+				_offset = GetTickCount() % 1000;
+				break;
+			}
+		}
 	}
 
 	void calibrate(int seconds)
-    {
-        SYSTEMTIME st1, st2;
+	{
+		SYSTEMTIME st1, st2;
 		systemTime(&st1);
 
 		WORD s = st1.wSecond;
-        int sum = 0;
-        int remaining = seconds;
-        while (remaining > 0)
-        {
-            systemTime(&st2);
-            WORD s2 = st2.wSecond;
+		int sum = 0;
+		int remaining = seconds;
+		while (remaining > 0)
+		{
+			systemTime(&st2);
+			WORD s2 = st2.wSecond;
 
 			if (s != s2)
-            {
-                remaining--;
-                // store the offset from zero
+			{
+				remaining--;
+				// store the offset from zero
 				sum += (st2.wMilliseconds > 500) ? (st2.wMilliseconds - 1000) : st2.wMilliseconds;
-                s = st2.wSecond;
-            }
-        }
+				s = st2.wSecond;
+			}
+		}
 
-        // adjust the offset by the average deviation from zero (round to the integer farthest from zero)
-        if (sum < 0)
+		// adjust the offset by the average deviation from zero (round to the integer farthest from zero)
+		if (sum < 0)
 			_offset += (int) std::floor(sum / (float)seconds);
-        else
+		else
 			_offset += (int) std::ceil(sum / (float)seconds);
-    }
+	}
 
 	void systemTime(SYSTEMTIME* pST)
 	{
diff --git a/Foundation/src/UTF8String.cpp b/Foundation/src/UTF8String.cpp
index d5c8eb95c..2e22db394 100644
--- a/Foundation/src/UTF8String.cpp
+++ b/Foundation/src/UTF8String.cpp
@@ -62,19 +62,19 @@ int UTF8::icompare(const std::string& str, std::string::size_type pos, std::stri
 	TextIterator uend2(end2);
 	while (uit1 != uend1 && uit2 != uend2)
 	{
-        int c1 = Unicode::toLower(*uit1);
-        int c2 = Unicode::toLower(*uit2);
-        if (c1 < c2)
-            return -1;
-        else if (c1 > c2)
-            return 1;
-        ++uit1; ++uit2;
+		int c1 = Unicode::toLower(*uit1);
+		int c2 = Unicode::toLower(*uit2);
+		if (c1 < c2)
+			return -1;
+		else if (c1 > c2)
+			return 1;
+		++uit1; ++uit2;
 	}
-    
-    if (uit1 == uend1)
+	
+	if (uit1 == uend1)
 		return uit2 == uend2 ? 0 : -1;
-    else
-        return 1;
+	else
+		return 1;
 }
 
 
@@ -132,19 +132,19 @@ int UTF8::icompare(const std::string& str, std::string::size_type pos, std::stri
 	TextIterator uend(str.begin() + pos + n);
 	while (uit != uend && *ptr)
 	{
-        int c1 = Unicode::toLower(*uit);
-        int c2 = Unicode::toLower(*ptr);
-        if (c1 < c2)
-            return -1;
-        else if (c1 > c2)
-            return 1;
-        ++uit; ++ptr;
+		int c1 = Unicode::toLower(*uit);
+		int c2 = Unicode::toLower(*ptr);
+		if (c1 < c2)
+			return -1;
+		else if (c1 > c2)
+			return 1;
+		++uit; ++ptr;
 	}
-    
-    if (uit == uend)
+	
+	if (uit == uend)
 		return *ptr == 0 ? 0 : -1;
-    else
-        return 1;
+	else
+		return 1;
 }
 
 
diff --git a/Foundation/testsuite/src/DateTimeTest.cpp b/Foundation/testsuite/src/DateTimeTest.cpp
index 8c1798bee..cce388224 100644
--- a/Foundation/testsuite/src/DateTimeTest.cpp
+++ b/Foundation/testsuite/src/DateTimeTest.cpp
@@ -121,17 +121,17 @@ void DateTimeTest::testJulian()
 	assert (dt.dayOfWeek() == 1);
 	assert (dt.julianDay() == 0);
 
-    // Test that we can represent down to the microsecond.
-    dt = DateTime(2010, 1, 31, 17, 30, 15, 800, 3);
+	// Test that we can represent down to the microsecond.
+	dt = DateTime(2010, 1, 31, 17, 30, 15, 800, 3);
 
-    assert (dt.year() == 2010);
-    assert (dt.month() == 1);
-    assert (dt.day() == 31);
-    assert (dt.hour() == 17);
-    assert (dt.minute() == 30);
-    assert (dt.second() == 15);
-    assert (dt.millisecond() == 800);
-    assert (dt.microsecond() == 3);
+	assert (dt.year() == 2010);
+	assert (dt.month() == 1);
+	assert (dt.day() == 31);
+	assert (dt.hour() == 17);
+	assert (dt.minute() == 30);
+	assert (dt.second() == 15);
+	assert (dt.millisecond() == 800);
+	assert (dt.microsecond() == 3);
 }
 
 
@@ -341,245 +341,245 @@ void DateTimeTest::testAMPM()
 
 void DateTimeTest::testRelational()
 {
-    DateTime dt1(2005, 1, 1, 0, 15, 30);
-    DateTime dt2(2005, 1, 2, 0, 15, 30);
-    DateTime dt3(dt1);
+	DateTime dt1(2005, 1, 1, 0, 15, 30);
+	DateTime dt2(2005, 1, 2, 0, 15, 30);
+	DateTime dt3(dt1);
 	
-    assert (dt1 < dt2);
-    assert (dt1 <= dt2);
-    assert (dt2 > dt1);
-    assert (dt2 >= dt1);
-    assert (dt1 != dt2);
-    assert (!(dt1 == dt2));
+	assert (dt1 < dt2);
+	assert (dt1 <= dt2);
+	assert (dt2 > dt1);
+	assert (dt2 >= dt1);
+	assert (dt1 != dt2);
+	assert (!(dt1 == dt2));
 	
-    assert (dt1 == dt3);
-    assert (!(dt1 != dt3));
-    assert (dt1 >= dt3);
-    assert (dt1 <= dt3);
-    assert (!(dt1 > dt3));
-    assert (!(dt1 < dt3));
+	assert (dt1 == dt3);
+	assert (!(dt1 != dt3));
+	assert (dt1 >= dt3);
+	assert (dt1 <= dt3);
+	assert (!(dt1 > dt3));
+	assert (!(dt1 < dt3));
 
-    static const struct 
-    {
-        int year;
-        int month;  
-        int day;
-    } values[] = 
-    {
-        {    1,  1,  1 }, 
-        {   10,  4,  5 }, 
-        {  100,  6,  7 },
-        { 1000,  8,  9 }, 
-        { 2000,  1, 31 }, 
-        { 2002,  7,  4 },
-        { 2002, 12, 31 }, 
-        { 2003,  1,  1 }, 
-        { 2003,  1,  2 },
-        { 2003,  8,  5 }, 
-        { 2003,  8,  6 }, 
-        { 2003,  8,  7 },
-        { 2004,  9,  3 }, 
-        { 2004,  9,  4 }, 
-    };
+	static const struct 
+	{
+		int year;
+		int month;  
+		int day;
+	} values[] = 
+	{
+		{	1,  1,  1 }, 
+		{   10,  4,  5 }, 
+		{  100,  6,  7 },
+		{ 1000,  8,  9 }, 
+		{ 2000,  1, 31 }, 
+		{ 2002,  7,  4 },
+		{ 2002, 12, 31 }, 
+		{ 2003,  1,  1 }, 
+		{ 2003,  1,  2 },
+		{ 2003,  8,  5 }, 
+		{ 2003,  8,  6 }, 
+		{ 2003,  8,  7 },
+		{ 2004,  9,  3 }, 
+		{ 2004,  9,  4 }, 
+	};
 
-    const int num_values = sizeof values / sizeof *values;
-    for (int i = 0; i < num_values; ++i) 
-    {
-        DateTime v;
-        const DateTime& V = v;
-        v.assign(values[i].year, values[i].month, values[i].day);
-        for (int j = 0; j < num_values; ++j) 
-        {
-            DateTime u;  
-            const DateTime& U = u;
-            u.assign(values[j].year, values[j].month, values[j].day);
+	const int num_values = sizeof values / sizeof *values;
+	for (int i = 0; i < num_values; ++i) 
+	{
+		DateTime v;
+		const DateTime& V = v;
+		v.assign(values[i].year, values[i].month, values[i].day);
+		for (int j = 0; j < num_values; ++j) 
+		{
+			DateTime u;  
+			const DateTime& U = u;
+			u.assign(values[j].year, values[j].month, values[j].day);
 
-            loop_2_assert(i, j, (j <  i) == (U <  V));
-            loop_2_assert(i, j, (j <= i) == (U <= V));
-            loop_2_assert(i, j, (j >= i) == (U >= V));
-            loop_2_assert(i, j, (j >  i) == (U >  V));
-        }
-    }
+			loop_2_assert(i, j, (j <  i) == (U <  V));
+			loop_2_assert(i, j, (j <= i) == (U <= V));
+			loop_2_assert(i, j, (j >= i) == (U >= V));
+			loop_2_assert(i, j, (j >  i) == (U >  V));
+		}
+	}
 }
 
 
 void DateTimeTest::testArithmetics()
 {
-    DateTime dt1(2005, 1, 1, 0, 15, 30);
-    DateTime dt2(2005, 1, 2, 0, 15, 30);
+	DateTime dt1(2005, 1, 1, 0, 15, 30);
+	DateTime dt2(2005, 1, 2, 0, 15, 30);
 	
-    Timespan s = dt2 - dt1;
-    assert (s.days() == 1);
+	Timespan s = dt2 - dt1;
+	assert (s.days() == 1);
 	
-    DateTime dt3 = dt1 + s;
-    assert (dt3 == dt2);
+	DateTime dt3 = dt1 + s;
+	assert (dt3 == dt2);
 	
-    dt3 -= s;
-    assert (dt3 == dt1);
-    dt1 += s;
-    assert (dt1 == dt2);
+	dt3 -= s;
+	assert (dt3 == dt1);
+	dt1 += s;
+	assert (dt1 == dt2);
 
-    static const struct 
-    {
-        int lineNum;		// source line number
-        int year1;			// operand/result date1 year
-        int month1;			// operand/result date1 month
-        unsigned int day1;	// operand/result date1 day
-        int numDays;		// operand/result 'int' number of days
-        int year2;			// operand/result date2 year
-        int month2;			// operand/result date2 month
-        unsigned int day2;	// operand/result date2 day
-    } data[] = 
-    {
-        //          - - - -first- - - -           - - - second - - - 
-        //line no.  year   month   day   numDays  year   month   day
-        //-------   -----  -----  -----  -------  -----  -----  ----- 
-        { __LINE__,       1,     1,     1,      1,      1,     1,     2 },
-        { __LINE__,      10,     2,    28,      1,     10,     3,     1 },
-        { __LINE__,     100,     3,    31,      2,    100,     4,     2 },
-        { __LINE__,    1000,     4,    30,      4,   1000,     5,     4 },
-        { __LINE__,    1000,     6,     1,    -31,   1000,     5,     1 },
-        { __LINE__,    1001,     1,     1,   -365,   1000,     1,     1 },
-        { __LINE__,    1100,     5,    31,     30,   1100,     6,    30 },
-        { __LINE__,    1200,     6,    30,     32,   1200,     8,     1 },
-        { __LINE__,    1996,     2,    28,    367,   1997,     3,     1 },
-        { __LINE__,    1997,     2,    28,    366,   1998,     3,     1 },
-        { __LINE__,    1998,     2,    28,    365,   1999,     2,    28 },
-        { __LINE__,    1999,     2,    28,    364,   2000,     2,    27 },
-        { __LINE__,    1999,     2,    28,   1096,   2002,     2,    28 },
-        { __LINE__,    2002,     2,    28,  -1096,   1999,     2,    28 },
-    };
+	static const struct 
+	{
+		int lineNum;		// source line number
+		int year1;			// operand/result date1 year
+		int month1;			// operand/result date1 month
+		unsigned int day1;	// operand/result date1 day
+		int numDays;		// operand/result 'int' number of days
+		int year2;			// operand/result date2 year
+		int month2;			// operand/result date2 month
+		unsigned int day2;	// operand/result date2 day
+	} data[] = 
+	{
+		//          - - - -first- - - -           - - - second - - - 
+		//line no.  year   month   day   numDays  year   month   day
+		//-------   -----  -----  -----  -------  -----  -----  ----- 
+		{ __LINE__,       1,     1,     1,      1,      1,     1,     2 },
+		{ __LINE__,      10,     2,    28,      1,     10,     3,     1 },
+		{ __LINE__,     100,     3,    31,      2,    100,     4,     2 },
+		{ __LINE__,    1000,     4,    30,      4,   1000,     5,     4 },
+		{ __LINE__,    1000,     6,     1,    -31,   1000,     5,     1 },
+		{ __LINE__,    1001,     1,     1,   -365,   1000,     1,     1 },
+		{ __LINE__,    1100,     5,    31,     30,   1100,     6,    30 },
+		{ __LINE__,    1200,     6,    30,     32,   1200,     8,     1 },
+		{ __LINE__,    1996,     2,    28,    367,   1997,     3,     1 },
+		{ __LINE__,    1997,     2,    28,    366,   1998,     3,     1 },
+		{ __LINE__,    1998,     2,    28,    365,   1999,     2,    28 },
+		{ __LINE__,    1999,     2,    28,    364,   2000,     2,    27 },
+		{ __LINE__,    1999,     2,    28,   1096,   2002,     2,    28 },
+		{ __LINE__,    2002,     2,    28,  -1096,   1999,     2,    28 },
+	};
 
-    const int num_data = sizeof data / sizeof *data;
-    for (int di = 0; di < num_data; ++di) 
-    {
-        const int line     = data[di].lineNum;
-        const int num_days = data[di].numDays;
-        DateTime x = DateTime(data[di].year1, data[di].month1, data[di].day1);
-        const DateTime& X = x;
-        x += Timespan(num_days, 0, 0, 0, 0);
-        loop_1_assert(line, data[di].year2 == X.year());
-        loop_1_assert(line, data[di].month2 == X.month());
-        loop_1_assert(line, data[di].day2 == X.day());
-    }
+	const int num_data = sizeof data / sizeof *data;
+	for (int di = 0; di < num_data; ++di) 
+	{
+		const int line	 = data[di].lineNum;
+		const int num_days = data[di].numDays;
+		DateTime x = DateTime(data[di].year1, data[di].month1, data[di].day1);
+		const DateTime& X = x;
+		x += Timespan(num_days, 0, 0, 0, 0);
+		loop_1_assert(line, data[di].year2 == X.year());
+		loop_1_assert(line, data[di].month2 == X.month());
+		loop_1_assert(line, data[di].day2 == X.day());
+	}
 }
 
 void DateTimeTest::testIncrementDecrement()
 {
-    static const struct 
-    {
-        int lineNum;		// source line number
-        int year1;			// (first) date year
-        int month1;			// (first) date month
-        unsigned int day1;	// (first) date day
-        int year2;			// (second) date year
-        int month2;			// (second) date month
-        unsigned int day2;	// (second) date day
-    } data[] = 
-    {
-       //          - - - -first- - - -    - - - second - - - 
-       //line no.  year   month   day     year   month   day
-       //-------   -----  -----  -----    -----  -----  ----- 
-      { __LINE__,       1,     1,     1,       1,     1,     2 },
-      { __LINE__,      10,     2,    28,      10,     3,     1 },
-      { __LINE__,     100,     3,    31,     100,     4,     1 },
-      { __LINE__,    1000,     4,    30,    1000,     5,     1 },
-      { __LINE__,    1100,     5,    31,    1100,     6,     1 },
-      { __LINE__,    1200,     6,    30,    1200,     7,     1 },
-      { __LINE__,    1300,     7,    31,    1300,     8,     1 },
-      { __LINE__,    1400,     8,    31,    1400,     9,     1 },
-      { __LINE__,    1500,     9,    30,    1500,    10,     1 },
-      { __LINE__,    1600,    10,    31,    1600,    11,     1 },
-      { __LINE__,    1700,    11,    30,    1700,    12,     1 },
-      { __LINE__,    1800,    12,    31,    1801,     1,     1 },
-      { __LINE__,    1996,     2,    28,    1996,     2,    29 },
-      { __LINE__,    1997,     2,    28,    1997,     3,     1 },
-      { __LINE__,    1998,     2,    28,    1998,     3,     1 },
-      { __LINE__,    1999,     2,    28,    1999,     3,     1 },
-      { __LINE__,    2000,     2,    28,    2000,     2,    29 },
-      { __LINE__,    2001,     2,    28,    2001,     3,     1 },
-      { __LINE__,    2004,     2,    28,    2004,     2,    29 },
-      { __LINE__,    2100,     2,    28,    2100,     3,     1 },
-      { __LINE__,    2400,     2,    28,    2400,     2,    29 },
-    };
+	static const struct 
+	{
+		int lineNum;		// source line number
+		int year1;			// (first) date year
+		int month1;			// (first) date month
+		unsigned int day1;	// (first) date day
+		int year2;			// (second) date year
+		int month2;			// (second) date month
+		unsigned int day2;	// (second) date day
+	} data[] = 
+	{
+		 //          - - - -first- - - -    - - - second - - - 
+		 //line no.  year   month   day     year   month   day
+		 //-------   -----  -----  -----    -----  -----  ----- 
+		{ __LINE__,       1,     1,     1,       1,     1,     2 },
+		{ __LINE__,      10,     2,    28,      10,     3,     1 },
+		{ __LINE__,     100,     3,    31,     100,     4,     1 },
+		{ __LINE__,    1000,     4,    30,    1000,     5,     1 },
+		{ __LINE__,    1100,     5,    31,    1100,     6,     1 },
+		{ __LINE__,    1200,     6,    30,    1200,     7,     1 },
+		{ __LINE__,    1300,     7,    31,    1300,     8,     1 },
+		{ __LINE__,    1400,     8,    31,    1400,     9,     1 },
+		{ __LINE__,    1500,     9,    30,    1500,    10,     1 },
+		{ __LINE__,    1600,    10,    31,    1600,    11,     1 },
+		{ __LINE__,    1700,    11,    30,    1700,    12,     1 },
+		{ __LINE__,    1800,    12,    31,    1801,     1,     1 },
+		{ __LINE__,    1996,     2,    28,    1996,     2,    29 },
+		{ __LINE__,    1997,     2,    28,    1997,     3,     1 },
+		{ __LINE__,    1998,     2,    28,    1998,     3,     1 },
+		{ __LINE__,    1999,     2,    28,    1999,     3,     1 },
+		{ __LINE__,    2000,     2,    28,    2000,     2,    29 },
+		{ __LINE__,    2001,     2,    28,    2001,     3,     1 },
+		{ __LINE__,    2004,     2,    28,    2004,     2,    29 },
+		{ __LINE__,    2100,     2,    28,    2100,     3,     1 },
+		{ __LINE__,    2400,     2,    28,    2400,     2,    29 },
+	};
 
-    const int num_data = sizeof data / sizeof *data;
-    int di;
+	const int num_data = sizeof data / sizeof *data;
+	int di;
 
-    for (di = 0; di < num_data; ++di) 
-    {
-        const int line = data[di].lineNum;
-        DateTime x = DateTime(data[di].year1, data[di].month1, 
-                              data[di].day1);
-        // Would do pre-increment of x here.
-        const DateTime& X = x;
-        x = x + Timespan(1,0,0,0,0);  
-        DateTime y = x; const DateTime& Y = y;
+	for (di = 0; di < num_data; ++di) 
+	{
+		const int line = data[di].lineNum;
+		DateTime x = DateTime(data[di].year1, data[di].month1, 
+							  data[di].day1);
+		// Would do pre-increment of x here.
+		const DateTime& X = x;
+		x = x + Timespan(1,0,0,0,0);  
+		DateTime y = x; const DateTime& Y = y;
 
-        loop_1_assert(line, data[di].year2  == X.year());
-        loop_1_assert(line, data[di].month2 == X.month());
-        loop_1_assert(line, data[di].day2   == X.day());
+		loop_1_assert(line, data[di].year2  == X.year());
+		loop_1_assert(line, data[di].month2 == X.month());
+		loop_1_assert(line, data[di].day2   == X.day());
 
-        loop_1_assert(line, data[di].year2  == Y.year());
-        loop_1_assert(line, data[di].month2 == Y.month());
-        loop_1_assert(line, data[di].day2   == Y.day());
-    }
+		loop_1_assert(line, data[di].year2  == Y.year());
+		loop_1_assert(line, data[di].month2 == Y.month());
+		loop_1_assert(line, data[di].day2   == Y.day());
+	}
 
-    for (di = 0; di < num_data; ++di) 
-    {
-        const int line = data[di].lineNum;
-        DateTime x = DateTime(data[di].year1, data[di].month1, data[di].day1);
-        DateTime x1 = DateTime(data[di].year1, data[di].month1, data[di].day1);
-        DateTime x2 = DateTime(data[di].year2, data[di].month2, data[di].day2);
-        DateTime y = x; const DateTime& Y = y;
+	for (di = 0; di < num_data; ++di) 
+	{
+		const int line = data[di].lineNum;
+		DateTime x = DateTime(data[di].year1, data[di].month1, data[di].day1);
+		DateTime x1 = DateTime(data[di].year1, data[di].month1, data[di].day1);
+		DateTime x2 = DateTime(data[di].year2, data[di].month2, data[di].day2);
+		DateTime y = x; const DateTime& Y = y;
 
-        // Would do post increment of x here.
-        const DateTime& X = x;
-        x = x + Timespan(1,0,0,0,0);  
+		// Would do post increment of x here.
+		const DateTime& X = x;
+		x = x + Timespan(1,0,0,0,0);  
 
-        loop_1_assert(line, data[di].year2  == X.year());
-        loop_1_assert(line, data[di].month2 == X.month());
-        loop_1_assert(line, data[di].day2   == X.day());
-        loop_1_assert(line, data[di].year1  == Y.year());
-        loop_1_assert(line, data[di].month1 == Y.month());
-        loop_1_assert(line, data[di].day1   == Y.day());
-    }
-            
-    for (di = 0; di < num_data; ++di) 
-    {
-        const int line = data[di].lineNum;
-        DateTime x = DateTime(data[di].year2, data[di].month2, data[di].day2);
-        const DateTime& X = x;
-        x = x - Timespan(1,0,0,0,0);  
-        DateTime y = x; DateTime Y = y;
+		loop_1_assert(line, data[di].year2  == X.year());
+		loop_1_assert(line, data[di].month2 == X.month());
+		loop_1_assert(line, data[di].day2   == X.day());
+		loop_1_assert(line, data[di].year1  == Y.year());
+		loop_1_assert(line, data[di].month1 == Y.month());
+		loop_1_assert(line, data[di].day1   == Y.day());
+	}
+			
+	for (di = 0; di < num_data; ++di) 
+	{
+		const int line = data[di].lineNum;
+		DateTime x = DateTime(data[di].year2, data[di].month2, data[di].day2);
+		const DateTime& X = x;
+		x = x - Timespan(1,0,0,0,0);  
+		DateTime y = x; DateTime Y = y;
 
-        loop_1_assert(line, data[di].year1  == X.year());
-        loop_1_assert(line, data[di].month1 == X.month());
-        loop_1_assert(line, data[di].day1   == X.day());
+		loop_1_assert(line, data[di].year1  == X.year());
+		loop_1_assert(line, data[di].month1 == X.month());
+		loop_1_assert(line, data[di].day1   == X.day());
 
-        loop_1_assert(line, data[di].year1  == Y.year());
-        loop_1_assert(line, data[di].month1 == Y.month());
-        loop_1_assert(line, data[di].day1   == Y.day());
-    }
+		loop_1_assert(line, data[di].year1  == Y.year());
+		loop_1_assert(line, data[di].month1 == Y.month());
+		loop_1_assert(line, data[di].day1   == Y.day());
+	}
 
-    for (di = 0; di < num_data; ++di) 
-    {
-        const int line = data[di].lineNum;
-        DateTime x1 = DateTime(data[di].year1, data[di].month1, data[di].day1);
-        DateTime x = DateTime(data[di].year2, data[di].month2, data[di].day2);
-        DateTime y = x; DateTime Y = y;
-        const DateTime& X = x;
-        // would post-decrement x here.
-        x = x - Timespan(1,0,0,0,0);  
+	for (di = 0; di < num_data; ++di) 
+	{
+		const int line = data[di].lineNum;
+		DateTime x1 = DateTime(data[di].year1, data[di].month1, data[di].day1);
+		DateTime x = DateTime(data[di].year2, data[di].month2, data[di].day2);
+		DateTime y = x; DateTime Y = y;
+		const DateTime& X = x;
+		// would post-decrement x here.
+		x = x - Timespan(1,0,0,0,0);  
 
-        loop_1_assert(line, data[di].year1  == X.year());
-        loop_1_assert(line, data[di].month1 == X.month());
-        loop_1_assert(line, data[di].day1   == X.day());
+		loop_1_assert(line, data[di].year1  == X.year());
+		loop_1_assert(line, data[di].month1 == X.month());
+		loop_1_assert(line, data[di].day1   == X.day());
 
-        loop_1_assert(line, data[di].year2  == Y.year());
-        loop_1_assert(line, data[di].month2 == Y.month());
-        loop_1_assert(line, data[di].day2   == Y.day());
-    }
+		loop_1_assert(line, data[di].year2  == Y.year());
+		loop_1_assert(line, data[di].month2 == Y.month());
+		loop_1_assert(line, data[di].day2   == Y.day());
+	}
 }
 
 
@@ -598,37 +598,37 @@ void DateTimeTest::testSwap()
 
 void DateTimeTest::testUsage()
 {
-    DateTime dt1(1776, 7, 4);
-    assert (dt1.year() == 1776);
-    assert (dt1.month() == 7);
-    assert (dt1.day() == 4);
+	DateTime dt1(1776, 7, 4);
+	assert (dt1.year() == 1776);
+	assert (dt1.month() == 7);
+	assert (dt1.day() == 4);
 
-    DateTime dt2(dt1);
-    dt2 += Timespan(6, 0, 0, 0, 0);
-    assert (dt2.year() == 1776);
-    assert (dt2.month() == 7);
-    assert (dt2.day() == 10);
+	DateTime dt2(dt1);
+	dt2 += Timespan(6, 0, 0, 0, 0);
+	assert (dt2.year() == 1776);
+	assert (dt2.month() == 7);
+	assert (dt2.day() == 10);
 
-    Timespan span = dt2 - dt1;
-    assert (span.days() == 6);
+	Timespan span = dt2 - dt1;
+	assert (span.days() == 6);
 
-    // TODO - When adding months and years we need to be
-    // able to specify the end-end convention.
-    // We cannot do this in POCO at the moment.
+	// TODO - When adding months and years we need to be
+	// able to specify the end-end convention.
+	// We cannot do this in POCO at the moment.
 }
 
 
 void DateTimeTest::testSetYearDay()
 {
-    static const struct 
-    {
-        int d_lineNum;			// source line number
-        int d_year;				// year under test
-        unsigned int d_day;		// day-of-year under test
-        int d_expMonth;			// expected month
-        unsigned int d_expDay;	// expected day
-    } data[] = 
-    {
+	static const struct 
+	{
+		int d_lineNum;			// source line number
+		int d_year;				// year under test
+		unsigned int d_day;		// day-of-year under test
+		int d_expMonth;			// expected month
+		unsigned int d_expDay;	// expected day
+	} data[] = 
+	{
 		//line no.  year   dayOfYr     exp. month   exp. day
 		//-------   -----  -------     ----------   --------
 		{ __LINE__,          1,       1,          1,         1 },   
@@ -638,93 +638,93 @@ void DateTimeTest::testSetYearDay()
 		{ __LINE__,       1996,       2,          1,         2 },
 		{ __LINE__,       1996,     365,         12,        30 },
 		{ __LINE__,       1996,     366,         12,        31 }
-    };
-
-    const int num_data = sizeof data / sizeof *data;
-    for (int di = 0; di < num_data; ++di) 
-    {
-        const int line      = data[di].d_lineNum;
-        const int year      = data[di].d_year;
-        const unsigned int day = data[di].d_day;
-
-        const int exp_month = data[di].d_expMonth;
-        const unsigned int exp_day   = data[di].d_expDay;
-        const DateTime r(year, exp_month, exp_day);
-        DateTime x;
-        const DateTime& X = x;
-
-#if 0
-        // TODO - need to be able to assign a day number in the year
-        // but POCO is not able to do this.
-
-        x.assign(year, day);                
-
-        // TODO - need to be able to assert with the loop counter
-        // but cppUnit is not able to do this.
-
-        assert (r   == x);
-        assert (day == X.dayOfYear());
-#endif
-    }
-
-    static const struct 
-    {
-        int d_lineNum;  // source line number
-        int d_year;     // year under test
-        int d_day;      // day-of-year under test
-        int d_exp;      // expected status
-    } data2[] = 
-    {
-        //line no.  year   dayOfYr     expected value
-        //-------   -----  -------     --------------
-        { __LINE__,          1,       1,          1 },   
-        { __LINE__,          1,      -1,          0 },
-        { __LINE__,          1,       0,          0 },
-        { __LINE__,          1,     365,          1 },
-        { __LINE__,          1,     366,          0 },
-        { __LINE__,          1,     367,          0 },
-        { __LINE__,          0,       0,          0 },   
-        { __LINE__,         -1,      -1,          0 },   
-        { __LINE__,       1996,       1,          1 },   
-        { __LINE__,       1996,       2,          1 },
-        { __LINE__,       1996,      32,          1 },
-        { __LINE__,       1996,     365,          1 },
-        { __LINE__,       1996,     366,          1 },
-        { __LINE__,       1996,     367,          0 },
 	};
 
-    const int num_data2 = sizeof data2 / sizeof *data2;
-    for (int di = 0; di < num_data2; ++di) 
-    {
-        const int line  = data2[di].d_lineNum;
-        const int year  = data2[di].d_year;
-        const int day   = data2[di].d_day;
-        const int exp   = data2[di].d_exp;
-        DateTime x;  
-        const DateTime& X = x;
-        if (1 == exp)
-        {
-            DateTime r;
-            const DateTime& r2 = r;
+	const int num_data = sizeof data / sizeof *data;
+	for (int di = 0; di < num_data; ++di) 
+	{
+		const int line	  = data[di].d_lineNum;
+		const int year	  = data[di].d_year;
+		const unsigned int day = data[di].d_day;
+
+		const int exp_month = data[di].d_expMonth;
+		const unsigned int exp_day   = data[di].d_expDay;
+		const DateTime r(year, exp_month, exp_day);
+		DateTime x;
+		const DateTime& X = x;
+
 #if 0
-            r.set(year, day);
+		// TODO - need to be able to assign a day number in the year
+		// but POCO is not able to do this.
+
+		x.assign(year, day);				
+
+		// TODO - need to be able to assert with the loop counter
+		// but cppUnit is not able to do this.
+
+		assert (r   == x);
+		assert (day == X.dayOfYear());
 #endif
-        }
-    }
+	}
+
+	static const struct 
+	{
+		int d_lineNum;  // source line number
+		int d_year;	 // year under test
+		int d_day;	  // day-of-year under test
+		int d_exp;	  // expected status
+	} data2[] = 
+	{
+		//line no.  year   dayOfYr     expected value
+		//-------   -----  -------     --------------
+		{ __LINE__,          1,       1,          1 },   
+		{ __LINE__,          1,      -1,          0 },
+		{ __LINE__,          1,       0,          0 },
+		{ __LINE__,          1,     365,          1 },
+		{ __LINE__,          1,     366,          0 },
+		{ __LINE__,          1,     367,          0 },
+		{ __LINE__,          0,       0,          0 },   
+		{ __LINE__,         -1,      -1,          0 },   
+		{ __LINE__,       1996,       1,          1 },   
+		{ __LINE__,       1996,       2,          1 },
+		{ __LINE__,       1996,      32,          1 },
+		{ __LINE__,       1996,     365,          1 },
+		{ __LINE__,       1996,     366,          1 },
+		{ __LINE__,       1996,     367,          0 },
+	};
+
+	const int num_data2 = sizeof data2 / sizeof *data2;
+	for (int di = 0; di < num_data2; ++di) 
+	{
+		const int line  = data2[di].d_lineNum;
+		const int year  = data2[di].d_year;
+		const int day   = data2[di].d_day;
+		const int exp   = data2[di].d_exp;
+		DateTime x;  
+		const DateTime& X = x;
+		if (1 == exp)
+		{
+			DateTime r;
+			const DateTime& r2 = r;
+#if 0
+			r.set(year, day);
+#endif
+		}
+	}
 }
 
 
 void DateTimeTest::testIsValid()
 {
-    static const struct 
-    {
-        int  d_lineNum;  // source line number
-        int  d_year;     // year under test
-        int  d_month;    // month under test
-        int  d_day;      // day under test
-        bool d_exp;      // expected value
-    } data[] = 
-    {
+	static const struct 
+	{
+		int  d_lineNum;  // source line number
+		int  d_year;	 // year under test
+		int  d_month;	// month under test
+		int  d_day;	  // day under test
+		bool d_exp;	  // expected value
+	} data[] = 
+	{
 		//line no.  year   month   day     expected value
 		//-------   -----  -----  -----    --------------
 		{ __LINE__,    0,     0,     0,      false },   
@@ -761,34 +761,34 @@ void DateTimeTest::testIsValid()
 		{ __LINE__, 2100,     2,    29,      false },   
 	};
 
-    const int num_data = sizeof data / sizeof *data;
-    for (int di = 0; di < num_data; ++di) 
-    {
-        const int  line  = data[di].d_lineNum;
-        const int  year  = data[di].d_year;
-        const int  month = data[di].d_month;
-        const int  day   = data[di].d_day;
-        const bool exp   = data[di].d_exp;
+	const int num_data = sizeof data / sizeof *data;
+	for (int di = 0; di < num_data; ++di) 
+	{
+		const int  line  = data[di].d_lineNum;
+		const int  year  = data[di].d_year;
+		const int  month = data[di].d_month;
+		const int  day   = data[di].d_day;
+		const bool exp   = data[di].d_exp;
 
 		bool isValid = DateTime::isValid(year, month, day);
-        loop_1_assert(line, exp == isValid);
-    }
+		loop_1_assert(line, exp == isValid);
+	}
 }
 
 
 void DateTimeTest::testDayOfWeek()
 {
-    typedef DateTime::DaysOfWeek DOW;
+	typedef DateTime::DaysOfWeek DOW;
 
-    static const struct 
-    {
-        int d_lineNum;	// source line number
-        int d_year;		// year under test
-        int d_month;	// month under test
-        int d_day;		// day under test
-        DOW d_expDay;	// number of days to be added
-    } data[] = 
-    {
+	static const struct 
+	{
+		int d_lineNum;	// source line number
+		int d_year;		// year under test
+		int d_month;	// month under test
+		int d_day;		// day under test
+		DOW d_expDay;	// number of days to be added
+	} data[] = 
+	{
 		//Line no.    year   month   day    expDay
 		//-------   -----  -----  -----   -------
 		{ __LINE__,  1600,   1,       1,   DateTime::SATURDAY  },
@@ -820,16 +820,16 @@ void DateTimeTest::testDayOfWeek()
 		{ __LINE__,  2000,   1,       2,   DateTime::SUNDAY    },
 		{ __LINE__,  2000,   1,       3,   DateTime::MONDAY    },
 		{ __LINE__,  2000,   1,       4,   DateTime::TUESDAY   },
-    };
-            
-    const int num_data = sizeof data / sizeof *data;
-    for (int di = 0; di < num_data ; ++di) 
-    {
-        const int line = data[di].d_lineNum;
-        DateTime x = DateTime(data[di].d_year, data[di].d_month, data[di].d_day);
-        const DateTime& X = x;
-        loop_1_assert(line, data[di].d_expDay == X.dayOfWeek());
-    }
+	};
+			
+	const int num_data = sizeof data / sizeof *data;
+	for (int di = 0; di < num_data ; ++di) 
+	{
+		const int line = data[di].d_lineNum;
+		DateTime x = DateTime(data[di].d_year, data[di].d_month, data[di].d_day);
+		const DateTime& X = x;
+		loop_1_assert(line, data[di].d_expDay == X.dayOfWeek());
+	}
 }
 
 
diff --git a/Foundation/testsuite/src/FileChannelTest.cpp b/Foundation/testsuite/src/FileChannelTest.cpp
index c5605de26..3db000dd5 100644
--- a/Foundation/testsuite/src/FileChannelTest.cpp
+++ b/Foundation/testsuite/src/FileChannelTest.cpp
@@ -446,17 +446,17 @@ void FileChannelTest::noPurgeAge(const std::string& npa)
 
 void FileChannelTest::testPurgeAge()
 {
-        purgeAge("5 seconds");
-        try
-        {
-                noPurgeAge("0 seconds");
-                fail ("must fail");
-        } catch (InvalidArgumentException&)
-        {
-        }
+		purgeAge("5 seconds");
+		try
+		{
+				noPurgeAge("0 seconds");
+				fail ("must fail");
+		} catch (InvalidArgumentException&)
+		{
+		}
 
-        noPurgeAge("");
-        noPurgeAge("none");
+		noPurgeAge("");
+		noPurgeAge("none");
 }
 
 
diff --git a/Foundation/testsuite/src/FileChannelTest.h b/Foundation/testsuite/src/FileChannelTest.h
index bb6ea7dad..25dc67928 100644
--- a/Foundation/testsuite/src/FileChannelTest.h
+++ b/Foundation/testsuite/src/FileChannelTest.h
@@ -72,14 +72,14 @@ public:
 	static CppUnit::Test* suite();
 
 private:
-        template <class D> std::string rotation(TimeRotation rtype) const;
-        void remove(const std::string& baseName);
-        std::string filename() const;
+		template <class D> std::string rotation(TimeRotation rtype) const;
+		void remove(const std::string& baseName);
+		std::string filename() const;
 
-        void purgeAge(const std::string& purgeAge);
-        void noPurgeAge(const std::string& purgeAge);
-        void purgeCount(const std::string& pc);
-        void noPurgeCount(const std::string& pc);
+		void purgeAge(const std::string& purgeAge);
+		void noPurgeAge(const std::string& purgeAge);
+		void purgeCount(const std::string& pc);
+		void noPurgeCount(const std::string& pc);
 };
 
 
diff --git a/Foundation/testsuite/src/NamedTuplesTest.cpp b/Foundation/testsuite/src/NamedTuplesTest.cpp
index 5c6e590e0..b79036413 100644
--- a/Foundation/testsuite/src/NamedTuplesTest.cpp
+++ b/Foundation/testsuite/src/NamedTuplesTest.cpp
@@ -73,17 +73,17 @@ void NamedTuplesTest::testNamedTuple1()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 1);
-    
-    TupleType aTuple2("string1", "1");
+	
+	TupleType aTuple2("string1", "1");
 	assert (aTuple2["string1"] == "1");
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.set<0>("2");
+	aTuple2.set<0>("2");
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3.length == 1);
@@ -109,19 +109,19 @@ void NamedTuplesTest::testNamedTuple2()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 2);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1);
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -151,21 +151,21 @@ void NamedTuplesTest::testNamedTuple3()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 3);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true);
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -197,23 +197,23 @@ void NamedTuplesTest::testNamedTuple4()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 4);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f);
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
 	assert (aTuple2["float1"] == 1.5);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -247,12 +247,12 @@ void NamedTuplesTest::testNamedTuple5()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 5);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c');
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c');
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -260,12 +260,12 @@ void NamedTuplesTest::testNamedTuple5()
 	assert (aTuple2["char1"] == 'c');
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -302,13 +302,13 @@ void NamedTuplesTest::testNamedTuple6()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 6);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999);
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -317,12 +317,12 @@ void NamedTuplesTest::testNamedTuple6()
 	assert (aTuple2["long1"] == 999); 
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -361,14 +361,14 @@ void NamedTuplesTest::testNamedTuple7()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 7);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5);
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -378,12 +378,12 @@ void NamedTuplesTest::testNamedTuple7()
 	assert (aTuple2["double1"] == 1.5);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -424,15 +424,15 @@ void NamedTuplesTest::testNamedTuple8()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 8);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700);
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -443,12 +443,12 @@ void NamedTuplesTest::testNamedTuple8()
 	assert (aTuple2["short1"] == 32700);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -493,16 +493,16 @@ void NamedTuplesTest::testNamedTuple9()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 9);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2");
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2");
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -514,12 +514,12 @@ void NamedTuplesTest::testNamedTuple9()
 	assert (aTuple2["string2"] == "2");
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -566,17 +566,17 @@ void NamedTuplesTest::testNamedTuple10()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 10);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2 );
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2 );
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -589,12 +589,12 @@ void NamedTuplesTest::testNamedTuple10()
 	assert (aTuple2["int2"] == 2); 
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -644,17 +644,17 @@ void NamedTuplesTest::testNamedTuple11()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 11);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3");
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
@@ -669,12 +669,12 @@ void NamedTuplesTest::testNamedTuple11()
 	assert (aTuple2["string3"] == "3");
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -727,19 +727,19 @@ void NamedTuplesTest::testNamedTuple12()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 12);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3);
+		"int3", 3);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -754,12 +754,12 @@ void NamedTuplesTest::testNamedTuple12()
 	assert (aTuple2["int3"] == 3); 
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -814,20 +814,20 @@ void NamedTuplesTest::testNamedTuple13()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 13);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true);
+		"int3", 3, 
+		"bool2", true);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -843,12 +843,12 @@ void NamedTuplesTest::testNamedTuple13()
 	assert (aTuple2["bool2"] == true);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -904,21 +904,21 @@ void NamedTuplesTest::testNamedTuple14()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 14);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5);
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -935,12 +935,12 @@ void NamedTuplesTest::testNamedTuple14()
 	assert (aTuple2["float2"] == 2.5);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -998,22 +998,22 @@ void NamedTuplesTest::testNamedTuple15()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 15);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5,
-        "char2", 'c');
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5,
+		"char2", 'c');
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -1031,12 +1031,12 @@ void NamedTuplesTest::testNamedTuple15()
 	assert (aTuple2["char2"] == 'c');
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -1097,23 +1097,23 @@ void NamedTuplesTest::testNamedTuple16()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 16);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5,
-        "char2", 'c',
-        "long2", 999);
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5,
+		"char2", 'c',
+		"long2", 999);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -1133,12 +1133,12 @@ void NamedTuplesTest::testNamedTuple16()
 	assert (aTuple2.length == 16);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -1202,24 +1202,24 @@ void NamedTuplesTest::testNamedTuple17()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 17);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5,
-        "char2", 'c',
-        "long2", 999,
-        "double2", 2.5);
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5,
+		"char2", 'c',
+		"long2", 999,
+		"double2", 2.5);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -1240,12 +1240,12 @@ void NamedTuplesTest::testNamedTuple17()
 	assert (aTuple2.length == 17);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -1312,25 +1312,25 @@ void NamedTuplesTest::testNamedTuple18()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 18);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5,
-        "char2", 'c',
-        "long2", 999,
-        "double2", 2.5,
-        "short2", 32700);
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5,
+		"char2", 'c',
+		"long2", 999,
+		"double2", 2.5,
+		"short2", 32700);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -1352,12 +1352,12 @@ void NamedTuplesTest::testNamedTuple18()
 	assert (aTuple2.length == 18);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -1427,26 +1427,26 @@ void NamedTuplesTest::testNamedTuple19()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 19);
-    
-    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+	
+	TupleType aTuple2("string1", "1", 
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5,
-        "char2", 'c',
-        "long2", 999,
-        "double2", 2.5,
-        "short2", 32700, 
-        "string4", "4");
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5,
+		"char2", 'c',
+		"long2", 999,
+		"double2", 2.5,
+		"short2", 32700, 
+		"string4", "4");
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -1469,12 +1469,12 @@ void NamedTuplesTest::testNamedTuple19()
 	assert (aTuple2.length == 19);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
@@ -1546,27 +1546,27 @@ void NamedTuplesTest::testNamedTuple20()
 	try { int xyz; xyz = aTuple["XYZ"]; fail ("must fail"); }
 	catch (NotFoundException&) { }
 	assert (aTuple.length == 20);
-    
+	
    TupleType aTuple2("string1", "1", 
-        "int1", 1,
-        "bool1", true,
-        "float1", 1.5f,
-        "char1", 'c',
-        "long1", 999,
-        "double1", 1.5,
-        "short1", 32700, 
-        "string2", "2",
-        "int2", 2,
+		"int1", 1,
+		"bool1", true,
+		"float1", 1.5f,
+		"char1", 'c',
+		"long1", 999,
+		"double1", 1.5,
+		"short1", 32700, 
+		"string2", "2",
+		"int2", 2,
 		"string3", "3", 
-        "int3", 3, 
-        "bool2", true,
-        "float2", 2.5,
-        "char2", 'c',
-        "long2", 999,
-        "double2", 2.5,
-        "short2", 32700, 
-        "string4", "4",
-        "int4", 4);
+		"int3", 3, 
+		"bool2", true,
+		"float2", 2.5,
+		"char2", 'c',
+		"long2", 999,
+		"double2", 2.5,
+		"short2", 32700, 
+		"string4", "4",
+		"int4", 4);
 	assert (aTuple2["string1"] == "1");
 	assert (aTuple2["int1"] == 1); 
 	assert (aTuple2["bool1"] == true);
@@ -1590,12 +1590,12 @@ void NamedTuplesTest::testNamedTuple20()
 	assert (aTuple2.length == 20);
 
 	assert (aTuple != aTuple2);
-    aTuple = aTuple2;
+	aTuple = aTuple2;
 	assert (aTuple == aTuple2);
-    aTuple2.get<1>()++;
+	aTuple2.get<1>()++;
 	assert (aTuple < aTuple2);
 
-    TupleType aTuple3(aTuple2.names());
+	TupleType aTuple3(aTuple2.names());
 	assert (aTuple3.names() == aTuple2.names());
 	assert (aTuple3["string1"] == "");
 	assert (aTuple3["int1"] == 0); 
diff --git a/Foundation/testsuite/src/URITest.cpp b/Foundation/testsuite/src/URITest.cpp
index 5f8c6fa76..bcbfeff51 100644
--- a/Foundation/testsuite/src/URITest.cpp
+++ b/Foundation/testsuite/src/URITest.cpp
@@ -740,30 +740,30 @@ void URITest::testSwap()
 
 void URITest::testOther()
 {
-    // The search string is "hello%world"; google happens to ignore the '%'
-    // character, so it finds lots of hits for "hello world" programs. This is
-    // a convenient reproduction case, and a URL that actually works.
-    Poco::URI uri("http://google.com/search?q=hello%25world#frag%20ment");
+	// The search string is "hello%world"; google happens to ignore the '%'
+	// character, so it finds lots of hits for "hello world" programs. This is
+	// a convenient reproduction case, and a URL that actually works.
+	Poco::URI uri("http://google.com/search?q=hello%25world#frag%20ment");
 
-    assert(uri.getHost() == "google.com");
-    assert(uri.getPath() == "/search");
-    assert(uri.getQuery() == "q=hello%world");
-    assert(uri.getRawQuery() == "q=hello%25world");
-    assert(uri.getFragment() == "frag ment");
-    assert(uri.toString() == "http://google.com/search?q=hello%25world#frag%20ment");
-    assert(uri.getPathEtc() == "/search?q=hello%25world#frag%20ment");
+	assert(uri.getHost() == "google.com");
+	assert(uri.getPath() == "/search");
+	assert(uri.getQuery() == "q=hello%world");
+	assert(uri.getRawQuery() == "q=hello%25world");
+	assert(uri.getFragment() == "frag ment");
+	assert(uri.toString() == "http://google.com/search?q=hello%25world#frag%20ment");
+	assert(uri.getPathEtc() == "/search?q=hello%25world#frag%20ment");
 
-    uri.setQuery("q=goodbye cruel world");
-    assert(uri.getQuery() == "q=goodbye cruel world");
-    assert(uri.getRawQuery() == "q=goodbye%20cruel%20world");
-    assert(uri.toString() == "http://google.com/search?q=goodbye%20cruel%20world#frag%20ment");
-    assert(uri.getPathEtc() == "/search?q=goodbye%20cruel%20world#frag%20ment");
+	uri.setQuery("q=goodbye cruel world");
+	assert(uri.getQuery() == "q=goodbye cruel world");
+	assert(uri.getRawQuery() == "q=goodbye%20cruel%20world");
+	assert(uri.toString() == "http://google.com/search?q=goodbye%20cruel%20world#frag%20ment");
+	assert(uri.getPathEtc() == "/search?q=goodbye%20cruel%20world#frag%20ment");
 
-    uri.setRawQuery("q=pony%7eride");
-    assert(uri.getQuery() == "q=pony~ride");
-    assert(uri.getRawQuery() == "q=pony%7eride");
-    assert(uri.toString() == "http://google.com/search?q=pony%7eride#frag%20ment");
-    assert(uri.getPathEtc() == "/search?q=pony%7eride#frag%20ment");
+	uri.setRawQuery("q=pony%7eride");
+	assert(uri.getQuery() == "q=pony~ride");
+	assert(uri.getRawQuery() == "q=pony%7eride");
+	assert(uri.toString() == "http://google.com/search?q=pony%7eride#frag%20ment");
+	assert(uri.getPathEtc() == "/search?q=pony%7eride#frag%20ment");
 }
 
 
diff --git a/Foundation/testsuite/test.txt b/Foundation/testsuite/test.txt
deleted file mode 100644
index 42a9539e2..000000000
--- a/Foundation/testsuite/test.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-0123456789
-abcdefghij
-klmnopqrst