see CHANGELOG

- added Poco::istring (case-insensitive string) and Poco::isubstr
(case-insensitive substring search)
- improved SQLite execute() return (affected rows) value
- added SQLite sys.dual (in-memory system table)
- applied SF Patch #120: The ExpireLRUCache does not compile with a
tuple as key on Visual Studio 2010
- fixed SF Bug #599: JSON::Array and JSON::Object size() member can
implicitly lose precision
- fixed SF Bug #602: iterating database table rows not correct if no
data in table
- fixed SF Bug #603: count() is missing in HashMap
- fixed GH #23: JSON::Object::stringify throw BadCastException
- fixed GH #16: NetworkInterface::firstAddress() should not throw on
unconfigured interfaces
- Android compile/build support (by Rangel Reale)
- TypeHandler::prepare() now takes const-reference

CHANGELOG

@@ -3,6 +3,17 @@ This is the changelog file for the POCO C++ Libraries.
 Release 1.5.0 (2012-12-17)
 ==========================
 - using double-conversion library for floating-point numeric/string conversions
+- added Poco::istring (case-insensitive string) and Poco::isubstr
+- improved SQLite execute() return (affected rows) value
+- added SQLite sys.dual (in-memory system table)
+- applied SF Patch #120: The ExpireLRUCache does not compile with a tuple as key on Visual Studio 2010
+- fixed SF Bug #599: JSON::Array and JSON::Object size() member can implicitly lose precision
+- fixed SF Bug #602: iterating database table rows not correct if no data in table
+- fixed SF Bug #603: count() is missing in HashMap
+- fixed GH #23: JSON::Object::stringify throw BadCastException
+- fixed GH #16: NetworkInterface::firstAddress() should not throw on unconfigured interfaces
+- Android compile/build support (by Rangel Reale)
+- TypeHandler::prepare() now takes const-reference
 
 Release 1.5.0 (2012-10-14)
 ==========================

CONTRIBUTORS

@@ -24,6 +24,10 @@ Marian Krivos
 Franky Braem
 Philip Prindeville
 Anton Yabchinskiy
+Rangel Reale
+Fabrizio Duhem
+Patrick White
+Mike Naquin
 
 --
 $Id$

Data/MySQL/testsuite/src/SQLExecutor.cpp

@@ -119,7 +119,7 @@ public:
 		pBinder->bind(pos++, obj.age, dir);
 	}
 
-	static void prepare(std::size_t pos, Person& obj, AbstractPreparator* pPrepare)
+	static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPrepare)
 	{
 		// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
 		poco_assert_dbg (pPrepare != 0);

Data/ODBC/testsuite/src/SQLExecutor.cpp

@@ -211,7 +211,7 @@ public:
 		pBinder->bind(pos++, obj.age, dir);
 	}
 
-	static void prepare(std::size_t pos, Person& obj, AbstractPreparator* pPrepare)
+	static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPrepare)
 	{
 		// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
 		poco_assert_dbg (pPrepare != 0);

Data/SQLite/include/Poco/Data/SQLite/SQLiteStatementImpl.h

@@ -141,6 +141,8 @@ private:
 	bool             _canBind;
 	bool             _isExtracted;
 	bool             _canCompile;
+
+	static const std::size_t POCO_SQLITE_INV_ROW_CNT;
 };
 
 

Data/SQLite/include/Poco/Data/SQLite/SessionImpl.h

@@ -71,6 +71,17 @@ public:
 
 	void open(const std::string& connect = "");
 		/// Opens a connection to the Database.
+		/// 
+		/// An in-memory system database (sys), with a single table (dual) 
+		/// containing single field (dummy) is attached to the database.
+		/// The in-memory system database is used to force change count
+		/// to be reset to zero on every new query (or batch of queries) 
+		/// execution. Without this functionality, select statements
+		/// executions that do not return any rows return the count of
+		/// changes effected by the most recent insert, update or delete.
+		/// In-memory system database can be queried and updated but can not
+		/// be dropped. It may be used for other purposes 
+		/// in the future.
 
 	void close();
 		/// Closes the session.

Data/SQLite/src/SQLiteStatementImpl.cpp

