source: XMLIO_V2/external/include/Poco/NamedTuple.h @ 80

Last change on this file since 80 was 80, checked in by ymipsl, 14 years ago

ajout lib externe
  • Property svn:eol-style set to native
File size: 154.2 KB
Line 
1//
2// NamedTuple.h
3//
4// $Id: //poco/1.3/Foundation/include/Poco/NamedTuple.h#3 $
5//
6// Library: Foundation
7// Package: Core
8// Module:  NamedTuple
9//
10// Definition of the NamedTuple class.
11//
12// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
13// and Contributors.
14//
15// Permission is hereby granted, free of charge, to any person or organization
16// obtaining a copy of the software and accompanying documentation covered by
17// this license (the "Software") to use, reproduce, display, distribute,
18// execute, and transmit the Software, and to prepare derivative works of the
19// Software, and to permit third-parties to whom the Software is furnished to
20// do so, all subject to the following:
21//
22// The copyright notices in the Software and this entire statement, including
23// the above license grant, this restriction and the following disclaimer,
24// must be included in all copies of the Software, in whole or in part, and
25// all derivative works of the Software, unless such copies or derivative
26// works are solely in the form of machine-executable object code generated by
27// a source language processor.
28//
29// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
31// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
32// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
33// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
34// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
35// DEALINGS IN THE SOFTWARE.
36//
37
38
39#ifndef Foundation_NamedTuple_INCLUDED
40#define Foundation_NamedTuple_INCLUDED
41
42
43#include "Poco/Foundation.h"
44#include "Poco/Tuple.h"
45#include "Poco/TypeList.h"
46#include "Poco/DynamicAny.h"
47#include "Poco/SharedPtr.h"
48#include "Poco/Format.h"
49
50
51namespace Poco {
52
53
54template<class T0, 
55    class T1 = NullTypeList,
56    class T2 = NullTypeList,
57    class T3 = NullTypeList,
58    class T4 = NullTypeList,
59    class T5 = NullTypeList,
60    class T6 = NullTypeList,
61    class T7 = NullTypeList, 
62    class T8 = NullTypeList,
63    class T9 = NullTypeList,
64    class T10 = NullTypeList,
65    class T11 = NullTypeList,
66    class T12 = NullTypeList,
67    class T13 = NullTypeList,
68    class T14 = NullTypeList,
69    class T15 = NullTypeList,
70    class T16 = NullTypeList,
71    class T17 = NullTypeList,
72    class T18 = NullTypeList,
73    class T19 = NullTypeList>
74struct NamedTuple: public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
75{
76        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> TupleType;
77        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::Type Type;
78    typedef std::vector<std::string> NameVec; 
79    typedef SharedPtr<NameVec> NameVecPtr; 
80
81    NamedTuple(): _pNames(0)
82    {
83        init();
84    }
85
86    NamedTuple(const NameVecPtr& rNames)
87    {
88        if (rNames->size() != TupleType::length)
89            throw InvalidArgumentException("Wrong names vector length."); 
90
91        _pNames = rNames;
92    }
93
94    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
95        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
96        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
97        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
98        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
99        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
100        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
101        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
102        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
103        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
104        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
105        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
106        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
107        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
108        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
109        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
110        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
111        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
112        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
113        typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
114                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19), 
115                _pNames(0)
116    {
117        init();
118    }
119
120    NamedTuple(const NameVecPtr& rNames, 
121        typename TypeWrapper<T0>::CONSTTYPE& t0,
122        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
123        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
124        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
125        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
126        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
127        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
128        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
129        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
130        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
131        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
132        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
133        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
134        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
135        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
136        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
137        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
138        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
139        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
140        typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
141                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19)
142    {
143                if (rNames->size() != TupleType::length)
144            throw InvalidArgumentException("Wrong names vector length."); 
145
146        _pNames = rNames;
147    }
148
149    NamedTuple(const std::string& n0,
150        typename TypeWrapper<T0>::CONSTTYPE& t0, 
151        const std::string& n1 = "B",
152        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
153        const std::string& n2 = "C",
154        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
155        const std::string& n3 = "D",
156        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
157        const std::string& n4 = "E",
158        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
159        const std::string& n5 = "F",
160        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
161        const std::string& n6 = "G",
162        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
163        const std::string& n7 = "H",
164        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
165        const std::string& n8 = "I",
166        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
167        const std::string& n9 = "J",
168        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
169        const std::string& n10 = "K",
170        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
171        const std::string& n11 = "L",
172        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
173        const std::string& n12 = "M",
174        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
175        const std::string& n13 = "N",
176        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
177        const std::string& n14 = "O",
178        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
179        const std::string& n15 = "P",
180        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
181        const std::string& n16 = "Q",
182        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
183        const std::string& n17 = "R",
184        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
185        const std::string& n18 = "S",
186        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18),
187                const std::string& n19 = "T",
188        typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
189                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19), 
190                _pNames(0) 
191    {
192        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19);
193    }
194
195    const DynamicAny get(const std::string& name) const
196    {
197        NameVec::const_iterator it = _pNames->begin(); 
198        NameVec::const_iterator itEnd = _pNames->end();
199
200        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
201        {
202            if (name == *it)
203            {
204                switch (counter)
205                { 
206                    case 0: return TupleType::template get<0>();
207                    case 1: return TupleType::template get<1>();
208                    case 2: return TupleType::template get<2>();
209                    case 3: return TupleType::template get<3>(); 
210                    case 4: return TupleType::template get<4>();
211                    case 5: return TupleType::template get<5>();
212                    case 6: return TupleType::template get<6>();
213                    case 7: return TupleType::template get<7>(); 
214                    case 8: return TupleType::template get<8>();
215                    case 9: return TupleType::template get<9>();
216                                        case 10: return TupleType::template get<10>();
217                                        case 11: return TupleType::template get<11>();
218                                        case 12: return TupleType::template get<12>();
219                                        case 13: return TupleType::template get<13>();
220                                        case 14: return TupleType::template get<14>();
221                                        case 15: return TupleType::template get<15>();
222                                        case 16: return TupleType::template get<16>();
223                                        case 17: return TupleType::template get<17>();
224                                        case 18: return TupleType::template get<18>();
225                                        case 19: return TupleType::template get<19>();
226                    default: throw RangeException();
227                }
228            }
229        } 
230
231        throw NotFoundException("Name not found: " + name);
232    }
233
234    const DynamicAny operator [] (const std::string& name) const
235    {
236        return get(name);
237    }
238
239    template<int N>
240    typename TypeGetter<N, Type>::ConstHeadType& get() const 
241    {
242        return TupleType::template get<N>();
243    }
244
245    template<int N>
246    typename TypeGetter<N, Type>::HeadType& get()
247    {
248        return TupleType::template get<N>();
249    }
250
251    template<int N>
252    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
253    {
254        return TupleType::template set<N>(val);
255    }
256
257    const NameVecPtr& names()
258    {
259        return _pNames; 
260    }
261
262        void setName(std::size_t index, const std::string& name)
263        {
264                if (index >= _pNames->size())
265                        throw InvalidArgumentException(format("Invalid index: %z", index));
266
267                (*_pNames)[index] = name;
268        }
269
270        const std::string& getName(std::size_t index)
271        {
272                if (index >= _pNames->size())
273                        throw InvalidArgumentException(format("Invalid index: %z", index));
274
275                return (*_pNames)[index];
276        }
277
278    bool operator == (const NamedTuple& other) const
279    {
280        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
281    }
282
283    bool operator != (const NamedTuple& other) const 
284    {
285        return !(*this == other);
286    }
287
288    bool operator < (const NamedTuple& other) const
289    {
290        TupleType th(*this);
291        TupleType oth(other); 
292
293        return (th < oth && _pNames == other._pNames) || 
294            (th == oth && _pNames < other._pNames) ||
295            (th < oth && _pNames < other._pNames);
296    }
297
298private:
299    void init(const std::string& n0 = "A",
300        const std::string& n1 = "B",
301        const std::string& n2 = "C",
302        const std::string& n3 = "D",
303        const std::string& n4 = "E",
304        const std::string& n5 = "F", 
305        const std::string& n6 = "G",
306        const std::string& n7 = "H",
307        const std::string& n8 = "I",
308        const std::string& n9 = "J",
309        const std::string& n10 = "K",
310        const std::string& n11 = "L",
311        const std::string& n12 = "M",
312        const std::string& n13 = "N",
313        const std::string& n14 = "O",
314        const std::string& n15 = "P",
315        const std::string& n16 = "Q",
316        const std::string& n17 = "R",
317        const std::string& n18 = "S",
318        const std::string& n19 = "T")
319    { 
320        if (!_pNames)
321        {
322            _pNames = new NameVec;
323            _pNames->push_back(n0);
324            _pNames->push_back(n1);
325            _pNames->push_back(n2);
326            _pNames->push_back(n3); 
327            _pNames->push_back(n4);
328            _pNames->push_back(n5);
329            _pNames->push_back(n6);
330            _pNames->push_back(n7);
331            _pNames->push_back(n8);
332            _pNames->push_back(n9); 
333                        _pNames->push_back(n10); 
334                        _pNames->push_back(n11); 
335                        _pNames->push_back(n12); 
336                        _pNames->push_back(n13); 
337                        _pNames->push_back(n14); 
338                        _pNames->push_back(n15); 
339                        _pNames->push_back(n16); 
340                        _pNames->push_back(n17); 
341                        _pNames->push_back(n18); 
342                        _pNames->push_back(n19); 
343        }
344    }
345
346    NameVecPtr _pNames;
347};
348
349
350template<class T0, 
351    class T1,
352    class T2,
353    class T3,
354    class T4,
355    class T5,
356    class T6,
357    class T7, 
358    class T8,
359    class T9,
360    class T10,
361    class T11,
362    class T12,
363    class T13,
364    class T14,
365    class T15,
366    class T16,
367    class T17,
368    class T18>
369struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,NullTypeList>:
370        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
371{
372        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> TupleType;
373        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::Type Type;
374    typedef std::vector<std::string> NameVec; 
375    typedef SharedPtr<NameVec> NameVecPtr; 
376
377    NamedTuple(): _pNames(0)
378    {
379        init();
380    }
381
382    NamedTuple(const NameVecPtr& rNames) 
383    {
384        if (rNames->size() != TupleType::length)
385            throw InvalidArgumentException("Wrong names vector length."); 
386
387        _pNames = rNames;
388    }
389
390    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
391        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
392        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
393        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
394        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
395        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
396        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
397        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
398        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
399        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
400        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
401        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
402        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
403        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
404        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
405        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
406        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
407        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
408        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
409                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18), 
410                _pNames(0)
411    {
412        init();
413    }
414
415    NamedTuple(const NameVecPtr& rNames, 
416        typename TypeWrapper<T0>::CONSTTYPE& t0,
417        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
418        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
419        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
420        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
421        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
422        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
423        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
424        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
425        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
426        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
427        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
428        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
429        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
430        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
431        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
432        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
433        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
434        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
435                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18)
436    {
437                if (rNames->size() != TupleType::length)
438            throw InvalidArgumentException("Wrong names vector length."); 
439
440        _pNames = rNames;
441    }
442
443    NamedTuple(const std::string& n0,
444        typename TypeWrapper<T0>::CONSTTYPE& t0, 
445        const std::string& n1 = "B",
446        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
447        const std::string& n2 = "C",
448        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
449        const std::string& n3 = "D",
450        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
451        const std::string& n4 = "E",
452        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
453        const std::string& n5 = "F",
454        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
455        const std::string& n6 = "G",
456        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
457        const std::string& n7 = "H",
458        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
459        const std::string& n8 = "I",
460        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
461        const std::string& n9 = "J",
462        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
463        const std::string& n10 = "K",
464        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
465        const std::string& n11 = "L",
466        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
467        const std::string& n12 = "M",
468        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
469        const std::string& n13 = "N",
470        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
471        const std::string& n14 = "O",
472        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
473        const std::string& n15 = "P",
474        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
475        const std::string& n16 = "Q",
476        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
477        const std::string& n17 = "R",
478        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
479        const std::string& n18 = "S",
480        typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
481                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18), 
482                _pNames(0) 
483    {
484        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18);
485    }
486
487    const DynamicAny get(const std::string& name) const
488    {
489        NameVec::const_iterator it = _pNames->begin(); 
490        NameVec::const_iterator itEnd = _pNames->end();
491
492        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
493        {
494            if (name == *it)
495            {
496                switch (counter)
497                { 
498                    case 0: return TupleType::template get<0>();
499                    case 1: return TupleType::template get<1>();
500                    case 2: return TupleType::template get<2>();
501                    case 3: return TupleType::template get<3>(); 
502                    case 4: return TupleType::template get<4>();
503                    case 5: return TupleType::template get<5>();
504                    case 6: return TupleType::template get<6>();
505                    case 7: return TupleType::template get<7>(); 
506                    case 8: return TupleType::template get<8>();
507                    case 9: return TupleType::template get<9>();
508                                        case 10: return TupleType::template get<10>();
509                                        case 11: return TupleType::template get<11>();
510                                        case 12: return TupleType::template get<12>();
511                                        case 13: return TupleType::template get<13>();
512                                        case 14: return TupleType::template get<14>();
513                                        case 15: return TupleType::template get<15>();
514                                        case 16: return TupleType::template get<16>();
515                                        case 17: return TupleType::template get<17>();
516                                        case 18: return TupleType::template get<18>();
517                    default: throw RangeException();
518                }
519            }
520        } 
521
522                throw NotFoundException("Name not found: " + name);
523    }
524
525    const DynamicAny operator [] (const std::string& name) const
526    {
527        return get(name);
528    }
529
530    template<int N>
531    typename TypeGetter<N, Type>::ConstHeadType& get() const 
532    {
533        return TupleType::template get<N>();
534    }
535
536    template<int N>
537    typename TypeGetter<N, Type>::HeadType& get()
538    {
539        return TupleType::template get<N>();
540    }
541
542    template<int N>
543    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
544    {
545        return TupleType::template set<N>(val);
546    }
547
548    const NameVecPtr& names()
549    {
550        return _pNames; 
551    }
552
553    void setName(std::size_t index, const std::string& name)
554        {
555                if (index >= _pNames->size())
556                        throw InvalidArgumentException(format("Invalid index: %z", index));
557
558                (*_pNames)[index] = name;
559        }
560
561        const std::string& getName(std::size_t index)
562        {
563                if (index >= _pNames->size())
564                        throw InvalidArgumentException(format("Invalid index: %z", index));
565
566                return (*_pNames)[index];
567        }
568
569    bool operator == (const NamedTuple& other) const
570    {
571        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
572    }
573
574    bool operator != (const NamedTuple& other) const 
575    {
576        return !(*this == other);
577    }
578
579    bool operator < (const NamedTuple& other) const
580    {
581        TupleType th(*this);
582        TupleType oth(other); 
583
584        return (th < oth && _pNames == other._pNames) || 
585            (th == oth && _pNames < other._pNames) ||
586            (th < oth && _pNames < other._pNames);
587    }
588
589private:
590    void init(const std::string& n0 = "A",
591        const std::string& n1 = "B",
592        const std::string& n2 = "C",
593        const std::string& n3 = "D",
594        const std::string& n4 = "E",
595        const std::string& n5 = "F", 
596        const std::string& n6 = "G",
597        const std::string& n7 = "H",
598        const std::string& n8 = "I",
599        const std::string& n9 = "J",
600        const std::string& n10 = "K",
601        const std::string& n11 = "L",
602        const std::string& n12 = "M",
603        const std::string& n13 = "N",
604        const std::string& n14 = "O",
605        const std::string& n15 = "P",
606        const std::string& n16 = "Q",
607        const std::string& n17 = "R",
608        const std::string& n18 = "S")
609    { 
610        if (!_pNames)
611        {
612            _pNames = new NameVec;
613            _pNames->push_back(n0);
614            _pNames->push_back(n1);
615            _pNames->push_back(n2);
616            _pNames->push_back(n3); 
617            _pNames->push_back(n4);
618            _pNames->push_back(n5);
619            _pNames->push_back(n6);
620            _pNames->push_back(n7);
621            _pNames->push_back(n8);
622            _pNames->push_back(n9); 
623                        _pNames->push_back(n10); 
624                        _pNames->push_back(n11); 
625                        _pNames->push_back(n12); 
626                        _pNames->push_back(n13); 
627                        _pNames->push_back(n14); 
628                        _pNames->push_back(n15); 
629                        _pNames->push_back(n16); 
630                        _pNames->push_back(n17); 
631                        _pNames->push_back(n18); 
632        }
633    }
634
635    NameVecPtr _pNames;
636};
637
638
639template<class T0, 
640    class T1,
641    class T2,
642    class T3,
643    class T4,
644    class T5,
645    class T6,
646    class T7, 
647    class T8,
648    class T9,
649    class T10,
650    class T11,
651    class T12,
652    class T13,
653    class T14,
654    class T15,
655    class T16,
656    class T17>
657struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>:
658        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
659{
660        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> TupleType;
661        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::Type Type;
662    typedef std::vector<std::string> NameVec; 
663    typedef SharedPtr<NameVec> NameVecPtr; 
664
665    NamedTuple(): _pNames(0)
666    {
667        init();
668    }
669
670    NamedTuple(const NameVecPtr& rNames)
671    {
672        if (rNames->size() != TupleType::length)
673            throw InvalidArgumentException("Wrong names vector length."); 
674
675        _pNames = rNames;
676    }
677
678    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
679        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
680        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
681        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
682        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
683        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
684        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
685        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
686        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
687        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
688        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
689        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
690        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
691        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
692        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
693        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
694        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
695        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
696                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17), 
697                _pNames(0)
698    {
699        init();
700    }
701
702    NamedTuple(const NameVecPtr& rNames, 
703        typename TypeWrapper<T0>::CONSTTYPE& t0,
704        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
705        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
706        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
707        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
708        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
709        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
710        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
711        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
712        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
713        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
714        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
715        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
716        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
717        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
718        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
719        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
720        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
721                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17)
722    {
723                if (rNames->size() != TupleType::length)
724            throw InvalidArgumentException("Wrong names vector length."); 
725
726        _pNames = rNames;
727    }
728
729    NamedTuple(const std::string& n0,
730        typename TypeWrapper<T0>::CONSTTYPE& t0, 
731        const std::string& n1 = "B",
732        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
733        const std::string& n2 = "C",
734        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
735        const std::string& n3 = "D",
736        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
737        const std::string& n4 = "E",
738        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
739        const std::string& n5 = "F",
740        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
741        const std::string& n6 = "G",
742        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
743        const std::string& n7 = "H",
744        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
745        const std::string& n8 = "I",
746        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
747        const std::string& n9 = "J",
748        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
749        const std::string& n10 = "K",
750        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
751        const std::string& n11 = "L",
752        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
753        const std::string& n12 = "M",
754        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
755        const std::string& n13 = "N",
756        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
757        const std::string& n14 = "O",
758        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
759        const std::string& n15 = "P",
760        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
761        const std::string& n16 = "Q",
762        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
763        const std::string& n17 = "R",
764        typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
765                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17), 
766                _pNames(0) 
767    {
768        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17);
769    }
770
771    const DynamicAny get(const std::string& name) const
772    {
773        NameVec::const_iterator it = _pNames->begin(); 
774        NameVec::const_iterator itEnd = _pNames->end();
775
776        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
777        {
778            if (name == *it)
779            {
780                switch (counter)
781                { 
782                    case 0: return TupleType::template get<0>();
783                    case 1: return TupleType::template get<1>();
784                    case 2: return TupleType::template get<2>();
785                    case 3: return TupleType::template get<3>(); 
786                    case 4: return TupleType::template get<4>();
787                    case 5: return TupleType::template get<5>();
788                    case 6: return TupleType::template get<6>();
789                    case 7: return TupleType::template get<7>(); 
790                    case 8: return TupleType::template get<8>();
791                    case 9: return TupleType::template get<9>();
792                                        case 10: return TupleType::template get<10>();
793                                        case 11: return TupleType::template get<11>();
794                                        case 12: return TupleType::template get<12>();
795                                        case 13: return TupleType::template get<13>();
796                                        case 14: return TupleType::template get<14>();
797                                        case 15: return TupleType::template get<15>();
798                                        case 16: return TupleType::template get<16>();
799                                        case 17: return TupleType::template get<17>();
800                    default: throw RangeException();
801                }
802            }
803        } 
804
805                throw NotFoundException("Name not found: " + name);
806    }
807
808    const DynamicAny operator [] (const std::string& name) const
809    {
810        return get(name);
811    }
812
813    template<int N>
814    typename TypeGetter<N, Type>::ConstHeadType& get() const 
815    {
816        return TupleType::template get<N>();
817    }
818
819    template<int N>
820    typename TypeGetter<N, Type>::HeadType& get()
821    {
822        return TupleType::template get<N>();
823    }
824
825    template<int N>
826    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
827    {
828        return TupleType::template set<N>(val);
829    }
830
831    const NameVecPtr& names()
832    {
833        return _pNames; 
834    }
835
836    void setName(std::size_t index, const std::string& name)
837        {
838                if (index >= _pNames->size())
839                        throw InvalidArgumentException(format("Invalid index: %z", index));
840
841                (*_pNames)[index] = name;
842        }
843
844        const std::string& getName(std::size_t index)
845        {
846                if (index >= _pNames->size())
847                        throw InvalidArgumentException(format("Invalid index: %z", index));
848
849                return (*_pNames)[index];
850        }
851
852    bool operator == (const NamedTuple& other) const
853    {
854        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
855    }
856
857    bool operator != (const NamedTuple& other) const 
858    {
859        return !(*this == other);
860    }
861
862    bool operator < (const NamedTuple& other) const
863    {
864        TupleType th(*this);
865        TupleType oth(other); 
866
867        return (th < oth && _pNames == other._pNames) || 
868            (th == oth && _pNames < other._pNames) ||
869            (th < oth && _pNames < other._pNames);
870    }
871
872private:
873    void init(const std::string& n0 = "A",
874        const std::string& n1 = "B",
875        const std::string& n2 = "C",
876        const std::string& n3 = "D",
877        const std::string& n4 = "E",
878        const std::string& n5 = "F", 
879        const std::string& n6 = "G",
880        const std::string& n7 = "H",
881        const std::string& n8 = "I",
882        const std::string& n9 = "J",
883        const std::string& n10 = "K",
884        const std::string& n11 = "L",
885        const std::string& n12 = "M",
886        const std::string& n13 = "N",
887        const std::string& n14 = "O",
888        const std::string& n15 = "P",
889        const std::string& n16 = "Q",
890        const std::string& n17 = "R")
891    { 
892        if (!_pNames)
893        {
894            _pNames = new NameVec;
895            _pNames->push_back(n0);
896            _pNames->push_back(n1);
897            _pNames->push_back(n2);
898            _pNames->push_back(n3); 
899            _pNames->push_back(n4);
900            _pNames->push_back(n5);
901            _pNames->push_back(n6);
902            _pNames->push_back(n7);
903            _pNames->push_back(n8);
904            _pNames->push_back(n9); 
905                        _pNames->push_back(n10); 
906                        _pNames->push_back(n11); 
907                        _pNames->push_back(n12); 
908                        _pNames->push_back(n13); 
909                        _pNames->push_back(n14); 
910                        _pNames->push_back(n15); 
911                        _pNames->push_back(n16); 
912                        _pNames->push_back(n17); 
913        }
914    }
915
916    NameVecPtr _pNames;
917};
918
919
920template<class T0, 
921    class T1,
922    class T2,
923    class T3,
924    class T4,
925    class T5,
926    class T6,
927    class T7, 
928    class T8,
929    class T9,
930    class T10,
931    class T11,
932    class T12,
933    class T13,
934    class T14,
935    class T15,
936    class T16>
937struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>:
938        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
939{
940        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> TupleType;
941        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::Type Type;
942    typedef std::vector<std::string> NameVec; 
943    typedef SharedPtr<NameVec> NameVecPtr; 
944
945    NamedTuple(): _pNames(0)
946    {
947        init();
948    }
949
950    NamedTuple(const NameVecPtr& rNames) 
951    {
952        if (rNames->size() != TupleType::length)
953            throw InvalidArgumentException("Wrong names vector length."); 
954
955        _pNames = rNames;
956    }
957
958    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
959        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
960        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
961        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
962        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
963        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
964        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
965        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
966        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
967        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
968        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
969        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
970        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
971        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
972        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
973        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
974        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
975                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16), 
976                _pNames(0)
977    {
978        init();
979    }
980
981    NamedTuple(const NameVecPtr& rNames, 
982        typename TypeWrapper<T0>::CONSTTYPE& t0,
983        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
984        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
985        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
986        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
987        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
988        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
989        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
990        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
991        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
992        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
993        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
994        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
995        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
996        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
997        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
998        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
999                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16)
1000    {
1001                if (rNames->size() != TupleType::length)
1002            throw InvalidArgumentException("Wrong names vector length."); 
1003
1004        _pNames = rNames;
1005    }
1006
1007    NamedTuple(const std::string& n0,
1008        typename TypeWrapper<T0>::CONSTTYPE& t0, 
1009        const std::string& n1 = "B",
1010        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1011        const std::string& n2 = "C",
1012        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1013        const std::string& n3 = "D",
1014        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1015        const std::string& n4 = "E",
1016        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
1017        const std::string& n5 = "F",
1018        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
1019        const std::string& n6 = "G",
1020        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
1021        const std::string& n7 = "H",
1022        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1023        const std::string& n8 = "I",
1024        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1025        const std::string& n9 = "J",
1026        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
1027        const std::string& n10 = "K",
1028        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
1029        const std::string& n11 = "L",
1030        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
1031        const std::string& n12 = "M",
1032        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
1033        const std::string& n13 = "N",
1034        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
1035        const std::string& n14 = "O",
1036        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
1037        const std::string& n15 = "P",
1038        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
1039        const std::string& n16 = "Q",
1040        typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
1041                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16), 
1042                _pNames(0) 
1043    {
1044        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16);
1045    }
1046
1047    const DynamicAny get(const std::string& name) const
1048    {
1049        NameVec::const_iterator it = _pNames->begin(); 
1050        NameVec::const_iterator itEnd = _pNames->end();
1051
1052        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
1053        {
1054            if (name == *it)
1055            {
1056                switch (counter)
1057                { 
1058                    case 0: return TupleType::template get<0>();
1059                    case 1: return TupleType::template get<1>();
1060                    case 2: return TupleType::template get<2>();
1061                    case 3: return TupleType::template get<3>(); 
1062                    case 4: return TupleType::template get<4>();
1063                    case 5: return TupleType::template get<5>();
1064                    case 6: return TupleType::template get<6>();
1065                    case 7: return TupleType::template get<7>(); 
1066                    case 8: return TupleType::template get<8>();
1067                    case 9: return TupleType::template get<9>();
1068                                        case 10: return TupleType::template get<10>();
1069                                        case 11: return TupleType::template get<11>();
1070                                        case 12: return TupleType::template get<12>();
1071                                        case 13: return TupleType::template get<13>();
1072                                        case 14: return TupleType::template get<14>();
1073                                        case 15: return TupleType::template get<15>();
1074                                        case 16: return TupleType::template get<16>();
1075                    default: throw RangeException();
1076                }
1077            }
1078        } 
1079
1080                throw NotFoundException("Name not found: " + name);
1081    }
1082
1083    const DynamicAny operator [] (const std::string& name) const
1084    {
1085        return get(name);
1086    }
1087
1088    template<int N>
1089    typename TypeGetter<N, Type>::ConstHeadType& get() const 
1090    {
1091        return TupleType::template get<N>();
1092    }
1093
1094    template<int N>
1095    typename TypeGetter<N, Type>::HeadType& get()
1096    {
1097        return TupleType::template get<N>();
1098    }
1099
1100    template<int N>
1101    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
1102    {
1103        return TupleType::template set<N>(val);
1104    }
1105
1106    const NameVecPtr& names()
1107    {
1108        return _pNames; 
1109    }
1110
1111    void setName(std::size_t index, const std::string& name)
1112        {
1113                if (index >= _pNames->size())
1114                        throw InvalidArgumentException(format("Invalid index: %z", index));
1115
1116                (*_pNames)[index] = name;
1117        }
1118
1119        const std::string& getName(std::size_t index)
1120        {
1121                if (index >= _pNames->size())
1122                        throw InvalidArgumentException(format("Invalid index: %z", index));
1123
1124                return (*_pNames)[index];
1125        }
1126
1127    bool operator == (const NamedTuple& other) const
1128    {
1129        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
1130    }
1131
1132    bool operator != (const NamedTuple& other) const 
1133    {
1134        return !(*this == other);
1135    }
1136
1137    bool operator < (const NamedTuple& other) const
1138    {
1139        TupleType th(*this);
1140        TupleType oth(other); 
1141
1142        return (th < oth && _pNames == other._pNames) || 
1143            (th == oth && _pNames < other._pNames) ||
1144            (th < oth && _pNames < other._pNames);
1145    }
1146
1147private:
1148    void init(const std::string& n0 = "A",
1149        const std::string& n1 = "B",
1150        const std::string& n2 = "C",
1151        const std::string& n3 = "D",
1152        const std::string& n4 = "E",
1153        const std::string& n5 = "F", 
1154        const std::string& n6 = "G",
1155        const std::string& n7 = "H",
1156        const std::string& n8 = "I",
1157        const std::string& n9 = "J",
1158        const std::string& n10 = "K",
1159        const std::string& n11 = "L",
1160        const std::string& n12 = "M",
1161        const std::string& n13 = "N",
1162        const std::string& n14 = "O",
1163        const std::string& n15 = "P",
1164        const std::string& n16 = "Q")
1165    { 
1166        if (!_pNames)
1167        {
1168            _pNames = new NameVec;
1169            _pNames->push_back(n0);
1170            _pNames->push_back(n1);
1171            _pNames->push_back(n2);
1172            _pNames->push_back(n3); 
1173            _pNames->push_back(n4);
1174            _pNames->push_back(n5);
1175            _pNames->push_back(n6);
1176            _pNames->push_back(n7);
1177            _pNames->push_back(n8);
1178            _pNames->push_back(n9); 
1179                        _pNames->push_back(n10); 
1180                        _pNames->push_back(n11); 
1181                        _pNames->push_back(n12); 
1182                        _pNames->push_back(n13); 
1183                        _pNames->push_back(n14); 
1184                        _pNames->push_back(n15); 
1185                        _pNames->push_back(n16); 
1186        }
1187    }
1188
1189    NameVecPtr _pNames;
1190};
1191
1192
1193template<class T0, 
1194    class T1,
1195    class T2,
1196    class T3,
1197    class T4,
1198    class T5,
1199    class T6,
1200    class T7, 
1201    class T8,
1202    class T9,
1203    class T10,
1204    class T11,
1205    class T12,
1206    class T13,
1207    class T14,
1208    class T15>
1209struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>:
1210        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
1211{
1212        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> TupleType;
1213        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::Type Type;
1214
1215    typedef std::vector<std::string> NameVec; 
1216    typedef SharedPtr<NameVec> NameVecPtr; 
1217
1218    NamedTuple(): _pNames(0)
1219    {
1220        init();
1221    }
1222
1223    NamedTuple(const NameVecPtr& rNames) 
1224    {
1225        if (rNames->size() != TupleType::length)
1226            throw InvalidArgumentException("Wrong names vector length."); 
1227
1228        _pNames = rNames;
1229    }
1230
1231    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
1232        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
1233        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1234        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1235        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
1236        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
1237        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
1238        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1239        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1240        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
1241        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
1242        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
1243        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
1244        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
1245        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
1246        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
1247                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15), 
1248                _pNames(0)
1249    {
1250        init();
1251    }
1252
1253    NamedTuple(const NameVecPtr& rNames, 
1254        typename TypeWrapper<T0>::CONSTTYPE& t0,
1255        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1256        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1257        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1258        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
1259        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
1260        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
1261        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1262        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1263        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
1264        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
1265        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
1266        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
1267        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
1268        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
1269        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
1270                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15)
1271    {
1272                if (rNames->size() != TupleType::length)
1273            throw InvalidArgumentException("Wrong names vector length."); 
1274
1275        _pNames = rNames;
1276    }
1277
1278    NamedTuple(const std::string& n0,
1279        typename TypeWrapper<T0>::CONSTTYPE& t0, 
1280        const std::string& n1 = "B",
1281        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1282        const std::string& n2 = "C",
1283        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1284        const std::string& n3 = "D",
1285        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1286        const std::string& n4 = "E",
1287        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
1288        const std::string& n5 = "F",
1289        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
1290        const std::string& n6 = "G",
1291        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
1292        const std::string& n7 = "H",
1293        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1294        const std::string& n8 = "I",
1295        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1296        const std::string& n9 = "J",
1297        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
1298        const std::string& n10 = "K",
1299        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
1300        const std::string& n11 = "L",
1301        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
1302        const std::string& n12 = "M",
1303        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
1304        const std::string& n13 = "N",
1305        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
1306        const std::string& n14 = "O",
1307        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
1308        const std::string& n15 = "P",
1309        typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
1310                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15), 
1311                _pNames(0) 
1312    {
1313        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15);
1314    }
1315
1316    const DynamicAny get(const std::string& name) const
1317    {
1318        NameVec::const_iterator it = _pNames->begin(); 
1319        NameVec::const_iterator itEnd = _pNames->end();
1320
1321        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
1322        {
1323            if (name == *it)
1324            {
1325                switch (counter)
1326                { 
1327                    case 0: return TupleType::template get<0>();
1328                    case 1: return TupleType::template get<1>();
1329                    case 2: return TupleType::template get<2>();
1330                    case 3: return TupleType::template get<3>(); 
1331                    case 4: return TupleType::template get<4>();
1332                    case 5: return TupleType::template get<5>();
1333                    case 6: return TupleType::template get<6>();
1334                    case 7: return TupleType::template get<7>(); 
1335                    case 8: return TupleType::template get<8>();
1336                    case 9: return TupleType::template get<9>();
1337                                        case 10: return TupleType::template get<10>();
1338                                        case 11: return TupleType::template get<11>();
1339                                        case 12: return TupleType::template get<12>();
1340                                        case 13: return TupleType::template get<13>();
1341                                        case 14: return TupleType::template get<14>();
1342                                        case 15: return TupleType::template get<15>();
1343                    default: throw RangeException();
1344                }
1345            }
1346        } 
1347
1348                throw NotFoundException("Name not found: " + name);
1349    }
1350
1351    const DynamicAny operator [] (const std::string& name) const
1352    {
1353        return get(name);
1354    }
1355
1356    template<int N>
1357    typename TypeGetter<N, Type>::ConstHeadType& get() const 
1358    {
1359        return TupleType::template get<N>();
1360    }
1361
1362    template<int N>
1363    typename TypeGetter<N, Type>::HeadType& get()
1364    {
1365        return TupleType::template get<N>();
1366    }
1367
1368    template<int N>
1369    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
1370    {
1371        return TupleType::template set<N>(val);
1372    }
1373
1374    const NameVecPtr& names()
1375    {
1376        return _pNames; 
1377    }
1378
1379    void setName(std::size_t index, const std::string& name)
1380        {
1381                if (index >= _pNames->size())
1382                        throw InvalidArgumentException(format("Invalid index: %z", index));
1383
1384                (*_pNames)[index] = name;
1385        }
1386
1387        const std::string& getName(std::size_t index)
1388        {
1389                if (index >= _pNames->size())
1390                        throw InvalidArgumentException(format("Invalid index: %z", index));
1391
1392                return (*_pNames)[index];
1393        }
1394
1395    bool operator == (const NamedTuple& other) const
1396    {
1397        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
1398    }
1399
1400    bool operator != (const NamedTuple& other) const 
1401    {
1402        return !(*this == other);
1403    }
1404
1405    bool operator < (const NamedTuple& other) const
1406    {
1407        TupleType th(*this);
1408        TupleType oth(other); 
1409
1410        return (th < oth && _pNames == other._pNames) || 
1411            (th == oth && _pNames < other._pNames) ||
1412            (th < oth && _pNames < other._pNames);
1413    }
1414
1415private:
1416    void init(const std::string& n0 = "A",
1417        const std::string& n1 = "B",
1418        const std::string& n2 = "C",
1419        const std::string& n3 = "D",
1420        const std::string& n4 = "E",
1421        const std::string& n5 = "F", 
1422        const std::string& n6 = "G",
1423        const std::string& n7 = "H",
1424        const std::string& n8 = "I",
1425        const std::string& n9 = "J",
1426        const std::string& n10 = "K",
1427        const std::string& n11 = "L",
1428        const std::string& n12 = "M",
1429        const std::string& n13 = "N",
1430        const std::string& n14 = "O",
1431        const std::string& n15 = "P")
1432    { 
1433        if (!_pNames)
1434        {
1435            _pNames = new NameVec;
1436            _pNames->push_back(n0);
1437            _pNames->push_back(n1);
1438            _pNames->push_back(n2);
1439            _pNames->push_back(n3); 
1440            _pNames->push_back(n4);
1441            _pNames->push_back(n5);
1442            _pNames->push_back(n6);
1443            _pNames->push_back(n7);
1444            _pNames->push_back(n8);
1445            _pNames->push_back(n9); 
1446                        _pNames->push_back(n10); 
1447                        _pNames->push_back(n11); 
1448                        _pNames->push_back(n12); 
1449                        _pNames->push_back(n13); 
1450                        _pNames->push_back(n14); 
1451                        _pNames->push_back(n15); 
1452        }
1453    }
1454
1455    NameVecPtr _pNames;
1456};
1457
1458
1459template<class T0, 
1460    class T1,
1461    class T2,
1462    class T3,
1463    class T4,
1464    class T5,
1465    class T6,
1466    class T7, 
1467    class T8,
1468    class T9,
1469    class T10,
1470    class T11,
1471    class T12,
1472    class T13,
1473    class T14>
1474struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>:
1475        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
1476{
1477        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> TupleType;
1478        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::Type Type;
1479
1480    typedef std::vector<std::string> NameVec; 
1481    typedef SharedPtr<NameVec> NameVecPtr; 
1482
1483    NamedTuple(): _pNames(0)
1484    {
1485        init();
1486    }
1487
1488    NamedTuple(const NameVecPtr& rNames) 
1489    {
1490        if (rNames->size() != TupleType::length)
1491            throw InvalidArgumentException("Wrong names vector length."); 
1492
1493        _pNames = rNames;
1494    }
1495
1496    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
1497        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
1498        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1499        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1500        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
1501        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
1502        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
1503        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1504        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1505        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
1506        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
1507        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
1508        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
1509        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
1510        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
1511                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14), 
1512                _pNames(0)
1513    {
1514        init();
1515    }
1516
1517    NamedTuple(const NameVecPtr& rNames, 
1518        typename TypeWrapper<T0>::CONSTTYPE& t0,
1519        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1520        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1521        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1522        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
1523        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
1524        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
1525        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1526        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1527        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
1528        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
1529        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
1530        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
1531        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
1532        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
1533                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14)
1534    {
1535                if (rNames->size() != TupleType::length)
1536            throw InvalidArgumentException("Wrong names vector length."); 
1537
1538        _pNames = rNames;
1539    }
1540
1541    NamedTuple(const std::string& n0,
1542        typename TypeWrapper<T0>::CONSTTYPE& t0, 
1543        const std::string& n1 = "B",
1544        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1545        const std::string& n2 = "C",
1546        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1547        const std::string& n3 = "D",
1548        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1549        const std::string& n4 = "E",
1550        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
1551        const std::string& n5 = "F",
1552        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
1553        const std::string& n6 = "G",
1554        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
1555        const std::string& n7 = "H",
1556        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1557        const std::string& n8 = "I",
1558        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1559        const std::string& n9 = "J",
1560        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
1561        const std::string& n10 = "K",
1562        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
1563        const std::string& n11 = "L",
1564        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
1565        const std::string& n12 = "M",
1566        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
1567        const std::string& n13 = "N",
1568        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
1569        const std::string& n14 = "O",
1570        typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
1571                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14), 
1572                _pNames(0) 
1573    {
1574        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14);
1575    }
1576
1577    const DynamicAny get(const std::string& name) const
1578    {
1579        NameVec::const_iterator it = _pNames->begin(); 
1580        NameVec::const_iterator itEnd = _pNames->end();
1581
1582        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
1583        {
1584            if (name == *it)
1585            {
1586                switch (counter)
1587                { 
1588                    case 0: return TupleType::template get<0>();
1589                    case 1: return TupleType::template get<1>();
1590                    case 2: return TupleType::template get<2>();
1591                    case 3: return TupleType::template get<3>(); 
1592                    case 4: return TupleType::template get<4>();
1593                    case 5: return TupleType::template get<5>();
1594                    case 6: return TupleType::template get<6>();
1595                    case 7: return TupleType::template get<7>(); 
1596                    case 8: return TupleType::template get<8>();
1597                    case 9: return TupleType::template get<9>();
1598                                        case 10: return TupleType::template get<10>();
1599                                        case 11: return TupleType::template get<11>();
1600                                        case 12: return TupleType::template get<12>();
1601                                        case 13: return TupleType::template get<13>();
1602                                        case 14: return TupleType::template get<14>();
1603                    default: throw RangeException();
1604                }
1605            }
1606        } 
1607
1608                throw NotFoundException("Name not found: " + name);
1609    }
1610
1611    const DynamicAny operator [] (const std::string& name) const
1612    {
1613        return get(name);
1614    }
1615
1616    template<int N>
1617    typename TypeGetter<N, Type>::ConstHeadType& get() const 
1618    {
1619        return TupleType::template get<N>();
1620    }
1621
1622    template<int N>
1623    typename TypeGetter<N, Type>::HeadType& get()
1624    {
1625        return TupleType::template get<N>();
1626    }
1627
1628    template<int N>
1629    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
1630    {
1631        return TupleType::template set<N>(val);
1632    }
1633
1634    const NameVecPtr& names()
1635    {
1636        return _pNames; 
1637    }
1638
1639    void setName(std::size_t index, const std::string& name)
1640        {
1641                if (index >= _pNames->size())
1642                        throw InvalidArgumentException(format("Invalid index: %z", index));
1643
1644                (*_pNames)[index] = name;
1645        }
1646
1647        const std::string& getName(std::size_t index)
1648        {
1649                if (index >= _pNames->size())
1650                        throw InvalidArgumentException(format("Invalid index: %z", index));
1651
1652                return (*_pNames)[index];
1653        }
1654
1655    bool operator == (const NamedTuple& other) const
1656    {
1657        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
1658    }
1659
1660    bool operator != (const NamedTuple& other) const 
1661    {
1662        return !(*this == other);
1663    }
1664
1665    bool operator < (const NamedTuple& other) const
1666    {
1667        TupleType th(*this);
1668        TupleType oth(other); 
1669
1670        return (th < oth && _pNames == other._pNames) || 
1671            (th == oth && _pNames < other._pNames) ||
1672            (th < oth && _pNames < other._pNames);
1673    }
1674
1675private:
1676    void init(const std::string& n0 = "A",
1677        const std::string& n1 = "B",
1678        const std::string& n2 = "C",
1679        const std::string& n3 = "D",
1680        const std::string& n4 = "E",
1681        const std::string& n5 = "F", 
1682        const std::string& n6 = "G",
1683        const std::string& n7 = "H",
1684        const std::string& n8 = "I",
1685        const std::string& n9 = "J",
1686        const std::string& n10 = "K",
1687        const std::string& n11 = "L",
1688        const std::string& n12 = "M",
1689        const std::string& n13 = "N",
1690        const std::string& n14 = "O")
1691    { 
1692        if (!_pNames)
1693        {
1694            _pNames = new NameVec;
1695            _pNames->push_back(n0);
1696            _pNames->push_back(n1);
1697            _pNames->push_back(n2);
1698            _pNames->push_back(n3); 
1699            _pNames->push_back(n4);
1700            _pNames->push_back(n5);
1701            _pNames->push_back(n6);
1702            _pNames->push_back(n7);
1703            _pNames->push_back(n8);
1704            _pNames->push_back(n9); 
1705                        _pNames->push_back(n10); 
1706                        _pNames->push_back(n11); 
1707                        _pNames->push_back(n12); 
1708                        _pNames->push_back(n13); 
1709                        _pNames->push_back(n14); 
1710        }
1711    }
1712
1713    NameVecPtr _pNames;
1714};
1715
1716
1717template<class T0, 
1718    class T1,
1719    class T2,
1720    class T3,
1721    class T4,
1722    class T5,
1723    class T6,
1724    class T7, 
1725    class T8,
1726    class T9,
1727    class T10,
1728    class T11,
1729    class T12,
1730    class T13>
1731struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>:
1732        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
1733{
1734        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> TupleType;
1735        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::Type Type;
1736
1737    typedef std::vector<std::string> NameVec; 
1738    typedef SharedPtr<NameVec> NameVecPtr; 
1739
1740    NamedTuple(): _pNames(0)
1741    {
1742        init();
1743    }
1744
1745    NamedTuple(const NameVecPtr& rNames) 
1746    {
1747        if (rNames->size() != TupleType::length)
1748            throw InvalidArgumentException("Wrong names vector length."); 
1749
1750        _pNames = rNames;
1751    }
1752
1753    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
1754        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
1755        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1756        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1757        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
1758        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
1759        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
1760        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1761        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1762        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
1763        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
1764        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
1765        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
1766        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
1767                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13), 
1768                _pNames(0)
1769    {
1770        init();
1771    }
1772
1773    NamedTuple(const NameVecPtr& rNames, 
1774        typename TypeWrapper<T0>::CONSTTYPE& t0,
1775        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1776        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1777        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1778        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
1779        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
1780        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
1781        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1782        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1783        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
1784        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
1785        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
1786        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
1787        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
1788                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13)
1789    {
1790                if (rNames->size() != TupleType::length)
1791            throw InvalidArgumentException("Wrong names vector length."); 
1792
1793        _pNames = rNames;
1794    }
1795
1796    NamedTuple(const std::string& n0,
1797        typename TypeWrapper<T0>::CONSTTYPE& t0, 
1798        const std::string& n1 = "B",
1799        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
1800        const std::string& n2 = "C",
1801        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
1802        const std::string& n3 = "D",
1803        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
1804        const std::string& n4 = "E",
1805        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
1806        const std::string& n5 = "F",
1807        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
1808        const std::string& n6 = "G",
1809        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
1810        const std::string& n7 = "H",
1811        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
1812        const std::string& n8 = "I",
1813        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
1814        const std::string& n9 = "J",
1815        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
1816        const std::string& n10 = "K",
1817        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
1818        const std::string& n11 = "L",
1819        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
1820        const std::string& n12 = "M",
1821        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
1822        const std::string& n13 = "N",
1823        typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
1824                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13), 
1825                _pNames(0) 
1826    {
1827        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13);
1828    }
1829
1830    const DynamicAny get(const std::string& name) const
1831    {
1832        NameVec::const_iterator it = _pNames->begin(); 
1833        NameVec::const_iterator itEnd = _pNames->end();
1834
1835        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
1836        {
1837            if (name == *it)
1838            {
1839                switch (counter)
1840                { 
1841                    case 0: return TupleType::template get<0>();
1842                    case 1: return TupleType::template get<1>();
1843                    case 2: return TupleType::template get<2>();
1844                    case 3: return TupleType::template get<3>(); 
1845                    case 4: return TupleType::template get<4>();
1846                    case 5: return TupleType::template get<5>();
1847                    case 6: return TupleType::template get<6>();
1848                    case 7: return TupleType::template get<7>(); 
1849                    case 8: return TupleType::template get<8>();
1850                    case 9: return TupleType::template get<9>();
1851                                        case 10: return TupleType::template get<10>();
1852                                        case 11: return TupleType::template get<11>();
1853                                        case 12: return TupleType::template get<12>();
1854                                        case 13: return TupleType::template get<13>();
1855                    default: throw RangeException();
1856                }
1857            }
1858        } 
1859
1860                throw NotFoundException("Name not found: " + name);
1861    }
1862
1863    const DynamicAny operator [] (const std::string& name) const
1864    {
1865        return get(name);
1866    }
1867
1868    template<int N>
1869    typename TypeGetter<N, Type>::ConstHeadType& get() const 
1870    {
1871        return TupleType::template get<N>();
1872    }
1873
1874    template<int N>
1875    typename TypeGetter<N, Type>::HeadType& get()
1876    {
1877        return TupleType::template get<N>();
1878    }
1879
1880    template<int N>
1881    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
1882    {
1883        return TupleType::template set<N>(val);
1884    }
1885
1886    const NameVecPtr& names()
1887    {
1888        return _pNames; 
1889    }
1890
1891    void setName(std::size_t index, const std::string& name)
1892        {
1893                if (index >= _pNames->size())
1894                        throw InvalidArgumentException(format("Invalid index: %z", index));
1895
1896                (*_pNames)[index] = name;
1897        }
1898
1899        const std::string& getName(std::size_t index)
1900        {
1901                if (index >= _pNames->size())
1902                        throw InvalidArgumentException(format("Invalid index: %z", index));
1903
1904                return (*_pNames)[index];
1905        }
1906
1907    bool operator == (const NamedTuple& other) const
1908    {
1909        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
1910    }
1911
1912    bool operator != (const NamedTuple& other) const 
1913    {
1914        return !(*this == other);
1915    }
1916
1917    bool operator < (const NamedTuple& other) const
1918    {
1919        TupleType th(*this);
1920        TupleType oth(other); 
1921
1922        return (th < oth && _pNames == other._pNames) || 
1923            (th == oth && _pNames < other._pNames) ||
1924            (th < oth && _pNames < other._pNames);
1925    }
1926
1927private:
1928    void init(const std::string& n0 = "A",
1929        const std::string& n1 = "B",
1930        const std::string& n2 = "C",
1931        const std::string& n3 = "D",
1932        const std::string& n4 = "E",
1933        const std::string& n5 = "F", 
1934        const std::string& n6 = "G",
1935        const std::string& n7 = "H",
1936        const std::string& n8 = "I",
1937        const std::string& n9 = "J",
1938        const std::string& n10 = "K",
1939        const std::string& n11 = "L",
1940        const std::string& n12 = "M",
1941        const std::string& n13 = "N")
1942    { 
1943        if (!_pNames)
1944        {
1945            _pNames = new NameVec;
1946            _pNames->push_back(n0);
1947            _pNames->push_back(n1);
1948            _pNames->push_back(n2);
1949            _pNames->push_back(n3); 
1950            _pNames->push_back(n4);
1951            _pNames->push_back(n5);
1952            _pNames->push_back(n6);
1953            _pNames->push_back(n7);
1954            _pNames->push_back(n8);
1955            _pNames->push_back(n9); 
1956                        _pNames->push_back(n10); 
1957                        _pNames->push_back(n11); 
1958                        _pNames->push_back(n12); 
1959                        _pNames->push_back(n13); 
1960        }
1961    }
1962
1963    NameVecPtr _pNames;
1964};
1965
1966
1967template<class T0, 
1968    class T1,
1969    class T2,
1970    class T3,
1971    class T4,
1972    class T5,
1973    class T6,
1974    class T7, 
1975    class T8,
1976    class T9,
1977    class T10,
1978    class T11,
1979    class T12>
1980struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList>:
1981        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
1982{
1983        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> TupleType;
1984        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::Type Type;
1985
1986    typedef std::vector<std::string> NameVec; 
1987    typedef SharedPtr<NameVec> NameVecPtr; 
1988
1989    NamedTuple(): _pNames(0)
1990    {
1991        init();
1992    }
1993
1994    NamedTuple(const NameVecPtr& rNames) 
1995    {
1996        if (rNames->size() != TupleType::length)
1997            throw InvalidArgumentException("Wrong names vector length."); 
1998
1999        _pNames = rNames;
2000    }
2001
2002    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
2003        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
2004        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2005        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2006        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2007        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2008        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2009        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2010        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2011        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
2012        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
2013        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
2014        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
2015                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), 
2016                _pNames(0)
2017    {
2018        init();
2019    }
2020
2021    NamedTuple(const NameVecPtr& rNames, 
2022        typename TypeWrapper<T0>::CONSTTYPE& t0,
2023        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2024        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2025        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2026        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2027        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2028        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2029        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2030        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2031        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
2032        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
2033        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
2034        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
2035                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12)
2036    {
2037                if (rNames->size() != TupleType::length)
2038            throw InvalidArgumentException("Wrong names vector length."); 
2039
2040        _pNames = rNames;
2041    }
2042
2043    NamedTuple(const std::string& n0,
2044        typename TypeWrapper<T0>::CONSTTYPE& t0, 
2045        const std::string& n1 = "B",
2046        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2047        const std::string& n2 = "C",
2048        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2049        const std::string& n3 = "D",
2050        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2051        const std::string& n4 = "E",
2052        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
2053        const std::string& n5 = "F",
2054        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
2055        const std::string& n6 = "G",
2056        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
2057        const std::string& n7 = "H",
2058        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2059        const std::string& n8 = "I",
2060        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2061        const std::string& n9 = "J",
2062        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
2063        const std::string& n10 = "K",
2064        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
2065        const std::string& n11 = "L",
2066        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
2067        const std::string& n12 = "M",
2068        typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
2069    TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), _pNames(0) 
2070    {
2071        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12);
2072    }
2073
2074    const DynamicAny get(const std::string& name) const
2075    {
2076        NameVec::const_iterator it = _pNames->begin(); 
2077        NameVec::const_iterator itEnd = _pNames->end();
2078
2079        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
2080        {
2081            if (name == *it)
2082            {
2083                switch (counter)
2084                { 
2085                    case 0: return TupleType::template get<0>();
2086                    case 1: return TupleType::template get<1>();
2087                    case 2: return TupleType::template get<2>();
2088                    case 3: return TupleType::template get<3>(); 
2089                    case 4: return TupleType::template get<4>();
2090                    case 5: return TupleType::template get<5>();
2091                    case 6: return TupleType::template get<6>();
2092                    case 7: return TupleType::template get<7>(); 
2093                    case 8: return TupleType::template get<8>();
2094                    case 9: return TupleType::template get<9>();
2095                                        case 10: return TupleType::template get<10>();
2096                                        case 11: return TupleType::template get<11>();
2097                                        case 12: return TupleType::template get<12>();
2098                    default: throw RangeException();
2099                }
2100            }
2101        } 
2102
2103                throw NotFoundException("Name not found: " + name);
2104    }
2105
2106    const DynamicAny operator [] (const std::string& name) const
2107    {
2108        return get(name);
2109    }
2110
2111    template<int N>
2112    typename TypeGetter<N, Type>::ConstHeadType& get() const 
2113    {
2114        return TupleType::template get<N>();
2115    }
2116
2117    template<int N>
2118    typename TypeGetter<N, Type>::HeadType& get()
2119    {
2120        return TupleType::template get<N>();
2121    }
2122
2123    template<int N>
2124    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
2125    {
2126        return TupleType::template set<N>(val);
2127    }
2128
2129    const NameVecPtr& names()
2130    {
2131        return _pNames; 
2132    }
2133
2134    void setName(std::size_t index, const std::string& name)
2135        {
2136                if (index >= _pNames->size())
2137                        throw InvalidArgumentException(format("Invalid index: %z", index));
2138
2139                (*_pNames)[index] = name;
2140        }
2141
2142        const std::string& getName(std::size_t index)
2143        {
2144                if (index >= _pNames->size())
2145                        throw InvalidArgumentException(format("Invalid index: %z", index));
2146
2147                return (*_pNames)[index];
2148        }
2149
2150    bool operator == (const NamedTuple& other) const
2151    {
2152        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
2153    }
2154
2155    bool operator != (const NamedTuple& other) const 
2156    {
2157        return !(*this == other);
2158    }
2159
2160    bool operator < (const NamedTuple& other) const
2161    {
2162        TupleType th(*this);
2163        TupleType oth(other); 
2164
2165        return (th < oth && _pNames == other._pNames) || 
2166            (th == oth && _pNames < other._pNames) ||
2167            (th < oth && _pNames < other._pNames);
2168    }
2169
2170private:
2171    void init(const std::string& n0 = "A",
2172        const std::string& n1 = "B",
2173        const std::string& n2 = "C",
2174        const std::string& n3 = "D",
2175        const std::string& n4 = "E",
2176        const std::string& n5 = "F", 
2177        const std::string& n6 = "G",
2178        const std::string& n7 = "H",
2179        const std::string& n8 = "I",
2180        const std::string& n9 = "J",
2181        const std::string& n10 = "K",
2182        const std::string& n11 = "L",
2183        const std::string& n12 = "M")
2184    { 
2185        if (!_pNames)
2186        {
2187            _pNames = new NameVec;
2188            _pNames->push_back(n0);
2189            _pNames->push_back(n1);
2190            _pNames->push_back(n2);
2191            _pNames->push_back(n3); 
2192            _pNames->push_back(n4);
2193            _pNames->push_back(n5);
2194            _pNames->push_back(n6);
2195            _pNames->push_back(n7);
2196            _pNames->push_back(n8);
2197            _pNames->push_back(n9); 
2198                        _pNames->push_back(n10); 
2199                        _pNames->push_back(n11); 
2200                        _pNames->push_back(n12); 
2201        }
2202    }
2203
2204    NameVecPtr _pNames;
2205};
2206
2207
2208template<class T0, 
2209    class T1,
2210    class T2,
2211    class T3,
2212    class T4,
2213    class T5,
2214    class T6,
2215    class T7, 
2216    class T8,
2217    class T9,
2218    class T10,
2219    class T11>
2220struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>:
2221        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
2222{
2223        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> TupleType;
2224        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::Type Type;
2225
2226    typedef std::vector<std::string> NameVec; 
2227    typedef SharedPtr<NameVec> NameVecPtr; 
2228
2229    NamedTuple(): _pNames(0)
2230    {
2231        init();
2232    }
2233
2234    NamedTuple(const NameVecPtr& rNames) 
2235    {
2236        if (rNames->size() != TupleType::length)
2237            throw InvalidArgumentException("Wrong names vector length."); 
2238
2239        _pNames = rNames;
2240    }
2241
2242    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
2243        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
2244        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2245        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2246        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2247        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2248        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2249        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2250        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2251        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
2252        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
2253        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
2254                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11), 
2255                _pNames(0)
2256    {
2257        init();
2258    }
2259
2260    NamedTuple(const NameVecPtr& rNames, 
2261        typename TypeWrapper<T0>::CONSTTYPE& t0,
2262        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2263        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2264        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2265        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2266        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2267        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2268        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2269        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2270        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
2271        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
2272        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
2273                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11)
2274    {
2275                if (rNames->size() != TupleType::length)
2276            throw InvalidArgumentException("Wrong names vector length."); 
2277
2278        _pNames = rNames;
2279    }
2280
2281    NamedTuple(const std::string& n0,
2282        typename TypeWrapper<T0>::CONSTTYPE& t0, 
2283        const std::string& n1 = "B",
2284        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2285        const std::string& n2 = "C",
2286        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2287        const std::string& n3 = "D",
2288        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2289        const std::string& n4 = "E",
2290        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
2291        const std::string& n5 = "F",
2292        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
2293        const std::string& n6 = "G",
2294        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
2295        const std::string& n7 = "H",
2296        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2297        const std::string& n8 = "I",
2298        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2299        const std::string& n9 = "J",
2300        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
2301        const std::string& n10 = "K",
2302        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
2303        const std::string& n11 = "L",
2304        typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
2305                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11), 
2306                _pNames(0) 
2307    {
2308        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11);
2309    }
2310
2311    const DynamicAny get(const std::string& name) const
2312    {
2313        NameVec::const_iterator it = _pNames->begin(); 
2314        NameVec::const_iterator itEnd = _pNames->end();
2315
2316        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
2317        {
2318            if (name == *it)
2319            {
2320                switch (counter)
2321                { 
2322                    case 0: return TupleType::template get<0>();
2323                    case 1: return TupleType::template get<1>();
2324                    case 2: return TupleType::template get<2>();
2325                    case 3: return TupleType::template get<3>(); 
2326                    case 4: return TupleType::template get<4>();
2327                    case 5: return TupleType::template get<5>();
2328                    case 6: return TupleType::template get<6>();
2329                    case 7: return TupleType::template get<7>(); 
2330                    case 8: return TupleType::template get<8>();
2331                    case 9: return TupleType::template get<9>();
2332                                        case 10: return TupleType::template get<10>();
2333                                        case 11: return TupleType::template get<11>();
2334                    default: throw RangeException();
2335                }
2336            }
2337        } 
2338
2339                throw NotFoundException("Name not found: " + name);
2340    }
2341
2342    const DynamicAny operator [] (const std::string& name) const
2343    {
2344        return get(name);
2345    }
2346
2347    template<int N>
2348    typename TypeGetter<N, Type>::ConstHeadType& get() const 
2349    {
2350        return TupleType::template get<N>();
2351    }
2352
2353    template<int N>
2354    typename TypeGetter<N, Type>::HeadType& get()
2355    {
2356        return TupleType::template get<N>();
2357    }
2358
2359    template<int N>
2360    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
2361    {
2362        return TupleType::template set<N>(val);
2363    }
2364
2365    const NameVecPtr& names()
2366    {
2367        return _pNames; 
2368    }
2369
2370    void setName(std::size_t index, const std::string& name)
2371        {
2372                if (index >= _pNames->size())
2373                        throw InvalidArgumentException(format("Invalid index: %z", index));
2374
2375                (*_pNames)[index] = name;
2376        }
2377
2378        const std::string& getName(std::size_t index)
2379        {
2380                if (index >= _pNames->size())
2381                        throw InvalidArgumentException(format("Invalid index: %z", index));
2382
2383                return (*_pNames)[index];
2384        }
2385
2386    bool operator == (const NamedTuple& other) const
2387    {
2388        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
2389    }
2390
2391    bool operator != (const NamedTuple& other) const 
2392    {
2393        return !(*this == other);
2394    }
2395
2396    bool operator < (const NamedTuple& other) const
2397    {
2398        TupleType th(*this);
2399        TupleType oth(other); 
2400
2401        return (th < oth && _pNames == other._pNames) || 
2402            (th == oth && _pNames < other._pNames) ||
2403            (th < oth && _pNames < other._pNames);
2404    }
2405
2406private:
2407    void init(const std::string& n0 = "A",
2408        const std::string& n1 = "B",
2409        const std::string& n2 = "C",
2410        const std::string& n3 = "D",
2411        const std::string& n4 = "E",
2412        const std::string& n5 = "F", 
2413        const std::string& n6 = "G",
2414        const std::string& n7 = "H",
2415        const std::string& n8 = "I",
2416        const std::string& n9 = "J",
2417        const std::string& n10 = "K",
2418        const std::string& n11 = "L")
2419    { 
2420        if (!_pNames)
2421        {
2422            _pNames = new NameVec;
2423            _pNames->push_back(n0);
2424            _pNames->push_back(n1);
2425            _pNames->push_back(n2);
2426            _pNames->push_back(n3); 
2427            _pNames->push_back(n4);
2428            _pNames->push_back(n5);
2429            _pNames->push_back(n6);
2430            _pNames->push_back(n7);
2431            _pNames->push_back(n8);
2432            _pNames->push_back(n9); 
2433                        _pNames->push_back(n10); 
2434                        _pNames->push_back(n11); 
2435        }
2436    }
2437
2438    NameVecPtr _pNames;
2439};
2440
2441
2442template<class T0, 
2443    class T1,
2444    class T2,
2445    class T3,
2446    class T4,
2447    class T5,
2448    class T6,
2449    class T7, 
2450    class T8,
2451    class T9,
2452    class T10>
2453struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,NullTypeList>:
2454        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
2455{
2456        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleType;
2457        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::Type Type;
2458
2459    typedef std::vector<std::string> NameVec; 
2460    typedef SharedPtr<NameVec> NameVecPtr; 
2461
2462    NamedTuple(): _pNames(0)
2463    {
2464        init();
2465    }
2466
2467    NamedTuple(const NameVecPtr& rNames) 
2468    {
2469        if (rNames->size() != TupleType::length)
2470            throw InvalidArgumentException("Wrong names vector length."); 
2471
2472        _pNames = rNames;
2473    }
2474
2475    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
2476        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
2477        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2478        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2479        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2480        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2481        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2482        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2483        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2484        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
2485        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
2486                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), 
2487                _pNames(0)
2488    {
2489        init();
2490    }
2491
2492    NamedTuple(const NameVecPtr& rNames, 
2493        typename TypeWrapper<T0>::CONSTTYPE& t0,
2494        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2495        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2496        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2497        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2498        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2499        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2500        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2501        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2502        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
2503        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
2504                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10)
2505    {
2506                if (rNames->size() != TupleType::length)
2507            throw InvalidArgumentException("Wrong names vector length."); 
2508
2509        _pNames = rNames;
2510    }
2511
2512    NamedTuple(const std::string& n0,
2513        typename TypeWrapper<T0>::CONSTTYPE& t0, 
2514        const std::string& n1 = "B",
2515        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2516        const std::string& n2 = "C",
2517        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2518        const std::string& n3 = "D",
2519        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2520        const std::string& n4 = "E",
2521        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
2522        const std::string& n5 = "F",
2523        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
2524        const std::string& n6 = "G",
2525        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
2526        const std::string& n7 = "H",
2527        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2528        const std::string& n8 = "I",
2529        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2530        const std::string& n9 = "J",
2531        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
2532        const std::string& n10 = "K",
2533        typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
2534    TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), _pNames(0) 
2535    {
2536        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10);
2537    }
2538
2539    const DynamicAny get(const std::string& name) const
2540    {
2541        NameVec::const_iterator it = _pNames->begin(); 
2542        NameVec::const_iterator itEnd = _pNames->end();
2543
2544        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
2545        {
2546            if (name == *it)
2547            {
2548                switch (counter)
2549                { 
2550                    case 0: return TupleType::template get<0>();
2551                    case 1: return TupleType::template get<1>();
2552                    case 2: return TupleType::template get<2>();
2553                    case 3: return TupleType::template get<3>(); 
2554                    case 4: return TupleType::template get<4>();
2555                    case 5: return TupleType::template get<5>();
2556                    case 6: return TupleType::template get<6>();
2557                    case 7: return TupleType::template get<7>(); 
2558                    case 8: return TupleType::template get<8>();
2559                    case 9: return TupleType::template get<9>();
2560                                        case 10: return TupleType::template get<10>();
2561                    default: throw RangeException();
2562                }
2563            }
2564        } 
2565
2566                throw NotFoundException("Name not found: " + name);
2567    }
2568
2569    const DynamicAny operator [] (const std::string& name) const
2570    {
2571        return get(name);
2572    }
2573
2574    template<int N>
2575    typename TypeGetter<N, Type>::ConstHeadType& get() const 
2576    {
2577        return TupleType::template get<N>();
2578    }
2579
2580    template<int N>
2581    typename TypeGetter<N, Type>::HeadType& get()
2582    {
2583        return TupleType::template get<N>();
2584    }
2585
2586    template<int N>
2587    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
2588    {
2589        return TupleType::template set<N>(val);
2590    }
2591
2592    const NameVecPtr& names()
2593    {
2594        return _pNames; 
2595    }
2596
2597    void setName(std::size_t index, const std::string& name)
2598        {
2599                if (index >= _pNames->size())
2600                        throw InvalidArgumentException(format("Invalid index: %z", index));
2601
2602                (*_pNames)[index] = name;
2603        }
2604
2605        const std::string& getName(std::size_t index)
2606        {
2607                if (index >= _pNames->size())
2608                        throw InvalidArgumentException(format("Invalid index: %z", index));
2609
2610                return (*_pNames)[index];
2611        }
2612
2613    bool operator == (const NamedTuple& other) const
2614    {
2615        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
2616    }
2617
2618    bool operator != (const NamedTuple& other) const 
2619    {
2620        return !(*this == other);
2621    }
2622
2623    bool operator < (const NamedTuple& other) const
2624    {
2625        TupleType th(*this);
2626        TupleType oth(other); 
2627
2628        return (th < oth && _pNames == other._pNames) || 
2629            (th == oth && _pNames < other._pNames) ||
2630            (th < oth && _pNames < other._pNames);
2631    }
2632
2633private:
2634    void init(const std::string& n0 = "A",
2635        const std::string& n1 = "B",
2636        const std::string& n2 = "C",
2637        const std::string& n3 = "D",
2638        const std::string& n4 = "E",
2639        const std::string& n5 = "F", 
2640        const std::string& n6 = "G",
2641        const std::string& n7 = "H",
2642        const std::string& n8 = "I",
2643        const std::string& n9 = "J",
2644        const std::string& n10 = "K")
2645    { 
2646        if (!_pNames)
2647        {
2648            _pNames = new NameVec;
2649            _pNames->push_back(n0);
2650            _pNames->push_back(n1);
2651            _pNames->push_back(n2);
2652            _pNames->push_back(n3); 
2653            _pNames->push_back(n4);
2654            _pNames->push_back(n5);
2655            _pNames->push_back(n6);
2656            _pNames->push_back(n7);
2657            _pNames->push_back(n8);
2658            _pNames->push_back(n9); 
2659                        _pNames->push_back(n10); 
2660        }
2661    }
2662
2663    NameVecPtr _pNames;
2664};
2665
2666
2667template<class T0, 
2668    class T1,
2669    class T2,
2670    class T3,
2671    class T4,
2672    class T5,
2673    class T6,
2674    class T7, 
2675    class T8,
2676    class T9>
2677struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,NullTypeList>:
2678        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
2679{
2680        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleType;
2681        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type Type;
2682
2683    typedef std::vector<std::string> NameVec; 
2684    typedef SharedPtr<NameVec> NameVecPtr; 
2685
2686    NamedTuple(): _pNames(0)
2687    {
2688        init();
2689    }
2690
2691    NamedTuple(const NameVecPtr& rNames) 
2692    {
2693        if (rNames->size() != TupleType::length)
2694            throw InvalidArgumentException("Wrong names vector length."); 
2695
2696        _pNames = rNames;
2697    }
2698
2699    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
2700        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
2701        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2702        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2703        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2704        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2705        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2706        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2707        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2708        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
2709                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9), 
2710                _pNames(0)
2711    {
2712        init();
2713    }
2714
2715    NamedTuple(const NameVecPtr& rNames, 
2716        typename TypeWrapper<T0>::CONSTTYPE& t0,
2717        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2718        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2719        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2720        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2721        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2722        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2723        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2724        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2725        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
2726                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9)
2727    {
2728                if (rNames->size() != TupleType::length)
2729            throw InvalidArgumentException("Wrong names vector length."); 
2730
2731        _pNames = rNames;
2732    }
2733
2734    NamedTuple(const std::string& n0,
2735        typename TypeWrapper<T0>::CONSTTYPE& t0, 
2736        const std::string& n1 = "B",
2737        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2738        const std::string& n2 = "C",
2739        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2740        const std::string& n3 = "D",
2741        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2742        const std::string& n4 = "E",
2743        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
2744        const std::string& n5 = "F",
2745        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
2746        const std::string& n6 = "G",
2747        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
2748        const std::string& n7 = "H",
2749        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2750        const std::string& n8 = "I",
2751        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
2752        const std::string& n9 = "J",
2753        typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
2754                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9), 
2755                _pNames(0) 
2756    {
2757        init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9);
2758    }
2759
2760    const DynamicAny get(const std::string& name) const
2761    {
2762        NameVec::const_iterator it = _pNames->begin(); 
2763        NameVec::const_iterator itEnd = _pNames->end();
2764
2765        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
2766        {
2767            if (name == *it)
2768            {
2769                switch (counter)
2770                { 
2771                    case 0: return TupleType::template get<0>();
2772                    case 1: return TupleType::template get<1>();
2773                    case 2: return TupleType::template get<2>();
2774                    case 3: return TupleType::template get<3>(); 
2775                    case 4: return TupleType::template get<4>();
2776                    case 5: return TupleType::template get<5>();
2777                    case 6: return TupleType::template get<6>();
2778                    case 7: return TupleType::template get<7>(); 
2779                    case 8: return TupleType::template get<8>();
2780                    case 9: return TupleType::template get<9>();
2781                    default: throw RangeException();
2782                }
2783            }
2784        } 
2785
2786                throw NotFoundException("Name not found: " + name);
2787    }
2788
2789    const DynamicAny operator [] (const std::string& name) const
2790    {
2791        return get(name);
2792    }
2793
2794    template<int N>
2795    typename TypeGetter<N, Type>::ConstHeadType& get() const 
2796    {
2797        return TupleType::template get<N>();
2798    }
2799
2800    template<int N>
2801    typename TypeGetter<N, Type>::HeadType& get()
2802    {
2803        return TupleType::template get<N>();
2804    }
2805
2806    template<int N>
2807    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
2808    {
2809        return TupleType::template set<N>(val);
2810    }
2811
2812    const NameVecPtr& names()
2813    {
2814        return _pNames; 
2815    }
2816
2817    void setName(std::size_t index, const std::string& name)
2818        {
2819                if (index >= _pNames->size())
2820                        throw InvalidArgumentException(format("Invalid index: %z", index));
2821
2822                (*_pNames)[index] = name;
2823        }
2824
2825        const std::string& getName(std::size_t index)
2826        {
2827                if (index >= _pNames->size())
2828                        throw InvalidArgumentException(format("Invalid index: %z", index));
2829
2830                return (*_pNames)[index];
2831        }
2832
2833    bool operator == (const NamedTuple& other) const
2834    {
2835        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
2836    }
2837
2838    bool operator != (const NamedTuple& other) const 
2839    {
2840        return !(*this == other);
2841    }
2842
2843    bool operator < (const NamedTuple& other) const
2844    {
2845        TupleType th(*this);
2846        TupleType oth(other); 
2847
2848        return (th < oth && _pNames == other._pNames) || 
2849            (th == oth && _pNames < other._pNames) ||
2850            (th < oth && _pNames < other._pNames);
2851    }
2852
2853private:
2854    void init(const std::string& n0 = "A",
2855        const std::string& n1 = "B",
2856        const std::string& n2 = "C",
2857        const std::string& n3 = "D",
2858        const std::string& n4 = "E",
2859        const std::string& n5 = "F", 
2860        const std::string& n6 = "G",
2861        const std::string& n7 = "H",
2862        const std::string& n8 = "I",
2863        const std::string& n9 = "J")
2864    { 
2865        if (!_pNames)
2866        {
2867            _pNames = new NameVec;
2868            _pNames->push_back(n0);
2869            _pNames->push_back(n1);
2870            _pNames->push_back(n2);
2871            _pNames->push_back(n3); 
2872            _pNames->push_back(n4);
2873            _pNames->push_back(n5);
2874            _pNames->push_back(n6);
2875            _pNames->push_back(n7);
2876            _pNames->push_back(n8);
2877            _pNames->push_back(n9); 
2878        }
2879    }
2880
2881    NameVecPtr _pNames;
2882};
2883
2884
2885template<class T0, 
2886    class T1,
2887    class T2,
2888    class T3,
2889    class T4,
2890    class T5,
2891    class T6,
2892    class T7, 
2893    class T8>
2894struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,NullTypeList>:
2895        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>
2896{
2897        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8> TupleType;
2898        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>::Type Type;
2899
2900    typedef std::vector<std::string> NameVec; 
2901    typedef SharedPtr<NameVec> NameVecPtr; 
2902
2903    NamedTuple(): _pNames(0)
2904    {
2905        init();
2906    }
2907
2908    NamedTuple(const NameVecPtr& rNames) 
2909    {
2910        if (rNames->size() != TupleType::length)
2911            throw InvalidArgumentException("Wrong names vector length."); 
2912
2913        _pNames = rNames;
2914    }
2915
2916    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
2917        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
2918        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2919        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2920        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2921        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2922        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2923        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2924        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
2925                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8), 
2926                _pNames(0)
2927    {
2928        init();
2929    }
2930
2931    NamedTuple(const NameVecPtr& rNames, 
2932        typename TypeWrapper<T0>::CONSTTYPE& t0,
2933        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2934        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2935        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2936        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
2937        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
2938        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
2939        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2940        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
2941                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8)
2942    {
2943                if (rNames->size() != TupleType::length)
2944            throw InvalidArgumentException("Wrong names vector length."); 
2945
2946        _pNames = rNames;
2947    }
2948
2949    NamedTuple(const std::string& n0,
2950        typename TypeWrapper<T0>::CONSTTYPE& t0, 
2951        const std::string& n1 = "B",
2952        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
2953        const std::string& n2 = "C",
2954        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
2955        const std::string& n3 = "D",
2956        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
2957        const std::string& n4 = "E",
2958        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
2959        const std::string& n5 = "F",
2960        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
2961        const std::string& n6 = "G",
2962        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
2963        const std::string& n7 = "H",
2964        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
2965        const std::string& n8 = "I",
2966        typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
2967                TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8), 
2968                _pNames(0) 
2969    {
2970        init(n0,n1,n2,n3,n4,n5,n6,n7,n8);
2971    }
2972
2973    const DynamicAny get(const std::string& name) const
2974    {
2975        NameVec::const_iterator it = _pNames->begin(); 
2976        NameVec::const_iterator itEnd = _pNames->end();
2977
2978        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
2979        {
2980            if (name == *it)
2981            {
2982                switch (counter)
2983                { 
2984                    case 0: return TupleType::template get<0>();
2985                    case 1: return TupleType::template get<1>();
2986                    case 2: return TupleType::template get<2>();
2987                    case 3: return TupleType::template get<3>(); 
2988                    case 4: return TupleType::template get<4>();
2989                    case 5: return TupleType::template get<5>();
2990                    case 6: return TupleType::template get<6>();
2991                    case 7: return TupleType::template get<7>(); 
2992                    case 8: return TupleType::template get<8>();
2993                    default: throw RangeException();
2994                }
2995            }
2996        } 
2997
2998                throw NotFoundException("Name not found: " + name);
2999    }
3000
3001    const DynamicAny operator [] (const std::string& name) const
3002    {
3003        return get(name);
3004    }
3005
3006    template<int N>
3007    typename TypeGetter<N, Type>::ConstHeadType& get() const 
3008    {
3009        return TupleType::template get<N>();
3010    }
3011
3012    template<int N>
3013    typename TypeGetter<N, Type>::HeadType& get()
3014    {
3015        return TupleType::template get<N>();
3016    }
3017
3018    template<int N>
3019    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
3020    {
3021        return TupleType::template set<N>(val);
3022    }
3023
3024    const NameVecPtr& names()
3025    {
3026        return _pNames; 
3027    }
3028
3029    void setName(std::size_t index, const std::string& name)
3030        {
3031                if (index >= _pNames->size())
3032                        throw InvalidArgumentException(format("Invalid index: %z", index));
3033
3034                (*_pNames)[index] = name;
3035        }
3036
3037        const std::string& getName(std::size_t index)
3038        {
3039                if (index >= _pNames->size())
3040                        throw InvalidArgumentException(format("Invalid index: %z", index));
3041
3042                return (*_pNames)[index];
3043        }
3044
3045    bool operator == (const NamedTuple& other) const
3046    {
3047        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
3048    }
3049
3050    bool operator != (const NamedTuple& other) const 
3051    {
3052        return !(*this == other);
3053    }
3054
3055    bool operator < (const NamedTuple& other) const
3056    {
3057        TupleType th(*this);
3058        TupleType oth(other); 
3059
3060        return (th < oth && _pNames == other._pNames) || 
3061            (th == oth && _pNames < other._pNames) ||
3062            (th < oth && _pNames < other._pNames);
3063    }
3064
3065private:
3066    void init(const std::string& n0 = "A",
3067        const std::string& n1 = "B",
3068        const std::string& n2 = "C",
3069        const std::string& n3 = "D",
3070        const std::string& n4 = "E",
3071        const std::string& n5 = "F", 
3072        const std::string& n6 = "G",
3073        const std::string& n7 = "H",
3074        const std::string& n8 = "I")
3075    { 
3076        if (!_pNames)
3077        {
3078            _pNames = new NameVec;
3079            _pNames->push_back(n0);
3080            _pNames->push_back(n1);
3081            _pNames->push_back(n2);
3082            _pNames->push_back(n3); 
3083            _pNames->push_back(n4);
3084            _pNames->push_back(n5);
3085            _pNames->push_back(n6);
3086            _pNames->push_back(n7);
3087            _pNames->push_back(n8);
3088        }
3089    }
3090
3091    NameVecPtr _pNames;
3092};
3093
3094
3095template<class T0, 
3096    class T1,
3097    class T2,
3098    class T3,
3099    class T4,
3100    class T5,
3101    class T6,
3102    class T7>
3103struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,NullTypeList>:
3104        public Tuple<T0,T1,T2,T3,T4,T5,T6,T7>
3105{
3106        typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7> TupleType;
3107        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7>::Type Type;
3108
3109    typedef std::vector<std::string> NameVec; 
3110    typedef SharedPtr<NameVec> NameVecPtr; 
3111
3112    NamedTuple(): _pNames(0)
3113    {
3114        init();
3115    }
3116
3117    NamedTuple(const NameVecPtr& rNames) 
3118    {
3119        if (rNames->size() != TupleType::length)
3120            throw InvalidArgumentException("Wrong names vector length."); 
3121
3122        _pNames = rNames;
3123    }
3124
3125    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
3126        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
3127        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3128        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3129        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
3130        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
3131        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
3132        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
3133                TupleType(t0,t1,t2,t3,t4,t5,t6,t7), 
3134                _pNames(0)
3135    {
3136        init();
3137    }
3138
3139    NamedTuple(const NameVecPtr& rNames, 
3140        typename TypeWrapper<T0>::CONSTTYPE& t0,
3141        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3142        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3143        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3144        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
3145        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
3146        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
3147        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
3148                TupleType(t0,t1,t2,t3,t4,t5,t6,t7)
3149    {
3150                if (rNames->size() != TupleType::length)
3151            throw InvalidArgumentException("Wrong names vector length."); 
3152
3153        _pNames = rNames;
3154    }
3155
3156    NamedTuple(const std::string& n0,
3157        typename TypeWrapper<T0>::CONSTTYPE& t0, 
3158        const std::string& n1 = "B",
3159        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3160        const std::string& n2 = "C",
3161        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3162        const std::string& n3 = "D",
3163        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3164        const std::string& n4 = "E",
3165        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
3166        const std::string& n5 = "F",
3167        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
3168        const std::string& n6 = "G",
3169        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
3170        const std::string& n7 = "H",
3171        typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
3172                TupleType(t0,t1,t2,t3,t4,t5,t6,t7), 
3173                _pNames(0) 
3174    {
3175        init(n0,n1,n2,n3,n4,n5,n6,n7);
3176    }
3177
3178    const DynamicAny get(const std::string& name) const
3179    {
3180        NameVec::const_iterator it = _pNames->begin(); 
3181        NameVec::const_iterator itEnd = _pNames->end();
3182
3183        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
3184        {
3185            if (name == *it)
3186            {
3187                switch (counter)
3188                { 
3189                    case 0: return TupleType::template get<0>();
3190                    case 1: return TupleType::template get<1>();
3191                    case 2: return TupleType::template get<2>();
3192                    case 3: return TupleType::template get<3>(); 
3193                    case 4: return TupleType::template get<4>();
3194                    case 5: return TupleType::template get<5>();
3195                    case 6: return TupleType::template get<6>();
3196                    case 7: return TupleType::template get<7>(); 
3197                    default: throw RangeException();
3198                }
3199            }
3200        } 
3201
3202                throw NotFoundException("Name not found: " + name);
3203    }
3204
3205    const DynamicAny operator [] (const std::string& name) const
3206    {
3207        return get(name);
3208    }
3209
3210    template<int N>
3211    typename TypeGetter<N, Type>::ConstHeadType& get() const 
3212    {
3213        return TupleType::template get<N>();
3214    }
3215
3216    template<int N>
3217    typename TypeGetter<N, Type>::HeadType& get()
3218    {
3219        return TupleType::template get<N>();
3220    }
3221
3222    template<int N>
3223    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
3224    {
3225        return TupleType::template set<N>(val);
3226    }
3227
3228    const NameVecPtr& names()
3229    {
3230        return _pNames; 
3231    }
3232
3233    void setName(std::size_t index, const std::string& name)
3234        {
3235                if (index >= _pNames->size())
3236                        throw InvalidArgumentException(format("Invalid index: %z", index));
3237
3238                (*_pNames)[index] = name;
3239        }
3240
3241        const std::string& getName(std::size_t index)
3242        {
3243                if (index >= _pNames->size())
3244                        throw InvalidArgumentException(format("Invalid index: %z", index));
3245
3246                return (*_pNames)[index];
3247        }
3248
3249    bool operator == (const NamedTuple& other) const
3250    {
3251        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
3252    }
3253
3254    bool operator != (const NamedTuple& other) const 
3255    {
3256        return !(*this == other);
3257    }
3258
3259    bool operator < (const NamedTuple& other) const
3260    {
3261        TupleType th(*this);
3262        TupleType oth(other); 
3263
3264        return (th < oth && _pNames == other._pNames) || 
3265            (th == oth && _pNames < other._pNames) ||
3266            (th < oth && _pNames < other._pNames);
3267    }
3268
3269private:
3270    void init(const std::string& n0 = "A",
3271        const std::string& n1 = "B",
3272        const std::string& n2 = "C",
3273        const std::string& n3 = "D",
3274        const std::string& n4 = "E",
3275        const std::string& n5 = "F", 
3276        const std::string& n6 = "G",
3277        const std::string& n7 = "H")
3278    { 
3279        if (!_pNames)
3280        {
3281            _pNames = new NameVec;
3282            _pNames->push_back(n0);
3283            _pNames->push_back(n1);
3284            _pNames->push_back(n2);
3285            _pNames->push_back(n3); 
3286            _pNames->push_back(n4);
3287            _pNames->push_back(n5);
3288            _pNames->push_back(n6);
3289            _pNames->push_back(n7);
3290        }
3291    }
3292
3293    NameVecPtr _pNames;
3294};
3295
3296
3297template<class T0, 
3298    class T1,
3299    class T2,
3300    class T3,
3301    class T4,
3302    class T5,
3303    class T6>
3304struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,NullTypeList>:
3305        public Tuple<T0,T1,T2,T3,T4,T5,T6>
3306{
3307        typedef Tuple<T0,T1,T2,T3,T4,T5,T6> TupleType;
3308        typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6>::Type Type;
3309
3310    typedef std::vector<std::string> NameVec; 
3311    typedef SharedPtr<NameVec> NameVecPtr; 
3312
3313    NamedTuple(): _pNames(0)
3314    {
3315        init();
3316    }
3317
3318    NamedTuple(const NameVecPtr& rNames) 
3319    {
3320        if (rNames->size() != TupleType::length)
3321            throw InvalidArgumentException("Wrong names vector length."); 
3322
3323        _pNames = rNames;
3324    }
3325
3326    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
3327        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
3328        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3329        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3330        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
3331        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
3332        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
3333    TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0)
3334    {
3335        init();
3336    }
3337
3338    NamedTuple(const NameVecPtr& rNames, 
3339        typename TypeWrapper<T0>::CONSTTYPE& t0,
3340        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3341        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3342        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3343        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
3344        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
3345        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
3346    TupleType(t0,t1,t2,t3,t4,t5,t6)
3347    {
3348                if (rNames->size() != TupleType::length)
3349            throw InvalidArgumentException("Wrong names vector length."); 
3350
3351        _pNames = rNames;
3352    }
3353
3354    NamedTuple(const std::string& n0,
3355        typename TypeWrapper<T0>::CONSTTYPE& t0, 
3356        const std::string& n1 = "B",
3357        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3358        const std::string& n2 = "C",
3359        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3360        const std::string& n3 = "D",
3361        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3362        const std::string& n4 = "E",
3363        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
3364        const std::string& n5 = "F",
3365        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
3366        const std::string& n6 = "G",
3367        typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
3368    TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0) 
3369    {
3370        init(n0,n1,n2,n3,n4,n5,n6);
3371    }
3372
3373    const DynamicAny get(const std::string& name) const
3374    {
3375        NameVec::const_iterator it = _pNames->begin(); 
3376        NameVec::const_iterator itEnd = _pNames->end();
3377
3378        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
3379        {
3380            if (name == *it)
3381            {
3382                switch (counter)
3383                { 
3384                    case 0: return TupleType::template get<0>();
3385                    case 1: return TupleType::template get<1>();
3386                    case 2: return TupleType::template get<2>();
3387                    case 3: return TupleType::template get<3>(); 
3388                    case 4: return TupleType::template get<4>();
3389                    case 5: return TupleType::template get<5>();
3390                    case 6: return TupleType::template get<6>();
3391                    default: throw RangeException();
3392                }
3393            }
3394        } 
3395
3396                throw NotFoundException("Name not found: " + name);
3397    }
3398
3399    const DynamicAny operator [] (const std::string& name) const
3400    {
3401        return get(name);
3402    }
3403
3404    template<int N>
3405    typename TypeGetter<N, Type>::ConstHeadType& get() const 
3406    {
3407        return TupleType::template get<N>();
3408    }
3409
3410    template<int N>
3411    typename TypeGetter<N, Type>::HeadType& get()
3412    {
3413        return TupleType::template get<N>();
3414    }
3415
3416    template<int N>
3417    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
3418    {
3419        return TupleType::template set<N>(val);
3420    }
3421
3422    const NameVecPtr& names()
3423    {
3424        return _pNames; 
3425    }
3426
3427    void setName(std::size_t index, const std::string& name)
3428        {
3429                if (index >= _pNames->size())
3430                        throw InvalidArgumentException(format("Invalid index: %z", index));
3431
3432                (*_pNames)[index] = name;
3433        }
3434
3435        const std::string& getName(std::size_t index)
3436        {
3437                if (index >= _pNames->size())
3438                        throw InvalidArgumentException(format("Invalid index: %z", index));
3439
3440                return (*_pNames)[index];
3441        }
3442
3443    bool operator == (const NamedTuple& other) const
3444    {
3445        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
3446    }
3447
3448    bool operator != (const NamedTuple& other) const 
3449    {
3450        return !(*this == other);
3451    }
3452
3453    bool operator < (const NamedTuple& other) const
3454    {
3455        TupleType th(*this);
3456        TupleType oth(other); 
3457
3458        return (th < oth && _pNames == other._pNames) || 
3459            (th == oth && _pNames < other._pNames) ||
3460            (th < oth && _pNames < other._pNames);
3461    }
3462
3463private:
3464    void init(const std::string& n0 = "A",
3465        const std::string& n1 = "B",
3466        const std::string& n2 = "C",
3467        const std::string& n3 = "D",
3468        const std::string& n4 = "E",
3469        const std::string& n5 = "F", 
3470        const std::string& n6 = "G")
3471    { 
3472        if (!_pNames)
3473        {
3474            _pNames = new NameVec;
3475            _pNames->push_back(n0);
3476            _pNames->push_back(n1);
3477            _pNames->push_back(n2);
3478            _pNames->push_back(n3); 
3479            _pNames->push_back(n4);
3480            _pNames->push_back(n5);
3481            _pNames->push_back(n6);
3482        }
3483    }
3484
3485    NameVecPtr _pNames;
3486};
3487
3488
3489template<class T0, 
3490    class T1,
3491    class T2,
3492    class T3,
3493    class T4,
3494    class T5>
3495struct NamedTuple<T0,T1,T2,T3,T4,T5,NullTypeList>:
3496        public Tuple<T0,T1,T2,T3,T4,T5>
3497{
3498        typedef Tuple<T0,T1,T2,T3,T4,T5> TupleType;
3499        typedef typename Tuple<T0,T1,T2,T3,T4,T5>::Type Type;
3500
3501    typedef std::vector<std::string> NameVec; 
3502    typedef SharedPtr<NameVec> NameVecPtr; 
3503
3504    NamedTuple(): _pNames(0)
3505    {
3506        init();
3507    }
3508
3509    NamedTuple(const NameVecPtr& rNames) 
3510    {
3511        if (rNames->size() != TupleType::length)
3512            throw InvalidArgumentException("Wrong names vector length."); 
3513
3514        _pNames = rNames;
3515    }
3516
3517    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
3518        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
3519        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3520        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3521        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
3522        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
3523    TupleType(t0,t1,t2,t3,t4,t5), _pNames(0)
3524    {
3525        init();
3526    }
3527
3528    NamedTuple(const NameVecPtr& rNames, 
3529        typename TypeWrapper<T0>::CONSTTYPE& t0,
3530        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3531        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3532        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3533        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
3534        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
3535    TupleType(t0,t1,t2,t3,t4,t5)
3536    {
3537                if (rNames->size() != TupleType::length)
3538            throw InvalidArgumentException("Wrong names vector length."); 
3539
3540        _pNames = rNames;
3541    }
3542
3543    NamedTuple(const std::string& n0,
3544        typename TypeWrapper<T0>::CONSTTYPE& t0, 
3545        const std::string& n1 = "B",
3546        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3547        const std::string& n2 = "C",
3548        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3549        const std::string& n3 = "D",
3550        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3551        const std::string& n4 = "E",
3552        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
3553        const std::string& n5 = "F",
3554        typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
3555    TupleType(t0,t1,t2,t3,t4,t5), _pNames(0) 
3556    {
3557        init(n0,n1,n2,n3,n4,n5);
3558    }
3559
3560    const DynamicAny get(const std::string& name) const
3561    {
3562        NameVec::const_iterator it = _pNames->begin(); 
3563        NameVec::const_iterator itEnd = _pNames->end();
3564
3565        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
3566        {
3567            if (name == *it)
3568            {
3569                switch (counter)
3570                { 
3571                    case 0: return TupleType::template get<0>();
3572                    case 1: return TupleType::template get<1>();
3573                    case 2: return TupleType::template get<2>();
3574                    case 3: return TupleType::template get<3>(); 
3575                    case 4: return TupleType::template get<4>();
3576                    case 5: return TupleType::template get<5>();
3577                    default: throw RangeException();
3578                }
3579            }
3580        } 
3581
3582                throw NotFoundException("Name not found: " + name);
3583    }
3584
3585    const DynamicAny operator [] (const std::string& name) const
3586    {
3587        return get(name);
3588    }
3589
3590    template<int N>
3591    typename TypeGetter<N, Type>::ConstHeadType& get() const 
3592    {
3593        return TupleType::template get<N>();
3594    }
3595
3596    template<int N>
3597    typename TypeGetter<N, Type>::HeadType& get()
3598    {
3599        return TupleType::template get<N>();
3600    }
3601
3602    template<int N>
3603    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
3604    {
3605        return TupleType::template set<N>(val);
3606    }
3607
3608    const NameVecPtr& names()
3609    {
3610        return _pNames; 
3611    }
3612
3613    void setName(std::size_t index, const std::string& name)
3614        {
3615                if (index >= _pNames->size())
3616                        throw InvalidArgumentException(format("Invalid index: %z", index));
3617
3618                (*_pNames)[index] = name;
3619        }
3620
3621        const std::string& getName(std::size_t index)
3622        {
3623                if (index >= _pNames->size())
3624                        throw InvalidArgumentException(format("Invalid index: %z", index));
3625
3626                return (*_pNames)[index];
3627        }
3628
3629    bool operator == (const NamedTuple& other) const
3630    {
3631        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
3632    }
3633
3634    bool operator != (const NamedTuple& other) const 
3635    {
3636        return !(*this == other);
3637    }
3638
3639    bool operator < (const NamedTuple& other) const
3640    {
3641        TupleType th(*this);
3642        TupleType oth(other); 
3643
3644        return (th < oth && _pNames == other._pNames) || 
3645            (th == oth && _pNames < other._pNames) ||
3646            (th < oth && _pNames < other._pNames);
3647    }
3648
3649private:
3650    void init(const std::string& n0 = "A",
3651        const std::string& n1 = "B",
3652        const std::string& n2 = "C",
3653        const std::string& n3 = "D",
3654        const std::string& n4 = "E",
3655        const std::string& n5 = "F")
3656    { 
3657        if (!_pNames)
3658        {
3659            _pNames = new NameVec;
3660            _pNames->push_back(n0);
3661            _pNames->push_back(n1);
3662            _pNames->push_back(n2);
3663            _pNames->push_back(n3); 
3664            _pNames->push_back(n4);
3665            _pNames->push_back(n5);
3666        }
3667    }
3668
3669    NameVecPtr _pNames;
3670};
3671
3672
3673template<class T0, 
3674    class T1,
3675    class T2,
3676    class T3,
3677    class T4>
3678struct NamedTuple<T0,T1,T2,T3,T4,NullTypeList>:
3679        public Tuple<T0,T1,T2,T3,T4>
3680{
3681        typedef Tuple<T0,T1,T2,T3,T4> TupleType;
3682        typedef typename Tuple<T0,T1,T2,T3,T4>::Type Type;
3683
3684    typedef std::vector<std::string> NameVec; 
3685    typedef SharedPtr<NameVec> NameVecPtr; 
3686
3687    NamedTuple(): _pNames(0)
3688    {
3689        init();
3690    }
3691
3692    NamedTuple(const NameVecPtr& rNames) 
3693    {
3694        if (rNames->size() != TupleType::length)
3695            throw InvalidArgumentException("Wrong names vector length."); 
3696
3697        _pNames = rNames;
3698    }
3699
3700    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
3701        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
3702        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3703        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3704        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
3705                TupleType(t0,t1,t2,t3,t4), 
3706                _pNames(0)
3707    {
3708        init();
3709    }
3710
3711    NamedTuple(const NameVecPtr& rNames, 
3712        typename TypeWrapper<T0>::CONSTTYPE& t0,
3713        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3714        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3715        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3716        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
3717                TupleType(t0,t1,t2,t3,t4)
3718    {
3719                if (rNames->size() != TupleType::length)
3720            throw InvalidArgumentException("Wrong names vector length."); 
3721
3722        _pNames = rNames;
3723    }
3724
3725    NamedTuple(const std::string& n0,
3726        typename TypeWrapper<T0>::CONSTTYPE& t0, 
3727        const std::string& n1 = "B",
3728        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3729        const std::string& n2 = "C",
3730        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3731        const std::string& n3 = "D",
3732        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
3733        const std::string& n4 = "E",
3734        typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
3735                TupleType(t0,t1,t2,t3,t4), 
3736                _pNames(0) 
3737    {
3738        init(n0,n1,n2,n3,n4);
3739    }
3740
3741    const DynamicAny get(const std::string& name) const
3742    {
3743        NameVec::const_iterator it = _pNames->begin(); 
3744        NameVec::const_iterator itEnd = _pNames->end();
3745
3746        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
3747        {
3748            if (name == *it)
3749            {
3750                switch (counter)
3751                { 
3752                    case 0: return TupleType::template get<0>();
3753                    case 1: return TupleType::template get<1>();
3754                    case 2: return TupleType::template get<2>();
3755                    case 3: return TupleType::template get<3>(); 
3756                    case 4: return TupleType::template get<4>();
3757                    default: throw RangeException();
3758                }
3759            }
3760        } 
3761
3762                throw NotFoundException("Name not found: " + name);
3763    }
3764
3765    const DynamicAny operator [] (const std::string& name) const
3766    {
3767        return get(name);
3768    }
3769
3770    template<int N>
3771    typename TypeGetter<N, Type>::ConstHeadType& get() const 
3772    {
3773        return TupleType::template get<N>();
3774    }
3775
3776    template<int N>
3777    typename TypeGetter<N, Type>::HeadType& get()
3778    {
3779        return TupleType::template get<N>();
3780    }
3781
3782    template<int N>
3783    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
3784    {
3785        return TupleType::template set<N>(val);
3786    }
3787
3788    const NameVecPtr& names()
3789    {
3790        return _pNames; 
3791    }
3792
3793    void setName(std::size_t index, const std::string& name)
3794        {
3795                if (index >= _pNames->size())
3796                        throw InvalidArgumentException(format("Invalid index: %z", index));
3797
3798                (*_pNames)[index] = name;
3799        }
3800
3801        const std::string& getName(std::size_t index)
3802        {
3803                if (index >= _pNames->size())
3804                        throw InvalidArgumentException(format("Invalid index: %z", index));
3805
3806                return (*_pNames)[index];
3807        }
3808
3809    bool operator == (const NamedTuple& other) const
3810    {
3811        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
3812    }
3813
3814    bool operator != (const NamedTuple& other) const 
3815    {
3816        return !(*this == other);
3817    }
3818
3819    bool operator < (const NamedTuple& other) const
3820    {
3821        TupleType th(*this);
3822        TupleType oth(other); 
3823
3824        return (th < oth && _pNames == other._pNames) || 
3825            (th == oth && _pNames < other._pNames) ||
3826            (th < oth && _pNames < other._pNames);
3827    }
3828
3829private:
3830    void init(const std::string& n0 = "A",
3831        const std::string& n1 = "B",
3832        const std::string& n2 = "C",
3833        const std::string& n3 = "D",
3834        const std::string& n4 = "E")
3835    { 
3836        if (!_pNames)
3837        {
3838            _pNames = new NameVec;
3839            _pNames->push_back(n0);
3840            _pNames->push_back(n1);
3841            _pNames->push_back(n2);
3842            _pNames->push_back(n3); 
3843            _pNames->push_back(n4);
3844        }
3845    }
3846
3847    NameVecPtr _pNames;
3848};
3849
3850
3851template<class T0, 
3852    class T1,
3853    class T2,
3854    class T3>
3855struct NamedTuple<T0,T1,T2,T3,NullTypeList>:
3856        public Tuple<T0,T1,T2,T3>
3857{
3858        typedef Tuple<T0,T1,T2,T3> TupleType;
3859        typedef typename Tuple<T0,T1,T2,T3>::Type Type;
3860
3861    typedef std::vector<std::string> NameVec; 
3862    typedef SharedPtr<NameVec> NameVecPtr; 
3863
3864    NamedTuple(): _pNames(0)
3865    {
3866        init();
3867    }
3868
3869    NamedTuple(const NameVecPtr& rNames) 
3870    {
3871        if (rNames->size() != TupleType::length)
3872            throw InvalidArgumentException("Wrong names vector length."); 
3873
3874        _pNames = rNames;
3875    }
3876
3877    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
3878        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
3879        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3880        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
3881                TupleType(t0,t1,t2,t3), 
3882                _pNames(0)
3883    {
3884        init();
3885    }
3886
3887    NamedTuple(const NameVecPtr& rNames, 
3888        typename TypeWrapper<T0>::CONSTTYPE& t0,
3889        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3890        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3891        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
3892                TupleType(t0,t1,t2,t3)
3893    {
3894                if (rNames->size() != TupleType::length)
3895            throw InvalidArgumentException("Wrong names vector length."); 
3896
3897        _pNames = rNames;
3898    }
3899
3900    NamedTuple(const std::string& n0,
3901        typename TypeWrapper<T0>::CONSTTYPE& t0, 
3902        const std::string& n1 = "B",
3903        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
3904        const std::string& n2 = "C",
3905        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
3906        const std::string& n3 = "D",
3907        typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
3908    TupleType(t0,t1,t2,t3), _pNames(0) 
3909    {
3910        init(n0,n1,n2,n3);
3911    }
3912
3913    const DynamicAny get(const std::string& name) const
3914    {
3915        NameVec::const_iterator it = _pNames->begin(); 
3916        NameVec::const_iterator itEnd = _pNames->end();
3917
3918        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
3919        {
3920            if (name == *it)
3921            {
3922                switch (counter)
3923                { 
3924                    case 0: return TupleType::template get<0>();
3925                    case 1: return TupleType::template get<1>();
3926                    case 2: return TupleType::template get<2>();
3927                    case 3: return TupleType::template get<3>(); 
3928                    default: throw RangeException();
3929                }
3930            }
3931        } 
3932
3933                throw NotFoundException("Name not found: " + name);
3934    }
3935
3936    const DynamicAny operator [] (const std::string& name) const
3937    {
3938        return get(name);
3939    }
3940
3941    template<int N>
3942    typename TypeGetter<N, Type>::ConstHeadType& get() const 
3943    {
3944        return TupleType::template get<N>();
3945    }
3946
3947    template<int N>
3948    typename TypeGetter<N, Type>::HeadType& get()
3949    {
3950        return TupleType::template get<N>();
3951    }
3952
3953    template<int N>
3954    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
3955    {
3956        return TupleType::template set<N>(val);
3957    }
3958
3959    const NameVecPtr& names()
3960    {
3961        return _pNames; 
3962    }
3963
3964    void setName(std::size_t index, const std::string& name)
3965        {
3966                if (index >= _pNames->size())
3967                        throw InvalidArgumentException(format("Invalid index: %z", index));
3968
3969                (*_pNames)[index] = name;
3970        }
3971
3972        const std::string& getName(std::size_t index)
3973        {
3974                if (index >= _pNames->size())
3975                        throw InvalidArgumentException(format("Invalid index: %z", index));
3976
3977                return (*_pNames)[index];
3978        }
3979
3980    bool operator == (const NamedTuple& other) const
3981    {
3982        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
3983    }
3984
3985    bool operator != (const NamedTuple& other) const 
3986    {
3987        return !(*this == other);
3988    }
3989
3990    bool operator < (const NamedTuple& other) const
3991    {
3992        TupleType th(*this);
3993        TupleType oth(other); 
3994
3995        return (th < oth && _pNames == other._pNames) || 
3996            (th == oth && _pNames < other._pNames) ||
3997            (th < oth && _pNames < other._pNames);
3998    }
3999
4000private:
4001    void init(const std::string& n0 = "A",
4002        const std::string& n1 = "B",
4003        const std::string& n2 = "C",
4004        const std::string& n3 = "D")
4005    { 
4006        if (!_pNames)
4007        {
4008            _pNames = new NameVec;
4009            _pNames->push_back(n0);
4010            _pNames->push_back(n1);
4011            _pNames->push_back(n2);
4012            _pNames->push_back(n3); 
4013        }
4014    }
4015
4016    NameVecPtr _pNames;
4017};
4018
4019
4020template<class T0, 
4021    class T1,
4022    class T2>
4023struct NamedTuple<T0,T1,T2,NullTypeList>:
4024        public Tuple<T0,T1,T2>
4025{
4026        typedef Tuple<T0,T1,T2> TupleType;
4027        typedef typename Tuple<T0,T1,T2>::Type Type;
4028
4029    typedef std::vector<std::string> NameVec; 
4030    typedef SharedPtr<NameVec> NameVecPtr; 
4031
4032    NamedTuple(): _pNames(0)
4033    {
4034        init();
4035    }
4036
4037    NamedTuple(const NameVecPtr& rNames) 
4038    {
4039        if (rNames->size() != TupleType::length)
4040            throw InvalidArgumentException("Wrong names vector length."); 
4041
4042        _pNames = rNames;
4043    }
4044
4045    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
4046        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
4047        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
4048                TupleType(t0,t1,t2), 
4049                _pNames(0)
4050    {
4051        init();
4052    }
4053
4054    NamedTuple(const NameVecPtr& rNames, 
4055        typename TypeWrapper<T0>::CONSTTYPE& t0,
4056        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
4057        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
4058                TupleType(t0,t1,t2)
4059    {
4060                if (rNames->size() != TupleType::length)
4061            throw InvalidArgumentException("Wrong names vector length."); 
4062
4063        _pNames = rNames;
4064    }
4065
4066    NamedTuple(const std::string& n0,
4067        typename TypeWrapper<T0>::CONSTTYPE& t0, 
4068        const std::string& n1 = "B",
4069        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
4070        const std::string& n2 = "C",
4071        typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
4072                TupleType(t0,t1,t2), 
4073                _pNames(0) 
4074    {
4075        init(n0,n1,n2);
4076    }
4077
4078    const DynamicAny get(const std::string& name) const
4079    {
4080        NameVec::const_iterator it = _pNames->begin(); 
4081        NameVec::const_iterator itEnd = _pNames->end();
4082
4083        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
4084        {
4085            if (name == *it)
4086            {
4087                switch (counter)
4088                { 
4089                    case 0: return TupleType::template get<0>();
4090                    case 1: return TupleType::template get<1>();
4091                    case 2: return TupleType::template get<2>();
4092                    default: throw RangeException();
4093                }
4094            }
4095        } 
4096
4097                throw NotFoundException("Name not found: " + name);
4098    }
4099
4100    const DynamicAny operator [] (const std::string& name) const
4101    {
4102        return get(name);
4103    }
4104
4105    template<int N>
4106    typename TypeGetter<N, Type>::ConstHeadType& get() const 
4107    {
4108        return TupleType::template get<N>();
4109    }
4110
4111    template<int N>
4112    typename TypeGetter<N, Type>::HeadType& get()
4113    {
4114        return TupleType::template get<N>();
4115    }
4116
4117    template<int N>
4118    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
4119    {
4120        return TupleType::template set<N>(val);
4121    }
4122
4123    const NameVecPtr& names()
4124    {
4125        return _pNames; 
4126    }
4127
4128    void setName(std::size_t index, const std::string& name)
4129        {
4130                if (index >= _pNames->size())
4131                        throw InvalidArgumentException(format("Invalid index: %z", index));
4132
4133                (*_pNames)[index] = name;
4134        }
4135
4136        const std::string& getName(std::size_t index)
4137        {
4138                if (index >= _pNames->size())
4139                        throw InvalidArgumentException(format("Invalid index: %z", index));
4140
4141                return (*_pNames)[index];
4142        }
4143
4144    bool operator == (const NamedTuple& other) const
4145    {
4146        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
4147    }
4148
4149    bool operator != (const NamedTuple& other) const 
4150    {
4151        return !(*this == other);
4152    }
4153
4154    bool operator < (const NamedTuple& other) const
4155    {
4156        TupleType th(*this);
4157        TupleType oth(other); 
4158
4159        return (th < oth && _pNames == other._pNames) || 
4160            (th == oth && _pNames < other._pNames) ||
4161            (th < oth && _pNames < other._pNames);
4162    }
4163
4164private:
4165    void init(const std::string& n0 = "A",
4166        const std::string& n1 = "B",
4167        const std::string& n2 = "C")
4168    { 
4169        if (!_pNames)
4170        {
4171            _pNames = new NameVec;
4172            _pNames->push_back(n0);
4173            _pNames->push_back(n1);
4174            _pNames->push_back(n2);
4175        }
4176    }
4177
4178    NameVecPtr _pNames;
4179};
4180
4181
4182template<class T0, 
4183    class T1>
4184struct NamedTuple<T0,T1,NullTypeList>:
4185        public Tuple<T0,T1>
4186{
4187        typedef Tuple<T0,T1> TupleType;
4188        typedef typename Tuple<T0,T1>::Type Type;
4189
4190    typedef std::vector<std::string> NameVec; 
4191    typedef SharedPtr<NameVec> NameVecPtr; 
4192
4193    NamedTuple(): _pNames(0)
4194    {
4195        init();
4196    }
4197
4198    NamedTuple(const NameVecPtr& rNames) 
4199    {
4200        if (rNames->size() != TupleType::length)
4201            throw InvalidArgumentException("Wrong names vector length."); 
4202
4203        _pNames = rNames;
4204    }
4205
4206    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
4207        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
4208                TupleType(t0,t1), 
4209                _pNames(0)
4210    {
4211        init();
4212    }
4213
4214    NamedTuple(const NameVecPtr& rNames, 
4215        typename TypeWrapper<T0>::CONSTTYPE& t0,
4216        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
4217                TupleType(t0,t1)
4218    {
4219                if (rNames->size() != TupleType::length)
4220            throw InvalidArgumentException("Wrong names vector length."); 
4221
4222        _pNames = rNames;
4223    }
4224
4225    NamedTuple(const std::string& n0,
4226        typename TypeWrapper<T0>::CONSTTYPE& t0, 
4227        const std::string& n1 = "B",
4228        typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
4229                TupleType(t0,t1), 
4230                _pNames(0) 
4231    {
4232        init(n0,n1);
4233    }
4234
4235    const DynamicAny get(const std::string& name) const
4236    {
4237        NameVec::const_iterator it = _pNames->begin(); 
4238        NameVec::const_iterator itEnd = _pNames->end();
4239
4240        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
4241        {
4242            if (name == *it)
4243            {
4244                switch (counter)
4245                { 
4246                    case 0: return TupleType::template get<0>();
4247                    case 1: return TupleType::template get<1>();
4248                    default: throw RangeException();
4249                }
4250            }
4251        } 
4252
4253                throw NotFoundException("Name not found: " + name);
4254    }
4255
4256    const DynamicAny operator [] (const std::string& name) const
4257    {
4258        return get(name);
4259    }
4260
4261    template<int N>
4262    typename TypeGetter<N, Type>::ConstHeadType& get() const 
4263    {
4264        return TupleType::template get<N>();
4265    }
4266
4267    template<int N>
4268    typename TypeGetter<N, Type>::HeadType& get()
4269    {
4270        return TupleType::template get<N>();
4271    }
4272
4273    template<int N>
4274    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
4275    {
4276        return TupleType::template set<N>(val);
4277    }
4278
4279    const NameVecPtr& names()
4280    {
4281        return _pNames; 
4282    }
4283
4284    void setName(std::size_t index, const std::string& name)
4285        {
4286                if (index >= _pNames->size())
4287                        throw InvalidArgumentException(format("Invalid index: %z", index));
4288
4289                (*_pNames)[index] = name;
4290        }
4291
4292        const std::string& getName(std::size_t index)
4293        {
4294                if (index >= _pNames->size())
4295                        throw InvalidArgumentException(format("Invalid index: %z", index));
4296
4297                return (*_pNames)[index];
4298        }
4299
4300    bool operator == (const NamedTuple& other) const
4301    {
4302        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
4303    }
4304
4305    bool operator != (const NamedTuple& other) const 
4306    {
4307        return !(*this == other);
4308    }
4309
4310    bool operator < (const NamedTuple& other) const
4311    {
4312        TupleType th(*this);
4313        TupleType oth(other); 
4314
4315        return (th < oth && _pNames == other._pNames) || 
4316            (th == oth && _pNames < other._pNames) ||
4317            (th < oth && _pNames < other._pNames);
4318    }
4319
4320private:
4321    void init(const std::string& n0 = "A",
4322        const std::string& n1 = "B")
4323    { 
4324        if (!_pNames)
4325        {
4326            _pNames = new NameVec;
4327            _pNames->push_back(n0);
4328            _pNames->push_back(n1);
4329        }
4330    }
4331
4332    NameVecPtr _pNames;
4333};
4334
4335
4336template<class T0>
4337struct NamedTuple<T0,NullTypeList>:
4338        public Tuple<T0>
4339{
4340        typedef Tuple<T0> TupleType;
4341        typedef typename Tuple<T0>::Type Type;
4342
4343    typedef std::vector<std::string> NameVec; 
4344    typedef SharedPtr<NameVec> NameVecPtr; 
4345
4346    NamedTuple(): _pNames(0)
4347    {
4348        init();
4349    }
4350
4351    NamedTuple(const NameVecPtr& rNames) 
4352    {
4353        if (rNames->size() != TupleType::length)
4354            throw InvalidArgumentException("Wrong names vector length."); 
4355
4356        _pNames = rNames;
4357    }
4358
4359    NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0): 
4360                TupleType(t0), 
4361                _pNames(0)
4362    {
4363        init();
4364    }
4365
4366    NamedTuple(const NameVecPtr& rNames, 
4367        typename TypeWrapper<T0>::CONSTTYPE& t0): 
4368                TupleType(t0)
4369    {
4370                if (rNames->size() != TupleType::length)
4371            throw InvalidArgumentException("Wrong names vector length."); 
4372
4373        _pNames = rNames;
4374    }
4375
4376    NamedTuple(const std::string& n0, typename TypeWrapper<T0>::CONSTTYPE& t0): 
4377                TupleType(t0), 
4378                _pNames(0) 
4379    {
4380        init(n0);
4381    }
4382
4383    const DynamicAny get(const std::string& name) const
4384    {
4385        NameVec::const_iterator it = _pNames->begin(); 
4386        NameVec::const_iterator itEnd = _pNames->end();
4387
4388        for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
4389        {
4390            if (name == *it)
4391            {
4392                switch (counter)
4393                { 
4394                    case 0: return TupleType::template get<0>();
4395                    default: throw RangeException();
4396                }
4397            }
4398        } 
4399
4400                throw NotFoundException("Name not found: " + name);
4401    }
4402
4403    const DynamicAny operator [] (const std::string& name) const
4404    {
4405        return get(name);
4406    }
4407
4408    template<int N>
4409    typename TypeGetter<N, Type>::ConstHeadType& get() const 
4410    {
4411        return TupleType::template get<N>();
4412    }
4413
4414    template<int N>
4415    typename TypeGetter<N, Type>::HeadType& get()
4416    {
4417        return TupleType::template get<N>();
4418    }
4419
4420    template<int N>
4421    void set(typename TypeGetter<N, Type>::ConstHeadType& val)
4422    {
4423        return TupleType::template set<N>(val);
4424    }
4425
4426    const NameVecPtr& names()
4427    {
4428        return _pNames; 
4429    }
4430
4431    void setName(std::size_t index, const std::string& name)
4432        {
4433                if (index >= _pNames->size())
4434                        throw InvalidArgumentException(format("Invalid index: %z", index));
4435
4436                (*_pNames)[index] = name;
4437        }
4438
4439        const std::string& getName(std::size_t index)
4440        {
4441                if (index >= _pNames->size())
4442                        throw InvalidArgumentException(format("Invalid index: %z", index));
4443
4444                return (*_pNames)[index];
4445        }
4446
4447    bool operator == (const NamedTuple& other) const
4448    {
4449        return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
4450    }
4451
4452    bool operator != (const NamedTuple& other) const 
4453    {
4454        return !(*this == other);
4455    }
4456
4457    bool operator < (const NamedTuple& other) const
4458    {
4459        TupleType th(*this);
4460        TupleType oth(other); 
4461
4462        return (th < oth && _pNames == other._pNames) || 
4463            (th == oth && _pNames < other._pNames) ||
4464            (th < oth && _pNames < other._pNames);
4465    }
4466
4467private:
4468    void init(const std::string& n0 = "A")
4469    { 
4470        if (!_pNames)
4471        {
4472            _pNames = new NameVec;
4473            _pNames->push_back(n0);
4474        }
4475    }
4476
4477    NameVecPtr _pNames;
4478};
4479
4480
4481} // namespace Poco
4482
4483
4484#endif // Foundation_Tuple_INCLUDED
Note: See TracBrowser for help on using the repository browser.