generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-03-04 07:27:23 +01:00
Code Issues Projects Releases Wiki Activity

more Data housekeeping

Browse Source 
replaced more pointers with SharedPtr
This commit is contained in:
Aleksandar Fabijanic 2013-04-28 20:09:36 -05:00
parent a65d86a0b2
commit ebff906402
23 changed files with 368 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Data/ODBC/src/ODBCStatementImpl.cpp
View File

@ -187,10 +187,11 @@ void ODBCStatementImpl::doPrepare()
"SQLSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE)");
}
AbstractPreparation::Ptr pAP = 0;
Poco::Data::AbstractPreparator::Ptr pP = _preparations[curDataSet];
for (std::size_t pos = 0; it != itEnd; ++it)
{
Poco::Data::AbstractPreparator::Ptr pP = _preparations[curDataSet];
std::auto_ptr<AbstractPreparation> pAP((*it)->createPreparation(pP, pos));
pAP = (*it)->createPreparation(pP, pos);
pAP->prepare();
pos += (*it)->numOfColumnsHandled();
}

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

@ -200,21 +200,21 @@ class TypeHandler<Person>
public:
static void bind(std::size_t pos,
const Person& obj,
AbstractBinder* pBinder,
AbstractBinder::Ptr pBinder,
AbstractBinder::Direction dir = AbstractBinder::PD_IN)
{
// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos++, obj.lastName, dir);
pBinder->bind(pos++, obj.firstName, dir);
pBinder->bind(pos++, obj.address, dir);
pBinder->bind(pos++, obj.age, dir);
}
static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPrepare)
static void prepare(std::size_t pos, const Person& obj, AbstractPreparator::Ptr pPrepare)
{
// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
poco_assert_dbg (pPrepare != 0);
poco_assert_dbg (!pPrepare.isNull());
pPrepare->prepare(pos++, obj.lastName);
pPrepare->prepare(pos++, obj.firstName);
pPrepare->prepare(pos++, obj.address);
@ -226,9 +226,9 @@ public:
return 4;
}
static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
if (!pExt->extract(pos++, obj.lastName))
obj.lastName = defVal.lastName;
if (!pExt->extract(pos++, obj.firstName))
@ -251,21 +251,21 @@ class TypeHandler<RefCountedPerson>
public:
static void bind(std::size_t pos,
const RefCountedPerson& obj,
AbstractBinder* pBinder,
AbstractBinder::Ptr pBinder,
AbstractBinder::Direction dir = AbstractBinder::PD_IN)
{
// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos++, obj.lastName, dir);
pBinder->bind(pos++, obj.firstName, dir);
pBinder->bind(pos++, obj.address, dir);
pBinder->bind(pos++, obj.age, dir);
}
static void prepare(std::size_t pos, RefCountedPerson& obj, AbstractPreparator* pPrepare)
static void prepare(std::size_t pos, RefCountedPerson& obj, AbstractPreparator::Ptr pPrepare)
{
// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
poco_assert_dbg (pPrepare != 0);
poco_assert_dbg (!pPrepare.isNull());
pPrepare->prepare(pos++, obj.lastName);
pPrepare->prepare(pos++, obj.firstName);
pPrepare->prepare(pos++, obj.address);
@ -277,9 +277,9 @@ public:
return 4;
}
static void extract(std::size_t pos, RefCountedPerson& obj, const RefCountedPerson& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, RefCountedPerson& obj, const RefCountedPerson& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
if (!pExt->extract(pos++, obj.lastName))
obj.lastName = defVal.lastName;
if (!pExt->extract(pos++, obj.firstName))

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

@ -194,24 +194,19 @@ template <>
class TypeHandler<Person>
{
public:
static void bind(std::size_t pos, const Person& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const Person& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos++, obj.getLastName(), dir);
pBinder->bind(pos++, obj.getFirstName(), dir);
pBinder->bind(pos++, obj.getAddress(), dir);
pBinder->bind(pos++, obj.getAge(), dir);
}
static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPrepare)
static void prepare(std::size_t pos, const Person& obj, AbstractPreparator::Ptr pPrepare)
{
// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3))
poco_assert_dbg (pPrepare != 0);
pPrepare->prepare(pos++, obj.getLastName());
pPrepare->prepare(pos++, obj.getFirstName());
pPrepare->prepare(pos++, obj.getAddress());
pPrepare->prepare(pos++, obj.getAge());
// no-op (SQLite is prepare-less connector)
}
static std::size_t size()
@ -219,9 +214,9 @@ public:
return 4;
}
static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
std::string lastName;
std::string firstName;
std::string address;

6
Data/doc/00200-DataUserManual.page
View File

@ -963,7 +963,7 @@ The template specialization must implement the following methods:
class TypeHandler<class Person>
{
public:
static void bind(std::size_t pos, const Person&amp; obj, AbstractBinder* pBinder)
static void bind(std::size_t pos, const Person&amp; obj, AbstractBinder::Ptr pBinder)
{
poco_assert_dbg (pBinder != 0);
// the table is defined as Person (FirstName VARCHAR(30), lastName VARCHAR, SocialSecNr INTEGER(3))
@ -978,7 +978,7 @@ The template specialization must implement the following methods:
return 3; // we handle three columns of the Table!
}
static void prepare(std::size_t pos, const Person&amp; obj, AbstractPreparation* pPrepare)
static void prepare(std::size_t pos, const Person&amp; obj, AbstractPreparation::Ptr pPrepare)
{
poco_assert_dbg (pBinder != 0);
// the table is defined as Person (FirstName VARCHAR(30), lastName VARCHAR, SocialSecNr INTEGER(3))
@ -988,7 +988,7 @@ The template specialization must implement the following methods:
TypeHandler<Poco::UInt64>::prepare(pos++, obj.getSocialSecNr(), pPrepare);
}
static void extract(std::size_t pos, Person&amp; obj, const Person&amp; defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, Person&amp; obj, const Person&amp; defVal, AbstractExtractor::Ptr pExt)
/// obj will contain the result, defVal contains values we should use when one column is NULL
{
poco_assert_dbg (pExt != 0);

41
Data/doc/99100-DataReleaseNotes.page
View File

@ -20,3 +20,44 @@ to existing code.
!!Incompatible Changes and Possible Transition Issues
Keywords (use, into, limit, etc) now reside in Poco::Data::Keywords namespace.
!!!Release 1.5.2
!!Summary of Changes
- framework-wide refactoring to use SharedPtr-based garbage collection
!!Incompatible Changes and Possible Transition Issues
Internally, (Abstract)Binder, Extracion nas (where applicable) Preparator are garbage collected.
While old way of passing pointers to TypeHandler may still work, it is strongly recommended
to pass SharedPtr to handler functions, e.g. :
template <>
class TypeHandler<Person>
{
public:
static std::size_t size()
{
return 3;
}
static void bind(std::size_t pos, const Person& person, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
TypeHandler<std::string>::bind(pos++, person.name, pBinder, dir);
// ...
}
static void extract(std::size_t pos, Person& person, const Person& deflt, AbstractExtractor::Ptr pExtr)
{
TypeHandler<std::string>::extract(pos++, person.name, deflt.name, pExtr);
// ...
}
static void prepare(std::size_t pos, const Person& person, AbstractPreparator::Ptr pPrep)
{
TypeHandler<std::string>::prepare(pos++, person.name, pPrep);
// ...
}
};

7
Data/include/Poco/Data/AbstractExtraction.h
View File

@ -42,6 +42,7 @@
#include "Poco/Data/Data.h"
#include "Poco/Data/AbstractExtractor.h"
#include "Poco/Data/AbstractPreparation.h"
#include "Poco/Data/Limit.h"
#include "Poco/RefCountedObject.h"
#include "Poco/AutoPtr.h"
@ -55,7 +56,6 @@ namespace Poco {
namespace Data {
class AbstractPreparation;
class AbstractPreparator;
@ -113,9 +113,8 @@ public:
virtual bool canExtract() const;
/// Returns true. Implementations should override it for different behavior.
virtual AbstractPreparation* createPreparation(PreparatorPtr& pPrep, std::size_t pos) = 0;
/// Creates a Preparation object for the extracting object. The returned pointer points to
/// a preparation object allocated on the heap; caller must take ownership of it.
virtual AbstractPreparation::Ptr createPreparation(PreparatorPtr& pPrep, std::size_t pos) = 0;
/// Creates and returns shared pointer to Preparation object for the extracting object.
void setLimit(Poco::UInt32 limit);
/// Sets the limit.

4
Data/include/Poco/Data/AbstractPreparation.h
View File

@ -67,6 +67,10 @@ public:
/// Preparations data.
protected:
AbstractPreparation();
AbstractPreparation(const AbstractPreparation&);
AbstractPreparation& operator = (const AbstractPreparation&);
PreparatorPtr preparation();
/// Returns the preparation object

2
Data/include/Poco/Data/AbstractPreparator.h
View File

@ -67,7 +67,7 @@ class Date;
class Time;
class Data_API AbstractPreparator: public Poco::RefCountedObject
class Data_API AbstractPreparator
/// Interface used for database preparation where we first have to register all data types
/// (and memory output locations) before extracting data, e.g. ODBC.
/// Extract works as two-phase extract: first we call prepare once, then extract n-times.

5
Data/include/Poco/Data/Binding.h
View File

@ -73,8 +73,9 @@ class Binding: public AbstractBinding
/// function. An attempt to pass a constant by reference shall result in compile-time error.
{
public:
typedef T ValType;
typedef Binding<ValType> Type;
typedef T ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Binding<ValType> Type;
typedef SharedPtr<Type> Ptr;
explicit Binding(T& val,

24
Data/include/Poco/Data/BulkExtraction.h
View File

@ -60,7 +60,11 @@ class BulkExtraction: public AbstractExtraction
/// - std::list
{
public:
typedef typename C::value_type T;
typedef C ValType;
typedef typename C::value_type CValType;
typedef SharedPtr<ValType> ValPtr;
typedef BulkExtraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
BulkExtraction(C& result, Poco::UInt32 limit, const Position& pos = Position(0)):
AbstractExtraction(limit, pos.value(), true),
@ -71,7 +75,7 @@ public:
result.resize(limit);
}
BulkExtraction(C& result, const T& def, Poco::UInt32 limit, const Position& pos = Position(0)):
BulkExtraction(C& result, const CValType& def, Poco::UInt32 limit, const Position& pos = Position(0)):
AbstractExtraction(limit, pos.value(), true),
_rResult(result),
_default(def)
@ -112,7 +116,7 @@ public:
std::size_t extract(std::size_t col)
{
AbstractExtractor* pExt = getExtractor();
AbstractExtractor::Ptr pExt = getExtractor();
TypeHandler<C>::extract(col, _rResult, _default, pExt);
typename C::iterator it = _rResult.begin();
typename C::iterator end = _rResult.end();
@ -128,7 +132,7 @@ public:
{
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t col)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t col)
{
Poco::UInt32 limit = getLimit();
if (limit != _rResult.size()) _rResult.resize(limit);
@ -145,7 +149,7 @@ protected:
private:
C& _rResult;
T _default;
CValType _default;
std::deque<bool> _nulls;
};
@ -163,13 +167,17 @@ class InternalBulkExtraction: public BulkExtraction<C>
/// InternalBulkExtraction objects can not be copied or assigned.
{
public:
typedef typename C::value_type T;
typedef C ValType;
typedef typename C::value_type CValType;
typedef SharedPtr<ValType> ValPtr;
typedef InternalBulkExtraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
explicit InternalBulkExtraction(C& result,
Column<C>* pColumn,
Poco::UInt32 limit,
const Position& pos = Position(0)):
BulkExtraction<C>(result, T(), limit, pos),
BulkExtraction<C>(result, CValType(), limit, pos),
_pColumn(pColumn)
/// Creates InternalBulkExtraction.
{
@ -186,7 +194,7 @@ public:
_pColumn->reset();
}
const T& value(int index) const
const CValType& value(int index) const
{
try
{

85
Data/include/Poco/Data/Extraction.h
View File

@ -64,6 +64,11 @@ class Extraction: public AbstractExtraction
/// Concrete Data Type specific extraction of values from a query result set.
{
public:
typedef T ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(T& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -113,7 +118,7 @@ public:
{
if (_extracted) throw ExtractException("value already extracted");
_extracted = true;
AbstractExtractor* pExt = getExtractor();
AbstractExtractor::Ptr pExt = getExtractor();
TypeHandler<T>::extract(pos, _rResult, _default, pExt);
_null = isValueNull<T>(_rResult, pExt->isNull(pos));
@ -130,7 +135,7 @@ public:
return !_extracted;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<T>(pPrep, pos, _rResult);
}
@ -148,6 +153,12 @@ class Extraction<std::vector<T> >: public AbstractExtraction
/// Vector Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::vector<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::vector<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -197,14 +208,14 @@ public:
std::size_t extract(std::size_t pos)
{
AbstractExtractor* pExt = getExtractor();
AbstractExtractor::Ptr pExt = getExtractor();
_rResult.push_back(_default);
TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<T>(pPrep, pos, _default);
}
@ -228,6 +239,11 @@ class Extraction<std::vector<bool> >: public AbstractExtraction
/// Vector bool specialization for extraction of values from a query result set.
{
public:
typedef std::vector<bool> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::vector<bool>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -276,7 +292,7 @@ public:
std::size_t extract(std::size_t pos)
{
AbstractExtractor* pExt = getExtractor();
AbstractExtractor::Ptr pExt = getExtractor();
bool tmp = _default;
TypeHandler<bool>::extract(pos, tmp, _default, pExt);
@ -285,7 +301,7 @@ public:
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<bool>(pPrep, pos, _default);
}
@ -309,6 +325,11 @@ class Extraction<std::list<T> >: public AbstractExtraction
/// List Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::list<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::list<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -357,14 +378,14 @@ public:
std::size_t extract(std::size_t pos)
{
AbstractExtractor* pExt = getExtractor();
AbstractExtractor::Ptr pExt = getExtractor();
_rResult.push_back(_default);
TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<T>(pPrep, pos, _default);
}
@ -388,6 +409,11 @@ class Extraction<std::deque<T> >: public AbstractExtraction
/// Deque Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::deque<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::deque<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -436,14 +462,14 @@ public:
std::size_t extract(std::size_t pos)
{
AbstractExtractor* pExt = getExtractor();
AbstractExtractor::Ptr pExt = getExtractor();
_rResult.push_back(_default);
TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<T>(pPrep, pos, _default);
}
@ -475,10 +501,14 @@ class InternalExtraction: public Extraction<C>
/// InternalExtraction objects can not be copied or assigned.
{
public:
typedef typename C::value_type T;
typedef typename C::value_type ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
explicit InternalExtraction(C& result, Column<C>* pColumn, const Position& pos = Position(0)):
Extraction<C>(result, T(), pos),
Extraction<C>(result, ValType(), pos),
_pColumn(pColumn)
/// Creates InternalExtraction.
{
@ -495,7 +525,7 @@ public:
_pColumn->reset();
}
const T& value(int index) const
const ValType& value(int index) const
{
try
{
@ -531,7 +561,11 @@ class Extraction<std::set<T> >: public AbstractExtraction
/// Set Data Type specialization for extraction of values from a query result set.
{
public:
typedef typename std::set<T>::iterator Iterator;
typedef std::set<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
typedef typename ValType::iterator Iterator;
Extraction(std::set<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@ -576,7 +610,7 @@ public:
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<T>(pPrep, pos, _default);
}
@ -592,6 +626,11 @@ class Extraction<std::multiset<T> >: public AbstractExtraction
/// Multiset Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::multiset<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::multiset<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -635,7 +674,7 @@ public:
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<T>(pPrep, pos, _default);
}
@ -651,6 +690,11 @@ class Extraction<std::map<K, V> >: public AbstractExtraction
/// Map Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::map<K, V> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::map<K, V>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -694,7 +738,7 @@ public:
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<V>(pPrep, pos, _default);
}
@ -710,6 +754,11 @@ class Extraction<std::multimap<K, V> >: public AbstractExtraction
/// Multimap Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::multimap<K, V> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
Extraction(std::multimap<K, V>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
_rResult(result),
@ -753,7 +802,7 @@ public:
return 1u;
}
AbstractPreparation* createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
{
return new Preparation<V>(pPrep, pos, _default);
}

6
Data/include/Poco/Data/Preparation.h
View File

@ -88,7 +88,7 @@ class Preparation<std::vector<T> >: public AbstractPreparation
/// the whole vector preparation, rather than only individual contained values.
{
public:
Preparation(AbstractPreparator* pPreparator, std::size_t pos, std::vector<T>& val = std::vector<T>()):
Preparation(AbstractPreparator::Ptr pPreparator, std::size_t pos, std::vector<T>& val = std::vector<T>()):
AbstractPreparation(pPreparator),
_pos(pos),
_val(val)
@ -120,7 +120,7 @@ class Preparation<std::deque<T> >: public AbstractPreparation
/// the whole deque preparation, rather than only individual contained values.
{
public:
Preparation(AbstractPreparator* pPreparator, std::size_t pos, std::deque<T>& val = std::deque<T>()):
Preparation(AbstractPreparator::Ptr pPreparator, std::size_t pos, std::deque<T>& val = std::deque<T>()):
AbstractPreparation(pPreparator),
_pos(pos),
_val(val)
@ -152,7 +152,7 @@ class Preparation<std::list<T> >: public AbstractPreparation
/// the whole list preparation, rather than only individual contained values.
{
public:
Preparation(AbstractPreparator* pPreparator, std::size_t pos, std::list<T>& val = std::list<T>()):
Preparation(AbstractPreparator::Ptr pPreparator, std::size_t pos, std::list<T>& val = std::list<T>()):
AbstractPreparation(pPreparator),
_pos(pos),
_val(val)

6
Data/include/Poco/Data/RecordSet.h
View File

@ -99,12 +99,12 @@ public:
static const std::size_t UNKNOWN_TOTAL_ROW_COUNT;
explicit RecordSet(const Statement& rStatement,
RowFormatterPtr pRowFormatter = 0);
RowFormatter::Ptr pRowFormatter = 0);
/// Creates the RecordSet.
explicit RecordSet(Session& rSession,
const std::string& query,
RowFormatterPtr pRowFormatter = 0);
RowFormatter::Ptr pRowFormatter = 0);
/// Creates the RecordSet.
explicit RecordSet(Session& rSession,
@ -131,7 +131,7 @@ public:
~RecordSet();
/// Destroys the RecordSet.
void setRowFormatter(RowFormatterPtr pRowFormatter);
void setRowFormatter(RowFormatter::Ptr pRowFormatter);
/// Assigns the row formatter to the statement and all recordset rows.
Statement& operator = (const Statement& stmt);

20
Data/include/Poco/Data/Row.h
View File

@ -104,12 +104,12 @@ public:
/// Creates the Row.
Row(NameVecPtr pNames,
const RowFormatterPtr& pFormatter = 0);
const RowFormatter::Ptr& pFormatter = 0);
/// Creates the Row.
Row(NameVecPtr pNames,
const SortMapPtr& pSortMap,
const RowFormatterPtr& pFormatter = 0);
const RowFormatter::Ptr& pFormatter = 0);
/// Creates the Row.
~Row();
@ -221,7 +221,7 @@ public:
const ValueVec& values() const;
/// Returns the const reference to values vector.
void setFormatter(const RowFormatterPtr& pFormatter = 0);
void setFormatter(const RowFormatter::Ptr& pFormatter = 0);
/// Sets the formatter for this row and takes the
/// shared ownership of it.
@ -236,7 +236,7 @@ public:
/// Returns the reference to the sorting fields.
private:
void init(const SortMapPtr& pSortMap, const RowFormatterPtr& pFormatter);
void init(const SortMapPtr& pSortMap, const RowFormatter::Ptr& pFormatter);
void checkEmpty(std::size_t pos, const Poco::Dynamic::Var& val);
/// Check if row contains only empty values and throws IllegalStateException
@ -249,12 +249,12 @@ private:
bool isEqualSize(const Row& other) const;
bool isEqualType(const Row& other) const;
NameVecPtr _pNames;
ValueVec _values;
SortMapPtr _pSortMap;
mutable RowFormatterPtr _pFormatter;
mutable std::string _nameStr;
mutable std::string _valueStr;
NameVecPtr _pNames;
ValueVec _values;
SortMapPtr _pSortMap;
mutable RowFormatter::Ptr _pFormatter;
mutable std::string _nameStr;
mutable std::string _valueStr;
};

6
Data/include/Poco/Data/RowFormatter.h
View File

@ -90,6 +90,7 @@ class Data_API RowFormatter
///
{
public:
typedef SharedPtr<RowFormatter> Ptr;
typedef std::vector<std::string> NameVec;
typedef SharedPtr<std::vector<std::string> > NameVecPtr;
typedef std::vector<Poco::Dynamic::Var> ValueVec;
@ -232,14 +233,11 @@ inline void RowFormatter::setMode(Mode mode)
}
typedef SharedPtr<RowFormatter> RowFormatterPtr;
namespace Keywords {
template <typename T>
inline RowFormatterPtr format(const T& formatter)
inline RowFormatter::Ptr format(const T& formatter)
/// Utility function used to pass formatter to the statement.
{
return new T(formatter);

14
Data/include/Poco/Data/Statement.h
View File

@ -234,7 +234,7 @@ public:
///
/// Set per default to zero to Limit::LIMIT_UNLIMITED, which disables the limit.
Statement& operator , (RowFormatterPtr pRowFformatter);
Statement& operator , (RowFormatter::Ptr pRowFformatter);
/// Sets the row formatter for the statement.
Statement& operator , (const Range& extrRange);
@ -385,7 +385,7 @@ public:
/// Returns false if the current data set index points to the last
/// data set. Otherwise, it returns true.
void setRowFormatter(RowFormatterPtr pRowFormatter);
void setRowFormatter(RowFormatter::Ptr pRowFormatter);
/// Sets the row formatter for this statement.
/// Statement takes the ownership of the formatter.
@ -410,7 +410,7 @@ protected:
ImplPtr impl() const;
/// Returns pointer to statement implementation.
const RowFormatterPtr& getRowFormatter();
const RowFormatter::Ptr& getRowFormatter();
/// Returns the row formatter for this statement.
Session session();
@ -436,7 +436,7 @@ private:
Mutex _mutex;
AsyncExecMethodPtr _pAsyncExec;
std::vector<Any> _arguments;
RowFormatterPtr _pRowFormatter;
RowFormatter::Ptr _pRowFormatter;
mutable std::string _stmtString;
};
@ -530,7 +530,7 @@ inline void Data_API reset(Statement& statement)
// inlines
//
inline Statement& Statement::operator , (RowFormatterPtr pRowFformatter)
inline Statement& Statement::operator , (RowFormatter::Ptr pRowFformatter)
{
_pRowFormatter = pRowFformatter;
return *this;
@ -796,13 +796,13 @@ inline bool Statement::isAsync() const
}
inline void Statement::setRowFormatter(RowFormatterPtr pRowFormatter)
inline void Statement::setRowFormatter(RowFormatter::Ptr pRowFormatter)
{
_pRowFormatter = pRowFormatter;
}
inline const RowFormatterPtr& Statement::getRowFormatter()
inline const RowFormatter::Ptr& Statement::getRowFormatter()
{
if (!_pRowFormatter) _pRowFormatter = new SimpleRowFormatter;
return _pRowFormatter;

4
Data/include/Poco/Data/StatementImpl.h
View File

@ -335,7 +335,7 @@ private:
/// Resets extraction so it can be reused again.
template <class C>
InternalExtraction<C>* createExtract(const MetaColumn& mc)
typename InternalExtraction<C>::Ptr createExtract(const MetaColumn& mc)
{
C* pData = new C;
Column<C>* pCol = new Column<C>(mc, pData);
@ -343,7 +343,7 @@ private:
}
template <class C>
InternalBulkExtraction<C>* createBulkExtract(const MetaColumn& mc)
typename InternalBulkExtraction<C>::Ptr createBulkExtract(const MetaColumn& mc)
{
C* pData = new C;
Column<C>* pCol = new Column<C>(mc, pData);

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

@ -96,30 +96,30 @@ class TypeHandler: public AbstractTypeHandler
/// return 3; // lastName + firstname + age occupy three columns
/// }
///
/// static void bind(std::size_t pos, const Person& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
/// static void bind(std::size_t pos, const Person& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
/// {
/// // the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
/// // Note that we advance pos by the number of columns the datatype uses! For string/int this is one.
/// poco_assert_dbg (pBinder != 0);
/// poco_assert_dbg (!pBinder.isNull());
/// TypeHandler<std::string>::bind(pos++, obj.getLastName(), pBinder, dir);
/// TypeHandler<std::string>::bind(pos++, obj.getFirstName(), pBinder, dir);
/// TypeHandler<int>::bind(pos++, obj.getAge(), pBinder, dir);
/// }
///
/// static void prepare(std::size_t pos, const Person& obj, AbstractPreparator* pPreparator)
/// static void prepare(std::size_t pos, const Person& obj, AbstractPreparator::Ptr pPreparator)
/// {
/// // the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
/// poco_assert_dbg (pPreparator != 0);
/// poco_assert_dbg (!pPreparator.isNull());
/// TypeHandler<std::string>::prepare(pos++, obj.getLastName(), pPreparator);
/// TypeHandler<std::string>::prepare(pos++, obj.getFirstName(), pPreparator);
/// TypeHandler<int>::prepare(pos++, obj.getAge(), pPreparator);
/// }
///
/// static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor* pExt)
/// static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor::Ptr pExt)
/// {
/// // defVal is the default person we should use if we encunter NULL entries, so we take the individual fields
/// // as defaults. You can do more complex checking, ie return defVal if only one single entry of the fields is null etc...
/// poco_assert_dbg (pExt != 0);
/// poco_assert_dbg (!pExt.isNull());
/// std::string lastName;
/// std::string firstName;
/// int age = 0;
@ -137,9 +137,9 @@ class TypeHandler: public AbstractTypeHandler
/// Apart from that no further work is needed. One can now use Person with into and use clauses.
{
public:
static void bind(std::size_t pos, const T& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const T& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos, obj, dir);
}
@ -148,15 +148,15 @@ public:
return 1u;
}
static void extract(std::size_t pos, T& obj, const T& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, T& obj, const T& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
if (!pExt->extract(pos, obj)) obj = defVal;
}
static void prepare(std::size_t pos, const T& obj, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const T& obj, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
pPreparator->prepare(pos, obj);
}
@ -171,9 +171,9 @@ class TypeHandler<std::deque<T> >: public AbstractTypeHandler
/// Specialization of type handler for std::deque.
{
public:
static void bind(std::size_t pos, const std::deque<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const std::deque<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos, obj, dir);
}
@ -182,16 +182,16 @@ public:
return 1u;
}
static void extract(std::size_t pos, std::deque<T>& obj, const T& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, std::deque<T>& obj, const T& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
if (!pExt->extract(pos, obj))
obj.assign(obj.size(), defVal);
}
static void prepare(std::size_t pos, const std::deque<T>& obj, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const std::deque<T>& obj, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
pPreparator->prepare(pos, obj);
}
@ -206,9 +206,9 @@ class TypeHandler<std::vector<T> >: public AbstractTypeHandler
/// Specialization of type handler for std::vector.
{
public:
static void bind(std::size_t pos, const std::vector<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const std::vector<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos, obj, dir);
}
@ -217,16 +217,16 @@ public:
return 1u;
}
static void extract(std::size_t pos, std::vector<T>& obj, const T& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, std::vector<T>& obj, const T& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
if (!pExt->extract(pos, obj))
obj.assign(obj.size(), defVal);
}
static void prepare(std::size_t pos, const std::vector<T>& obj, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const std::vector<T>& obj, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
pPreparator->prepare(pos, obj);
}
@ -241,9 +241,9 @@ class TypeHandler<std::list<T> >: public AbstractTypeHandler
/// Specialization of type handler for std::list.
{
public:
static void bind(std::size_t pos, const std::list<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const std::list<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
pBinder->bind(pos, obj, dir);
}
@ -252,16 +252,16 @@ public:
return 1u;
}
static void extract(std::size_t pos, std::list<T>& obj, const T& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, std::list<T>& obj, const T& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
if (!pExt->extract(pos, obj))
obj.assign(obj.size(), defVal);
}
static void prepare(std::size_t pos, const std::list<T>& obj, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const std::list<T>& obj, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
pPreparator->prepare(pos, obj);
}
@ -276,9 +276,9 @@ class TypeHandler<Nullable<T> >
{
public:
static void bind(std::size_t pos, const Nullable<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const Nullable<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert_dbg (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
if (obj.isNull())
{
pBinder->bind(pos++, Poco::Data::Keywords::null, dir);
@ -289,9 +289,9 @@ public:
}
}
static void prepare(std::size_t pos, const Nullable<T>& obj, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const Nullable<T>& obj, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
if (obj.isNull())
{
pPreparator->prepare(pos++, Poco::Data::Keywords::null);
@ -307,9 +307,9 @@ public:
return 1u;
}
static void extract(std::size_t pos, Nullable<T>& obj, const Nullable<T>& , AbstractExtractor* pExt)
static void extract(std::size_t pos, Nullable<T>& obj, const Nullable<T>& , AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
T val;
if (pExt->extract(pos++, val))
@ -339,7 +339,7 @@ private:
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)
void tupleBind(std::size_t& pos, TupleType tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
TypeHandler<Type>::bind(pos, tuple.template get<N>(), pBinder, dir);
pos += TypeHandler<Type>::size();
@ -348,7 +348,7 @@ void tupleBind(std::size_t& pos, TupleType tuple, AbstractBinder* pBinder, Abstr
template <typename TupleType, typename Type, int N>
POCO_TUPLE_TYPE_HANDLER_INLINE
void tuplePrepare(std::size_t& pos, TupleType tuple, AbstractPreparator* pPreparator)
void tuplePrepare(std::size_t& pos, TupleType tuple, AbstractPreparator::Ptr pPreparator)
{
TypeHandler<Type>::prepare(pos, tuple.template get<N>(), pPreparator);
pos += TypeHandler<Type>::size();
@ -357,7 +357,7 @@ void tuplePrepare(std::size_t& pos, TupleType tuple, AbstractPreparator* pPrepar
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)
void tupleExtract(std::size_t& pos, TupleType tuple, DefValType defVal, AbstractExtractor::Ptr pExt)
{
Poco::Data::TypeHandler<Type>::extract(pos, tuple.template get<N>(),
defVal.template get<N>(), pExt);
@ -391,9 +391,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -416,9 +416,9 @@ public:
tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -465,9 +465,9 @@ public:
TypeHandler<T19>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -521,9 +521,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -545,9 +545,9 @@ public:
tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -592,9 +592,9 @@ public:
TypeHandler<T18>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -646,9 +646,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -669,9 +669,9 @@ public:
tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -714,9 +714,9 @@ public:
TypeHandler<T17>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -766,9 +766,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -788,9 +788,9 @@ public:
tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -831,9 +831,9 @@ public:
TypeHandler<T16>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -881,9 +881,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -902,9 +902,9 @@ public:
tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -943,9 +943,9 @@ public:
TypeHandler<T15>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -991,9 +991,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1011,9 +1011,9 @@ public:
tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1050,9 +1050,9 @@ public:
TypeHandler<T14>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1096,9 +1096,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1115,9 +1115,9 @@ public:
tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1152,9 +1152,9 @@ public:
TypeHandler<T13>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1196,9 +1196,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1214,9 +1214,9 @@ public:
tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1249,9 +1249,9 @@ public:
TypeHandler<T12>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1291,9 +1291,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1308,9 +1308,9 @@ public:
tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1341,9 +1341,9 @@ public:
TypeHandler<T11>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1381,9 +1381,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1397,9 +1397,9 @@ public:
tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1428,9 +1428,9 @@ public:
TypeHandler<T10>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1457,9 +1457,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1472,9 +1472,9 @@ public:
tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1501,9 +1501,9 @@ public:
TypeHandler<T9>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1529,9 +1529,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1543,9 +1543,9 @@ public:
tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1570,9 +1570,9 @@ public:
TypeHandler<T8>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1597,9 +1597,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1610,9 +1610,9 @@ public:
tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1635,9 +1635,9 @@ public:
TypeHandler<T7>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1661,9 +1661,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1673,9 +1673,9 @@ public:
tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1696,9 +1696,9 @@ public:
TypeHandler<T6>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1721,9 +1721,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1732,9 +1732,9 @@ public:
tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1753,9 +1753,9 @@ public:
TypeHandler<T5>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1777,9 +1777,9 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
@ -1787,9 +1787,9 @@ public:
tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1806,9 +1806,9 @@ public:
TypeHandler<T4>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1829,18 +1829,18 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1855,9 +1855,9 @@ public:
TypeHandler<T3>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1877,17 +1877,17 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
@ -1900,9 +1900,9 @@ public:
TypeHandler<T2>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
@ -1921,16 +1921,16 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
}
@ -1941,9 +1941,9 @@ public:
TypeHandler<T1>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
}
@ -1961,15 +1961,15 @@ public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList> >::REFTYPE TupleRef;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
poco_assert (pBinder != 0);
poco_assert_dbg (!pBinder.isNull());
tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
}
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
{
poco_assert (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
}
@ -1979,9 +1979,9 @@ public:
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal,
AbstractExtractor* pExt)
AbstractExtractor::Ptr pExt)
{
poco_assert (pExt != 0);
poco_assert_dbg (!pExt.isNull());
tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
}
@ -1995,7 +1995,7 @@ template <class K, class V>
class TypeHandler<std::pair<K, V> >: public AbstractTypeHandler
{
public:
static void bind(std::size_t pos, const std::pair<K, V>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const std::pair<K, V>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
TypeHandler<K>::bind(pos, obj.first, pBinder, dir);
pos += TypeHandler<K>::size();
@ -2007,14 +2007,14 @@ public:
return static_cast<std::size_t>(TypeHandler<K>::size() + TypeHandler<V>::size());
}
static void extract(std::size_t pos, std::pair<K, V>& obj, const std::pair<K, V>& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, std::pair<K, V>& obj, const std::pair<K, V>& defVal, AbstractExtractor::Ptr pExt)
{
TypeHandler<K>::extract(pos, obj.first, defVal.first, pExt);
pos += TypeHandler<K>::size();
TypeHandler<V>::extract(pos, obj.second, defVal.second, pExt);
}
static void prepare(std::size_t pos, const std::pair<K, V>& obj, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const std::pair<K, V>& obj, AbstractPreparator::Ptr pPreparator)
{
TypeHandler<K>::prepare(pos, obj.first, pPreparator);
pos += TypeHandler<K>::size();
@ -2032,7 +2032,7 @@ class TypeHandler<Poco::AutoPtr<T> >: public AbstractTypeHandler
/// Specialization of type handler for Poco::AutoPtr
{
public:
static void bind(std::size_t pos, const Poco::AutoPtr<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const Poco::AutoPtr<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
// *obj will trigger a nullpointer exception if empty: this is on purpose
TypeHandler<T>::bind(pos, *obj, pBinder, dir);
@ -2043,9 +2043,9 @@ public:
return static_cast<std::size_t>(TypeHandler<T>::size());
}
static void extract(std::size_t pos, Poco::AutoPtr<T>& obj, const Poco::AutoPtr<T>& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, Poco::AutoPtr<T>& obj, const Poco::AutoPtr<T>& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
obj = Poco::AutoPtr<T>(new T());
if (defVal)
@ -2054,9 +2054,9 @@ public:
TypeHandler<T>::extract(pos, *obj, *obj, pExt);
}
static void prepare(std::size_t pos, const Poco::AutoPtr<T>&, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const Poco::AutoPtr<T>&, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
TypeHandler<T>::prepare(pos, T(), pPreparator);
}
@ -2072,7 +2072,7 @@ class TypeHandler<Poco::SharedPtr<T> >: public AbstractTypeHandler
/// Specialization of type handler for Poco::SharedPtr
{
public:
static void bind(std::size_t pos, const Poco::SharedPtr<T>& obj, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const Poco::SharedPtr<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
// *obj will trigger a nullpointer exception if empty
TypeHandler<T>::bind(pos, *obj, pBinder, dir);
@ -2083,9 +2083,9 @@ public:
return static_cast<std::size_t>(TypeHandler<T>::size());
}
static void extract(std::size_t pos, Poco::SharedPtr<T>& obj, const Poco::SharedPtr<T>& defVal, AbstractExtractor* pExt)
static void extract(std::size_t pos, Poco::SharedPtr<T>& obj, const Poco::SharedPtr<T>& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (pExt != 0);
poco_assert_dbg (!pExt.isNull());
obj = Poco::SharedPtr<T>(new T());
if (defVal)
@ -2094,9 +2094,9 @@ public:
TypeHandler<T>::extract(pos, *obj, *obj, pExt);
}
static void prepare(std::size_t pos, const Poco::SharedPtr<T>&, AbstractPreparator* pPreparator)
static void prepare(std::size_t pos, const Poco::SharedPtr<T>&, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (pPreparator != 0);
poco_assert_dbg (!pPreparator.isNull());
TypeHandler<T>::prepare(pos, T(), pPreparator);
}

1
Data/samples/RowFormatter/src/RowFormatter.cpp
View File

@ -49,7 +49,6 @@ using Poco::Data::Session;
using Poco::Data::Statement;
using Poco::Data::RecordSet;
using Poco::Data::RowFormatter;
using Poco::Data::RowFormatterPtr;
class HTMLTableFormatter : public RowFormatter

6
Data/samples/TypeHandler/src/TypeHandler.cpp
View File

@ -72,7 +72,7 @@ public:
return 3;
}
static void bind(std::size_t pos, const Person& person, AbstractBinder* pBinder, AbstractBinder::Direction dir)
static void bind(std::size_t pos, const Person& person, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
TypeHandler<std::string>::bind(pos++, person.name, pBinder, dir);
TypeHandler<std::string>::bind(pos++, person.address, pBinder, dir);
@ -80,7 +80,7 @@ public:
TypeHandler<DateTime>::bind(pos++, person.birthday, pBinder, dir);
}
static void extract(std::size_t pos, Person& person, const Person& deflt, AbstractExtractor* pExtr)
static void extract(std::size_t pos, Person& person, const Person& deflt, AbstractExtractor::Ptr pExtr)
{
TypeHandler<std::string>::extract(pos++, person.name, deflt.name, pExtr);
TypeHandler<std::string>::extract(pos++, person.address, deflt.address, pExtr);
@ -88,7 +88,7 @@ public:
TypeHandler<DateTime>::extract(pos++, person.birthday, deflt.birthday, pExtr);
}
static void prepare(std::size_t pos, const Person& person, AbstractPreparator* pPrep)
static void prepare(std::size_t pos, const Person& person, AbstractPreparator::Ptr pPrep)
{
TypeHandler<std::string>::prepare(pos++, person.name, pPrep);
TypeHandler<std::string>::prepare(pos++, person.address, pPrep);

6
Data/src/RecordSet.cpp
View File

@ -54,7 +54,7 @@ const std::size_t RecordSet::UNKNOWN_TOTAL_ROW_COUNT = std::numeric_limits<std::
RecordSet::RecordSet(const Statement& rStatement,
RowFormatterPtr pRowFormatter):
RowFormatter::Ptr pRowFormatter):
Statement(rStatement),
_currentRow(0),
_pBegin(new RowIterator(this, 0 == rowsExtracted())),
@ -68,7 +68,7 @@ RecordSet::RecordSet(const Statement& rStatement,
RecordSet::RecordSet(Session& rSession,
const std::string& query,
RowFormatterPtr pRowFormatter):
RowFormatter::Ptr pRowFormatter):
Statement((rSession << query, now)),
_currentRow(0),
_pBegin(new RowIterator(this, 0 == rowsExtracted())),
@ -308,7 +308,7 @@ bool RecordSet::moveLast()
}
void RecordSet::setRowFormatter(RowFormatterPtr pRowFormatter)
void RecordSet::setRowFormatter(RowFormatter::Ptr pRowFormatter)
{
pRowFormatter->setTotalRowCount(static_cast<int>(getTotalRowCount()));
Statement::setRowFormatter(pRowFormatter);

8
Data/src/Row.cpp
View File

@ -60,7 +60,7 @@ Row::Row():
Row::Row(NameVecPtr pNames,
const RowFormatterPtr& pFormatter): _pNames(pNames)
const RowFormatter::Ptr& pFormatter): _pNames(pNames)
{
if (!_pNames) throw NullPointerException();
init(0, pFormatter);
@ -69,14 +69,14 @@ Row::Row(NameVecPtr pNames,
Row::Row(NameVecPtr pNames,
const SortMapPtr& pSortMap,
const RowFormatterPtr& pFormatter): _pNames(pNames)
const RowFormatter::Ptr& pFormatter): _pNames(pNames)
{
if (!_pNames) throw NullPointerException();
init(pSortMap, pFormatter);
}
void Row::init(const SortMapPtr& pSortMap, const RowFormatterPtr& pFormatter)
void Row::init(const SortMapPtr& pSortMap, const RowFormatter::Ptr& pFormatter)
{
setFormatter(pFormatter);
setSortMap(pSortMap);
@ -371,7 +371,7 @@ bool Row::operator < (const Row& other) const
}
void Row::setFormatter(const RowFormatterPtr& pFormatter)
void Row::setFormatter(const RowFormatter::Ptr& pFormatter)
{
if (pFormatter.get())
_pFormatter = pFormatter;

4
Data/testsuite/src/DataTest.cpp
View File

@ -1339,10 +1339,6 @@ void DataTest::testDateAndTime()
void DataTest::testExternalBindingAndExtraction()
{
AbstractExtractionVecVec extractionVec;
AbstractExtractionVec extraction;
AbstractBindingVec binding;
Session tmp (Poco::Data::Test::Connector::KEY, "dummy.db");
int i;