@@ -52,13 +52,16 @@ namespace Data {
 namespace SQLite {
 
 
+const std::size_t SQLiteStatementImpl::POCO_SQLITE_INV_ROW_CNT = std::numeric_limits<std::size_t>::max();
+
+
 SQLiteStatementImpl::SQLiteStatementImpl(Poco::Data::SessionImpl& rSession, sqlite3* pDB):
 	StatementImpl(rSession),
 	_pDB(pDB),
 	_pStmt(0),
 	_stepCalled(false),
 	_nextResponse(0),
-	_affectedRowCount(0),
+	_affectedRowCount(POCO_SQLITE_INV_ROW_CNT),
 	_canBind(false),
 	_isExtracted(false),
 	_canCompile(true)
@@ -75,9 +78,29 @@ SQLiteStatementImpl::~SQLiteStatementImpl()
 
 void SQLiteStatementImpl::compileImpl()
 {
-	if (!_pLeftover) _bindBegin = bindings().begin();
+	if (!_pLeftover)
+	{
+		// Executed to force reset of previous changes count to zero.
+		// Without this, execute() will not return accurate (zero) count if select 
+		// statement returns no results previous [insert|update|delete] affected rows.
+		if (sqlite3_changes(_pDB))
+		{
+			if (SQLITE_OK != sqlite3_exec(_pDB, "delete from sys.dual where 1 <> 1;", 0, 0, 0))
+				throw ExecutionException("Error updating system database.");
+		}
+
+		_bindBegin = bindings().begin();
+	}
 
 	std::string statement(toString());
+
+	if (isubstr(statement, std::string("drop")) != istring::npos &&
+		isubstr(statement, std::string("table")) != istring::npos &&
+		isubstr(statement, std::string("dual")) != istring::npos)
+	{
+		throw InvalidAccessException("Cannot drop system table!");
+	}
+
 	sqlite3_stmt* pStmt = 0;
 	const char* pSql = _pLeftover ? _pLeftover->c_str() : statement.c_str();
 
@@ -194,12 +217,12 @@ void SQLiteStatementImpl::bindImpl()
 
 	if (_bindBegin != bindings().end())
 	{
-		std::size_t boundRowCount = (*_bindBegin)->numOfRowsHandled();
+		_affectedRowCount = (*_bindBegin)->numOfRowsHandled();
 
 		Bindings::iterator oldBegin = _bindBegin;
 		for (std::size_t pos = 1; _bindBegin != bindEnd && (*_bindBegin)->canBind(); ++_bindBegin)
 		{
-			if (boundRowCount != (*_bindBegin)->numOfRowsHandled())
+			if (_affectedRowCount != (*_bindBegin)->numOfRowsHandled())
 				throw BindingException("Size mismatch in Bindings. All Bindings MUST have the same size");
 
 			(*_bindBegin)->bind(pos);
@@ -220,7 +243,7 @@ void SQLiteStatementImpl::bindImpl()
 void SQLiteStatementImpl::clear()
 {
 	_columns[currentDataSet()].clear();
-	_affectedRowCount = 0;
+	_affectedRowCount = POCO_SQLITE_INV_ROW_CNT;
 
 	if (_pStmt)
 	{
@@ -304,7 +327,7 @@ const MetaColumn& SQLiteStatementImpl::metaColumn(std::size_t pos) const
 
 std::size_t SQLiteStatementImpl::affectedRowCount() const
 {
-	return _affectedRowCount ? _affectedRowCount : sqlite3_changes(_pDB);
+	return _affectedRowCount != POCO_SQLITE_INV_ROW_CNT ? _affectedRowCount : sqlite3_changes(_pDB);
 }
 
 

Data/SQLite/src/SessionImpl.cpp

@@ -43,7 +43,7 @@
 #include "Poco/ActiveMethod.h"
 #include "Poco/ActiveResult.h"
 #include "Poco/String.h"
-#include "Poco/Exception.h"
+#include "Poco/Data/DataException.h"
 #include "sqlite3.h"
 #include <cstdlib>
 
@@ -195,6 +195,14 @@ void SessionImpl::open(const std::string& connect)
 		throw ConnectionFailedException(ex.displayText());
 	}
 
+	if (SQLITE_OK != sqlite3_exec(_pDB,
+		"attach database ':memory:' as sys;"
+		"create table sys.dual (dummy);", 
+		0, 0, 0))
+	{
+		throw ExecutionException("Cannot create system database.");
+	}
+
 	_connected = true;
 }
 

Data/SQLite/testsuite/src/SQLiteTest.cpp

@@ -193,7 +193,7 @@ public:
 		pBinder->bind(pos++, obj.getAge(), dir);
 	}
 
-	static void prepare(std::size_t pos, Person& obj, AbstractPreparator* pPrepare)
+	static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPrepare)
 	{
 		// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
 		poco_assert_dbg (pPrepare != 0);
@@ -674,6 +674,11 @@ void SQLiteTest::testAffectedRows()
 	tmp << "DROP TABLE IF EXISTS Strings", now;
 	tmp << "CREATE TABLE IF NOT EXISTS Strings (str VARCHAR(30))", now;
 
+	Statement stmt((tmp << "SELECT * FROM Strings"));
+	tmp << "SELECT COUNT(*) FROM Strings", into(count), now;
+	assert (count == 0);
+	assert (0 == stmt.execute());
+
 	Statement stmt1((tmp << "INSERT INTO Strings VALUES(:str)", use(str)));
 	tmp << "SELECT COUNT(*) FROM Strings", into(count), now;
 	assert (count == 0);
@@ -1242,6 +1247,12 @@ void SQLiteTest::testCombinedLimits()
 	tmp << "DROP TABLE IF EXISTS Person", now;
 	tmp << "CREATE TABLE IF NOT EXISTS Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))", now;
 	tmp << "INSERT INTO PERSON VALUES(:ln, :fn, :ad, :age)", use(people), now;
+
+	std::string a, b, c;
+	Statement stmt = (tmp << "SELECT LastName, FirstName, Address FROM Person WHERE Address = 'invalid value'",
+		into(a), into(b), into(c), limit(1));
+	assert (!stmt.done() && stmt.execute() == 0);
+	
 	int count = 0;
 	tmp << "SELECT COUNT(*) FROM PERSON", into(count), now;
 	assert (count == 2);
@@ -2543,6 +2554,32 @@ void SQLiteTest::testReconnect()
 }
 
 
+void SQLiteTest::testSystemTable()
+{
+	Session session (Poco::Data::SQLite::Connector::KEY, "dummy.db");
+
+	int cnt = -1;
+	session << "SELECT count(*) FROM sys.dual", into(cnt), now;
+	assert (0 == cnt);
+
+	session << "INSERT INTO sys.dual VALUES ('test')", now;
+	session << "SELECT count(*) FROM sys.dual", into(cnt), now;
+	assert (1 == cnt);
+
+	session << "DELETE FROM sys.dual", now;
+	session << "SELECT count(*) FROM sys.dual", into(cnt), now;
+	assert (0 == cnt);
+
+	try
+	{
+		session << "DROP TABLE sys.dual", now;
+		fail ("must throw");
+	}
+	catch (InvalidAccessException&) { }
+
+}
+
+
 void SQLiteTest::setUp()
 {
 }
@@ -2633,6 +2670,7 @@ CppUnit::Test* SQLiteTest::suite()
 	CppUnit_addTest(pSuite, SQLiteTest, testMultipleResults);
 	CppUnit_addTest(pSuite, SQLiteTest, testPair);
 	CppUnit_addTest(pSuite, SQLiteTest, testReconnect);
+	CppUnit_addTest(pSuite, SQLiteTest, testSystemTable);
 
 	return pSuite;
 }

Data/SQLite/testsuite/src/SQLiteTest.h

@@ -132,6 +132,7 @@ public:
 	void testMultipleResults();
 
 	void testReconnect();
+	void testSystemTable();
 
 	void setUp();
 	void tearDown();

Data/include/Poco/Data/Extraction.h

@@ -96,7 +96,7 @@ public:
 
 	std::size_t numOfRowsHandled() const
 	{
-		return 1u;
+		return 0;
 	}
 
 	std::size_t numOfRowsAllowed() const

Data/include/Poco/Data/TypeHandler.h

@@ -106,7 +106,7 @@ class TypeHandler: public AbstractTypeHandler
 	///			TypeHandler<int>::bind(pos++, obj.getAge(), pBinder);
 	///		}
 	///	
-	///		static void prepare(std::size_t pos, Person& obj, AbstractPreparator* pPreparator)
+	///		static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPreparator)
 	///		{
 	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
 	///			poco_assert_dbg (pPreparator != 0);
@@ -154,7 +154,7 @@ public:
 		if (!pExt->extract(pos, obj)) obj = defVal;
 	}
 
-	static void prepare(std::size_t pos, T& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const T& obj, AbstractPreparator* pPreparator)
 	{
 		poco_assert_dbg (pPreparator != 0);
 		pPreparator->prepare(pos, obj);
@@ -189,7 +189,7 @@ public:
 			obj.assign(obj.size(), defVal);
 	}
 
-	static void prepare(std::size_t pos, std::deque<T>& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const std::deque<T>& obj, AbstractPreparator* pPreparator)
 	{
 		poco_assert_dbg (pPreparator != 0);
 		pPreparator->prepare(pos, obj);
@@ -224,7 +224,7 @@ public:
 			obj.assign(obj.size(), defVal);
 	}
 
-	static void prepare(std::size_t pos, std::vector<T>& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const std::vector<T>& obj, AbstractPreparator* pPreparator)
 	{
 		poco_assert_dbg (pPreparator != 0);
 		pPreparator->prepare(pos, obj);
@@ -259,7 +259,7 @@ public:
 			obj.assign(obj.size(), defVal);
 	}
 
-	static void prepare(std::size_t pos, std::list<T>& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const std::list<T>& obj, AbstractPreparator* pPreparator)
 	{
 		poco_assert_dbg (pPreparator != 0);
 		pPreparator->prepare(pos, obj);
@@ -281,7 +281,7 @@ public:
 		poco_assert_dbg (pBinder != 0);
 		if (obj.isNull()) 
 		{
-		pBinder->bind(pos++, Poco::Data::Keywords::null, dir);
+			pBinder->bind(pos++, Poco::Data::Keywords::null, dir);
 		}
 		else 
 		{
@@ -289,7 +289,7 @@ public:
 		}
 	}
 	
-	static void prepare(std::size_t pos, Nullable<T>& obj, AbstractPreparator* pPreparator) 
+	static void prepare(std::size_t pos, const Nullable<T>& obj, AbstractPreparator* pPreparator) 
 	{
 		poco_assert_dbg (pPreparator != 0);
 		if (obj.isNull()) 
@@ -416,29 +416,29 @@ public:
 		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T12, 12>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T13, 13>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T14, 14>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T15, 15>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T16, 16>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T17, 17>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T18, 18>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T19, 19>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -545,28 +545,28 @@ public:
 		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T12, 12>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T13, 13>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T14, 14>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T15, 15>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T16, 16>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T17, 17>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -669,27 +669,27 @@ public:
 		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		TypeHandler<T0>::prepare(pos++, tuple.template get<0>(), pPreparator);
-		TypeHandler<T1>::prepare(pos++, tuple.template get<1>(), pPreparator);
-		TypeHandler<T2>::prepare(pos++, tuple.template get<2>(), pPreparator);
-		TypeHandler<T3>::prepare(pos++, tuple.template get<3>(), pPreparator);
-		TypeHandler<T4>::prepare(pos++, tuple.template get<4>(), pPreparator);
-		TypeHandler<T5>::prepare(pos++, tuple.template get<5>(), pPreparator);
-		TypeHandler<T6>::prepare(pos++, tuple.template get<6>(), pPreparator);
-		TypeHandler<T7>::prepare(pos++, tuple.template get<7>(), pPreparator);
-		TypeHandler<T8>::prepare(pos++, tuple.template get<8>(), pPreparator);
-		TypeHandler<T9>::prepare(pos++, tuple.template get<9>(), pPreparator);
-		TypeHandler<T10>::prepare(pos++, tuple.template get<10>(), pPreparator);
-		TypeHandler<T11>::prepare(pos++, tuple.template get<11>(), pPreparator);
-		TypeHandler<T12>::prepare(pos++, tuple.template get<12>(), pPreparator);
-		TypeHandler<T13>::prepare(pos++, tuple.template get<13>(), pPreparator);
-		TypeHandler<T14>::prepare(pos++, tuple.template get<14>(), pPreparator);
-		TypeHandler<T15>::prepare(pos++, tuple.template get<15>(), pPreparator);
-		TypeHandler<T16>::prepare(pos++, tuple.template get<16>(), pPreparator);
-		TypeHandler<T17>::prepare(pos++, tuple.template get<17>(), pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -791,23 +791,23 @@ public:
 	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T12, 12>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T13, 13>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T14, 14>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T15, 15>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -902,25 +902,25 @@ public:
 		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T12, 12>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T13, 13>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T14, 14>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1011,24 +1011,24 @@ public:
 		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		TypeHandler<T0>::prepare(pos++, tuple.template get<0>(), pPreparator);
-		TypeHandler<T1>::prepare(pos++, tuple.template get<1>(), pPreparator);
-		TypeHandler<T2>::prepare(pos++, tuple.template get<2>(), pPreparator);
-		TypeHandler<T3>::prepare(pos++, tuple.template get<3>(), pPreparator);
-		TypeHandler<T4>::prepare(pos++, tuple.template get<4>(), pPreparator);
-		TypeHandler<T5>::prepare(pos++, tuple.template get<5>(), pPreparator);
-		TypeHandler<T6>::prepare(pos++, tuple.template get<6>(), pPreparator);
-		TypeHandler<T7>::prepare(pos++, tuple.template get<7>(), pPreparator);
-		TypeHandler<T8>::prepare(pos++, tuple.template get<8>(), pPreparator);
-		TypeHandler<T9>::prepare(pos++, tuple.template get<9>(), pPreparator);
-		TypeHandler<T10>::prepare(pos++, tuple.template get<10>(), pPreparator);
-		TypeHandler<T11>::prepare(pos++, tuple.template get<11>(), pPreparator);
-		TypeHandler<T12>::prepare(pos++, tuple.template get<12>(), pPreparator);
-		TypeHandler<T13>::prepare(pos++, tuple.template get<13>(), pPreparator);
-		TypeHandler<T14>::prepare(pos++, tuple.template get<14>(), pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1115,23 +1115,23 @@ public:
 		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T12, 12>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1214,22 +1214,22 @@ public:
 		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1308,21 +1308,21 @@ public:
 		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1397,20 +1397,20 @@ public:
 		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1472,19 +1472,19 @@ public:
 		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1543,18 +1543,18 @@ public:
 		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1610,17 +1610,17 @@ public:
 		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1673,16 +1673,16 @@ public:
 		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1732,15 +1732,15 @@ public:
 		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1787,14 +1787,14 @@ public:
 		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1838,13 +1838,13 @@ public:
 		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1885,12 +1885,12 @@ public:
 		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1928,11 +1928,11 @@ public:
 		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
-		tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -1967,10 +1967,10 @@ public:
 		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
 	}
 
-	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
 	{
 		poco_assert (pPreparator != 0);
-		tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
 	}
 
 	static std::size_t size()
@@ -2015,7 +2015,7 @@ public:
 		TypeHandler<V>::extract(pos, obj.second, defVal.second, pExt);
 	}
 
-	static void prepare(std::size_t pos, std::pair<K, V>& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const std::pair<K, V>& obj, AbstractPreparator* pPreparator)
 	{
 		TypeHandler<K>::prepare(pos, obj.first, pPreparator);
 		pos += TypeHandler<K>::size();
@@ -2055,7 +2055,7 @@ public:
 			TypeHandler<T>::extract(pos, *obj, *obj, pExt);
 	}
 
-	static void prepare(std::size_t pos, Poco::AutoPtr<T>& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const Poco::AutoPtr<T>& obj, AbstractPreparator* pPreparator)
 	{
 		poco_assert_dbg (pPreparator != 0);
 		if (!obj)
@@ -2077,7 +2077,7 @@ class TypeHandler<Poco::SharedPtr<T> >: public AbstractTypeHandler
 public:
 	static void bind(std::size_t pos, const Poco::SharedPtr<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
 	{
-		// *obj will trigger a nullpointer exception if empty: this is on purpose
+		// *obj will trigger a nullpointer exception if empty
 		TypeHandler<T>::bind(pos, *obj, pBinder, dir); 
 	}
 
@@ -2097,11 +2097,10 @@ public:
 			TypeHandler<T>::extract(pos, *obj, *obj, pExt);
 	}
 
-	static void prepare(std::size_t pos, Poco::SharedPtr<T>& obj, AbstractPreparator* pPreparator)
+	static void prepare(std::size_t pos, const Poco::SharedPtr<T>& obj, AbstractPreparator* pPreparator)
 	{
 		poco_assert_dbg (pPreparator != 0);
-		if (!obj)
-			obj = new T();
+		// *obj will trigger a nullpointer exception if empty
 		TypeHandler<T>::prepare(pos, *obj, pPreparator);
 	}
 

Data/samples/TypeHandler/src/TypeHandler.cpp

@@ -82,7 +82,7 @@ public:
 		TypeHandler<int>::extract(pos++, person.age, deflt.age, pExtr);
 	}
 	
-	static void prepare(std::size_t pos, Person& person, AbstractPreparator* pPrep)
+	static void prepare(std::size_t pos, const Person& person, AbstractPreparator* pPrep)
 	{
 		TypeHandler<std::string>::prepare(pos++, person.name, pPrep);
 		TypeHandler<std::string>::prepare(pos++, person.address, pPrep);

Foundation/include/Poco/String.h

@@ -43,6 +43,7 @@
 #include "Poco/Foundation.h"
 #include "Poco/Ascii.h"
 #include <cstring>
+#include <locale>
 
 
 namespace Poco {
@@ -642,6 +643,64 @@ S cat(const S& delim, const It& begin, const It& end)
 }
 
 
+//
+// case-insensitive string equality
+//
+
+
+template <typename charT>
+struct i_char_traits : public std::char_traits<charT>
+{
+	static bool eq(charT c1, charT c2)
+	{
+		return Ascii::toLower(c1) == Ascii::toLower(c2);
+	}
+
+	static bool ne(charT c1, charT c2)
+	{
+		return !eq(c1, c2);
+	}
+
+	static bool lt(charT c1, charT c2)
+	{
+		return Ascii::toLower(c1) < Ascii::toLower(c2);
+	}
+
+	static int compare(const charT* s1, const charT* s2, size_t n)
+	{
+		for (int i = 0; i < n && s1 && s2; ++i, ++s1, ++s2)
+		{
+			if (Ascii::toLower(*s1) == Ascii::toLower(*s2)) continue;
+			else if (Ascii::toLower(*s1) < Ascii::toLower(*s2)) return -1;
+			else return 1;
+		}
+
+		return 0;
+	}
+
+	static const charT* find(const charT* s, int n, charT a)
+	{
+		while(n-- > 0 && Ascii::toLower(*s) != Ascii::toLower(a)) { ++s; }
+		return s;
+	}
+};
+
+
+typedef std::basic_string<char, i_char_traits<char> > istring;
+
+
+template<typename T>
+int isubstr(const T& str, const T& sought)
+{
+	typename T::const_iterator it = std::search(str.begin(), str.end(),
+		sought.begin(), sought.end(), 
+		i_char_traits<typename T::value_type>::eq);
+
+	if (it != str.end()) return it - str.begin();
+	else return T::npos;
+}
+
+
 } // namespace Poco
 
 

Foundation/testsuite/src/StringTest.cpp

@@ -1,4 +1,4 @@
-//
+//
 // StringTest.cpp
 //
 // $Id: //poco/1.4/Foundation/testsuite/src/StringTest.cpp#1 $
@@ -54,6 +54,8 @@ using Poco::toUpperInPlace;
 using Poco::toLower;
 using Poco::toLowerInPlace;
 using Poco::icompare;
+using Poco::istring;
+using Poco::isubstr;
 using Poco::translate;
 using Poco::translateInPlace;
 using Poco::replace;
@@ -228,6 +230,36 @@ void StringTest::testToLower()
 }
 
 
+void StringTest::testIstring()
+{
+	istring is1 = "AbC";
+	istring is2 = "aBc";
+	assert (is1 == is2);
+
+	const char c1[] = { 'G', 0, (char) 0xFC, 'n', 't', 'e', 'r', '\0' };
+	const char c2[] = { 'g', 0, (char) 0xDC, 'N', 'T', 'E', 'R', '\0' };
+	is1 = c1;
+	is2 = c2;
+	assert (is1 == is2);
+	is1[0] = 'f';
+	assert (is1 < is2);
+	is1[0] = 'F';
+	assert (is1 < is2);
+	is1[0] = 'H';
+	assert (is1 > is2);
+	is1[0] = 'h';
+	assert (is1 > is2);
+
+	is1 = "aAaBbBcCc";
+	is2 = "bbb";
+	assert (isubstr(is1, is2) == 3);
+	is2 = "bC";
+	assert (isubstr(is1, is2) == 5);
+	is2 = "xxx";
+	assert (isubstr(is1, is2) == istring::npos);
+}
+
+
 void StringTest::testIcompare()
 {
 	std::string s1 = "AAA";
@@ -1044,6 +1076,7 @@ CppUnit::Test* StringTest::suite()
 	CppUnit_addTest(pSuite, StringTest, testTrimRightInPlace);
 	CppUnit_addTest(pSuite, StringTest, testToUpper);
 	CppUnit_addTest(pSuite, StringTest, testToLower);
+	CppUnit_addTest(pSuite, StringTest, testIstring);
 	CppUnit_addTest(pSuite, StringTest, testIcompare);
 	CppUnit_addTest(pSuite, StringTest, testTranslate);
 	CppUnit_addTest(pSuite, StringTest, testTranslateInPlace);

Foundation/testsuite/src/StringTest.h

@@ -56,6 +56,7 @@ public:
 	void testTrimInPlace();
 	void testToUpper();
 	void testToLower();
+	void testIstring();
 	void testIcompare();
 	void testTranslate();
 	void testTranslateInPlace();

Net/include/Poco/Net/NetworkInterface.h

@@ -155,6 +155,11 @@ public:
 		/// Throws NotFoundException if the address family is not
 		/// configured on the interface.
 
+	void firstAddress(IPAddress& addr, IPAddress::Family family = IPAddress::IPv4) const;
+		/// Returns the first IP address bound to the interface.
+		/// If the address family is not configured on the interface,
+		/// the address returned in addr will be unspecified (wildcard).
+
 	const IPAddress& address(unsigned index = 0) const;
 		/// Returns the IP address bound to the interface at index position.
 

Net/src/NetworkInterface.cpp

@@ -612,6 +612,19 @@ const IPAddress& NetworkInterface::firstAddress(IPAddress::Family family) const
 }
 
 
+void NetworkInterface::firstAddress(IPAddress& addr, IPAddress::Family family) const
+{
+	try
+	{
+		addr = firstAddress(family);
+	}
+	catch (NotFoundException&)
+	{
+		addr = IPAddress(family);
+	}
+}
+
+
 void NetworkInterface::addAddress(const IPAddress& address)
 {
 	_pImpl->addAddress(AddressTuple(address, IPAddress(), IPAddress()));

Net/testsuite/src/NetworkInterfaceTest.cpp

@@ -150,6 +150,11 @@ void NetworkInterfaceTest::testForAddress()
 		{
 			NetworkInterface ifc = NetworkInterface::forAddress(it->second.firstAddress(IPAddress::IPv4));
 			assert (ifc.firstAddress(IPAddress::IPv4) == it->second.firstAddress(IPAddress::IPv4));
+
+			IPAddress addr(IPAddress::IPv4);
+			assert (addr.isWildcard());
+			it->second.firstAddress(addr, IPAddress::IPv4);
+			assert (!addr.isWildcard());
 		}
 		else
 		{
@@ -159,6 +164,11 @@ void NetworkInterfaceTest::testForAddress()
 				fail ("must throw");
 			}
 			catch (NotFoundException&) { }
+
+			IPAddress addr(IPAddress::IPv4);
+			assert (addr.isWildcard());
+			it->second.firstAddress(addr, IPAddress::IPv4);
+			assert (addr.isWildcard());
 		}
 	}
 }