generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-26 18:42:41 +01:00
Code Issues Projects Releases Wiki Activity

SF [2150438] Tuple TypeHandler position increment size is wrong

Browse Source
This commit is contained in:
Aleksandar Fabijanic
2009-11-02 02:17:58 +00:00
parent 05131182b8
commit ffd027c38a
6 changed files with 2236 additions and 2203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
Data/ODBC/include/Poco/Data/ODBC/Preparator.h
View File

@@ -126,162 +126,162 @@ public:
~Preparator(); ~Preparator();
/// Destroys the Preparator. /// Destroys the Preparator.
void prepare(std::size_t pos, Poco::Int8& val); void prepare(std::size_t pos, const Poco::Int8& val);
/// Prepares an Int8. /// Prepares an Int8.
void prepare(std::size_t pos, std::vector<Poco::Int8>& val); void prepare(std::size_t pos, const std::vector<Poco::Int8>& val);
/// Prepares an Int8 vector. /// Prepares an Int8 vector.
void prepare(std::size_t pos, std::deque<Poco::Int8>& val); void prepare(std::size_t pos, const std::deque<Poco::Int8>& val);
/// Prepares an Int8 deque. /// Prepares an Int8 deque.
void prepare(std::size_t pos, std::list<Poco::Int8>& val); void prepare(std::size_t pos, const std::list<Poco::Int8>& val);
/// Prepares an Int8 list. /// Prepares an Int8 list.
void prepare(std::size_t pos, Poco::UInt8& val); void prepare(std::size_t pos, const Poco::UInt8& val);
/// Prepares an UInt8. /// Prepares an UInt8.
void prepare(std::size_t pos, std::vector<Poco::UInt8>& val); void prepare(std::size_t pos, const std::vector<Poco::UInt8>& val);
/// Prepares an UInt8 vector. /// Prepares an UInt8 vector.
void prepare(std::size_t pos, std::deque<Poco::UInt8>& val); void prepare(std::size_t pos, const std::deque<Poco::UInt8>& val);
/// Prepares an UInt8 deque. /// Prepares an UInt8 deque.
void prepare(std::size_t pos, std::list<Poco::UInt8>& val); void prepare(std::size_t pos, const std::list<Poco::UInt8>& val);
/// Prepares an UInt8 list. /// Prepares an UInt8 list.
void prepare(std::size_t pos, Poco::Int16& val); void prepare(std::size_t pos, const Poco::Int16& val);
/// Prepares an Int16. /// Prepares an Int16.
void prepare(std::size_t pos, std::vector<Poco::Int16>& val); void prepare(std::size_t pos, const std::vector<Poco::Int16>& val);
/// Prepares an Int16 vector. /// Prepares an Int16 vector.
void prepare(std::size_t pos, std::deque<Poco::Int16>& val); void prepare(std::size_t pos, const std::deque<Poco::Int16>& val);
/// Prepares an Int16 deque. /// Prepares an Int16 deque.
void prepare(std::size_t pos, std::list<Poco::Int16>& val); void prepare(std::size_t pos, const std::list<Poco::Int16>& val);
/// Prepares an Int16 list. /// Prepares an Int16 list.
void prepare(std::size_t pos, Poco::UInt16& val); void prepare(std::size_t pos, const Poco::UInt16& val);
/// Prepares an UInt16. /// Prepares an UInt16.
void prepare(std::size_t pos, std::vector<Poco::UInt16>& val); void prepare(std::size_t pos, const std::vector<Poco::UInt16>& val);
/// Prepares an UInt16 vector. /// Prepares an UInt16 vector.
void prepare(std::size_t pos, std::deque<Poco::UInt16>& val); void prepare(std::size_t pos, const std::deque<Poco::UInt16>& val);
/// Prepares an UInt16 deque. /// Prepares an UInt16 deque.
void prepare(std::size_t pos, std::list<Poco::UInt16>& val); void prepare(std::size_t pos, const std::list<Poco::UInt16>& val);
/// Prepares an UInt16 list. /// Prepares an UInt16 list.
void prepare(std::size_t pos, Poco::Int32& val); void prepare(std::size_t pos, const Poco::Int32& val);
/// Prepares an Int32. /// Prepares an Int32.
void prepare(std::size_t pos, std::vector<Poco::Int32>& val); void prepare(std::size_t pos, const std::vector<Poco::Int32>& val);
/// Prepares an Int32 vector. /// Prepares an Int32 vector.
void prepare(std::size_t pos, std::deque<Poco::Int32>& val); void prepare(std::size_t pos, const std::deque<Poco::Int32>& val);
/// Prepares an Int32 deque. /// Prepares an Int32 deque.
void prepare(std::size_t pos, std::list<Poco::Int32>& val); void prepare(std::size_t pos, const std::list<Poco::Int32>& val);
/// Prepares an Int32 list. /// Prepares an Int32 list.
void prepare(std::size_t pos, Poco::UInt32& val); void prepare(std::size_t pos, const Poco::UInt32& val);
/// Prepares an UInt32. /// Prepares an UInt32.
void prepare(std::size_t pos, std::vector<Poco::UInt32>& val); void prepare(std::size_t pos, const std::vector<Poco::UInt32>& val);
/// Prepares an UInt32 vector. /// Prepares an UInt32 vector.
void prepare(std::size_t pos, std::deque<Poco::UInt32>& val); void prepare(std::size_t pos, const std::deque<Poco::UInt32>& val);
/// Prepares an UInt32 deque. /// Prepares an UInt32 deque.
void prepare(std::size_t pos, std::list<Poco::UInt32>& val); void prepare(std::size_t pos, const std::list<Poco::UInt32>& val);
/// Prepares an UInt32 list. /// Prepares an UInt32 list.
void prepare(std::size_t pos, Poco::Int64& val); void prepare(std::size_t pos, const Poco::Int64& val);
/// Prepares an Int64. /// Prepares an Int64.
void prepare(std::size_t pos, std::vector<Poco::Int64>& val); void prepare(std::size_t pos, const std::vector<Poco::Int64>& val);
/// Prepares an Int64 vector. /// Prepares an Int64 vector.
void prepare(std::size_t pos, std::deque<Poco::Int64>& val); void prepare(std::size_t pos, const std::deque<Poco::Int64>& val);
/// Prepares an Int64 deque. /// Prepares an Int64 deque.
void prepare(std::size_t pos, std::list<Poco::Int64>& val); void prepare(std::size_t pos, const std::list<Poco::Int64>& val);
/// Prepares an Int64 list. /// Prepares an Int64 list.
void prepare(std::size_t pos, Poco::UInt64& val); void prepare(std::size_t pos, const Poco::UInt64& val);
/// Prepares an UInt64. /// Prepares an UInt64.
void prepare(std::size_t pos, std::vector<Poco::UInt64>& val); void prepare(std::size_t pos, const std::vector<Poco::UInt64>& val);
/// Prepares an UInt64 vector. /// Prepares an UInt64 vector.
void prepare(std::size_t pos, std::deque<Poco::UInt64>& val); void prepare(std::size_t pos, const std::deque<Poco::UInt64>& val);
/// Prepares an UInt64 deque. /// Prepares an UInt64 deque.
void prepare(std::size_t pos, std::list<Poco::UInt64>& val); void prepare(std::size_t pos, const std::list<Poco::UInt64>& val);
/// Prepares an UInt64 list. /// Prepares an UInt64 list.
#ifndef POCO_LONG_IS_64_BIT #ifndef POCO_LONG_IS_64_BIT
void prepare(std::size_t pos, long& val); void prepare(std::size_t pos, const long& val);
/// Prepares a long. /// Prepares a long.
void prepare(std::size_t pos, std::vector<long>& val); void prepare(std::size_t pos, const std::vector<long>& val);
/// Prepares a long vector. /// Prepares a long vector.
void prepare(std::size_t pos, std::deque<long>& val); void prepare(std::size_t pos, const std::deque<long>& val);
/// Prepares a long deque. /// Prepares a long deque.
void prepare(std::size_t pos, std::list<long>& val); void prepare(std::size_t pos, const std::list<long>& val);
/// Prepares a long list. /// Prepares a long list.
#endif #endif
void prepare(std::size_t pos, bool& val); void prepare(std::size_t pos, const bool& val);
/// Prepares a boolean. /// Prepares a boolean.
void prepare(std::size_t pos, std::vector<bool>& val); void prepare(std::size_t pos, const std::vector<bool>& val);
/// Prepares a boolean vector. /// Prepares a boolean vector.
void prepare(std::size_t pos, std::deque<bool>& val); void prepare(std::size_t pos, const std::deque<bool>& val);
/// Prepares a boolean deque. /// Prepares a boolean deque.
void prepare(std::size_t pos, std::list<bool>& val); void prepare(std::size_t pos, const std::list<bool>& val);
/// Prepares a boolean list. /// Prepares a boolean list.
void prepare(std::size_t pos, float& val); void prepare(std::size_t pos, const float& val);
/// Prepares a float. /// Prepares a float.
void prepare(std::size_t pos, std::vector<float>& val); void prepare(std::size_t pos, const std::vector<float>& val);
/// Prepares a float vector. /// Prepares a float vector.
void prepare(std::size_t pos, std::deque<float>& val); void prepare(std::size_t pos, const std::deque<float>& val);
/// Prepares a float deque. /// Prepares a float deque.
void prepare(std::size_t pos, std::list<float>& val); void prepare(std::size_t pos, const std::list<float>& val);
/// Prepares a float list. /// Prepares a float list.
void prepare(std::size_t pos, double& val); void prepare(std::size_t pos, const double& val);
/// Prepares a double. /// Prepares a double.
void prepare(std::size_t pos, std::vector<double>& val); void prepare(std::size_t pos, const std::vector<double>& val);
/// Prepares a double vector. /// Prepares a double vector.
void prepare(std::size_t pos, std::deque<double>& val); void prepare(std::size_t pos, const std::deque<double>& val);
/// Prepares a double deque. /// Prepares a double deque.
void prepare(std::size_t pos, std::list<double>& val); void prepare(std::size_t pos, const std::list<double>& val);
/// Prepares a double list. /// Prepares a double list.
void prepare(std::size_t pos, char& val); void prepare(std::size_t pos, const char& val);
/// Prepares a single character. /// Prepares a single character.
void prepare(std::size_t pos, std::vector<char>& val); void prepare(std::size_t pos, const std::vector<char>& val);
/// Prepares a single character vector. /// Prepares a single character vector.
void prepare(std::size_t pos, std::deque<char>& val); void prepare(std::size_t pos, const std::deque<char>& val);
/// Prepares a single character deque. /// Prepares a single character deque.
void prepare(std::size_t pos, std::list<char>& val); void prepare(std::size_t pos, const std::list<char>& val);
/// Prepares a single character list. /// Prepares a single character list.
void prepare(std::size_t pos, const std::string& val); void prepare(std::size_t pos, const std::string& val);
@@ -676,315 +676,315 @@ private:
// //
// inlines // inlines
// //
inline void Preparator::prepare(std::size_t pos, Poco::Int8&) inline void Preparator::prepare(std::size_t pos, const Poco::Int8&)
{ {
prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT); prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::Int8>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int8>& val)
{ {
prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size()); prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::Int8>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int8>& val)
{ {
prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size()); prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::Int8>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int8>& val)
{ {
prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size()); prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::UInt8&) inline void Preparator::prepare(std::size_t pos, const Poco::UInt8&)
{ {
prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT); prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::UInt8>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt8>& val)
{ {
prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size()); prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::UInt8>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt8>& val)
{ {
prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size()); prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::UInt8>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt8>& val)
{ {
prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size()); prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::Int16&) inline void Preparator::prepare(std::size_t pos, const Poco::Int16&)
{ {
prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT); prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::Int16>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int16>& val)
{ {
prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size()); prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::Int16>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int16>& val)
{ {
prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size()); prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::Int16>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int16>& val)
{ {
prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size()); prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::UInt16&) inline void Preparator::prepare(std::size_t pos, const Poco::UInt16&)
{ {
prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT); prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::UInt16>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt16>& val)
{ {
prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size()); prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::UInt16>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt16>& val)
{ {
prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size()); prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::UInt16>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt16>& val)
{ {
prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size()); prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::Int32&) inline void Preparator::prepare(std::size_t pos, const Poco::Int32&)
{ {
prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG); prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::Int32>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int32>& val)
{ {
prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size()); prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::Int32>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int32>& val)
{ {
prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size()); prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::Int32>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int32>& val)
{ {
prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size()); prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::UInt32&) inline void Preparator::prepare(std::size_t pos, const Poco::UInt32&)
{ {
prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG); prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::UInt32>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt32>& val)
{ {
prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size()); prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::UInt32>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt32>& val)
{ {
prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size()); prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::UInt32>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt32>& val)
{ {
prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size()); prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::Int64&) inline void Preparator::prepare(std::size_t pos, const Poco::Int64&)
{ {
prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT); prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::Int64>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int64>& val)
{ {
prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size()); prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::Int64>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int64>& val)
{ {
prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size()); prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::Int64>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int64>& val)
{ {
prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size()); prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, Poco::UInt64&) inline void Preparator::prepare(std::size_t pos, const Poco::UInt64&)
{ {
prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT); prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<Poco::UInt64>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt64>& val)
{ {
prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size()); prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<Poco::UInt64>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt64>& val)
{ {
prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size()); prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<Poco::UInt64>& val) inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt64>& val)
{ {
prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size()); prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
} }
#ifndef POCO_LONG_IS_64_BIT #ifndef POCO_LONG_IS_64_BIT
inline void Preparator::prepare(std::size_t pos, long&) inline void Preparator::prepare(std::size_t pos, const long&)
{ {
prepareFixedSize<long>(pos, SQL_C_SLONG); prepareFixedSize<long>(pos, SQL_C_SLONG);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<long>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<long>& val)
{ {
prepareFixedSize<long>(pos, SQL_C_SLONG, val.size()); prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<long>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<long>& val)
{ {
prepareFixedSize<long>(pos, SQL_C_SLONG, val.size()); prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<long>& val) inline void Preparator::prepare(std::size_t pos, const std::list<long>& val)
{ {
prepareFixedSize<long>(pos, SQL_C_SLONG, val.size()); prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
} }
#endif #endif
inline void Preparator::prepare(std::size_t pos, bool&) inline void Preparator::prepare(std::size_t pos, const bool&)
{ {
prepareFixedSize<bool>(pos, SQL_C_BIT); prepareFixedSize<bool>(pos, SQL_C_BIT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<bool>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<bool>& val)
{ {
prepareBoolArray(pos, SQL_C_BIT, val.size()); prepareBoolArray(pos, SQL_C_BIT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<bool>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<bool>& val)
{ {
prepareBoolArray(pos, SQL_C_BIT, val.size()); prepareBoolArray(pos, SQL_C_BIT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<bool>& val) inline void Preparator::prepare(std::size_t pos, const std::list<bool>& val)
{ {
prepareBoolArray(pos, SQL_C_BIT, val.size()); prepareBoolArray(pos, SQL_C_BIT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, float&) inline void Preparator::prepare(std::size_t pos, const float&)
{ {
prepareFixedSize<float>(pos, SQL_C_FLOAT); prepareFixedSize<float>(pos, SQL_C_FLOAT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<float>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<float>& val)
{ {
prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size()); prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<float>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<float>& val)
{ {
prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size()); prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<float>& val) inline void Preparator::prepare(std::size_t pos, const std::list<float>& val)
{ {
prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size()); prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, double&) inline void Preparator::prepare(std::size_t pos, const double&)
{ {
prepareFixedSize<double>(pos, SQL_C_DOUBLE); prepareFixedSize<double>(pos, SQL_C_DOUBLE);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<double>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<double>& val)
{ {
prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size()); prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<double>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<double>& val)
{ {
prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size()); prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<double>& val) inline void Preparator::prepare(std::size_t pos, const std::list<double>& val)
{ {
prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size()); prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
} }
inline void Preparator::prepare(std::size_t pos, char&) inline void Preparator::prepare(std::size_t pos, const char&)
{ {
prepareFixedSize<char>(pos, SQL_C_STINYINT); prepareFixedSize<char>(pos, SQL_C_STINYINT);
} }
inline void Preparator::prepare(std::size_t pos, std::vector<char>& val) inline void Preparator::prepare(std::size_t pos, const std::vector<char>& val)
{ {
prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size()); prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::deque<char>& val) inline void Preparator::prepare(std::size_t pos, const std::deque<char>& val)
{ {
prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size()); prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
} }
inline void Preparator::prepare(std::size_t pos, std::list<char>& val) inline void Preparator::prepare(std::size_t pos, const std::list<char>& val)
{ {
prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size()); prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
} }

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

@@ -68,13 +68,14 @@ class Time;
class Data_API AbstractPreparator: public Poco::RefCountedObject class Data_API AbstractPreparator: public Poco::RefCountedObject
/// Interface used for database preparation where we first have to register all data types (and memory output locations) /// Interface used for database preparation where we first have to register all data types
/// before extracting data, i.e. extract works as two-pase extract: first we call prepare once, then extract n-times. /// (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.
/// There are cases (bulk operations using std::vector storage) when extract is called only once. /// There are cases (bulk operations using std::vector storage) when extract is called only once.
/// The value passed to a prepare() call is not be used by the prepare, serving only as an indication of the data type /// The value passed to a prepare() call is not used by the prepare, serving only as an indication
/// being prepared. /// of the data type being prepared, thus all values are passed as const references.
/// Implementing this interface is not mandatory for a connector. Connectors that only extract data after SQL execution /// Implementing this interface is not mandatory for a connector. Connectors that only extract data
/// (e.g. SQLite) do not need this functionality at all. /// after SQL execution (e.g. SQLite) do not need this functionality at all.
{ {
public: public:
AbstractPreparator(Poco::UInt32 length = 1u); AbstractPreparator(Poco::UInt32 length = 1u);
@@ -83,259 +84,259 @@ public:
virtual ~AbstractPreparator(); virtual ~AbstractPreparator();
/// Destroys the AbstractPreparator. /// Destroys the AbstractPreparator.
virtual void prepare(std::size_t pos, Poco::Int8&) = 0; virtual void prepare(std::size_t pos, const Poco::Int8&) = 0;
/// Preparations an Int8. /// Prepares an Int8.
virtual void prepare(std::size_t pos, std::vector<Poco::Int8>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::Int8>& val);
/// Preparations an Int8 vector. /// Prepares an Int8 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::Int8>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::Int8>& val);
/// Preparations an Int8 deque. /// Prepares an Int8 deque.
virtual void prepare(std::size_t pos, std::list<Poco::Int8>& val); virtual void prepare(std::size_t pos, const std::list<Poco::Int8>& val);
/// Preparations an Int8 list. /// Prepares an Int8 list.
virtual void prepare(std::size_t pos, Poco::UInt8&) = 0; virtual void prepare(std::size_t pos, const Poco::UInt8&) = 0;
/// Preparations an UInt8. /// Prepares an UInt8.
virtual void prepare(std::size_t pos, std::vector<Poco::UInt8>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::UInt8>& val);
/// Preparations an UInt8 vector. /// Prepares an UInt8 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::UInt8>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::UInt8>& val);
/// Preparations an UInt8 deque. /// Prepares an UInt8 deque.
virtual void prepare(std::size_t pos, std::list<Poco::UInt8>& val); virtual void prepare(std::size_t pos, const std::list<Poco::UInt8>& val);
/// Preparations an UInt8 list. /// Prepares an UInt8 list.
virtual void prepare(std::size_t pos, Poco::Int16&) = 0; virtual void prepare(std::size_t pos, const Poco::Int16&) = 0;
/// Preparations an Int16. /// Prepares an Int16.
virtual void prepare(std::size_t pos, std::vector<Poco::Int16>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::Int16>& val);
/// Preparations an Int16 vector. /// Prepares an Int16 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::Int16>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::Int16>& val);
/// Preparations an Int16 deque. /// Prepares an Int16 deque.
virtual void prepare(std::size_t pos, std::list<Poco::Int16>& val); virtual void prepare(std::size_t pos, const std::list<Poco::Int16>& val);
/// Preparations an Int16 list. /// Prepares an Int16 list.
virtual void prepare(std::size_t pos, Poco::UInt16&) = 0; virtual void prepare(std::size_t pos, const Poco::UInt16&) = 0;
/// Preparations an UInt16. /// Prepares an UInt16.
virtual void prepare(std::size_t pos, std::vector<Poco::UInt16>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::UInt16>& val);
/// Preparations an UInt16 vector. /// Prepares an UInt16 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::UInt16>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::UInt16>& val);
/// Preparations an UInt16 deque. /// Prepares an UInt16 deque.
virtual void prepare(std::size_t pos, std::list<Poco::UInt16>& val); virtual void prepare(std::size_t pos, const std::list<Poco::UInt16>& val);
/// Preparations an UInt16 list. /// Prepares an UInt16 list.
virtual void prepare(std::size_t pos, Poco::Int32&) = 0; virtual void prepare(std::size_t pos, const Poco::Int32&) = 0;
/// Preparations an Int32. /// Prepares an Int32.
virtual void prepare(std::size_t pos, std::vector<Poco::Int32>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::Int32>& val);
/// Preparations an Int32 vector. /// Prepares an Int32 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::Int32>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::Int32>& val);
/// Preparations an Int32 deque. /// Prepares an Int32 deque.
virtual void prepare(std::size_t pos, std::list<Poco::Int32>& val); virtual void prepare(std::size_t pos, const std::list<Poco::Int32>& val);
/// Preparations an Int32 list. /// Prepares an Int32 list.
virtual void prepare(std::size_t pos, Poco::UInt32&) = 0; virtual void prepare(std::size_t pos, const Poco::UInt32&) = 0;
/// Preparations an UInt32. /// Prepares an UInt32.
virtual void prepare(std::size_t pos, std::vector<Poco::UInt32>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::UInt32>& val);
/// Preparations an UInt32 vector. /// Prepares an UInt32 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::UInt32>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::UInt32>& val);
/// Preparations an UInt32 deque. /// Prepares an UInt32 deque.
virtual void prepare(std::size_t pos, std::list<Poco::UInt32>& val); virtual void prepare(std::size_t pos, const std::list<Poco::UInt32>& val);
/// Preparations an UInt32 list. /// Prepares an UInt32 list.
virtual void prepare(std::size_t pos, Poco::Int64&) = 0; virtual void prepare(std::size_t pos, const Poco::Int64&) = 0;
/// Preparations an Int64. /// Prepares an Int64.
virtual void prepare(std::size_t pos, std::vector<Poco::Int64>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::Int64>& val);
/// Preparations an Int64 vector. /// Prepares an Int64 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::Int64>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::Int64>& val);
/// Preparations an Int64 deque. /// Prepares an Int64 deque.
virtual void prepare(std::size_t pos, std::list<Poco::Int64>& val); virtual void prepare(std::size_t pos, const std::list<Poco::Int64>& val);
/// Preparations an Int64 list. /// Prepares an Int64 list.
virtual void prepare(std::size_t pos, Poco::UInt64&) = 0; virtual void prepare(std::size_t pos, const Poco::UInt64&) = 0;
/// Preparations an UInt64. /// Prepares an UInt64.
virtual void prepare(std::size_t pos, std::vector<Poco::UInt64>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::UInt64>& val);
/// Preparations an UInt64 vector. /// Prepares an UInt64 vector.
virtual void prepare(std::size_t pos, std::deque<Poco::UInt64>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::UInt64>& val);
/// Preparations an UInt64 deque. /// Prepares an UInt64 deque.
virtual void prepare(std::size_t pos, std::list<Poco::UInt64>& val); virtual void prepare(std::size_t pos, const std::list<Poco::UInt64>& val);
/// Preparations an UInt64 list. /// Prepares an UInt64 list.
#ifndef POCO_LONG_IS_64_BIT #ifndef POCO_LONG_IS_64_BIT
virtual void prepare(std::size_t pos, long&) = 0; virtual void prepare(std::size_t pos, const long&) = 0;
/// Preparations a long. /// Prepares a long.
virtual void prepare(std::size_t pos, std::vector<long>& val); virtual void prepare(std::size_t pos, const std::vector<long>& val);
/// Preparations a long vector. /// Prepares a long vector.
virtual void prepare(std::size_t pos, std::deque<long>& val); virtual void prepare(std::size_t pos, const std::deque<long>& val);
/// Preparations a long deque. /// Prepares a long deque.
virtual void prepare(std::size_t pos, std::list<long>& val); virtual void prepare(std::size_t pos, const std::list<long>& val);
/// Preparations a long list. /// Prepares a long list.
#endif #endif
virtual void prepare(std::size_t pos, bool&) = 0; virtual void prepare(std::size_t pos, const bool&) = 0;
/// Preparations a boolean. /// Prepares a boolean.
virtual void prepare(std::size_t pos, std::vector<bool>& val); virtual void prepare(std::size_t pos, const std::vector<bool>& val);
/// Preparations a boolean vector. /// Prepares a boolean vector.
virtual void prepare(std::size_t pos, std::deque<bool>& val); virtual void prepare(std::size_t pos, const std::deque<bool>& val);
/// Preparations a boolean deque. /// Prepares a boolean deque.
virtual void prepare(std::size_t pos, std::list<bool>& val); virtual void prepare(std::size_t pos, const std::list<bool>& val);
/// Preparations a boolean list. /// Prepares a boolean list.
virtual void prepare(std::size_t pos, float&) = 0; virtual void prepare(std::size_t pos, const float&) = 0;
/// Preparations a float. /// Prepares a float.
virtual void prepare(std::size_t pos, std::vector<float>& val); virtual void prepare(std::size_t pos, const std::vector<float>& val);
/// Preparations a float vector. /// Prepares a float vector.
virtual void prepare(std::size_t pos, std::deque<float>& val); virtual void prepare(std::size_t pos, const std::deque<float>& val);
/// Preparations a float deque. /// Prepares a float deque.
virtual void prepare(std::size_t pos, std::list<float>& val); virtual void prepare(std::size_t pos, const std::list<float>& val);
/// Preparations a float list. /// Prepares a float list.
virtual void prepare(std::size_t pos, double&) = 0; virtual void prepare(std::size_t pos, const double&) = 0;
/// Preparations a double. /// Prepares a double.
virtual void prepare(std::size_t pos, std::vector<double>& val); virtual void prepare(std::size_t pos, const std::vector<double>& val);
/// Preparations a double vector. /// Prepares a double vector.
virtual void prepare(std::size_t pos, std::deque<double>& val); virtual void prepare(std::size_t pos, const std::deque<double>& val);
/// Preparations a double deque. /// Prepares a double deque.
virtual void prepare(std::size_t pos, std::list<double>& val); virtual void prepare(std::size_t pos, const std::list<double>& val);
/// Preparations a double list. /// Prepares a double list.
virtual void prepare(std::size_t pos, char&) = 0; virtual void prepare(std::size_t pos, const char&) = 0;
/// Preparations a single character. /// Prepares a single character.
virtual void prepare(std::size_t pos, std::vector<char>& val); virtual void prepare(std::size_t pos, const std::vector<char>& val);
/// Preparations a character vector. /// Prepares a character vector.
virtual void prepare(std::size_t pos, std::deque<char>& val); virtual void prepare(std::size_t pos, const std::deque<char>& val);
/// Preparations a character deque. /// Prepares a character deque.
virtual void prepare(std::size_t pos, std::list<char>& val); virtual void prepare(std::size_t pos, const std::list<char>& val);
/// Preparations a character list. /// Prepares a character list.
virtual void prepare(std::size_t pos, const std::string&) = 0; virtual void prepare(std::size_t pos, const std::string&) = 0;
/// Preparations a string. /// Prepares a string.
virtual void prepare(std::size_t pos, const std::vector<std::string>& val); virtual void prepare(std::size_t pos, const std::vector<std::string>& val);
/// Preparations a string vector. /// Prepares a string vector.
virtual void prepare(std::size_t pos, const std::deque<std::string>& val); virtual void prepare(std::size_t pos, const std::deque<std::string>& val);
/// Preparations a string deque. /// Prepares a string deque.
virtual void prepare(std::size_t pos, const std::list<std::string>& val); virtual void prepare(std::size_t pos, const std::list<std::string>& val);
/// Preparations a string list. /// Prepares a string list.
virtual void prepare(std::size_t pos, const BLOB&) = 0; virtual void prepare(std::size_t pos, const BLOB&) = 0;
/// Preparations a BLOB. /// Prepares a BLOB.
virtual void prepare(std::size_t pos, const CLOB&) = 0; virtual void prepare(std::size_t pos, const CLOB&) = 0;
/// Preparations a CLOB. /// Prepares a CLOB.
virtual void prepare(std::size_t pos, const std::vector<BLOB>& val); virtual void prepare(std::size_t pos, const std::vector<BLOB>& val);
/// Preparations a BLOB vector. /// Prepares a BLOB vector.
virtual void prepare(std::size_t pos, const std::deque<BLOB>& val); virtual void prepare(std::size_t pos, const std::deque<BLOB>& val);
/// Preparations a BLOB deque. /// Prepares a BLOB deque.
virtual void prepare(std::size_t pos, const std::list<BLOB>& val); virtual void prepare(std::size_t pos, const std::list<BLOB>& val);
/// Preparations a BLOB list. /// Prepares a BLOB list.
virtual void prepare(std::size_t pos, const std::vector<CLOB>& val); virtual void prepare(std::size_t pos, const std::vector<CLOB>& val);
/// Preparations a CLOB vector. /// Prepares a CLOB vector.
virtual void prepare(std::size_t pos, const std::deque<CLOB>& val); virtual void prepare(std::size_t pos, const std::deque<CLOB>& val);
/// Preparations a CLOB deque. /// Prepares a CLOB deque.
virtual void prepare(std::size_t pos, const std::list<CLOB>& val); virtual void prepare(std::size_t pos, const std::list<CLOB>& val);
/// Preparations a CLOB list. /// Prepares a CLOB list.
virtual void prepare(std::size_t pos, const DateTime&) = 0; virtual void prepare(std::size_t pos, const DateTime&) = 0;
/// Preparations a DateTime. /// Prepares a DateTime.
virtual void prepare(std::size_t pos, const std::vector<DateTime>& val); virtual void prepare(std::size_t pos, const std::vector<DateTime>& val);
/// Preparations a DateTime vector. /// Prepares a DateTime vector.
virtual void prepare(std::size_t pos, const std::deque<DateTime>& val); virtual void prepare(std::size_t pos, const std::deque<DateTime>& val);
/// Preparations a DateTime deque. /// Prepares a DateTime deque.
virtual void prepare(std::size_t pos, const std::list<DateTime>& val); virtual void prepare(std::size_t pos, const std::list<DateTime>& val);
/// Preparations a DateTime list. /// Prepares a DateTime list.
virtual void prepare(std::size_t pos, const Date&) = 0; virtual void prepare(std::size_t pos, const Date&) = 0;
/// Preparations a Date. /// Prepares a Date.
virtual void prepare(std::size_t pos, const std::vector<Date>& val); virtual void prepare(std::size_t pos, const std::vector<Date>& val);
/// Preparations a Date vector. /// Prepares a Date vector.
virtual void prepare(std::size_t pos, const std::deque<Date>& val); virtual void prepare(std::size_t pos, const std::deque<Date>& val);
/// Preparations a Date deque. /// Prepares a Date deque.
virtual void prepare(std::size_t pos, const std::list<Date>& val); virtual void prepare(std::size_t pos, const std::list<Date>& val);
/// Preparations a Date list. /// Prepares a Date list.
virtual void prepare(std::size_t pos, const Time&) = 0; virtual void prepare(std::size_t pos, const Time&) = 0;
/// Preparations a Time. /// Prepares a Time.
virtual void prepare(std::size_t pos, const std::vector<Time>& val); virtual void prepare(std::size_t pos, const std::vector<Time>& val);
/// Preparations a Time vector. /// Prepares a Time vector.
virtual void prepare(std::size_t pos, const std::deque<Time>& val); virtual void prepare(std::size_t pos, const std::deque<Time>& val);
/// Preparations a Time deque. /// Prepares a Time deque.
virtual void prepare(std::size_t pos, const std::list<Time>& val); virtual void prepare(std::size_t pos, const std::list<Time>& val);
/// Preparations a Time list. /// Prepares a Time list.
virtual void prepare(std::size_t pos, const Any&) = 0; virtual void prepare(std::size_t pos, const Any&) = 0;
/// Preparations an Any. /// Prepares an Any.
virtual void prepare(std::size_t pos, const std::vector<Any>& val); virtual void prepare(std::size_t pos, const std::vector<Any>& val);
/// Preparations an Any vector. /// Prepares an Any vector.
virtual void prepare(std::size_t pos, const std::deque<Any>& val); virtual void prepare(std::size_t pos, const std::deque<Any>& val);
/// Preparations an Any deque. /// Prepares an Any deque.
virtual void prepare(std::size_t pos, const std::list<Any>& val); virtual void prepare(std::size_t pos, const std::list<Any>& val);
/// Preparations an Any list. /// Prepares an Any list.
virtual void prepare(std::size_t pos, const Poco::Dynamic::Var&) = 0; virtual void prepare(std::size_t pos, const Poco::Dynamic::Var&) = 0;
/// Preparations a Var. /// Prepares a Var.
virtual void prepare(std::size_t pos, const std::vector<Poco::Dynamic::Var>& val); virtual void prepare(std::size_t pos, const std::vector<Poco::Dynamic::Var>& val);
/// Preparations a Var vector. /// Prepares a Var vector.
virtual void prepare(std::size_t pos, const std::deque<Poco::Dynamic::Var>& val); virtual void prepare(std::size_t pos, const std::deque<Poco::Dynamic::Var>& val);
/// Preparations a Var deque. /// Prepares a Var deque.
virtual void prepare(std::size_t pos, const std::list<Poco::Dynamic::Var>& val); virtual void prepare(std::size_t pos, const std::list<Poco::Dynamic::Var>& val);
/// Preparations a Var list. /// Prepares a Var list.
void setLength(Poco::UInt32 length); void setLength(Poco::UInt32 length);
/// Sets the length of prepared data. /// Sets the length of prepared data.

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

File diff suppressed because it is too large Load Diff

78
Data/src/AbstractPreparator.cpp
View File

@@ -53,237 +53,237 @@ AbstractPreparator::~AbstractPreparator()
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::Int8>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int8>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::Int8>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int8>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::Int8>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int8>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::UInt8>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt8>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::UInt8>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt8>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::UInt8>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt8>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::Int16>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int16>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::Int16>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int16>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::Int16>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int16>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::UInt16>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt16>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::UInt16>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt16>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::UInt16>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt16>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::Int32>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int32>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::Int32>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int32>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::Int32>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int32>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::UInt32>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt32>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::UInt32>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt32>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::UInt32>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt32>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::Int64>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int64>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::Int64>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int64>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::Int64>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int64>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<Poco::UInt64>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt64>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<Poco::UInt64>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt64>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<Poco::UInt64>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt64>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
#ifndef POCO_LONG_IS_64_BIT #ifndef POCO_LONG_IS_64_BIT
void AbstractPreparator::prepare(std::size_t pos, std::vector<long>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<long>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<long>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<long>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<long>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<long>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
#endif #endif
void AbstractPreparator::prepare(std::size_t pos, std::vector<bool>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<bool>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<bool>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<bool>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<bool>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<bool>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<float>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<float>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<float>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<float>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<float>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<float>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<double>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<double>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<double>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<double>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<double>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<double>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::vector<char>& val) void AbstractPreparator::prepare(std::size_t pos, const std::vector<char>& val)
{ {
throw NotImplementedException("std::vector preparator must be implemented."); throw NotImplementedException("std::vector preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::deque<char>& val) void AbstractPreparator::prepare(std::size_t pos, const std::deque<char>& val)
{ {
throw NotImplementedException("std::deque preparator must be implemented."); throw NotImplementedException("std::deque preparator must be implemented.");
} }
void AbstractPreparator::prepare(std::size_t pos, std::list<char>& val) void AbstractPreparator::prepare(std::size_t pos, const std::list<char>& val)
{ {
throw NotImplementedException("std::list preparator must be implemented."); throw NotImplementedException("std::list preparator must be implemented.");
} }

26
Data/testsuite/src/Preparator.cpp
View File

@@ -50,69 +50,69 @@ Preparator::~Preparator()
} }
void Preparator::prepare(std::size_t pos, Poco::Int8&) void Preparator::prepare(std::size_t pos, const Poco::Int8&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::UInt8&) void Preparator::prepare(std::size_t pos, const Poco::UInt8&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::Int16&) void Preparator::prepare(std::size_t pos, const Poco::Int16&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::UInt16&) void Preparator::prepare(std::size_t pos, const Poco::UInt16&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::Int32&) void Preparator::prepare(std::size_t pos, const Poco::Int32&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::UInt32&) void Preparator::prepare(std::size_t pos, const Poco::UInt32&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::Int64&) void Preparator::prepare(std::size_t pos, const Poco::Int64&)
{ {
} }
void Preparator::prepare(std::size_t pos, Poco::UInt64&) void Preparator::prepare(std::size_t pos, const Poco::UInt64&)
{ {
} }
#ifndef POCO_LONG_IS_64_BIT #ifndef POCO_LONG_IS_64_BIT
void Preparator::prepare(std::size_t pos, long&) void Preparator::prepare(std::size_t pos, const long&)
{ {
} }
#endif #endif
void Preparator::prepare(std::size_t pos, bool&) void Preparator::prepare(std::size_t pos, const bool&)
{ {
} }
void Preparator::prepare(std::size_t pos, float&) void Preparator::prepare(std::size_t pos, const float&)
{ {
} }
void Preparator::prepare(std::size_t pos, double&) void Preparator::prepare(std::size_t pos, const double&)
{ {
} }
void Preparator::prepare(std::size_t pos, char&) void Preparator::prepare(std::size_t pos, const char&)
{ {
} }

26
Data/testsuite/src/Preparator.h
View File

@@ -55,45 +55,45 @@ public:
~Preparator(); ~Preparator();
/// Destroys the Preparator. /// Destroys the Preparator.
void prepare(std::size_t pos, Poco::Int8&); void prepare(std::size_t pos, const Poco::Int8&);
/// Preparations an Int8. /// Preparations an Int8.
void prepare(std::size_t pos, Poco::UInt8&); void prepare(std::size_t pos, const Poco::UInt8&);
/// Preparations an UInt8. /// Preparations an UInt8.
void prepare(std::size_t pos, Poco::Int16&); void prepare(std::size_t pos, const Poco::Int16&);
/// Preparations an Int16. /// Preparations an Int16.
void prepare(std::size_t pos, Poco::UInt16&); void prepare(std::size_t pos, const Poco::UInt16&);
/// Preparations an UInt16. /// Preparations an UInt16.
void prepare(std::size_t pos, Poco::Int32&); void prepare(std::size_t pos, const Poco::Int32&);
/// Preparations an Int32. /// Preparations an Int32.
void prepare(std::size_t pos, Poco::UInt32&); void prepare(std::size_t pos, const Poco::UInt32&);
/// Preparations an UInt32. /// Preparations an UInt32.
void prepare(std::size_t pos, Poco::Int64&); void prepare(std::size_t pos, const Poco::Int64&);
/// Preparations an Int64. /// Preparations an Int64.
void prepare(std::size_t pos, Poco::UInt64&); void prepare(std::size_t pos, const Poco::UInt64&);
/// Preparations an UInt64. /// Preparations an UInt64.
#ifndef POCO_LONG_IS_64_BIT #ifndef POCO_LONG_IS_64_BIT
void prepare(std::size_t pos, long&); void prepare(std::size_t pos, const long&);
/// Preparations a long. /// Preparations a long.
#endif #endif
void prepare(std::size_t pos, bool&); void prepare(std::size_t pos, const bool&);
/// Preparations a boolean. /// Preparations a boolean.
void prepare(std::size_t pos, float&); void prepare(std::size_t pos, const float&);
/// Preparations a float. /// Preparations a float.
void prepare(std::size_t pos, double&); void prepare(std::size_t pos, const double&);
/// Preparations a double. /// Preparations a double.
void prepare(std::size_t pos, char&); void prepare(std::size_t pos, const char&);
/// Preparations a single character. /// Preparations a single character.
void prepare(std::size_t pos, const std::string&); void prepare(std::size_t pos, const std::string&);