more Data housekeeping

replaced more pointers with SharedPtr

Data/include/Poco/Data/AbstractExtraction.h

@@ -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.

Data/include/Poco/Data/AbstractPreparation.h

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

Data/include/Poco/Data/AbstractPreparator.h

@@ -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.

Data/include/Poco/Data/Binding.h

@@ -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,

Data/include/Poco/Data/BulkExtraction.h

@@ -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
 		{ 

Data/include/Poco/Data/Extraction.h

@@ -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);
 	}

Data/include/Poco/Data/Preparation.h

@@ -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)

Data/include/Poco/Data/RecordSet.h

@@ -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);

Data/include/Poco/Data/Row.h

@@ -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;
 };
 
 

Data/include/Poco/Data/RowFormatter.h

@@ -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);

Data/include/Poco/Data/Statement.h

@@ -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;

Data/include/Poco/Data/StatementImpl.h

@@ -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);

Data/include/Poco/Data/TypeHandler.h

@@ -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);
 	}