thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-07-01 14:37:10 +02:00
Code Releases Activity

Update POCO to 1.11.0

Browse Source
This commit is contained in:
Sandu Liviu Catalin
2021-08-22 18:07:06 +03:00
parent 151077c799
commit 7a3d92d1d1
450 changed files with 25219 additions and 6528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
vendor/POCO/Data/include/Poco/Data/AbstractBinder.h vendored
View File

@ -24,6 +24,7 @@
#include "Poco/Data/LOB.h"
#include "Poco/DateTime.h"
#include "Poco/Nullable.h"
#include "Poco/UUID.h"
#include "Poco/Any.h"
#include "Poco/Dynamic/Var.h"
#include "Poco/UTFString.h"
@ -317,6 +318,18 @@ public:
virtual void bind(std::size_t pos, const std::list<Time>& val, Direction dir = PD_IN);
/// Binds a Time list.
virtual void bind(std::size_t pos, const UUID& val, Direction dir = PD_IN) = 0;
/// Binds a UUID.
virtual void bind(std::size_t pos, const std::vector<UUID>& val, Direction dir = PD_IN);
/// Binds a UUID vector.
virtual void bind(std::size_t pos, const std::deque<UUID>& val, Direction dir = PD_IN);
/// Binds a UUID deque.
virtual void bind(std::size_t pos, const std::list<UUID>& val, Direction dir = PD_IN);
/// Binds a UUID list.
virtual void bind(std::size_t pos, const NullData& val, Direction dir = PD_IN) = 0;
/// Binds a null.

13
vendor/POCO/Data/include/Poco/Data/AbstractExtractor.h vendored
View File

@ -21,6 +21,7 @@
#include "Poco/Data/Data.h"
#include "Poco/Data/Constants.h"
#include "Poco/Data/LOB.h"
#include "Poco/UUID.h"
#include "Poco/UTFString.h"
#include <vector>
#include <deque>
@ -304,6 +305,18 @@ public:
virtual bool extract(std::size_t pos, std::list<Time>& val);
/// Extracts a Time list.
virtual bool extract(std::size_t pos, UUID& val) = 0;
/// Extracts a UUID. Returns false if null was received.
virtual bool extract(std::size_t pos, std::vector<UUID>& val);
/// Extracts a UUID vector.
virtual bool extract(std::size_t pos, std::deque<UUID>& val);
/// Extracts a UUID deque.
virtual bool extract(std::size_t pos, std::list<UUID>& val);
/// Extracts a UUID list.
virtual bool extract(std::size_t pos, Any& val) = 0;
/// Extracts an Any. Returns false if null was received.

13
vendor/POCO/Data/include/Poco/Data/AbstractPreparator.h vendored
View File

@ -21,6 +21,7 @@
#include "Poco/Data/Data.h"
#include "Poco/RefCountedObject.h"
#include "Poco/Data/LOB.h"
#include "Poco/UUID.h"
#include "Poco/UTFString.h"
#include <vector>
#include <deque>
@ -310,6 +311,18 @@ public:
virtual void prepare(std::size_t pos, const std::list<Time>& val);
/// Prepares a Time list.
virtual void prepare(std::size_t pos, const UUID&) = 0;
/// Prepares a UUID.
virtual void prepare(std::size_t pos, const std::vector<UUID>& val);
/// Prepares a UUID vector.
virtual void prepare(std::size_t pos, const std::deque<UUID>& val);
/// Prepares a UUID deque.
virtual void prepare(std::size_t pos, const std::list<UUID>& val);
/// Prepares a UUID list.
virtual void prepare(std::size_t pos, const Any&) = 0;
/// Prepares an Any.

31
vendor/POCO/Data/include/Poco/Data/LOB.h vendored
View File

@ -130,7 +130,18 @@ public:
if (_pContent->empty())
return 0;
else
return &(*_pContent)[0];
return _pContent->data();
}
T* rawContent()
/// Returns the raw content.
///
/// If the LOB is empty, returns NULL.
{
if (_pContent->empty())
return 0;
else
return _pContent->data();
}
void assignVal(std::size_t count, const T& val)
@ -155,6 +166,18 @@ public:
_pContent->insert(_pContent->end(), pChar, pChar+count);
}
void reserve(std::size_t size)
/// Sets the capacity of the internal buffer.
{
_pContent->reserve(size);
}
void resize(std::size_t size)
/// Resizes the internal buffer.
{
_pContent->resize(size);
}
void clear(bool doCompact = false)
/// Clears the content of the blob.
/// If doCompact is true, trims the excess capacity.
@ -185,6 +208,12 @@ public:
return static_cast<std::size_t>(_pContent->size());
}
std::size_t capacity() const
/// Returns the capacity of the underlying buffer.
{
return static_cast<std::size_t>(_pContent->capacity());
}
private:
ContentPtr _pContent;
};

