generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-02-20 22:31:23 +01:00
Code Issues Projects Releases Wiki Activity

SF [2903676] Tuple TypeHander does not handle composites.

Browse Source
This commit is contained in:
Aleksandar Fabijanic 2009-11-25 14:57:32 +00:00
parent 4856f84b21
commit 50a373c3b9
8 changed files with 465 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Data/ODBC/testsuite/src/ODBCOracleTest.cpp
View File

@ -698,6 +698,16 @@ void ODBCOracleTest::recreatePersonTable()
}
void ODBCOracleTest::recreatePersonTupleTable()
{
dropObject("TABLE", "Person");
try { *_pSession << "CREATE TABLE Person (LastName1 VARCHAR2(30), FirstName1 VARCHAR2(30), Address1 VARCHAR2(30), Age1 INTEGER,"
"LastName2 VARCHAR2(30), FirstName2 VARCHAR2(30), Address2 VARCHAR2(30), Age2 INTEGER)", now; }
catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail ("recreatePersonTupleTable()"); }
catch(StatementException& se){ std::cout << se.toString() << std::endl; fail ("recreatePersonTupleTable()"); }
}
void ODBCOracleTest::recreatePersonBLOBTable()
{
dropObject("TABLE", "Person");
@ -848,6 +858,7 @@ CppUnit::Test* ODBCOracleTest::suite()
CppUnit_addTest(pSuite, ODBCOracleTest, testBareboneODBC);
CppUnit_addTest(pSuite, ODBCOracleTest, testSimpleAccess);
CppUnit_addTest(pSuite, ODBCOracleTest, testComplexType);
CppUnit_addTest(pSuite, ODBCOracleTest, testComplexTypeTuple);
CppUnit_addTest(pSuite, ODBCOracleTest, testSimpleAccessVector);
CppUnit_addTest(pSuite, ODBCOracleTest, testComplexTypeVector);
CppUnit_addTest(pSuite, ODBCOracleTest, testSharedPtrComplexTypeVector);

1
Data/ODBC/testsuite/src/ODBCOracleTest.h
View File

@ -75,6 +75,7 @@ private:
void dropObject(const std::string& type, const std::string& name);
void recreatePersonTable();
void recreatePersonTupleTable();
void recreatePersonBLOBTable();
void recreatePersonDateTable();
void recreatePersonDateTimeTable();

15
Data/ODBC/testsuite/src/ODBCTest.cpp
View File

@ -131,6 +131,21 @@ void ODBCTest::testComplexType()
}
void ODBCTest::testComplexTypeTuple()
{
if (!_pSession) fail ("Test not available.");
for (int i = 0; i < 8;)
{
recreatePersonTupleTable();
_pSession->setFeature("autoBind", bindValue(i));
_pSession->setFeature("autoExtract", bindValue(i+1));
_pExecutor->complexTypeTuple();
i += 2;
}
}
void ODBCTest::testSimpleAccessVector()
{
if (!_pSession) fail ("Test not available.");

18
Data/ODBC/testsuite/src/ODBCTest.h
View File

@ -71,6 +71,7 @@ public:
virtual void testSimpleAccess();
virtual void testComplexType();
virtual void testComplexTypeTuple();
virtual void testSimpleAccessVector();
virtual void testComplexTypeVector();
@ -174,6 +175,7 @@ protected:
virtual void dropObject(const std::string& type, const std::string& name);
virtual void recreatePersonTable();
virtual void recreatePersonTupleTable();
virtual void recreatePersonBLOBTable();
virtual void recreatePersonDateTimeTable();
virtual void recreatePersonDateTable();
@ -273,31 +275,37 @@ inline void ODBCTest::dropObject(const std::string& type, const std::string& nam
inline void ODBCTest::recreatePersonTable()
{
throw Poco::NotImplementedException("ODBCTest::testStoredFunctionDynamicAny()");
throw Poco::NotImplementedException("ODBCTest::recreatePersonTable()");
}
inline void ODBCTest::recreatePersonTupleTable()
{
throw Poco::NotImplementedException("ODBCTest::recreatePersonTupleTable()");
}
inline void ODBCTest::recreatePersonBLOBTable()
{
throw Poco::NotImplementedException("ODBCTest::testStoredFunctionDynamicAny()");
throw Poco::NotImplementedException("ODBCTest::recreatePersonBLOBTable()");
}
inline void ODBCTest::recreatePersonDateTimeTable()
{
throw Poco::NotImplementedException("ODBCTest::testStoredFunctionDynamicAny()");
throw Poco::NotImplementedException("ODBCTest::recreatePersonDateTimeTable()");
}
inline void ODBCTest::recreatePersonDateTable()
{
throw Poco::NotImplementedException("ODBCTest::testStoredFunctionDynamicAny()");
throw Poco::NotImplementedException("ODBCTest::recreatePersonDateTable()");
}
inline void ODBCTest::recreatePersonTimeTable()
{
throw Poco::NotImplementedException("ODBCTest::testStoredFunctionDynamicAny()");
throw Poco::NotImplementedException("ODBCTest::recreatePersonTimeTable()");
}

20
Data/ODBC/testsuite/src/SQLExecutor.cpp
View File

@ -1005,6 +1005,26 @@ void SQLExecutor::complexType()
}
void SQLExecutor::complexTypeTuple()
{
std::string funct = "complexTypeTuple()";
Person p1("LN1", "FN1", "ADDR1", 1);
Person p2("LN2", "FN2", "ADDR2", 2);
Tuple<Person,Person> t(p1,p2);
try { *_pSession << "INSERT INTO PERSON VALUES(?,?,?,?,?,?,?,?)", use(t), now; }
catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
Tuple<Person,Person> ret;
assert (ret != t);
try { *_pSession << "SELECT * FROM PERSON", into(ret), now; }
catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); }
catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); }
assert (ret == t);
}
void SQLExecutor::simpleAccessVector()
{
std::string funct = "simpleAccessVector()";

1
Data/ODBC/testsuite/src/SQLExecutor.h
View File

@ -134,6 +134,7 @@ public:
void simpleAccess();
void complexType();
void complexTypeTuple();
void simpleAccessVector();
void complexTypeVector();

13
Data/SQLite/testsuite/src/SQLiteTest.cpp
View File

@ -409,6 +409,19 @@ void SQLiteTest::testComplexType()
Person c2;
tmp << "SELECT * FROM PERSON WHERE LASTNAME = :ln", into(c1), use(p1.lastName), now;
assert (c1 == p1);
tmp << "DROP TABLE IF EXISTS Person", now;
tmp << "CREATE TABLE IF NOT EXISTS Person (LastName1 VARCHAR(30), FirstName1 VARCHAR, Address1 VARCHAR, Age1 INTEGER(3),"
"LastName2 VARCHAR(30), FirstName2 VARCHAR, Address2 VARCHAR, Age2 INTEGER(3))", now;
Tuple<Person,Person> t(p1,p2);
tmp << "INSERT INTO PERSON VALUES(:ln1, :fn1, :ad1, :age1, :ln2, :fn2, :ad2, :age2)", use(t), now;
Tuple<Person,Person> ret;
assert (ret != t);
tmp << "SELECT * FROM PERSON", into(ret), now;
assert (ret == t);
}

