generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-01-06 08:41:11 +01:00
Code Issues Projects Releases Wiki Activity
48c86cf806
poco/Foundation/include/Poco/Tuple.h
Aleksandar Fabijanic 238306a6ed C++11 support #1793 (#1795) 
* * C++14 detection
* C++14 RWLock (disabled: std::shared_timed_mutex has separate read and write unlock)

* * C++11 Event - disable because
std::condition_variable nas no built-in concept of reset
std::condition_variable may be unblocked spuriously, must handle?

* * Fix std::condition_variable handling

* * C++11 semaphore

* * Use Semaphore max paramater

* * Implement manual reset Event and re-enable
* Disable std semaphore, C++ doesn't have native semaphore, better to use native ones for now

* * C++11 Thread (in progress)

* * Fix auto reset event

* * std::*mutex with timeout doesn't guarantee that the timeout will be respected
* Thread in unix has special member for signal handling

* * Workaround for AppleClang lack of thread_local

* * C++11 format

* * C++11 Logger

* * Fix Poco::format

* * std::function event delegate

* * Fix StdFunctionDelegate for GCC

* * C++11 move semantics

* * Fix format test

* * Add cpp11_changes files

* * Auto detect compiler C++11/14 support
* Option to force disable C++11/14

* * GCC/Clang need to enable C++11/14 support via command line switches

* * Fixes for VS2013 C++11 support

* * Makefile C++11/14 compiler detection (in progress)

* * Simple GCC version detection

* AppleClang version detection

* Fix gcc c++11 build script
Update c++11 status document

* Use predefined constant instead of --version

* Fix CC & CXX to gcc 4.8 for all matrix rows.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Restore apt-get update -qq

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Display g++ version and full g++ command line

* Fix typo

* Use command line/environment variables for CC & CXX

* Display GCCVERSION

* Use $(CXX) for setting GCCVERSION

* Do not use <cstdint>, otherwise NumberFormatter wo'nt compile

* restore silent mode on make

* Use predefined constants __clang_major__ and __clang_minor__

* Reverse clang++ options

* Add c++11/14 detection

* -std=c++14 is not valid for clang 3.4

* Run tests for both gcc 4.6 & gcc 4.8

* Restore Apple clang setup

* Align setup of std=c++11 from CLANGVERSION with check of clang version in Platform_POSIX.h

On Linux ubuntu at Travis, clang 3.4 does not support std=c++14

* Add OSX run with clang

* Add forgetted Linux guard on install

* Display clang's predefined constants on OSX

* Comment out Apple temporarly

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* export CC & CXX for OSX

* Test when clang is from Apple

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Remove typo

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Align test with comment

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Add Cygwin-clang

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Install CppUnit for running the unit tests on OSX. 

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Looking for libCppUnit.1.dylib

* Install libCppUnit*.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Exclude Redis for OSX. To be restored later on.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Remove some display lines

* Reenable tests

* Add run tests on cmake build with ctest -VV

* Split runtests.sh into ignored.sh and excluded.sh. ignored.sh will be
used for excluding tests from ctest.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Add ignored.sh to exclude CPPUNIT_IGNORE test on ctest

* Set proper path

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Exclude Data* from CTest. Run tests on ARM

* Add POCO_BASE for tests using test files under $POCO_BASE/component/testsuite

* Replace MB by KB otherwise Travis & AppVeyor are timing out.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Specialize runtests.sh & excluded.sh according to OSX or Linux

* Split OSX/Linux runtests.sh

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Removed invalid comment

* Make runtests.sh executable

* c++11 atomic<> default constructor is never initialized

* Initialize to 0 in any case.

* Comment out set -ev for now

* Comment out set -ev for now

* reset verbose mode

* reset verbose mode

*  catch SIGPIPE as returnfrom testrunner to avoid failure in networking tests

* Use source for export ignored tests to avoid the permission denied problem

* chmod 775

* Apply patches from @RangeIReale

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Add cpp11-appleclang

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Initialize AtomicCounter to 0 since the c++11 default constructor don't
do it.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* avoid SIGPIPE on send

* fix WbeSocketServer

* Remove SIGPIPE workaround

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Fix WebSocketServer

* Restore set -ev

* Restore set -ev

* Fix WebSocketServer responding loop

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Cleanup the exit test.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Add important comment.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Copy also cpp11-* so that mkrelease works!

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Avoid PocoDoc preprocessisng error.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* * Sync script and Platform_POSIX.h compiler versions