1
vendor/POCO/Data/include/Poco/Data/MetaColumn.h vendored
View File

@ -50,6 +50,7 @@ public:
FDT_DATE,
FDT_TIME,
FDT_TIMESTAMP,
FDT_UUID,
FDT_UNKNOWN
};

2
vendor/POCO/Data/include/Poco/Data/SQLChannel.h vendored
View File

@ -55,7 +55,7 @@ class Data_API SQLChannel: public Poco::Channel
/// To provide as non-intrusive operation as possbile, the log entries are cached and
/// inserted into the target database asynchronously by default. The blocking, however, will occur
/// before the next entry insertion with default timeout of 1 second. The default settings can be
/// overriden (see async, timeout and throw properties for details).
/// overridden (see async, timeout and throw properties for details).
/// If throw property is false, insertion timeouts are ignored, otherwise a TimeoutException is thrown.
/// To force insertion of every entry, set timeout to 0. This setting, however, introduces
/// a risk of long blocking periods in case of remote server communication delays.

84
vendor/POCO/Data/include/Poco/Data/StatementImpl.h vendored
View File

@ -70,19 +70,19 @@ public:
enum BulkType
{
BULK_UNDEFINED,
BULK_UNDEFINED,
/// Bulk mode not defined yet.
BULK_BINDING,
BULK_BINDING,
/// Binding in bulk mode.
/// If extraction is present in the same statement,
/// If extraction is present in the same statement,
/// it must also be bulk.
BULK_EXTRACTION,
BULK_EXTRACTION,
/// Extraction in bulk mode.
/// If binding is present in the same statement,
/// If binding is present in the same statement,
/// it must also be bulk.
BULK_FORBIDDEN
/// Bulk forbidden.
/// Happens when the statement has already been
BULK_FORBIDDEN
/// Bulk forbidden.
/// Happens when the statement has already been
/// configured as non-bulk.
};
@ -99,7 +99,7 @@ public:
virtual ~StatementImpl();
/// Destroys the StatementImpl.
template <typename T>
template <typename T>
void add(const T& t)
/// Appends SQL statement (fragments).
{
@ -117,15 +117,15 @@ public:
/// Registers objects used for extracting data with the StatementImpl.
void setExtractionLimit(const Limit& extrLimit);
/// Changes the extractionLimit to extrLimit.
/// Changes the extractionLimit to extrLimit.
/// Per default no limit (EXTRACT_UNLIMITED) is set.
std::string toString() const;
/// Create a string version of the SQL statement.
std::size_t execute(const bool& reset = true);
/// Executes a statement. Returns the number of rows
/// extracted for statements returning data or number of rows
/// Executes a statement. Returns the number of rows
/// extracted for statements returning data or number of rows
/// affected for all other statements (insert, update, delete).
/// If reset is true (default), the underlying bound storage is
/// reset and reused. In case of containers, this means they are
@ -154,15 +154,15 @@ public:
std::size_t dataSetCount() const;
/// Returns the number of data sets associated with the statement.
protected:
virtual std::size_t columnsReturned() const = 0;
/// Returns number of columns returned by query.
/// Returns number of columns returned by query.
virtual int affectedRowCount() const = 0;
/// Returns the number of affected rows.
/// Used to find out the number of rows affected by insert, delete or update.
///
///
/// Some back-ends may return a negative number in certain circumstances (e.g.
/// some ODBC drivers when this function is called after a select statement
/// execution).
@ -174,10 +174,10 @@ protected:
/// Returns column meta data.
virtual bool hasNext() = 0;
/// Returns true if a call to next() will return data.
/// Returns true if a call to next() will return data.
///
/// Note that the implementation must support
/// several consecutive calls to hasNext without data getting lost,
/// several consecutive calls to hasNext without data getting lost,
/// ie. hasNext(); hasNext(); next() must be equal to hasNext(); next();
virtual std::size_t next() = 0;
@ -232,8 +232,8 @@ protected:
/// Determines the type of the internal extraction container and
/// calls the extraction creation function (addInternalExtract)
/// with appropriate data type and container type arguments.
///
/// This function is only called in cases when there is data
///
/// This function is only called in cases when there is data
/// returned by query, but no data storage supplied by user.
///
/// The type of the internal container is determined in the
@ -273,24 +273,24 @@ protected:
/// Used as a help to determine whether to automatically create the
/// internal extractions when no outside extraction is supplied.
/// The reason for this function is to prevent unnecessary internal
/// extraction creation in cases (behavior exhibited by some ODBC drivers)
/// when there is data available from the stored procedure call
/// statement execution but no external extraction is supplied (as is
/// extraction creation in cases (behavior exhibited by some ODBC drivers)
/// when there is data available from the stored procedure call
/// statement execution but no external extraction is supplied (as is
/// usually the case when stored procedures are called). In such cases
/// no storage is needed because output parameters serve as storage.
/// At the Data framework level, this function always returns false.
/// When connector-specific behavior is desired, it should be overriden
/// When connector-specific behavior is desired, it should be overridden
/// by the statement implementation.
std::size_t currentDataSet() const;
/// Returns the current data set.
std::size_t activateNextDataSet();
/// Returns the next data set index, or throws NoDataException if the last
/// Returns the next data set index, or throws NoDataException if the last
/// data set was reached.
std::size_t activatePreviousDataSet();
/// Returns the previous data set index, or throws NoDataException if the last
/// Returns the previous data set index, or throws NoDataException if the last
/// data set was reached.
bool hasMoreDataSets() const;
@ -304,13 +304,13 @@ private:
/// Binds the statement, if not yet bound.
std::size_t executeWithLimit();
/// Executes with an upper limit set. Returns the number of rows
/// extracted for statements returning data or number of rows
/// Executes with an upper limit set. Returns the number of rows
/// extracted for statements returning data or number of rows
/// affected for all other statements (insert, update, delete).
std::size_t executeWithoutLimit();
/// Executes without an upper limit set. Returns the number of rows
/// extracted for statements returning data or number of rows
/// Executes without an upper limit set. Returns the number of rows
/// extracted for statements returning data or number of rows
/// affected for all other statements (insert, update, delete).
void resetExtraction();
@ -339,7 +339,7 @@ private:
void addInternalExtract(const MetaColumn& mc)
/// Creates and adds the internal extraction.
///
/// The decision about internal extraction container is done
/// The decision about internal extraction container is done
/// in a following way:
///
/// If this statement has _storage member set, that setting
@ -349,17 +349,17 @@ private:
/// type set, std::vector is the default container type used.
{
std::string storage;
switch (_storage)
{
case STORAGE_DEQUE_IMPL:
case STORAGE_DEQUE_IMPL:
storage = DEQUE; break;
case STORAGE_VECTOR_IMPL:
case STORAGE_VECTOR_IMPL:
storage = VECTOR; break;
case STORAGE_LIST_IMPL:
case STORAGE_LIST_IMPL:
storage = LIST; break;
case STORAGE_UNKNOWN_IMPL:
storage = AnyCast<std::string>(session().getProperty("storage"));
storage = AnyCast<std::string>(session().getProperty("storage"));
break;
}
@ -390,7 +390,7 @@ private:
bool isNull(std::size_t col, std::size_t row) const;
/// Returns true if the value in [col, row] is null.
void forbidBulk();
/// Forbids bulk operations.
@ -399,7 +399,7 @@ private:
void setBulkExtraction(const Bulk& l);
/// Sets the bulk extraction flag and extraction limit.
void resetBulk();
/// Resets the bulk extraction and binding flag.
@ -446,7 +446,7 @@ private:
BulkType _bulkExtraction;
CountVec _subTotalRowCount;
friend class Statement;
friend class Statement;
};
@ -538,13 +538,13 @@ inline bool StatementImpl::isStoredProcedure() const
inline bool StatementImpl::isNull(std::size_t col, std::size_t row) const
{
try
try
{
return extractions().at(col)->isNull(row);
}
catch (std::out_of_range& ex)
{
throw RangeException(ex.what());
{
throw RangeException(ex.what());
}
}
@ -605,7 +605,7 @@ inline bool StatementImpl::isBulkExtraction() const
return BULK_EXTRACTION == _bulkExtraction;
}
inline void StatementImpl::resetBulk()
{
_bulkExtraction = BULK_UNDEFINED;

342
vendor/POCO/Data/include/Poco/Data/TypeHandler.h vendored
View File

@ -34,7 +34,7 @@ namespace Data {
class AbstractTypeHandler
/// Parent class for type handlers.
/// Parent class for type handlers.
/// The reason for this class is to prevent instantiations of type handlers.
/// For documentation on type handlers, see TypeHandler class.
{
@ -59,12 +59,12 @@ class TypeHandler: public AbstractTypeHandler
/// int _age;
/// public:
/// const std::string& getLastName();
/// [...] // other set/get methods (returning const reference), a default constructor,
/// [...] // other set/get methods (returning const reference), a default constructor,
/// [...] // optional < operator (for set, multiset) or function operator (for map, multimap)
/// };
///
/// The TypeHandler must provide a custom bind, size, prepare and extract method:
///
///
/// template <>
/// class TypeHandler<struct Person>
/// {
@ -73,7 +73,7 @@ class TypeHandler: public AbstractTypeHandler
/// {
/// return 3; // lastName + firstname + age occupy three columns
/// }
///
///
/// 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))
@ -83,7 +83,7 @@ class TypeHandler: public AbstractTypeHandler
/// 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::Ptr pPreparator)
/// {
/// // the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
@ -92,7 +92,7 @@ class TypeHandler: public AbstractTypeHandler
/// 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::Ptr pExt)
/// {
/// // defVal is the default person we should use if we encunter NULL entries, so we take the individual fields
@ -249,52 +249,52 @@ private:
};
template <typename T>
class TypeHandler<Nullable<T>>
class TypeHandler<Nullable<T>>
/// Specialization of type handler for Nullable.
{
public:
static void bind(std::size_t pos, const Nullable<T>& obj, AbstractBinder::Ptr 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.isNull());
if (obj.isNull())
if (obj.isNull())
{
pBinder->bind(pos++, Poco::Data::Keywords::null, dir);
}
else
else
{
pBinder->bind(pos++, obj.value(), dir);
}
}
static void prepare(std::size_t pos, const Nullable<T>& obj, AbstractPreparator::Ptr pPreparator)
static void prepare(std::size_t pos, const Nullable<T>& obj, AbstractPreparator::Ptr pPreparator)
{
poco_assert_dbg (!pPreparator.isNull());
if (obj.isNull())
if (obj.isNull())
{
pPreparator->prepare(pos++, Poco::Data::Keywords::null);
pPreparator->prepare(pos++, T());
}
else
else
{
pPreparator->prepare(pos++, obj.value());
}
}
static std::size_t size()
static std::size_t size()
{
return 1u;
}
static void extract(std::size_t pos, Nullable<T>& obj, const Nullable<T>& , AbstractExtractor::Ptr pExt)
static void extract(std::size_t pos, Nullable<T>& obj, const Nullable<T>& , AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (!pExt.isNull());
T val;
if (pExt->extract(pos++, val))
if (pExt->extract(pos++, val))
{
obj = val;
obj = std::move(val);
}
else
else
{
obj.clear();
}
@ -343,25 +343,25 @@ void tupleExtract(std::size_t& pos, TupleType tuple, DefValType defVal, Abstract
}
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17,
class T18,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17,
class T18,
class T19>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>
{
@ -474,24 +474,24 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17,
class T18>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>
{
@ -600,23 +600,23 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>
{
@ -721,22 +721,22 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>
{
@ -837,21 +837,21 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>
{
@ -948,20 +948,20 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>
{
@ -1054,19 +1054,19 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>
{
@ -1155,18 +1155,18 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>
{
@ -1251,17 +1251,17 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>
{
@ -1342,16 +1342,16 @@ private:
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>
{
@ -1956,7 +1956,7 @@ public:
return TypeHandler<T0>::size();
}
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal,
static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal,
AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (!pExt.isNull());
@ -2013,7 +2013,7 @@ public:
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);
TypeHandler<T>::bind(pos, *obj, pBinder, dir);
}
static std::size_t size()
@ -2024,7 +2024,7 @@ public:
static void extract(std::size_t pos, Poco::AutoPtr<T>& obj, const Poco::AutoPtr<T>& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (!pExt.isNull());
obj = Poco::AutoPtr<T>(new T());
if (defVal)
TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
@ -2053,7 +2053,7 @@ public:
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);
TypeHandler<T>::bind(pos, *obj, pBinder, dir);
}
static std::size_t size()
@ -2064,7 +2064,7 @@ public:
static void extract(std::size_t pos, Poco::SharedPtr<T>& obj, const Poco::SharedPtr<T>& defVal, AbstractExtractor::Ptr pExt)
{
poco_assert_dbg (!pExt.isNull());
obj = Poco::SharedPtr<T>(new T());
if (defVal)
TypeHandler<T>::extract(pos, *obj, *defVal, pExt);