592
Data/include/Poco/Data/TypeHandler.h
View File

@ -338,7 +338,7 @@ template <typename TupleType, typename Type, int N>
POCO_TUPLE_TYPE_HANDLER_INLINE
void tupleBind(std::size_t& pos, TupleType tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
{
pBinder->bind(pos, tuple.template get<N>(), dir);
TypeHandler<Type>::bind(pos, tuple.template get<N>(), pBinder, dir);
pos += TypeHandler<Type>::size();
}
@ -347,7 +347,7 @@ template <typename TupleType, typename Type, int N>
POCO_TUPLE_TYPE_HANDLER_INLINE
void tuplePrepare(std::size_t& pos, TupleType tuple, AbstractPreparator* pPreparator)
{
pPreparator->prepare(pos, tuple.template get<N>());
TypeHandler<Type>::prepare(pos, tuple.template get<N>(), pPreparator);
pos += TypeHandler<Type>::size();
}
@ -356,8 +356,8 @@ template <typename TupleType, typename DefValType, typename Type, int N>
POCO_TUPLE_TYPE_HANDLER_INLINE
void tupleExtract(std::size_t& pos, TupleType tuple, DefValType defVal, AbstractExtractor* pExt)
{
if (!pExt->extract(pos, tuple.template get<N>()))
tuple.template set<N>(defVal.template get<N>());
Poco::Data::TypeHandler<Type>::extract(pos, tuple.template get<N>(),
defVal.template get<N>(), pExt);
pos += TypeHandler<Type>::size();
}
@ -416,31 +416,50 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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);
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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size() +
TypeHandler<T14>::size() +
TypeHandler<T15>::size() +
TypeHandler<T16>::size() +
TypeHandler<T17>::size() +
TypeHandler<T18>::size() +
TypeHandler<T19>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -526,30 +545,48 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size() +
TypeHandler<T14>::size() +
TypeHandler<T15>::size() +
TypeHandler<T16>::size() +
TypeHandler<T17>::size() +
TypeHandler<T18>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -654,7 +691,24 @@ public:
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size() +
TypeHandler<T14>::size() +
TypeHandler<T15>::size() +
TypeHandler<T16>::size() +
TypeHandler<T17>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -734,28 +788,44 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size() +
TypeHandler<T14>::size() +
TypeHandler<T15>::size() +
TypeHandler<T16>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -832,27 +902,42 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size() +
TypeHandler<T14>::size() +
TypeHandler<T15>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -945,7 +1030,21 @@ public:
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size() +
TypeHandler<T14>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1016,25 +1115,38 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size() +
TypeHandler<T13>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1102,24 +1214,36 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size() +
TypeHandler<T12>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1184,23 +1308,34 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size() +
TypeHandler<T11>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1262,22 +1397,32 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size() +
TypeHandler<T10>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1327,21 +1472,30 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size() +
TypeHandler<T9>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1389,20 +1543,28 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size() +
TypeHandler<T8>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1448,19 +1610,26 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size() +
TypeHandler<T7>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1504,18 +1673,24 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size() +
TypeHandler<T6>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1557,17 +1732,22 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size() +
TypeHandler<T5>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1607,16 +1787,20 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size() +
TypeHandler<T4>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1654,15 +1838,18 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
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<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);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, T3, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size() +
TypeHandler<T3>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1698,14 +1885,16 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleRef, T2, 2>(pos, tuple, pPreparator);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, T2, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size() +
TypeHandler<T2>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1739,13 +1928,14 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleRef, T1, 1>(pos, tuple, pPreparator);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, T1, NullTypeList>::length);
return TypeHandler<T0>::size() +
TypeHandler<T1>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
@ -1777,12 +1967,12 @@ public:
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
{
poco_assert (pPreparator != 0);
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleRef, T0, 0>(pos, tuple, pPreparator);
}
static std::size_t size()
{
return static_cast<std::size_t>(Poco::Tuple<T0, NullTypeList>::length);
return TypeHandler<T0>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal,