Remote Call Framework 3.4
tuple.hpp
1 
2 //******************************************************************************
3 // RCF - Remote Call Framework
4 //
5 // Copyright (c) 2005 - 2023, Delta V Software. All rights reserved.
6 // https://www.deltavsoft.com
7 //
8 // RCF is distributed under dual licenses - closed source or GPL.
9 // Consult your particular license for conditions of use.
10 //
11 // If you have not purchased a commercial license, you are using RCF under GPL terms.
12 //
13 // Version: 3.4
14 // Contact: support <at> deltavsoft.com
15 //
16 //******************************************************************************
17 
18 #ifndef INCLUDE_SF_TUPLE_STD_HPP
19 #define INCLUDE_SF_TUPLE_STD_HPP
20 
21 #include <RCF/Config.hpp>
22 
23 #include <tuple>
24 
25 namespace SF {
26 
27  class Archive;
28 
29  // std::tuple
30 
31  template<
32  typename T0>
33  void serialize(SF::Archive &ar, std::tuple<T0> &t)
34  {
35  ar
36  & std::get<0>(t);
37  }
38 
39  template<
40  typename T0,
41  typename T1>
42  void serialize(SF::Archive &ar, std::tuple<T0,T1> &t)
43  {
44  ar
45  & std::get<0>(t)
46  & std::get<1>(t);
47  }
48 
49  template<
50  typename T0,
51  typename T1,
52  typename T2>
53  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2> &t)
54  {
55  ar
56  & std::get<0>(t)
57  & std::get<1>(t)
58  & std::get<2>(t);
59  }
60 
61  template<
62  typename T0,
63  typename T1,
64  typename T2,
65  typename T3>
66  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3> &t)
67  {
68  ar
69  & std::get<0>(t)
70  & std::get<1>(t)
71  & std::get<2>(t)
72  & std::get<3>(t);
73  }
74 
75  template<
76  typename T0,
77  typename T1,
78  typename T2,
79  typename T3,
80  typename T4>
81  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3,T4> &t)
82  {
83  ar
84  & std::get<0>(t)
85  & std::get<1>(t)
86  & std::get<2>(t)
87  & std::get<3>(t)
88  & std::get<4>(t);
89  }
90 
91  template<
92  typename T0,
93  typename T1,
94  typename T2,
95  typename T3,
96  typename T4,
97  typename T5>
98  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3,T4,T5> &t)
99  {
100  ar
101  & std::get<0>(t)
102  & std::get<1>(t)
103  & std::get<2>(t)
104  & std::get<3>(t)
105  & std::get<4>(t)
106  & std::get<5>(t);
107  }
108 
109  template<
110  typename T0,
111  typename T1,
112  typename T2,
113  typename T3,
114  typename T4,
115  typename T5,
116  typename T6>
117  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3,T4,T5,T6> &t)
118  {
119  ar
120  & std::get<0>(t)
121  & std::get<1>(t)
122  & std::get<2>(t)
123  & std::get<3>(t)
124  & std::get<4>(t)
125  & std::get<5>(t)
126  & std::get<6>(t);
127  }
128 
129  template<
130  typename T0,
131  typename T1,
132  typename T2,
133  typename T3,
134  typename T4,
135  typename T5,
136  typename T6,
137  typename T7>
138  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3,T4,T5,T6,T7> &t)
139  {
140  ar
141  & std::get<0>(t)
142  & std::get<1>(t)
143  & std::get<2>(t)
144  & std::get<3>(t)
145  & std::get<4>(t)
146  & std::get<5>(t)
147  & std::get<6>(t)
148  & std::get<7>(t);
149  }
150 
151  // Visual C++ 11 doesn't support any more args to std::tuple<>.
152 
153  /*
154  template<
155  typename T0,
156  typename T1,
157  typename T2,
158  typename T3,
159  typename T4,
160  typename T5,
161  typename T6,
162  typename T7,
163  typename T8>
164  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8> &t)
165  {
166  ar
167  & std::get<0>(t)
168  & std::get<1>(t)
169  & std::get<2>(t)
170  & std::get<3>(t)
171  & std::get<4>(t)
172  & std::get<5>(t)
173  & std::get<6>(t)
174  & std::get<7>(t)
175  & std::get<8>(t);
176  }
177 
178  template<
179  typename T0,
180  typename T1,
181  typename T2,
182  typename T3,
183  typename T4,
184  typename T5,
185  typename T6,
186  typename T7,
187  typename T8,
188  typename T9>
189  void serialize(SF::Archive &ar, std::tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> &t)
190  {
191  ar
192  & std::get<0>(t)
193  & std::get<1>(t)
194  & std::get<2>(t)
195  & std::get<3>(t)
196  & std::get<4>(t)
197  & std::get<5>(t)
198  & std::get<6>(t)
199  & std::get<7>(t)
200  & std::get<8>(t)
201  & std::get<9>(t);
202  }
203  */
204 
205 }
206 
207 #endif // ! INCLUDE_SF_TUPLE_STD_HPP
SF::Archive
Represents an archive, in which serialized objects are stored.
Definition: Archive.hpp:31
SF
Definition: ByteBuffer.hpp:188