Rapicorn - Experimental UI Toolkit - Source Code  13.07.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines
aidavariants.hh
Go to the documentation of this file.
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 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines