generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-28 11:31:53 +01:00
Code Issues Projects Releases Wiki Activity

merge some changes from develop branch; modernize and clean-up code; remove support for compiling without POCO_WIN32_UTF8

Browse Source
This commit is contained in:
Günter Obiltschnig
2020-01-09 10:08:09 +01:00
parent 7c177b6f89
commit 1bf40a0cd2
389 changed files with 3029 additions and 4111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -37,7 +37,7 @@ namespace Poco {
namespace Data {
typedef NullType NullData;
using NullData = NullType;
namespace Keywords {
@@ -53,7 +53,7 @@ class Data_API AbstractBinder
/// Interface for Binding data types to placeholders.
{
public:
typedef SharedPtr<AbstractBinder> Ptr;
using Ptr = SharedPtr<AbstractBinder>;
enum Direction
/// Binding direction for a parameter.

10
Data/include/Poco/Data/AbstractBinding.h
View File

@@ -37,8 +37,8 @@ class Data_API AbstractBinding
/// AbstractBinding connects a value with a placeholder via an AbstractBinder interface.
{
public:
typedef SharedPtr<AbstractBinding> Ptr;
typedef AbstractBinder::Ptr BinderPtr;
using Ptr = SharedPtr<AbstractBinding>;
using BinderPtr = AbstractBinder::Ptr;
enum Direction
{
@@ -100,9 +100,9 @@ private:
};
typedef std::vector<AbstractBinding::Ptr> AbstractBindingVec;
typedef std::deque<AbstractBinding::Ptr> AbstractBindingDeq;
typedef std::list<AbstractBinding::Ptr> AbstractBindingLst;
using AbstractBindingVec = std::vector<AbstractBinding::Ptr>;
using AbstractBindingDeq = std::deque<AbstractBinding::Ptr>;
using AbstractBindingLst = std::list<AbstractBinding::Ptr>;
//

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

@@ -43,9 +43,9 @@ class Data_API AbstractExtraction
/// retrieved via an AbstractExtractor.
{
public:
typedef SharedPtr<AbstractExtraction> Ptr;
typedef SharedPtr<AbstractExtractor> ExtractorPtr;
typedef SharedPtr<AbstractPreparator> PreparatorPtr;
using Ptr = SharedPtr<AbstractExtraction>;
using ExtractorPtr = SharedPtr<AbstractExtractor>;
using PreparatorPtr = SharedPtr<AbstractPreparator>;
AbstractExtraction(Poco::UInt32 limit = Limit::LIMIT_UNLIMITED,
Poco::UInt32 position = 0, bool bulk = false);
@@ -172,12 +172,12 @@ private:
};
typedef std::vector<AbstractExtraction::Ptr> AbstractExtractionVec;
typedef std::vector<AbstractExtractionVec> AbstractExtractionVecVec;
typedef std::deque<AbstractExtraction::Ptr> AbstractExtractionDeq;
typedef std::vector<AbstractExtractionDeq> AbstractExtractionDeqVec;
typedef std::list<AbstractExtraction::Ptr> AbstractExtractionLst;
typedef std::vector<AbstractExtractionLst> AbstractExtractionLstVec;
using AbstractExtractionVec = std::vector<AbstractExtraction::Ptr>;
using AbstractExtractionVecVec = std::vector<AbstractExtractionVec>;
using AbstractExtractionDeq = std::deque<AbstractExtraction::Ptr>;
using AbstractExtractionDeqVec = std::vector<AbstractExtractionDeq>;
using AbstractExtractionLst = std::list<AbstractExtraction::Ptr>;
using AbstractExtractionLstVec = std::vector<AbstractExtractionLst>;
//

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

@@ -51,7 +51,7 @@ class Data_API AbstractExtractor
/// If an extractor receives null it is not allowed to change val!
{
public:
typedef SharedPtr<AbstractExtractor> Ptr;
using Ptr = SharedPtr<AbstractExtractor>;
AbstractExtractor();
/// Creates the AbstractExtractor.

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

@@ -32,8 +32,8 @@ class Data_API AbstractPreparation
/// Interface for calling the appropriate AbstractPreparator method
{
public:
typedef SharedPtr<AbstractPreparation> Ptr;
typedef AbstractPreparator::Ptr PreparatorPtr;
using Ptr = SharedPtr<AbstractPreparation>;
using PreparatorPtr = AbstractPreparator::Ptr;
AbstractPreparation(PreparatorPtr pPreparator);
/// Creates the AbstractPreparation.

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

@@ -57,7 +57,7 @@ class Data_API AbstractPreparator
/// after SQL execution (e.g. SQLite) do not need this functionality at all.
{
public:
typedef SharedPtr<AbstractPreparator> Ptr;
using Ptr = SharedPtr<AbstractPreparator>;
AbstractPreparator(Poco::UInt32 length = 1u);
/// Creates the AbstractPreparator.

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

@@ -59,7 +59,7 @@ public:
/// Creates the AbstractSessionImpl.
///
/// Adds "storage" property and sets the default internal storage container
/// type to std::deque.
/// type to std::vector.
/// The storage is created by statements automatically whenever a query
/// returning results is executed but external storage is provided by the user.
/// Storage type can be reconfigured at runtime both globally (for the
@@ -296,8 +296,8 @@ private:
PropertyGetter getter;
};
typedef std::map<std::string, Feature> FeatureMap;
typedef std::map<std::string, Property> PropertyMap;
using FeatureMap = std::map<std::string, Feature>;
using PropertyMap = std::map<std::string, Property>;
FeatureMap _features;
PropertyMap _properties;

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

@@ -70,8 +70,8 @@ public:
/// Sets the archive threshold.
protected:
typedef Poco::SharedPtr<Session> SessionPtr;
typedef Poco::SharedPtr<Statement> StatementPtr;
using SessionPtr = Poco::SharedPtr<Session>;
using StatementPtr = Poco::SharedPtr<Statement>;
Session& session();

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

@@ -26,7 +26,7 @@ namespace Poco {
namespace Data {
typedef Transaction AutoTransaction;
using AutoTransaction = Transaction;
} } // namespace Poco::Data

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

@@ -51,10 +51,10 @@ class Binding: public AbstractBinding
/// function. An attempt to pass a constant by reference shall result in compile-time error.
{
public:
typedef T ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Binding<ValType> Type;
typedef SharedPtr<Type> Ptr;
using ValType = T;
using ValPtr = SharedPtr<ValType>;
using Type = Binding<ValType>;
using Ptr = SharedPtr<Type>;
explicit Binding(T& val,
const std::string& name = "",
@@ -121,10 +121,10 @@ class CopyBinding: public AbstractBinding
/// Variables can be passed as either copies or references (i.e. using either use() or bind()).
{
public:
typedef T ValType;
typedef SharedPtr<ValType> ValPtr;
typedef CopyBinding<ValType> Type;
typedef SharedPtr<Type> Ptr;
using ValType = T;
using ValPtr = SharedPtr<ValType>;
using Type = CopyBinding<ValType>;
using Ptr = SharedPtr<Type>;
explicit CopyBinding(T& val,
const std::string& name = "",
@@ -184,10 +184,10 @@ class Binding<const char*>: public AbstractBinding
/// Binding const char* specialization wraps char pointer into string.
{
public:
typedef const char* ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Binding<const char*> Type;
typedef SharedPtr<Type> Ptr;
using ValType = const char*;
using ValPtr = SharedPtr<ValType>;
using Type = Binding<const char*>;
using Ptr = SharedPtr<Type>;
explicit Binding(const char* pVal,
const std::string& name = "",
@@ -246,10 +246,10 @@ class CopyBinding<const char*>: public AbstractBinding
/// Binding const char* specialization wraps char pointer into string.
{
public:
typedef const char* ValType;
typedef SharedPtr<ValType> ValPtr;
typedef CopyBinding<const char*> Type;
typedef SharedPtr<Type> Ptr;
using ValType = const char*;
using ValPtr = SharedPtr<ValType>;
using Type = CopyBinding<const char*>;
using Ptr = SharedPtr<Type>;
explicit CopyBinding(const char* pVal,
const std::string& name = "",
@@ -303,14 +303,14 @@ private:
template <class T>
class Binding<std::vector<T> >: public AbstractBinding
class Binding<std::vector<T>>: public AbstractBinding
/// Specialization for std::vector.
{
public:
typedef std::vector<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::vector<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::vector<T>& val,
const std::string& name = "",
@@ -369,15 +369,15 @@ private:
template <class T>
class CopyBinding<std::vector<T> >: public AbstractBinding
class CopyBinding<std::vector<T>>: public AbstractBinding
/// Specialization for std::vector.
{
public:
typedef std::vector<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::vector<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(std::vector<T>& val,
const std::string& name = "",
@@ -436,7 +436,7 @@ private:
template <>
class Binding<std::vector<bool> >: public AbstractBinding
class Binding<std::vector<bool>>: public AbstractBinding
/// Specialization for std::vector<bool>.
/// This specialization is necessary due to the nature of std::vector<bool>.
/// For details, see the standard library implementation of std::vector<bool>
@@ -451,10 +451,10 @@ class Binding<std::vector<bool> >: public AbstractBinding
/// Only IN binding is supported.
{
public:
typedef std::vector<bool> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef ValType::const_iterator Iterator;
using ValType = std::vector<bool>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = ValType::const_iterator;
explicit Binding(const std::vector<bool>& val,
const std::string& name = "",
@@ -500,7 +500,6 @@ public:
poco_assert_dbg(canBind());
TypeHandler<bool>::bind(pos, *_begin, getBinder(), getDirection());
++_begin;
}
void reset()
@@ -518,7 +517,7 @@ private:
template <>
class CopyBinding<std::vector<bool> >: public AbstractBinding
class CopyBinding<std::vector<bool>>: public AbstractBinding
/// Specialization for std::vector<bool>.
/// This specialization is necessary due to the nature of std::vector<bool>.
/// For details, see the standard library implementation of std::vector<bool>
@@ -533,10 +532,10 @@ class CopyBinding<std::vector<bool> >: public AbstractBinding
/// Only IN binding is supported.
{
public:
typedef std::vector<bool> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef ValType::const_iterator Iterator;
using ValType = std::vector<bool>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = ValType::const_iterator;
explicit CopyBinding(const std::vector<bool>& val,
const std::string& name = "",
@@ -598,14 +597,14 @@ private:
template <class T>
class Binding<std::list<T> >: public AbstractBinding
class Binding<std::list<T>>: public AbstractBinding
/// Specialization for std::list.
{
public:
typedef std::list<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::list<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::list<T>& val,
const std::string& name = "",
@@ -663,14 +662,14 @@ private:
template <class T>
class CopyBinding<std::list<T> >: public AbstractBinding
class CopyBinding<std::list<T>>: public AbstractBinding
/// Specialization for std::list.
{
public:
typedef typename std::list<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = typename std::list<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(ValType& val,
const std::string& name = "",
@@ -728,14 +727,14 @@ private:
template <class T>
class Binding<std::deque<T> >: public AbstractBinding
class Binding<std::deque<T>>: public AbstractBinding
/// Specialization for std::deque.
{
public:
typedef std::deque<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::deque<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::deque<T>& val,
const std::string& name = "",
@@ -793,14 +792,14 @@ private:
template <class T>
class CopyBinding<std::deque<T> >: public AbstractBinding
class CopyBinding<std::deque<T>>: public AbstractBinding
/// Specialization for std::deque.
{
public:
typedef std::deque<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::deque<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(std::deque<T>& val,
const std::string& name = "",
@@ -858,14 +857,14 @@ private:
template <class T>
class Binding<std::set<T> >: public AbstractBinding
class Binding<std::set<T>>: public AbstractBinding
/// Specialization for std::set.
{
public:
typedef std::set<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::set<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::set<T>& val,
const std::string& name = "",
@@ -923,14 +922,14 @@ private:
template <class T>
class CopyBinding<std::set<T> >: public AbstractBinding
class CopyBinding<std::set<T>>: public AbstractBinding
/// Specialization for std::set.
{
public:
typedef std::set<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::set<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(std::set<T>& val,
const std::string& name = "",
@@ -988,14 +987,14 @@ private:
template <class T>
class Binding<std::multiset<T> >: public AbstractBinding
class Binding<std::multiset<T>>: public AbstractBinding
/// Specialization for std::multiset.
{
public:
typedef std::multiset<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::multiset<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::multiset<T>& val,
const std::string& name = "",
@@ -1053,14 +1052,14 @@ private:
template <class T>
class CopyBinding<std::multiset<T> >: public AbstractBinding
class CopyBinding<std::multiset<T>>: public AbstractBinding
/// Specialization for std::multiset.
{
public:
typedef std::multiset<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::multiset<T>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(std::multiset<T>& val,
const std::string& name = "",
@@ -1118,14 +1117,14 @@ private:
template <class K, class V>
class Binding<std::map<K, V> >: public AbstractBinding
class Binding<std::map<K, V>>: public AbstractBinding
/// Specialization for std::map.
{
public:
typedef std::map<K, V> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::map<K, V>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::map<K, V>& val,
const std::string& name = "",
@@ -1183,14 +1182,14 @@ private:
template <class K, class V>
class CopyBinding<std::map<K, V> >: public AbstractBinding
class CopyBinding<std::map<K, V>>: public AbstractBinding
/// Specialization for std::map.
{
public:
typedef std::map<K, V> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::map<K, V>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(std::map<K, V>& val,
const std::string& name = "",
@@ -1248,14 +1247,14 @@ private:
template <class K, class V>
class Binding<std::multimap<K, V> >: public AbstractBinding
class Binding<std::multimap<K, V>>: public AbstractBinding
/// Specialization for std::multimap.
{
public:
typedef std::multimap<K, V> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<Binding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::multimap<K, V>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<Binding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit Binding(std::multimap<K, V>& val,
const std::string& name = "",
@@ -1313,14 +1312,14 @@ private:
template <class K, class V>
class CopyBinding<std::multimap<K, V> >: public AbstractBinding
class CopyBinding<std::multimap<K, V>>: public AbstractBinding
/// Specialization for std::multimap.
{
public:
typedef std::multimap<K, V> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef SharedPtr<CopyBinding<ValType> > Ptr;
typedef typename ValType::const_iterator Iterator;
using ValType = std::multimap<K, V>;
using ValPtr = SharedPtr<ValType>;
using Ptr = SharedPtr<CopyBinding<ValType>>;
using Iterator = typename ValType::const_iterator;
explicit CopyBinding(std::multimap<K, V>& val,
const std::string& name = "",

12
Data/include/Poco/Data/BulkBinding.h
View File

@@ -95,7 +95,7 @@ template <typename T>
AbstractBinding::Ptr use(const std::vector<T>& t, BulkFnType, const std::string& name = "")
/// Convenience function for a more compact BulkBinding creation for std::vector.
{
return new BulkBinding<std::vector<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
return new BulkBinding<std::vector<T>>(t, static_cast<Poco::UInt32>(t.size()), name);
}
@@ -103,7 +103,7 @@ template <typename T>
AbstractBinding::Ptr in(const std::vector<T>& t, BulkFnType, const std::string& name = "")
/// Convenience function for a more compact BulkBinding creation for std::vector.
{
return new BulkBinding<std::vector<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
return new BulkBinding<std::vector<T>>(t, static_cast<Poco::UInt32>(t.size()), name);
}
@@ -111,7 +111,7 @@ template <typename T>
AbstractBinding::Ptr use(const std::deque<T>& t, BulkFnType, const std::string& name = "")
/// Convenience function for a more compact BulkBinding creation for std::deque.
{
return new BulkBinding<std::deque<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
return new BulkBinding<std::deque<T>>(t, static_cast<Poco::UInt32>(t.size()), name);
}
@@ -119,7 +119,7 @@ template <typename T>
AbstractBinding::Ptr in(const std::deque<T>& t, BulkFnType, const std::string& name = "")
/// Convenience function for a more compact BulkBinding creation for std::deque.
{
return new BulkBinding<std::deque<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
return new BulkBinding<std::deque<T>>(t, static_cast<Poco::UInt32>(t.size()), name);
}
@@ -127,7 +127,7 @@ template <typename T>
AbstractBinding::Ptr use(const std::list<T>& t, BulkFnType, const std::string& name = "")
/// Convenience function for a more compact BulkBinding creation for std::list.
{
return new BulkBinding<std::list<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
return new BulkBinding<std::list<T>>(t, static_cast<Poco::UInt32>(t.size()), name);
}
@@ -135,7 +135,7 @@ template <typename T>
AbstractBinding::Ptr in(const std::list<T>& t, BulkFnType, const std::string& name = "")
/// Convenience function for a more compact BulkBinding creation for std::list.
{
return new BulkBinding<std::list<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
return new BulkBinding<std::list<T>>(t, static_cast<Poco::UInt32>(t.size()), name);
}

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

@@ -38,11 +38,11 @@ class BulkExtraction: public AbstractExtraction
/// - std::list
{
public:
typedef C ValType;
typedef typename C::value_type CValType;
typedef SharedPtr<ValType> ValPtr;
typedef BulkExtraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
using ValType = C;
using CValType = typename C::value_type;
using ValPtr = SharedPtr<ValType>;
using Type = BulkExtraction<ValType>;
using Ptr = SharedPtr<Type>;
BulkExtraction(C& result, Poco::UInt32 limit, const Position& pos = Position(0)):
AbstractExtraction(limit, pos.value(), true),
@@ -146,11 +146,11 @@ class InternalBulkExtraction: public BulkExtraction<C>
/// InternalBulkExtraction objects can not be copied or assigned.
{
public:
typedef C ValType;
typedef typename C::value_type CValType;
typedef SharedPtr<ValType> ValPtr;
typedef InternalBulkExtraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
using ValType = C;
using CValType = typename C::value_type;
using ValPtr = SharedPtr<ValType>;
using Type = InternalBulkExtraction<ValType>;
using Ptr = SharedPtr<Type>;
InternalBulkExtraction(C& result,
Column<C>* pColumn,
@@ -212,7 +212,7 @@ AbstractExtraction::Ptr into(std::vector<T>& t, const Bulk& bulk, const Position
/// Convenience function to allow for a more compact creation of an extraction object
/// with std::vector bulk extraction support.
{
return new BulkExtraction<std::vector<T> >(t, bulk.size(), pos);
return new BulkExtraction<std::vector<T>>(t, bulk.size(), pos);
}
@@ -223,7 +223,7 @@ AbstractExtraction::Ptr into(std::vector<T>& t, BulkFnType, const Position& pos
{
Poco::UInt32 size = static_cast<Poco::UInt32>(t.size());
if (0 == size) throw InvalidArgumentException("Zero length not allowed.");
return new BulkExtraction<std::vector<T> >(t, size, pos);
return new BulkExtraction<std::vector<T>>(t, size, pos);
}
@@ -232,7 +232,7 @@ AbstractExtraction::Ptr into(std::deque<T>& t, const Bulk& bulk, const Position&
/// Convenience function to allow for a more compact creation of an extraction object
/// with std::deque bulk extraction support.
{
return new BulkExtraction<std::deque<T> >(t, bulk.size(), pos);
return new BulkExtraction<std::deque<T>>(t, bulk.size(), pos);
}
@@ -243,7 +243,7 @@ AbstractExtraction::Ptr into(std::deque<T>& t, BulkFnType, const Position& pos =
{
Poco::UInt32 size = static_cast<Poco::UInt32>(t.size());
if (0 == size) throw InvalidArgumentException("Zero length not allowed.");
return new BulkExtraction<std::deque<T> >(t, size, pos);
return new BulkExtraction<std::deque<T>>(t, size, pos);
}
@@ -252,7 +252,7 @@ AbstractExtraction::Ptr into(std::list<T>& t, const Bulk& bulk, const Position&
/// Convenience function to allow for a more compact creation of an extraction object
/// with std::list bulk extraction support.
{
return new BulkExtraction<std::list<T> >(t, bulk.size(), pos);
return new BulkExtraction<std::list<T>>(t, bulk.size(), pos);
}
@@ -263,7 +263,7 @@ AbstractExtraction::Ptr into(std::list<T>& t, BulkFnType, const Position& pos =
{
Poco::UInt32 size = static_cast<Poco::UInt32>(t.size());
if (0 == size) throw InvalidArgumentException("Zero length not allowed.");
return new BulkExtraction<std::list<T> >(t, size, pos);
return new BulkExtraction<std::list<T>>(t, size, pos);
}

51
Data/include/Poco/Data/Column.h
View File

@@ -39,12 +39,12 @@ class Column
/// This class owns the data assigned to it and deletes the storage on destruction.
{
public:
typedef C Container;
typedef Poco::SharedPtr<C> ContainerPtr;
typedef typename C::const_iterator Iterator;
typedef typename C::const_reverse_iterator RIterator;
typedef typename C::size_type Size;
typedef typename C::value_type Type;
using Container = C;
using ContainerPtr = Poco::SharedPtr<C>;
using Iterator = typename C::const_iterator;
using RIterator = typename C::const_reverse_iterator;
using Size = typename C::size_type;
using Type = typename C::value_type;
Column(const MetaColumn& metaColumn, Container* pData):
_metaColumn(metaColumn),
@@ -62,6 +62,13 @@ public:
{
}
Column(Column&& col) noexcept:
_metaColumn(std::move(col._metaColumn)),
_pData(std::move(col._pData))
/// Creates the Column.
{
}
~Column()
/// Destroys the Column.
{
@@ -75,6 +82,14 @@ public:
return *this;
}
Column& operator = (Column&& col) noexcept
/// Assignment operator.
{
_metaColumn = std::move(col._metaColumn);
_pData = std::move(col._pData);
return *this;
}
void swap(Column& other)
/// Swaps the column with another one.
{
@@ -172,7 +187,7 @@ private:
template <>
class Column<std::vector<bool> >
class Column<std::vector<bool>>
/// The std::vector<bool> specialization for the Column class.
///
/// This specialization is necessary due to the nature of std::vector<bool>.
@@ -186,11 +201,11 @@ class Column<std::vector<bool> >
/// column data.
{
public:
typedef std::vector<bool> Container;
typedef Poco::SharedPtr<Container> ContainerPtr;
typedef Container::const_iterator Iterator;
typedef Container::const_reverse_iterator RIterator;
typedef Container::size_type Size;
using Container = std::vector<bool>;
using ContainerPtr = Poco::SharedPtr<Container>;
using Iterator = Container::const_iterator;
using RIterator = Container::const_reverse_iterator;
using Size = Container::size_type;
Column(const MetaColumn& metaColumn, Container* pData):
_metaColumn(metaColumn),
@@ -325,15 +340,15 @@ private:
template <class T>
class Column<std::list<T> >
class Column<std::list<T>>
/// Column specialization for std::list
{
public:
typedef std::list<T> Container;
typedef Poco::SharedPtr<Container> ContainerPtr;
typedef typename Container::const_iterator Iterator;
typedef typename Container::const_reverse_iterator RIterator;
typedef typename Container::size_type Size;
using Container = std::list<T>;
using ContainerPtr = Poco::SharedPtr<Container>;
using Iterator = typename Container::const_iterator;
using RIterator = typename Container::const_reverse_iterator;
using Size = typename Container::size_type;
Column(const MetaColumn& metaColumn, std::list<T>* pData):
_metaColumn(metaColumn),

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

@@ -27,8 +27,8 @@ namespace Poco {
namespace Data {
template <typename T> class LOB;
typedef LOB<unsigned char> BLOB;
typedef LOB<char> CLOB;
using BLOB = LOB<unsigned char>;
using CLOB = LOB<char>;
} } // namespace Poco::Data

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

@@ -42,10 +42,10 @@ 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;
using ValType = T;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(T& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -129,15 +129,14 @@ private:
template <class T>
class Extraction<std::vector<T> >: public AbstractExtraction
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;
using ValType = std::vector<T>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::vector<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -220,14 +219,14 @@ private:
template <>
class Extraction<std::vector<bool> >: public AbstractExtraction
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;
using ValType = std::vector<bool>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::vector<bool>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -312,14 +311,14 @@ private:
template <class T>
class Extraction<std::list<T> >: public AbstractExtraction
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;
using ValType = std::list<T>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::list<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -402,14 +401,14 @@ private:
template <class T>
class Extraction<std::deque<T> >: public AbstractExtraction
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;
using ValType = std::deque<T>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::deque<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -504,10 +503,10 @@ class InternalExtraction: public Extraction<C>
/// InternalExtraction objects can not be copied or assigned.
{
public:
typedef typename C::value_type ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
using ValType = typename C::value_type;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
InternalExtraction(C& result, Column<C>* pColumn, const Position& pos = Position(0)):
@@ -561,15 +560,15 @@ private:
template <class T>
class Extraction<std::set<T> >: public AbstractExtraction
class Extraction<std::set<T>>: public AbstractExtraction
/// Set Data Type specialization for extraction of values from a query result set.
{
public:
typedef std::set<T> ValType;
typedef SharedPtr<ValType> ValPtr;
typedef Extraction<ValType> Type;
typedef SharedPtr<Type> Ptr;
typedef typename ValType::iterator Iterator;
using ValType = std::set<T>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
using Iterator = typename ValType::iterator;
Extraction(std::set<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -626,14 +625,14 @@ private:
template <class T>
class Extraction<std::multiset<T> >: public AbstractExtraction
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;
using ValType = std::multiset<T>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::multiset<T>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -690,14 +689,14 @@ private:
template <class K, class V>
class Extraction<std::map<K, V> >: public AbstractExtraction
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;
using ValType = std::map<K, V>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::map<K, V>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
@@ -754,14 +753,14 @@ private:
template <class K, class V>
class Extraction<std::multimap<K, V> >: public AbstractExtraction
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;
using ValType = std::multimap<K, V>;
using ValPtr = SharedPtr<ValType>;
using Type = Extraction<ValType>;
using Ptr = SharedPtr<Type>;
Extraction(std::multimap<K, V>& result, const Position& pos = Position(0)):
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),

22
Data/include/Poco/Data/LOB.h
View File

@@ -41,10 +41,10 @@ class LOB
/// a convenient way to access the data in a LOB.
{
public:
typedef typename std::vector<T>::const_iterator Iterator;
typedef T ValueType;
typedef typename std::vector<T> Container;
typedef Poco::SharedPtr<Container> ContentPtr;
using Iterator = typename std::vector<T>::const_iterator;
using ValueType = T;
using Container = std::vector<T>;
using ContentPtr = Poco::SharedPtr<Container>;
LOB(): _pContent(new std::vector<T>())
/// Creates an empty LOB.
@@ -74,6 +74,10 @@ public:
{
}
LOB(LOB&& other) noexcept: _pContent(std::move(other._pContent))
{
}
~LOB()
/// Destroys the LOB.
{
@@ -87,6 +91,12 @@ public:
return *this;
}
LOB& operator = (LOB&& other) noexcept
{
_pContent = std::move(other._pContent);
return *this;
}
bool operator == (const LOB& other) const
/// Compares for equality LOB by value.
{
@@ -180,8 +190,8 @@ private:
};
typedef LOB<unsigned char> BLOB;
typedef LOB<char> CLOB;
using BLOB = LOB<unsigned char>;
using CLOB = LOB<char>;
//

18
Data/include/Poco/Data/LOBStream.h
View File

@@ -30,7 +30,7 @@ namespace Data {
template <typename T>
class LOBStreamBuf: public BasicUnbufferedStreamBuf<T, std::char_traits<T> >
class LOBStreamBuf: public BasicUnbufferedStreamBuf<T, std::char_traits<T>>
/// This is the streambuf class used for reading from and writing to a LOB.
{
public:
@@ -46,8 +46,8 @@ public:
}
protected:
typedef std::char_traits<T> TraitsType;
typedef BasicUnbufferedStreamBuf<T, TraitsType> BaseType;
using TraitsType = std::char_traits<T>;
using BaseType = BasicUnbufferedStreamBuf<T, TraitsType>;
typename BaseType::int_type readFromDevice()
{
@@ -101,7 +101,7 @@ protected:
template <typename T>
class LOBOutputStream: public LOBIOS<T>, public std::basic_ostream<T, std::char_traits<T> >
class LOBOutputStream: public LOBIOS<T>, public std::basic_ostream<T, std::char_traits<T>>
/// An output stream for writing to a LOB.
{
public:
@@ -120,7 +120,7 @@ public:
template <typename T>
class LOBInputStream: public LOBIOS<T>, public std::basic_istream<T, std::char_traits<T> >
class LOBInputStream: public LOBIOS<T>, public std::basic_istream<T, std::char_traits<T>>
/// An input stream for reading from a LOB.
{
public:
@@ -138,11 +138,11 @@ public:
};
typedef LOBOutputStream<unsigned char> BLOBOutputStream;
typedef LOBOutputStream<char> CLOBOutputStream;
using BLOBOutputStream = LOBOutputStream<unsigned char>;
using CLOBOutputStream = LOBOutputStream<char>;
typedef LOBInputStream<unsigned char> BLOBInputStream;
typedef LOBInputStream<char> CLOBInputStream;
using BLOBInputStream = LOBInputStream<unsigned char>;
using CLOBInputStream = LOBInputStream<char>;
} } // namespace Poco::Data

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

@@ -29,7 +29,7 @@ class Data_API Limit
/// Limit stores information how many rows a query should return.
{
public:
typedef Poco::UInt32 SizeT;
using SizeT = Poco::UInt32;
enum Type
{

17
Data/include/Poco/Data/MetaColumn.h
View File

@@ -64,7 +64,22 @@ public:
bool nullable = false);
/// Creates the MetaColumn.
virtual ~MetaColumn();
MetaColumn(const MetaColumn& other);
/// Copy constructor.
MetaColumn(MetaColumn&& other) noexcept;
/// Move constructor.
MetaColumn& operator = (const MetaColumn& other);
/// Assignment operator.
MetaColumn& operator = (MetaColumn&& other) noexcept;
/// Assignment operator.
void swap(MetaColumn& other);
/// Swaps the contents with another instance.
~MetaColumn();
/// Destroys the MetaColumn.
const std::string& name() const;

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

@@ -55,7 +55,7 @@ public:
void setConnectionTimeout(std::size_t timeout);
std::size_t getConnectionTimeout() const;
bool canTransact() const;
bool isTransaction()const ;
bool isTransaction() const;
void setTransactionIsolation(Poco::UInt32);
Poco::UInt32 getTransactionIsolation() const;
bool hasTransactionIsolation(Poco::UInt32) const;

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

@@ -60,7 +60,7 @@ private:
template<typename T>
class Preparation<std::vector<T> >: public AbstractPreparation
class Preparation<std::vector<T>>: public AbstractPreparation
/// Preparation specialization for std::vector.
/// This specialization is needed for bulk operations to enforce
/// the whole vector preparation, rather than only individual contained values.
@@ -82,7 +82,7 @@ public:
void prepare()
/// Prepares data.
{
TypeHandler<std::vector<T> >::prepare(_pos, _val, preparation());
TypeHandler<std::vector<T>>::prepare(_pos, _val, preparation());
}
private:
@@ -92,7 +92,7 @@ private:
template<typename T>
class Preparation<std::deque<T> >: public AbstractPreparation
class Preparation<std::deque<T>>: public AbstractPreparation
/// Preparation specialization for std::deque.
/// This specialization is needed for bulk operations to enforce
/// the whole deque preparation, rather than only individual contained values.
@@ -114,7 +114,7 @@ public:
void prepare()
/// Prepares data.
{
TypeHandler<std::deque<T> >::prepare(_pos, _val, preparation());
TypeHandler<std::deque<T>>::prepare(_pos, _val, preparation());
}
private:
@@ -124,7 +124,7 @@ private:
template<typename T>
class Preparation<std::list<T> >: public AbstractPreparation
class Preparation<std::list<T>>: public AbstractPreparation
/// Preparation specialization for std::list.
/// This specialization is needed for bulk operations to enforce
/// the whole list preparation, rather than only individual contained values.
@@ -146,7 +146,7 @@ public:
void prepare()
/// Prepares data.
{
TypeHandler<std::list<T> >::prepare(_pos, _val, preparation());
TypeHandler<std::list<T>>::prepare(_pos, _val, preparation());
}
private:

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

@@ -69,9 +69,9 @@ class Data_API RecordSet: private Statement
/// a limit for the Statement.
{
public:
typedef std::map<std::size_t, Row*> RowMap;
typedef const RowIterator ConstIterator;
typedef RowIterator Iterator;
using RowMap = std::map<std::size_t, Row*>;
using ConstIterator = const RowIterator;
using Iterator = RowIterator;
using Statement::isNull;
using Statement::subTotalRowCount;
@@ -107,15 +107,24 @@ public:
RecordSet(const RecordSet& other);
/// Copy-creates the recordset.
RecordSet(RecordSet&& other) noexcept;
/// Move-creates the recordset.
~RecordSet();
/// Destroys the RecordSet.
void setRowFormatter(RowFormatter::Ptr pRowFormatter);
/// Assigns the row formatter to the statement and all recordset rows.
Statement& operator = (const Statement& stmt);
RecordSet& operator = (const Statement& stmt);
/// Assignment operator.
RecordSet& operator = (const RecordSet& other);
/// Assignment operator.
RecordSet& operator = (RecordSet&& other) noexcept;
/// Move assignment.
std::size_t rowCount() const;
/// Returns the number of rows in the RecordSet.
/// The number of rows reported is dependent on filtering.
@@ -159,12 +168,12 @@ public:
{
if (isBulkExtraction())
{
typedef InternalBulkExtraction<C> E;
using E = InternalBulkExtraction<C>;
return columnImpl<C,E>(name);
}
else
{
typedef InternalExtraction<C> E;
using E = InternalExtraction<C>;
return columnImpl<C,E>(name);
}
}
@@ -175,12 +184,12 @@ public:
{
if (isBulkExtraction())
{
typedef InternalBulkExtraction<C> E;
using E = InternalBulkExtraction<C>;
return columnImpl<C,E>(pos);
}
else
{
typedef InternalExtraction<C> E;
using E = InternalExtraction<C>;
return columnImpl<C,E>(pos);
}
}
@@ -200,18 +209,18 @@ public:
{
case STORAGE_VECTOR:
{
typedef typename std::vector<T> C;
using C = typename std::vector<T>;
return column<C>(col).value(row);
}
case STORAGE_LIST:
{
typedef typename std::list<T> C;
using C = typename std::list<T>;
return column<C>(col).value(row);
}
case STORAGE_DEQUE:
case STORAGE_UNKNOWN:
{
typedef typename std::deque<T> C;
using C = typename std::deque<T>;
return column<C>(col).value(row);
}
default:
@@ -230,18 +239,18 @@ public:
{
case STORAGE_VECTOR:
{
typedef typename std::vector<T> C;
using C = typename std::vector<T>;
return column<C>(name).value(row);
}
case STORAGE_LIST:
{
typedef typename std::list<T> C;
using C = typename std::list<T>;
return column<C>(name).value(row);
}
case STORAGE_DEQUE:
case STORAGE_UNKNOWN:
{
typedef typename std::deque<T> C;
using C = typename std::deque<T>;
return column<C>(name).value(row);
}
default:
@@ -404,8 +413,8 @@ private:
std::size_t columnPosition(const std::string& name) const
/// Returns the position of the column with specified name.
{
typedef typename C::value_type T;
typedef const E* ExtractionVecPtr;
using T = typename C::value_type;
using ExtractionVecPtr = const E*;
bool typeFound = false;
@@ -443,8 +452,8 @@ private:
const Column<C>& columnImpl(std::size_t pos) const
/// Returns the reference to column at specified position.
{
typedef typename C::value_type T;
typedef const E* ExtractionVecPtr;
using T = typename C::value_type;
using ExtractionVecPtr = const E*;
const AbstractExtractionVec& rExtractions = extractions();
@@ -532,13 +541,20 @@ inline std::size_t RecordSet::columnCount() const
}
inline Statement& RecordSet::operator = (const Statement& stmt)
inline RecordSet& RecordSet::operator = (const Statement& stmt)
{
reset(stmt);
return *this;
}
inline RecordSet& RecordSet::operator = (const RecordSet& other)
{
reset(other);
return *this;
}
inline Poco::Dynamic::Var RecordSet::value(const std::string& name)
{
return value(name, _currentRow);

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

@@ -57,9 +57,9 @@ class Data_API Row
/// The stream operator is provided for Row data type as a free-standing function.
{
public:
typedef RowFormatter::NameVec NameVec;
typedef RowFormatter::NameVecPtr NameVecPtr;
typedef RowFormatter::ValueVec ValueVec;
using NameVec = RowFormatter::NameVec;
using NameVecPtr = RowFormatter::NameVecPtr;
using ValueVec = RowFormatter::ValueVec;
enum ComparisonType
{
@@ -69,14 +69,14 @@ public:
COMPARE_AS_STRING
};
typedef Tuple<std::size_t, ComparisonType> SortTuple;
typedef std::vector<SortTuple> SortMap;
using SortTuple = Tuple<std::size_t, ComparisonType>;
using SortMap = std::vector<SortTuple>;
/// The type for map holding fields used for sorting criteria.
/// Fields are added sequentially and have precedence that
/// corresponds to field adding sequence order (rather than field's
/// position in the row).
/// This requirement rules out use of std::map due to its sorted nature.
typedef SharedPtr<SortMap> SortMapPtr;
using SortMapPtr = SharedPtr<SortMap>;
Row();
/// Creates the Row.

10
Data/include/Poco/Data/RowFilter.h
View File

@@ -68,11 +68,11 @@ public:
};
typedef bool (*CompT)(const Poco::Dynamic::Var&, const Poco::Dynamic::Var&);
typedef AutoPtr<RowFilter> Ptr;
typedef std::map<std::string, Comparison> Comparisons;
typedef Tuple<Poco::Dynamic::Var, Comparison, LogicOperator> ComparisonEntry;
typedef std::multimap<std::string, ComparisonEntry> ComparisonMap;
typedef std::map<AutoPtr<RowFilter>, LogicOperator> FilterMap;
using Ptr = AutoPtr<RowFilter>;
using Comparisons = std::map<std::string, Comparison>;
using ComparisonEntry = Tuple<Poco::Dynamic::Var, Comparison, LogicOperator>;
using ComparisonMap = std::multimap<std::string, ComparisonEntry>;
using FilterMap = std::map<AutoPtr<RowFilter>, LogicOperator>;
RowFilter(RecordSet* pRecordSet);
/// Creates the top-level RowFilter and associates it with the recordset.

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

@@ -68,10 +68,10 @@ 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;
using Ptr = SharedPtr<RowFormatter>;
using NameVec = std::vector<std::string>;
using NameVecPtr = SharedPtr<std::vector<std::string>>;
using ValueVec = std::vector<Poco::Dynamic::Var>;
static const int INVALID_ROW_COUNT = -1;

16
Data/include/Poco/Data/RowIterator.h
View File

@@ -36,11 +36,11 @@ class Data_API RowIterator
/// RowIterator class.
{
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef Row value_type;
typedef std::ptrdiff_t difference_type;
typedef Row* pointer;
typedef Row& reference;
using iterator_category = std::bidirectional_iterator_tag;
using value_type = Row;
using difference_type = std::ptrdiff_t;
using pointer = Row*;
using reference = Row&;
static const std::size_t POSITION_END;
/// End position indicator.
@@ -53,12 +53,18 @@ public:
RowIterator(const RowIterator& other);
/// Creates a copy of other RowIterator.
RowIterator(RowIterator&& other) noexcept;
/// Move constructor.
~RowIterator();
/// Destroys the RowIterator.
RowIterator& operator = (const RowIterator& other);
/// Assigns the other RowIterator.
RowIterator& operator = (RowIterator&& other) noexcept;
/// Move assignment.
bool operator == (const RowIterator& other) const;
/// Equality operator.

10
Data/include/Poco/Data/SQLChannel.h
View File

@@ -61,6 +61,8 @@ class Data_API SQLChannel: public Poco::Channel
/// a risk of long blocking periods in case of remote server communication delays.
{
public:
using Ptr = Poco::AutoPtr<SQLChannel>;
SQLChannel();
/// Creates SQLChannel.
@@ -140,10 +142,10 @@ protected:
~SQLChannel();
private:
typedef Poco::SharedPtr<Session> SessionPtr;
typedef Poco::SharedPtr<Statement> StatementPtr;
typedef Poco::Message::Priority Priority;
typedef Poco::SharedPtr<ArchiveStrategy> StrategyPtr;
using SessionPtr = Poco::SharedPtr<Session>;
using StatementPtr = Poco::SharedPtr<Statement>;
using Priority = Poco::Message::Priority;
using StrategyPtr = Poco::SharedPtr<ArchiveStrategy>;
void initLogStatement();
/// Initiallizes the log statement.

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

@@ -176,9 +176,15 @@ public:
Session(const Session&);
/// Creates a session by copying another one.
Session(Session&&) noexcept;
/// Creates a session by moving another one.
Session& operator = (const Session&);
/// Assignment operator.
Session& operator = (Session&&) noexcept;
/// Move assignment.
~Session();
/// Destroys the Session.

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

@@ -39,7 +39,7 @@ class Data_API SessionImpl: public Poco::RefCountedObject
/// SessionImpl objects are noncopyable.
{
public:
typedef Poco::AutoPtr<SessionImpl> Ptr;
using Ptr = Poco::AutoPtr<SessionImpl>;
static const std::size_t LOGIN_TIMEOUT_INFINITE = 0;
/// Infinite connection/login timeout.

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

@@ -30,9 +30,9 @@ class Data_API SimpleRowFormatter: public RowFormatter
/// A simple row formatting class.
{
public:
//typedef RowFormatter::NameVec NameVec;
//typedef RowFormatter::NameVecPtr NameVecPtr;
//typedef RowFormatter::ValueVec ValueVec;
//using NameVec = RowFormatter::NameVec;
//using NameVecPtr = RowFormatter::NameVecPtr;
//using ValueVec = RowFormatter::ValueVec;
static const int DEFAULT_COLUMN_WIDTH = 16;
static const int DEFAULT_SPACING = 1;

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

@@ -74,10 +74,10 @@ class Data_API Statement
public:
typedef void (*Manipulator)(Statement&);
typedef ActiveResult<std::size_t> Result;
typedef SharedPtr<Result> ResultPtr;
typedef ActiveMethod<std::size_t, bool, StatementImpl> AsyncExecMethod;
typedef SharedPtr<AsyncExecMethod> AsyncExecMethodPtr;
using Result = ActiveResult<std::size_t>;
using ResultPtr = SharedPtr<Result>;
using AsyncExecMethod = ActiveMethod<std::size_t, bool, StatementImpl>;
using AsyncExecMethodPtr = SharedPtr<AsyncExecMethod>;
static const int WAIT_FOREVER = -1;
@@ -115,9 +115,15 @@ public:
/// synchronized prior to copy operation (i.e. is copied while executing),
/// this constructor shall synchronize it.
Statement(Statement&& other) noexcept;
/// Move constructor.
Statement& operator = (const Statement& stmt);
/// Assignment operator.
Statement& operator = (Statement&& stmt) noexcept;
/// Move assignment.
void swap(Statement& other);
/// Swaps the statement with another one.
@@ -379,7 +385,7 @@ public:
/// Statement takes the ownership of the formatter.
protected:
typedef StatementImpl::Ptr ImplPtr;
using ImplPtr = StatementImpl::Ptr;
const AbstractExtractionVec& extractions() const;
/// Returns the extractions vector.
@@ -406,7 +412,6 @@ protected:
/// Returns the underlying session.
private:
const Result& doAsyncExec(bool reset = true);
/// Asynchronously executes the statement.

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

@@ -41,11 +41,17 @@ public:
StatementCreator(const StatementCreator& other);
/// Creates a StatementCreator by copying another one.
StatementCreator(StatementCreator&& other) noexcept;
/// Creates a StatementCreator by moving another one.
~StatementCreator();
/// Destroys the StatementCreator.
StatementCreator& operator = (const StatementCreator& other);
/// Assignment operator.
StatementCreator& operator = (StatementCreator&& other) noexcept;
/// Assignment operator.
void swap(StatementCreator& other);
/// Swaps the StatementCreator with another one.

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

@@ -48,7 +48,7 @@ class Data_API StatementImpl
/// StatementImpl's are noncopyable.
{
public:
typedef Poco::SharedPtr<StatementImpl> Ptr;
using Ptr = Poco::SharedPtr<StatementImpl>;
enum State
{
@@ -243,11 +243,11 @@ protected:
/// session is queried for container type setting. If the
/// session container type setting is found, it is used.
/// 3. If neither session nor statement have the internal
/// container type set, std::deque is used.
/// container type set, std::vector is used.
///
/// Supported internal extraction container types are:
/// - std::deque (default)
/// - std::vector
/// - std::vector (default)
/// - std::deque
/// - std::list
SessionImpl& session();
@@ -317,7 +317,7 @@ private:
/// Resets extraction so it can be reused again.
template <class C>
SharedPtr<InternalExtraction<C> > createExtract(const MetaColumn& mc)
SharedPtr<InternalExtraction<C>> createExtract(const MetaColumn& mc)
{
C* pData = new C;
Column<C>* pCol = new Column<C>(mc, pData);
@@ -325,7 +325,7 @@ private:
}
template <class C>
SharedPtr<InternalBulkExtraction<C> > createBulkExtract(const MetaColumn& mc)
SharedPtr<InternalBulkExtraction<C>> createBulkExtract(const MetaColumn& mc)
{
C* pData = new C;
Column<C>* pCol = new Column<C>(mc, pData);
@@ -346,7 +346,7 @@ private:
/// overrides the session setting for storage, otherwise the
/// session setting is used.
/// If neither this statement nor the session have the storage
/// type set, std::deque is the default container type used.
/// type set, std::vector is the default container type used.
{
std::string storage;
@@ -368,23 +368,23 @@ private:
if (0 == icompare(DEQUE, storage))
{
if (!isBulkExtraction())
addExtract(createExtract<std::deque<T> >(mc));
addExtract(createExtract<std::deque<T>>(mc));
else
addExtract(createBulkExtract<std::deque<T> >(mc));
addExtract(createBulkExtract<std::deque<T>>(mc));
}
else if (0 == icompare(VECTOR, storage))
{
if (!isBulkExtraction())
addExtract(createExtract<std::vector<T> >(mc));
addExtract(createExtract<std::vector<T>>(mc));
else
addExtract(createBulkExtract<std::vector<T> >(mc));
addExtract(createBulkExtract<std::vector<T>>(mc));
}
else if (0 == icompare(LIST, storage))
{
if (!isBulkExtraction())
addExtract(createExtract<std::list<T> >(mc));
addExtract(createExtract<std::list<T>>(mc));
else
addExtract(createBulkExtract<std::list<T> >(mc));
addExtract(createBulkExtract<std::list<T>>(mc));
}
}
@@ -430,7 +430,7 @@ private:
StatementImpl(const StatementImpl& stmt);
StatementImpl& operator = (const StatementImpl& stmt);
typedef std::vector<std::size_t> CountVec;
using CountVec = std::vector<std::size_t>;
State _state;
Limit _extrLimit;

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

@@ -145,7 +145,7 @@ private:
template <class T>
class TypeHandler<std::deque<T> >: public AbstractTypeHandler
class TypeHandler<std::deque<T>>: public AbstractTypeHandler
/// Specialization of type handler for std::deque.
{
public:
@@ -180,7 +180,7 @@ private:
template <class T>
class TypeHandler<std::vector<T> >: public AbstractTypeHandler
class TypeHandler<std::vector<T>>: public AbstractTypeHandler
/// Specialization of type handler for std::vector.
{
public:
@@ -215,7 +215,7 @@ private:
template <class T>
class TypeHandler<std::list<T> >: public AbstractTypeHandler
class TypeHandler<std::list<T>>: public AbstractTypeHandler
/// Specialization of type handler for std::list.
{
public:
@@ -249,7 +249,7 @@ private:
};
template <typename T>
class TypeHandler<Nullable<T> >
class TypeHandler<Nullable<T>>
/// Specialization of type handler for Nullable.
{
public:
@@ -363,11 +363,11 @@ template <class T0,
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> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>
{
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;
using TupleConstRef = 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;
using TupleRef = 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;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -493,11 +493,11 @@ template <class T0,
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> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>
{
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;
using TupleConstRef = 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;
using TupleRef = 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;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -618,11 +618,11 @@ template <class T0,
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> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -738,11 +738,11 @@ template <class T0,
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> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -853,11 +853,11 @@ template <class T0,
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> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -963,11 +963,11 @@ template <class T0,
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> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1068,11 +1068,11 @@ template <class T0,
class T11,
class T12,
class T13>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1168,11 +1168,11 @@ template <class T0,
class T10,
class T11,
class T12>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1263,11 +1263,11 @@ template <class T0,
class T9,
class T10,
class T11>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1353,11 +1353,11 @@ template <class T0,
class T8,
class T9,
class T10>
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >
class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1429,11 +1429,11 @@ private:
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1501,11 +1501,11 @@ private:
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1569,11 +1569,11 @@ private:
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1633,11 +1633,11 @@ private:
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1693,11 +1693,11 @@ private:
template <class T0, class T1, class T2, class T3, class T4, class T5>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1749,11 +1749,11 @@ private:
template <class T0, class T1, class T2, class T3, class T4>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1801,11 +1801,11 @@ private:
template <class T0, class T1, class T2, class T3>
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, T3, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1849,11 +1849,11 @@ private:
template <class T0, class T1, class T2>
class TypeHandler<Poco::Tuple<T0, T1, T2, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, T2, NullTypeList>>
{
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;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1893,11 +1893,11 @@ private:
template <class T0, class T1>
class TypeHandler<Poco::Tuple<T0, T1, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, T1, NullTypeList>>
{
public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList> >::REFTYPE TupleRef;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1933,11 +1933,11 @@ private:
template <class T0>
class TypeHandler<Poco::Tuple<T0, NullTypeList> >
class TypeHandler<Poco::Tuple<T0, NullTypeList>>
{
public:
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList> >::CONSTREFTYPE TupleConstRef;
typedef typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList> >::REFTYPE TupleRef;
using TupleConstRef = typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList>>::CONSTREFTYPE;
using TupleRef = typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList>>::REFTYPE;
static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
{
@@ -1970,7 +1970,7 @@ private:
template <class K, class V>
class TypeHandler<std::pair<K, V> >: public AbstractTypeHandler
class TypeHandler<std::pair<K, V>>: public AbstractTypeHandler
{
public:
static void bind(std::size_t pos, const std::pair<K, V>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
@@ -2006,7 +2006,7 @@ private:
template <class T>
class TypeHandler<Poco::AutoPtr<T> >: public AbstractTypeHandler
class TypeHandler<Poco::AutoPtr<T>>: public AbstractTypeHandler
/// Specialization of type handler for Poco::AutoPtr
{
public:
@@ -2046,7 +2046,7 @@ private:
template <class T>
class TypeHandler<Poco::SharedPtr<T> >: public AbstractTypeHandler
class TypeHandler<Poco::SharedPtr<T>>: public AbstractTypeHandler
/// Specialization of type handler for Poco::SharedPtr
{
public: