Rapicorn - Experimental UI Toolkit - Source Code
13.07.0
|
00001 /* Aida Variants -- Generated from: aidaproto.hh xmanifold.py */ 00002 # 1 "/opt/src/rapicorn/rcore/aidaproto.hh" 00003 # 1 00004 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00005 namespace Rapicorn { namespace Aida { 00006 00009 template<class R> static inline R 00010 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R ()> &func, uint64 &emit_result_id) 00011 { 00012 const bool async = !std::is_void<R>::value; 00013 const size_t NARGS = 0; 00014 Aida::FieldReader fbr (fb); 00015 fbr.skip_header(); 00016 fbr.skip(); // skip handler_id 00017 if (async) 00018 emit_result_id = fbr.pop_int64(); 00019 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00020 Aida::fatal_error ("invalid number of signal arguments"); 00021 00022 00023 return func (); 00024 } 00025 00026 } } // Rapicorn::Aida 00027 00028 # 1001 00029 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00030 namespace Rapicorn { namespace Aida { 00031 00034 template<class R, class A1> static inline R 00035 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1)> &func, uint64 &emit_result_id) 00036 { 00037 const bool async = !std::is_void<R>::value; 00038 const size_t NARGS = 1; 00039 Aida::FieldReader fbr (fb); 00040 fbr.skip_header(); 00041 fbr.skip(); // skip handler_id 00042 if (async) 00043 emit_result_id = fbr.pop_int64(); 00044 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00045 Aida::fatal_error ("invalid number of signal arguments"); 00046 typename ValueType<A1>::T a1; 00047 fbr >>= a1; 00048 return func (a1); 00049 } 00050 00051 } } // Rapicorn::Aida 00052 00053 # 2001 00054 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00055 namespace Rapicorn { namespace Aida { 00056 00059 template<class R, class A1, class A2> static inline R 00060 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2)> &func, uint64 &emit_result_id) 00061 { 00062 const bool async = !std::is_void<R>::value; 00063 const size_t NARGS = 2; 00064 Aida::FieldReader fbr (fb); 00065 fbr.skip_header(); 00066 fbr.skip(); // skip handler_id 00067 if (async) 00068 emit_result_id = fbr.pop_int64(); 00069 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00070 Aida::fatal_error ("invalid number of signal arguments"); 00071 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; 00072 fbr >>= a1; fbr >>= a2; 00073 return func (a1, a2); 00074 } 00075 00076 } } // Rapicorn::Aida 00077 00078 # 3001 00079 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00080 namespace Rapicorn { namespace Aida { 00081 00084 template<class R, class A1, class A2, class A3> static inline R 00085 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3)> &func, uint64 &emit_result_id) 00086 { 00087 const bool async = !std::is_void<R>::value; 00088 const size_t NARGS = 3; 00089 Aida::FieldReader fbr (fb); 00090 fbr.skip_header(); 00091 fbr.skip(); // skip handler_id 00092 if (async) 00093 emit_result_id = fbr.pop_int64(); 00094 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00095 Aida::fatal_error ("invalid number of signal arguments"); 00096 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; 00097 fbr >>= a1; fbr >>= a2; fbr >>= a3; 00098 return func (a1, a2, a3); 00099 } 00100 00101 } } // Rapicorn::Aida 00102 00103 # 4001 00104 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00105 namespace Rapicorn { namespace Aida { 00106 00109 template<class R, class A1, class A2, class A3, class A4> static inline R 00110 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4)> &func, uint64 &emit_result_id) 00111 { 00112 const bool async = !std::is_void<R>::value; 00113 const size_t NARGS = 4; 00114 Aida::FieldReader fbr (fb); 00115 fbr.skip_header(); 00116 fbr.skip(); // skip handler_id 00117 if (async) 00118 emit_result_id = fbr.pop_int64(); 00119 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00120 Aida::fatal_error ("invalid number of signal arguments"); 00121 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; 00122 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; 00123 return func (a1, a2, a3, a4); 00124 } 00125 00126 } } // Rapicorn::Aida 00127 00128 # 5001 00129 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00130 namespace Rapicorn { namespace Aida { 00131 00134 template<class R, class A1, class A2, class A3, class A4, class A5> static inline R 00135 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5)> &func, uint64 &emit_result_id) 00136 { 00137 const bool async = !std::is_void<R>::value; 00138 const size_t NARGS = 5; 00139 Aida::FieldReader fbr (fb); 00140 fbr.skip_header(); 00141 fbr.skip(); // skip handler_id 00142 if (async) 00143 emit_result_id = fbr.pop_int64(); 00144 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00145 Aida::fatal_error ("invalid number of signal arguments"); 00146 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; 00147 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; 00148 return func (a1, a2, a3, a4, a5); 00149 } 00150 00151 } } // Rapicorn::Aida 00152 00153 # 6001 00154 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00155 namespace Rapicorn { namespace Aida { 00156 00159 template<class R, class A1, class A2, class A3, class A4, class A5, class A6> static inline R 00160 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6)> &func, uint64 &emit_result_id) 00161 { 00162 const bool async = !std::is_void<R>::value; 00163 const size_t NARGS = 6; 00164 Aida::FieldReader fbr (fb); 00165 fbr.skip_header(); 00166 fbr.skip(); // skip handler_id 00167 if (async) 00168 emit_result_id = fbr.pop_int64(); 00169 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00170 Aida::fatal_error ("invalid number of signal arguments"); 00171 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; 00172 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; 00173 return func (a1, a2, a3, a4, a5, a6); 00174 } 00175 00176 } } // Rapicorn::Aida 00177 00178 # 7001 00179 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00180 namespace Rapicorn { namespace Aida { 00181 00184 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> static inline R 00185 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7)> &func, uint64 &emit_result_id) 00186 { 00187 const bool async = !std::is_void<R>::value; 00188 const size_t NARGS = 7; 00189 Aida::FieldReader fbr (fb); 00190 fbr.skip_header(); 00191 fbr.skip(); // skip handler_id 00192 if (async) 00193 emit_result_id = fbr.pop_int64(); 00194 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00195 Aida::fatal_error ("invalid number of signal arguments"); 00196 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; 00197 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; 00198 return func (a1, a2, a3, a4, a5, a6, a7); 00199 } 00200 00201 } } // Rapicorn::Aida 00202 00203 # 8001 00204 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00205 namespace Rapicorn { namespace Aida { 00206 00209 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> static inline R 00210 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8)> &func, uint64 &emit_result_id) 00211 { 00212 const bool async = !std::is_void<R>::value; 00213 const size_t NARGS = 8; 00214 Aida::FieldReader fbr (fb); 00215 fbr.skip_header(); 00216 fbr.skip(); // skip handler_id 00217 if (async) 00218 emit_result_id = fbr.pop_int64(); 00219 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00220 Aida::fatal_error ("invalid number of signal arguments"); 00221 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; 00222 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; 00223 return func (a1, a2, a3, a4, a5, a6, a7, a8); 00224 } 00225 00226 } } // Rapicorn::Aida 00227 00228 # 9001 00229 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00230 namespace Rapicorn { namespace Aida { 00231 00234 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> static inline R 00235 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)> &func, uint64 &emit_result_id) 00236 { 00237 const bool async = !std::is_void<R>::value; 00238 const size_t NARGS = 9; 00239 Aida::FieldReader fbr (fb); 00240 fbr.skip_header(); 00241 fbr.skip(); // skip handler_id 00242 if (async) 00243 emit_result_id = fbr.pop_int64(); 00244 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00245 Aida::fatal_error ("invalid number of signal arguments"); 00246 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; 00247 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; 00248 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9); 00249 } 00250 00251 } } // Rapicorn::Aida 00252 00253 # 10001 00254 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00255 namespace Rapicorn { namespace Aida { 00256 00259 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> static inline R 00260 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> &func, uint64 &emit_result_id) 00261 { 00262 const bool async = !std::is_void<R>::value; 00263 const size_t NARGS = 10; 00264 Aida::FieldReader fbr (fb); 00265 fbr.skip_header(); 00266 fbr.skip(); // skip handler_id 00267 if (async) 00268 emit_result_id = fbr.pop_int64(); 00269 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00270 Aida::fatal_error ("invalid number of signal arguments"); 00271 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; 00272 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; 00273 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 00274 } 00275 00276 } } // Rapicorn::Aida 00277 00278 # 11001 00279 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00280 namespace Rapicorn { namespace Aida { 00281 00284 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> static inline R 00285 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)> &func, uint64 &emit_result_id) 00286 { 00287 const bool async = !std::is_void<R>::value; 00288 const size_t NARGS = 11; 00289 Aida::FieldReader fbr (fb); 00290 fbr.skip_header(); 00291 fbr.skip(); // skip handler_id 00292 if (async) 00293 emit_result_id = fbr.pop_int64(); 00294 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00295 Aida::fatal_error ("invalid number of signal arguments"); 00296 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; 00297 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; 00298 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); 00299 } 00300 00301 } } // Rapicorn::Aida 00302 00303 # 12001 00304 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00305 namespace Rapicorn { namespace Aida { 00306 00309 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> static inline R 00310 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)> &func, uint64 &emit_result_id) 00311 { 00312 const bool async = !std::is_void<R>::value; 00313 const size_t NARGS = 12; 00314 Aida::FieldReader fbr (fb); 00315 fbr.skip_header(); 00316 fbr.skip(); // skip handler_id 00317 if (async) 00318 emit_result_id = fbr.pop_int64(); 00319 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00320 Aida::fatal_error ("invalid number of signal arguments"); 00321 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; 00322 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; 00323 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); 00324 } 00325 00326 } } // Rapicorn::Aida 00327 00328 # 13001 00329 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00330 namespace Rapicorn { namespace Aida { 00331 00334 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> static inline R 00335 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)> &func, uint64 &emit_result_id) 00336 { 00337 const bool async = !std::is_void<R>::value; 00338 const size_t NARGS = 13; 00339 Aida::FieldReader fbr (fb); 00340 fbr.skip_header(); 00341 fbr.skip(); // skip handler_id 00342 if (async) 00343 emit_result_id = fbr.pop_int64(); 00344 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00345 Aida::fatal_error ("invalid number of signal arguments"); 00346 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; typename ValueType<A13>::T a13; 00347 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; fbr >>= a13; 00348 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); 00349 } 00350 00351 } } // Rapicorn::Aida 00352 00353 # 14001 00354 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00355 namespace Rapicorn { namespace Aida { 00356 00359 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> static inline R 00360 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)> &func, uint64 &emit_result_id) 00361 { 00362 const bool async = !std::is_void<R>::value; 00363 const size_t NARGS = 14; 00364 Aida::FieldReader fbr (fb); 00365 fbr.skip_header(); 00366 fbr.skip(); // skip handler_id 00367 if (async) 00368 emit_result_id = fbr.pop_int64(); 00369 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00370 Aida::fatal_error ("invalid number of signal arguments"); 00371 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; typename ValueType<A13>::T a13; typename ValueType<A14>::T a14; 00372 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; fbr >>= a13; fbr >>= a14; 00373 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); 00374 } 00375 00376 } } // Rapicorn::Aida 00377 00378 # 15001 00379 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00380 namespace Rapicorn { namespace Aida { 00381 00384 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> static inline R 00385 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)> &func, uint64 &emit_result_id) 00386 { 00387 const bool async = !std::is_void<R>::value; 00388 const size_t NARGS = 15; 00389 Aida::FieldReader fbr (fb); 00390 fbr.skip_header(); 00391 fbr.skip(); // skip handler_id 00392 if (async) 00393 emit_result_id = fbr.pop_int64(); 00394 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00395 Aida::fatal_error ("invalid number of signal arguments"); 00396 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; typename ValueType<A13>::T a13; typename ValueType<A14>::T a14; typename ValueType<A15>::T a15; 00397 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; fbr >>= a13; fbr >>= a14; fbr >>= a15; 00398 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); 00399 } 00400 00401 } } // Rapicorn::Aida 00402 00403 # 16001 00404 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00405 namespace Rapicorn { namespace Aida { 00406 00409 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16> static inline R 00410 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)> &func, uint64 &emit_result_id) 00411 { 00412 const bool async = !std::is_void<R>::value; 00413 const size_t NARGS = 16; 00414 Aida::FieldReader fbr (fb); 00415 fbr.skip_header(); 00416 fbr.skip(); // skip handler_id 00417 if (async) 00418 emit_result_id = fbr.pop_int64(); 00419 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00420 Aida::fatal_error ("invalid number of signal arguments"); 00421 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; typename ValueType<A13>::T a13; typename ValueType<A14>::T a14; typename ValueType<A15>::T a15; typename ValueType<A16>::T a16; 00422 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; fbr >>= a13; fbr >>= a14; fbr >>= a15; fbr >>= a16; 00423 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); 00424 } 00425 00426 } } // Rapicorn::Aida 00427 00428 # 17001 00429 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00430 namespace Rapicorn { namespace Aida { 00431 00434 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17> static inline R 00435 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)> &func, uint64 &emit_result_id) 00436 { 00437 const bool async = !std::is_void<R>::value; 00438 const size_t NARGS = 17; 00439 Aida::FieldReader fbr (fb); 00440 fbr.skip_header(); 00441 fbr.skip(); // skip handler_id 00442 if (async) 00443 emit_result_id = fbr.pop_int64(); 00444 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00445 Aida::fatal_error ("invalid number of signal arguments"); 00446 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; typename ValueType<A13>::T a13; typename ValueType<A14>::T a14; typename ValueType<A15>::T a15; typename ValueType<A16>::T a16; typename ValueType<A17>::T a17; 00447 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; fbr >>= a13; fbr >>= a14; fbr >>= a15; fbr >>= a16; fbr >>= a17; 00448 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); 00449 } 00450 00451 } } // Rapicorn::Aida 00452 00453 # 18001 00454 // CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ 00455 namespace Rapicorn { namespace Aida { 00456 00459 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18> static inline R 00460 field_buffer_emit_signal (const Aida::FieldBuffer &fb, const std::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)> &func, uint64 &emit_result_id) 00461 { 00462 const bool async = !std::is_void<R>::value; 00463 const size_t NARGS = 18; 00464 Aida::FieldReader fbr (fb); 00465 fbr.skip_header(); 00466 fbr.skip(); // skip handler_id 00467 if (async) 00468 emit_result_id = fbr.pop_int64(); 00469 if (AIDA_UNLIKELY (fbr.remaining() != NARGS)) 00470 Aida::fatal_error ("invalid number of signal arguments"); 00471 typename ValueType<A1>::T a1; typename ValueType<A2>::T a2; typename ValueType<A3>::T a3; typename ValueType<A4>::T a4; typename ValueType<A5>::T a5; typename ValueType<A6>::T a6; typename ValueType<A7>::T a7; typename ValueType<A8>::T a8; typename ValueType<A9>::T a9; typename ValueType<A10>::T a10; typename ValueType<A11>::T a11; typename ValueType<A12>::T a12; typename ValueType<A13>::T a13; typename ValueType<A14>::T a14; typename ValueType<A15>::T a15; typename ValueType<A16>::T a16; typename ValueType<A17>::T a17; typename ValueType<A18>::T a18; 00472 fbr >>= a1; fbr >>= a2; fbr >>= a3; fbr >>= a4; fbr >>= a5; fbr >>= a6; fbr >>= a7; fbr >>= a8; fbr >>= a9; fbr >>= a10; fbr >>= a11; fbr >>= a12; fbr >>= a13; fbr >>= a14; fbr >>= a15; fbr >>= a16; fbr >>= a17; fbr >>= a18; 00473 return func (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); 00474 } 00475 00476 } } // Rapicorn::Aida 00477