* VS2013 & VS2015 fixups.

Signed-off-by: Francis ANDRE <zosrothko@orange.fr>

* Backport to c++03 so that Travis and Appveyor be ok

Signed-off-by: Francis ANDRE <zosrothko@orange.fr>

* Add Copyright (c) 2016, Applied Informatics Software Engineering GmbH.
and Contributors.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* VS2013 fixup

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Backport to c++03

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* VS2013 fixup

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Backport to c++03

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* VS2013 fixup

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* BAckport c++03

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* OSX: clang++ rejects return (*static_cast<Derived*>(this));
cannot cast protected base class 'cpp_ex4::StoplightContext<cpp_ex4::Stoplight>' to 'cpp_ex4::Stoplight'


Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* BAckport to c++03

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Add generated file for now

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* deleted as source file name in lowercase.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Rename stoplight_sm.h to Stoplight_sm.h

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Rename stoplight_sm.h to Stoplight_sm.h

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Rename stoplight_sm.h to Stoplight_sm.h

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Put cmake and ctest on the DOS PATH

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Cygwin does not support timed_mutex

* Put installed CMake /CTest on the DOS PATH.

* Repackaging

* Build VS2013 & VS2014 first.

* Add std::string Foundation_API format(const std::string& fmt, const Any& value);

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Restore INLINES macros when compiling with c++03

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Rename stoplight_sm.h to Stoplight_sm.h

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* VS2013 fixup.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Baclport to c++03

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* cpp_ex4::StoplightContext<cpp_ex4::Stoplight> is an inaccessible base of ˜cpp_ex4::Stoplight

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Undef _XOPEN_SOURCE under Cygwin otherwise ulong is undefined.
usr/include/mysql/my_global.h:997:9: error: 'ulong' does not name a type
 typedef ulong nesting_map;  /* Used for flags of nesting constructs */
         ^
In file included from src/SQLExecutor.cpp:38:0:

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Fix merge failure. Set -ev option on shell.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Removed

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Undefine _XOPEN_SOURCE so that typedef unsigned long ulong be defined.

Signed-off-by: FrancisANDRE <zosrothko@orange.fr>

* Remove __*VISIBLE defines as GNU forbids their usage outside the system includes

Signed-off-by: Francis ANDRE <zosrothko@orange.fr>

* Use c++03 as last c++ version.

Signed-off-by: Francis ANDRE <zosrothko@orange.fr>

* MySQL needs ulong which are not visible when compiling with
c++11 and above.

Signed-off-by: Francis ANDRE <zosrothko@orange.fr>

* Add BUILD_CC=gcc to avoid strip issue

* Remove reference to FSM

* make ?= operator does not work with

* Remove BUILD_CC

* Remove FSM since it is now in its own branch

* Don't build Cygwin64 with std=c++14 until this issue be fixed https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77441

* enable c++11

* remove changes tracking file (moved to project)

* C++11: fixes for Travis CI (#1798)

* Use c++11 compliant compiler: g++ 5 & clang 3.5.0

* Fix typo on IntType

* Use Linux-clang config instead of Linux

* Check arm-linux-gnueabi-g++ version. Dump compiler constants

* Fix missing namespace qualifier

* Ignore ltdl for Cygwin platform

* Fix typo

* Commented out arm-linux-gnueabi-g++ since the version 4.7.0 which does
not support c++11 standard.

* Restore logic as in develop branch

* Add CXXFLAGS for launching the CXX compilation. CXXFLAGS defaulted to
-std=c++11

* Replace auto_ptr by unique_ptr

* Comment out failing tests until be fixed

* C++11: Fix AppVeyor CI yaml (#1812)

* C++11 support #1793: It's time. g++4.9, clang3.3 and VS2015 will become
minimum compiler versions.

* Comment out image with VS2017 since it crashes.

* New release of OpenSSL: 1_1_0f

* Refactor the download steps of OpenSSL

* C++11 support: Add VS2017 Win32 & x64 (#1816)

* Add VS2017.

* Use VSSetup to get VS150COMNTOOLS

* Fix VS150COMNTOOLS value

* Ignore Install-Module

* Install VSSetUp PS module.

* Fix typo missing $

* Split InstallPath againt "="

* Adjust VS150COMMONTOOLS path.

* Exit failed is VS commontools is undefined.

* Get the InstalledPath property value

* Replace mysql-5.7.17 by mysql-5.7.18

* Replace mysql-5.7.17 by mysql-5.7.18

* c++11 thread priority and affinity, and more (#1811)

* * c++11 thread priority and affinity
* AtomicCounter wasn't using std::atomic
* Buffer wasn't setting all fields on move
* Poco::Event is not directly available in c++11, keep using the native versions
* UnWindows.h define NOMINMAX to reduce conflicts
* Remove "-static" from Linux GCC parameters, this conflicts with c++11 classes (https://stackoverflow.com/questions/7090623/c0x-thread-static-linking-problem)
* Link "-lrt" before "-lpthread" on Linux, otherwise won't build on GCC 5+

* * Fixed std::thread POSIX handle

* * Fix OSX compilation

* raise cmake min version to 3.2.0

* Remove CMake jobs since it is already tested on Travis (#1832)

* Remove CMake jobs since it is already tested on Travis

* Add clang-3.7

* Ubuntu Trusty LLVM repo for gettign clang versions.

* Remove 3.3 & 3.4

* Add clang 3.8, clang 3.9 & clang 4.0

* Add CXXFLAGS=-stdlib=libc++

* use libstdc++ instead of libc++

* Remove for now -g compiler option to avoid this spurious error on clang
error: debug information for auto is not yet supported

* Use -ftemplate-backtrace-limit=0 to dump the recursive template stack.

* Cleanup

* Use good gcc version

* Fix gcc-5 & g++-5 name

* Use libc++ instead of libstdc++

* Restore installation of gcc-5

* Readd agt-get update for gcc-5/g++-5

* Reswitch from libc++ to libstdc++

* Increase template evaluation stack size up to 340 to avoid a stack
overflow in parsing 
TupleType t = std::make_tuple(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14...

* Add clang 3.4, 3.5, 3.6

* Adjust template evaluation stack for clang  3.4, 3.5, 3.6, 3.7

* Update notifications

* Add gcc-4.9

* Backport Travis CXXFLAGS to config/Linux-clang

* Remove CXXFLAGS from clang tests

* Test g++ first, then clang++ and then arm

* remove all non-c++11 code and POCO_ENABLE_CPP11 (default now)

* remove old file

* windows c++11 fixes

* fix conversion warning

* C++11: Use Mutex_POSIX for Cygwin since it does not support std::timed_mutex (#1864)

* Use Mutex_POSIX for Cygwin since it does not support std::timed_mutex

* Use Mutex_POSIX for Cygwin since it does not support std::timed_mutex

* Add Mutext_POSIX.cpp

* Json/parser (#1858)

* move parser implementation in separate file

* parser replacement, first attempt (wip)

* making tests pass (mostly done, 3 to go)

* add missing headers

* honor no-null-byte-in-string setting

* few more fixes

* add -std=c99

* fix cmake JSON build and formatting

* accept utf-8, fix tests

* skip calling isdigit()

* #740, #1860, license update, a warning fix

* var emtpy()->clear(); json array and object tidy up

* vs 2015 32-bit project update

* update VS2017 projects

* remove ProGen and all VS files older than 2015

* fixed GH #1865: AbstractEvent::hasDelegates() is not thread-safe

* merge develop

* add missing files

* add VS generated dir to gitignore

* add WEC2013.cmake

* fix exception message

* fix VS2017 ODBC project filter

* integrate PageCompiler changes from poco-1.7.9

* vs2015 openssl build

* added POCO_DEPRECATED macro

* added POCO_NO_DEPRECATED to disarm POCO_DEPRECATED macro

* PageCompiler: support <%@ include file="<path>" %> syntax for includes.

* remove '$Id$' headers

* remove '$Id$' headers

* remove old VMS and VxWorks build support

* Poco::NamedMutex and Poco::NamedEvent (System V Semaphores implementation): files are now opened with O_RDONLY | O_CREAT instead of O_WRONLY | O_CREAT, allowing sharing between different users. Furthermore, ftok() is called with 'p' as project ID argument.

* C++11 (#1887)

* Use Mutex_POSIX for Cygwin since it does not support std::timed_mutex

* Use Mutex_POSIX for Cygwin since it does not support std::timed_mutex

* Add Mutext_POSIX.cpp

* Remove clang 3.4, 3.5, 3.6, 3.7, 3.8, 3.9 since LLVM does not provide
anymore their packages for Ubuntu Trusy

* Remove ubuntu-toolchain-r/test/ubuntu since it is already installed

* Comment our the llvl-toolchain-trusty since its checksum is buggy
See https://bugs.llvm.org/show_bug.cgi?id=34572

* Display g++ version (#1889)

* merge change from develop|

* Support for PKCS#12 (#1876)

* rebuild openssl binaries; warning and stlye fixes

* fix vs2015 projects and openssl linking

* add PKCS12Container

* remove comments

* style

* add ECKey* and CryptoException

* EC key, unify RSA and EC under same inheritance, add constructor from PKCS12, couple of EC key tests

* simplify EVPPKey, ad EC tests

* EVPPKey test and fixes

* fix linux build

* PKCS12 tests and fixes

* linux build, fix crash

* fix leaks

* uncomment ifstream tests, some minor fixes

* fix stream tests and some tidy-up

* remove $Id

* add ECDSA

* update makefile

* align PKCS12 constructors signatures with X509

* EVPPKey EC curve name constructor

* ECDSA fixes and tests

* linux build, wrap tests in try/catch to get full exception message

* style

* update VS projects

* remove openssl, modify VS projects for git submodule directories

* add openssl submodule

* add _CRT_SECURE_NO_WARNINGS

* port crypto dev fixes from 1.8

* lock whole Event:set()

* fix openssl include path

* Add <memory> for std::unique_ptr (#1891)

* Missing include <iostream> (#1893)

* add file/stream load/save capabilities to EVPPKey

* add EVPTest

* add #include <typeinfo>

* fix posix compile

* update samples VS projects

* fix g++ test compile error
2017-09-20 22:13:19 -05:00

1820 lines
55 KiB
C++
Raw Blame History

//
// Tuple.h
//
// Library: Foundation
// Package: Core
// Module: Tuple
//
// Definition of the Tuple class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Tuple_INCLUDED
#define Foundation_Tuple_INCLUDED
// TODO: std::tuple doesn't accept partial initialization
//#define POCO_CXX11_TUPLE_FINISHED
#include "Poco/Foundation.h"
#if defined(POCO_CXX11_TUPLE_FINISHED)
#include <tuple>
#endif
#include "Poco/TypeList.h"
namespace Poco {
#if defined(POCO_CXX11_TUPLE_FINISHED)
template<class ...Types>
class Tuple : public std::tuple<Types...>
{
public:
//using std::tuple<Types...>::tuple;
Tuple() : std::tuple<Types...>()
{
}
/*
Tuple(Types... args) : std::tuple<Types...>(args...)
{
}
*/
template < typename ...Args >
Tuple(Args&&... args) : std::tuple<Types...>(std::forward<Args>(args)...)
{
}
//Tuple(const Tuple<Types...> &other) = delete;
//Tuple(const Tuple<Types...> &&other) = delete;
/*
Tuple(Types&... args) : std::tuple<Types...>(args...)
{
}
Tuple(Types&&... args) : std::tuple<Types...>(args...)
{
}
*/
enum TupleLengthType
{
length = std::tuple_size<std::tuple<Types...>>::value
};
template <int N, typename C>
void set(C value)
{
std::get<N>(*this) = value;
}
template <int N>
typename std::tuple_element<N, std::tuple<Types...>>::type& get()
{
return std::get<N>(*this);
}
};
#else
#if defined(_MSC_VER)
#define POCO_TYPEWRAPPER_DEFAULTVALUE(T) TypeWrapper<T>::TYPE()
#else
#define POCO_TYPEWRAPPER_DEFAULTVALUE(T) typename TypeWrapper<T>::TYPE()
#endif
template <class T0,
class T1 = NullTypeList,
class T2 = NullTypeList,
class T3 = NullTypeList,
class T4 = NullTypeList,
class T5 = NullTypeList,
class T6 = NullTypeList,
class T7 = NullTypeList,
class T8 = NullTypeList,
class T9 = NullTypeList,
class T10 = NullTypeList,
class T11 = NullTypeList,
class T12 = NullTypeList,
class T13 = NullTypeList,
class T14 = NullTypeList,
class T15 = NullTypeList,
class T16 = NullTypeList,
class T17 = NullTypeList,
class T18 = NullTypeList,
class T19 = NullTypeList>
struct Tuple
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18),
typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t10, typename TypeListType<T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t11, typename TypeListType<T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
(t12, typename TypeListType<T13,T14,T15,T16,T17,T18,T19>::HeadType
(t13, typename TypeListType<T14,T15,T16,T17,T18,T19>::HeadType
(t14, typename TypeListType<T15,T16,T17,T18,T19>::HeadType
(t15, typename TypeListType<T16,T17,T18,T19>::HeadType
(t16, typename TypeListType<T17,T18,T19>::HeadType
(t17, typename TypeListType<T18,T19>::HeadType
(t18, typename TypeListType<T19>::HeadType
(t19, NullTypeList()))))))))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17,
class T18>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t10, typename TypeListType<T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
(t11, typename TypeListType<T12,T13,T14,T15,T16,T17,T18>::HeadType
(t12, typename TypeListType<T13,T14,T15,T16,T17,T18>::HeadType
(t13, typename TypeListType<T14,T15,T16,T17,T18>::HeadType
(t14, typename TypeListType<T15,T16,T17,T18>::HeadType
(t15, typename TypeListType<T16,T17,T18>::HeadType
(t16, typename TypeListType<T17,T18>::HeadType
(t17, typename TypeListType<T18>::HeadType
(t18, NullTypeList())))))))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16,
class T17>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
(t10, typename TypeListType<T11,T12,T13,T14,T15,T16,T17>::HeadType
(t11, typename TypeListType<T12,T13,T14,T15,T16,T17>::HeadType
(t12, typename TypeListType<T13,T14,T15,T16,T17>::HeadType
(t13, typename TypeListType<T14,T15,T16,T17>::HeadType
(t14, typename TypeListType<T15,T16,T17>::HeadType
(t15, typename TypeListType<T16,T17>::HeadType
(t16, typename TypeListType<T17>::HeadType
(t17, NullTypeList()))))))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15,
class T16>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16>::HeadType
(t10, typename TypeListType<T11,T12,T13,T14,T15,T16>::HeadType
(t11, typename TypeListType<T12,T13,T14,T15,T16>::HeadType
(t12, typename TypeListType<T13,T14,T15,T16>::HeadType
(t13, typename TypeListType<T14,T15,T16>::HeadType
(t14, typename TypeListType<T15,T16>::HeadType
(t15, typename TypeListType<T16>::HeadType
(t16, NullTypeList())))))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13,T14,T15>::HeadType
(t10, typename TypeListType<T11,T12,T13,T14,T15>::HeadType
(t11, typename TypeListType<T12,T13,T14,T15>::HeadType
(t12, typename TypeListType<T13,T14,T15>::HeadType
(t13, typename TypeListType<T14,T15>::HeadType
(t14, typename TypeListType<T15>::HeadType
(t15, NullTypeList()))))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13,T14>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13,T14>::HeadType
(t10, typename TypeListType<T11,T12,T13,T14>::HeadType
(t11, typename TypeListType<T12,T13,T14>::HeadType
(t12, typename TypeListType<T13,T14>::HeadType
(t13, typename TypeListType<T14>::HeadType
(t14, NullTypeList())))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12,T13>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12,T13>::HeadType
(t9, typename TypeListType<T10,T11,T12,T13>::HeadType
(t10, typename TypeListType<T11,T12,T13>::HeadType
(t11, typename TypeListType<T12,T13>::HeadType
(t12, typename TypeListType<T13>::HeadType
(t13, NullTypeList()))))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11,T12>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11,T12>::HeadType
(t8, typename TypeListType<T9,T10,T11,T12>::HeadType
(t9, typename TypeListType<T10,T11,T12>::HeadType
(t10, typename TypeListType<T11,T12>::HeadType
(t11, typename TypeListType<T12>::HeadType
(t12, NullTypeList())))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11>
struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10,T11>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10,T11>::HeadType
(t7, typename TypeListType<T8,T9,T10,T11>::HeadType
(t8, typename TypeListType<T9,T10,T11>::HeadType
(t9, typename TypeListType<T10,T11>::HeadType
(t10, typename TypeListType<T11>::HeadType
(t11, NullTypeList()))))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10>
struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9,T10, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9,T10>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9,T10>::HeadType
(t6, typename TypeListType<T7,T8,T9,T10>::HeadType
(t7, typename TypeListType<T8,T9,T10>::HeadType
(t8, typename TypeListType<T9,T10>::HeadType
(t9, typename TypeListType<T10>::HeadType
(t10, NullTypeList())))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9>
struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9, NullTypeList>
{
typedef typename TypeListType<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8,T9>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8,T9>::HeadType
(t5, typename TypeListType<T6,T7,T8,T9>::HeadType
(t6, typename TypeListType<T7,T8,T9>::HeadType
(t7, typename TypeListType<T8,T9>::HeadType
(t8, typename TypeListType<T9>::HeadType
(t9, NullTypeList()))))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8>
struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7,T8>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7,T8>::HeadType
(t4, typename TypeListType<T5,T6,T7,T8>::HeadType
(t5, typename TypeListType<T6,T7,T8>::HeadType
(t6, typename TypeListType<T7,T8>::HeadType
(t7, typename TypeListType<T8>::HeadType
(t8, NullTypeList())))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7>
struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6,T7>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6,T7>::HeadType
(t3, typename TypeListType<T4,T5,T6,T7>::HeadType
(t4, typename TypeListType<T5,T6,T7>::HeadType
(t5, typename TypeListType<T6,T7>::HeadType
(t6, typename TypeListType<T7>::HeadType
(t7, NullTypeList()))))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6>
struct Tuple<T0, T1,T2,T3,T4,T5,T6, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5,T6>::HeadType
(t2, typename TypeListType<T3,T4,T5,T6>::HeadType
(t3, typename TypeListType<T4,T5,T6>::HeadType
(t4, typename TypeListType<T5,T6>::HeadType
(t5, typename TypeListType<T6>::HeadType
(t6, NullTypeList())))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4,
class T5>
struct Tuple<T0, T1,T2,T3,T4,T5, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4,T5>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)):
_data(t0, typename TypeListType<T1,T2,T3,T4,T5>::HeadType
(t1, typename TypeListType<T2,T3,T4,T5>::HeadType
(t2, typename TypeListType<T3,T4,T5>::HeadType
(t3, typename TypeListType<T4,T5>::HeadType
(t4, typename TypeListType<T5>::HeadType
(t5, NullTypeList()))))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3,
class T4>
struct Tuple<T0, T1,T2,T3,T4, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3,T4>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)):
_data(t0, typename TypeListType<T1,T2,T3,T4>::HeadType
(t1, typename TypeListType<T2,T3,T4>::HeadType
(t2, typename TypeListType<T3,T4>::HeadType
(t3, typename TypeListType<T4>::HeadType
(t4, NullTypeList())))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2,
class T3>
struct Tuple<T0, T1,T2,T3, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2,T3>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)):
_data(t0, typename TypeListType<T1,T2,T3>::HeadType
(t1, typename TypeListType<T2,T3>::HeadType
(t2, typename TypeListType<T3>::HeadType
(t3, NullTypeList()))))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1,
class T2>
struct Tuple<T0, T1,T2, NullTypeList>
{
typedef typename TypeListType<T0,T1,T2>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)):
_data(t0, typename TypeListType<T1,T2>::HeadType
(t1, typename TypeListType<T2>::HeadType
(t2, NullTypeList())))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0,
class T1>
struct Tuple<T0, T1, NullTypeList>
{
typedef typename TypeListType<T0,T1>::HeadType Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)):
_data(t0, typename TypeListType<T1>::HeadType(t1, NullTypeList()))
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
template <class T0>
struct Tuple<T0, NullTypeList>
{
typedef TypeList<T0, NullTypeList> Type;
enum TupleLengthType
{
length = Type::length
};
Tuple():_data()
{
}
Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0):
_data(t0, NullTypeList())
{
}
template <int N>
typename TypeGetter<N, Type>::ConstHeadType& get() const
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
typename TypeGetter<N, Type>::HeadType& get()
{
return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
}
template <int N>
void set(typename TypeGetter<N, Type>::ConstHeadType& val)
{
Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
}
bool operator == (const Tuple& other) const
{
return _data == other._data;
}
bool operator != (const Tuple& other) const
{
return !(_data == other._data);
}
bool operator < (const Tuple& other) const
{
return _data < other._data;
}
private:
Type _data;
};
#endif
} // namespace Poco
#endif // Foundation_Tuple_INCLUDED
Reference in New Issue View Git Blame Copy Permalink