00001 #ifndef QPID_AMQP_0_10_SPECIFICATION_H
00002 #define QPID_AMQP_0_10_SPECIFICATION_H
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00028
00029
00030 #include "qpid/amqp_0_10/specification_fwd.h"
00031 #include "qpid/amqp_0_10/all_built_in_types.h"
00032 #include "qpid/amqp_0_10/Packer.h"
00033 #include <boost/call_traits.hpp>
00034 #include <iosfwd>
00035 using boost::call_traits;
00036
00037 namespace qpid {
00038 namespace amqp_0_10 {
00039
00040
00041 namespace connection {
00042
00043
00044 }
00045
00046
00047 namespace session {
00048
00049
00050 struct CommandFragment:
00051 public Struct
00052 {
00053 SequenceNo commandId;
00054 ByteRanges byteRanges;
00055
00056 static const char* NAME;
00057 static const uint8_t SIZE=0;
00058 static const uint8_t PACK=0;
00059 static const uint8_t CODE=0;
00060 static const uint8_t CLASS_CODE=session::CODE;
00061 static const char* CLASS_NAME;
00062 CommandFragment();
00063 CommandFragment(
00064 call_traits<SequenceNo>::param_type commandId_,
00065 call_traits<ByteRanges>::param_type byteRanges_
00066 );
00067 void accept(Visitor&);
00068 void accept(ConstVisitor&) const;
00069 template <class S> void serialize(S& s) {
00070 s(commandId)(byteRanges);
00071 }
00072
00073 };
00074 std::ostream& operator << (std::ostream&, const CommandFragment&);
00075 bool operator==(const CommandFragment&, const CommandFragment&);
00076
00077 }
00078
00079
00080 namespace execution {
00081
00082
00083 }
00084
00085
00086 namespace message {
00087
00088
00089 }
00090
00091
00092 namespace tx {
00093
00094
00095 }
00096
00097
00098 namespace dtx {
00099
00100
00101 }
00102
00103
00104 namespace exchange {
00105
00106
00107 }
00108
00109
00110 namespace queue {
00111
00112
00113 }
00114
00115
00116 namespace file {
00117
00118
00119 }
00120
00121
00122 namespace stream {
00123
00124
00125 }
00126
00127
00128 namespace connection {
00129
00130
00131 struct Start:
00132 public Control
00133 {
00134 Map serverProperties;
00135 Str16Array mechanisms;
00136 Str16Array locales;
00137
00138 static const char* NAME;
00139 static const uint8_t CODE=0x1;
00140 static const uint8_t CLASS_CODE=connection::CODE;
00141 static const char* CLASS_NAME;
00142 Start();
00143 Start(
00144 call_traits<Map>::param_type serverProperties_,
00145 call_traits<Str16Array>::param_type mechanisms_,
00146 call_traits<Str16Array>::param_type locales_
00147 );
00148 void accept(Visitor&);
00149 void accept(ConstVisitor&) const;
00150 template <class S> void serialize(S& s) {
00151 s(serverProperties)(mechanisms)(locales);
00152 }
00153
00154 struct Handler
00155 {
00156 void connectionStart(
00157 call_traits<Map>::param_type serverProperties_,
00158 call_traits<Str16Array>::param_type mechanisms_,
00159 call_traits<Str16Array>::param_type locales_
00160 );
00161 };
00162
00163 template <class T> void invoke(T& target)const
00164 {
00165 target.connectionStart(serverProperties, mechanisms, locales );
00166 }
00167 };
00168 inline Packer<Start> serializable(Start& x) { return Packer<Start>(x); }
00169 std::ostream& operator << (std::ostream&, const Start&);
00170 bool operator==(const Start&, const Start&);
00171
00172 struct StartOk:
00173 public Control
00174 {
00175 Map clientProperties;
00176 Str8 mechanism;
00177 Vbin32 response;
00178 Str8 locale;
00179
00180 static const char* NAME;
00181 static const uint8_t CODE=0x2;
00182 static const uint8_t CLASS_CODE=connection::CODE;
00183 static const char* CLASS_NAME;
00184 StartOk();
00185 StartOk(
00186 call_traits<Map>::param_type clientProperties_,
00187 call_traits<Str8>::param_type mechanism_,
00188 call_traits<Vbin32>::param_type response_,
00189 call_traits<Str8>::param_type locale_
00190 );
00191 void accept(Visitor&);
00192 void accept(ConstVisitor&) const;
00193 template <class S> void serialize(S& s) {
00194 s(clientProperties)(mechanism)(response)(locale);
00195 }
00196
00197 struct Handler
00198 {
00199 void connectionStartOk(
00200 call_traits<Map>::param_type clientProperties_,
00201 call_traits<Str8>::param_type mechanism_,
00202 call_traits<Vbin32>::param_type response_,
00203 call_traits<Str8>::param_type locale_
00204 );
00205 };
00206
00207 template <class T> void invoke(T& target)const
00208 {
00209 target.connectionStartOk(clientProperties, mechanism, response, locale );
00210 }
00211 };
00212 inline Packer<StartOk> serializable(StartOk& x) { return Packer<StartOk>(x); }
00213 std::ostream& operator << (std::ostream&, const StartOk&);
00214 bool operator==(const StartOk&, const StartOk&);
00215
00216 struct Secure:
00217 public Control
00218 {
00219 Vbin32 challenge;
00220
00221 static const char* NAME;
00222 static const uint8_t CODE=0x3;
00223 static const uint8_t CLASS_CODE=connection::CODE;
00224 static const char* CLASS_NAME;
00225 Secure();
00226 Secure(call_traits<Vbin32>::param_type challenge_);
00227 void accept(Visitor&);
00228 void accept(ConstVisitor&) const;
00229 template <class S> void serialize(S& s) {
00230 s(challenge);
00231 }
00232
00233 struct Handler
00234 {
00235 void connectionSecure(
00236 call_traits<Vbin32>::param_type challenge_
00237 );
00238 };
00239
00240 template <class T> void invoke(T& target)const
00241 {
00242 target.connectionSecure(challenge );
00243 }
00244 };
00245 inline Packer<Secure> serializable(Secure& x) { return Packer<Secure>(x); }
00246 std::ostream& operator << (std::ostream&, const Secure&);
00247 bool operator==(const Secure&, const Secure&);
00248
00249 struct SecureOk:
00250 public Control
00251 {
00252 Vbin32 response;
00253
00254 static const char* NAME;
00255 static const uint8_t CODE=0x4;
00256 static const uint8_t CLASS_CODE=connection::CODE;
00257 static const char* CLASS_NAME;
00258 SecureOk();
00259 SecureOk(call_traits<Vbin32>::param_type response_);
00260 void accept(Visitor&);
00261 void accept(ConstVisitor&) const;
00262 template <class S> void serialize(S& s) {
00263 s(response);
00264 }
00265
00266 struct Handler
00267 {
00268 void connectionSecureOk(
00269 call_traits<Vbin32>::param_type response_
00270 );
00271 };
00272
00273 template <class T> void invoke(T& target)const
00274 {
00275 target.connectionSecureOk(response );
00276 }
00277 };
00278 inline Packer<SecureOk> serializable(SecureOk& x) { return Packer<SecureOk>(x); }
00279 std::ostream& operator << (std::ostream&, const SecureOk&);
00280 bool operator==(const SecureOk&, const SecureOk&);
00281
00282 struct Tune:
00283 public Control
00284 {
00285 Uint16 channelMax;
00286 Uint16 maxFrameSize;
00287 Uint16 heartbeatMin;
00288 Uint16 heartbeatMax;
00289
00290 static const char* NAME;
00291 static const uint8_t CODE=0x5;
00292 static const uint8_t CLASS_CODE=connection::CODE;
00293 static const char* CLASS_NAME;
00294 Tune();
00295 Tune(
00296 call_traits<Uint16>::param_type channelMax_,
00297 call_traits<Uint16>::param_type maxFrameSize_,
00298 call_traits<Uint16>::param_type heartbeatMin_,
00299 call_traits<Uint16>::param_type heartbeatMax_
00300 );
00301 void accept(Visitor&);
00302 void accept(ConstVisitor&) const;
00303 template <class S> void serialize(S& s) {
00304 s(channelMax)(maxFrameSize)(heartbeatMin)(heartbeatMax);
00305 }
00306
00307 struct Handler
00308 {
00309 void connectionTune(
00310 call_traits<Uint16>::param_type channelMax_,
00311 call_traits<Uint16>::param_type maxFrameSize_,
00312 call_traits<Uint16>::param_type heartbeatMin_,
00313 call_traits<Uint16>::param_type heartbeatMax_
00314 );
00315 };
00316
00317 template <class T> void invoke(T& target)const
00318 {
00319 target.connectionTune(channelMax, maxFrameSize, heartbeatMin, heartbeatMax );
00320 }
00321 };
00322 inline Packer<Tune> serializable(Tune& x) { return Packer<Tune>(x); }
00323 std::ostream& operator << (std::ostream&, const Tune&);
00324 bool operator==(const Tune&, const Tune&);
00325
00326 struct TuneOk:
00327 public Control
00328 {
00329 Uint16 channelMax;
00330 Uint16 maxFrameSize;
00331 Uint16 heartbeat;
00332
00333 static const char* NAME;
00334 static const uint8_t CODE=0x6;
00335 static const uint8_t CLASS_CODE=connection::CODE;
00336 static const char* CLASS_NAME;
00337 TuneOk();
00338 TuneOk(
00339 call_traits<Uint16>::param_type channelMax_,
00340 call_traits<Uint16>::param_type maxFrameSize_,
00341 call_traits<Uint16>::param_type heartbeat_
00342 );
00343 void accept(Visitor&);
00344 void accept(ConstVisitor&) const;
00345 template <class S> void serialize(S& s) {
00346 s(channelMax)(maxFrameSize)(heartbeat);
00347 }
00348
00349 struct Handler
00350 {
00351 void connectionTuneOk(
00352 call_traits<Uint16>::param_type channelMax_,
00353 call_traits<Uint16>::param_type maxFrameSize_,
00354 call_traits<Uint16>::param_type heartbeat_
00355 );
00356 };
00357
00358 template <class T> void invoke(T& target)const
00359 {
00360 target.connectionTuneOk(channelMax, maxFrameSize, heartbeat );
00361 }
00362 };
00363 inline Packer<TuneOk> serializable(TuneOk& x) { return Packer<TuneOk>(x); }
00364 std::ostream& operator << (std::ostream&, const TuneOk&);
00365 bool operator==(const TuneOk&, const TuneOk&);
00366
00367 struct Open:
00368 public Control
00369 {
00370 Str8 virtualHost;
00371 Str16Array capabilities;
00372 Bit insist;
00373
00374 static const char* NAME;
00375 static const uint8_t CODE=0x7;
00376 static const uint8_t CLASS_CODE=connection::CODE;
00377 static const char* CLASS_NAME;
00378 Open();
00379 Open(
00380 call_traits<Str8>::param_type virtualHost_,
00381 call_traits<Str16Array>::param_type capabilities_,
00382 call_traits<Bit>::param_type insist_
00383 );
00384 void accept(Visitor&);
00385 void accept(ConstVisitor&) const;
00386 template <class S> void serialize(S& s) {
00387 s(virtualHost)(capabilities)(insist);
00388 }
00389
00390 struct Handler
00391 {
00392 void connectionOpen(
00393 call_traits<Str8>::param_type virtualHost_,
00394 call_traits<Str16Array>::param_type capabilities_,
00395 call_traits<Bit>::param_type insist_
00396 );
00397 };
00398
00399 template <class T> void invoke(T& target)const
00400 {
00401 target.connectionOpen(virtualHost, capabilities, insist );
00402 }
00403 };
00404 inline Packer<Open> serializable(Open& x) { return Packer<Open>(x); }
00405 std::ostream& operator << (std::ostream&, const Open&);
00406 bool operator==(const Open&, const Open&);
00407
00408 struct OpenOk:
00409 public Control
00410 {
00411 AmqpHostArray knownHosts;
00412
00413 static const char* NAME;
00414 static const uint8_t CODE=0x8;
00415 static const uint8_t CLASS_CODE=connection::CODE;
00416 static const char* CLASS_NAME;
00417 OpenOk();
00418 OpenOk(call_traits<connection::AmqpHostArray>::param_type knownHosts_);
00419 void accept(Visitor&);
00420 void accept(ConstVisitor&) const;
00421 template <class S> void serialize(S& s) {
00422 s(knownHosts);
00423 }
00424
00425 struct Handler
00426 {
00427 void connectionOpenOk(
00428 call_traits<connection::AmqpHostArray>::param_type knownHosts_
00429 );
00430 };
00431
00432 template <class T> void invoke(T& target)const
00433 {
00434 target.connectionOpenOk(knownHosts );
00435 }
00436 };
00437 inline Packer<OpenOk> serializable(OpenOk& x) { return Packer<OpenOk>(x); }
00438 std::ostream& operator << (std::ostream&, const OpenOk&);
00439 bool operator==(const OpenOk&, const OpenOk&);
00440
00441 struct Redirect:
00442 public Control
00443 {
00444 AmqpHostUrl host;
00445 AmqpHostArray knownHosts;
00446
00447 static const char* NAME;
00448 static const uint8_t CODE=0x9;
00449 static const uint8_t CLASS_CODE=connection::CODE;
00450 static const char* CLASS_NAME;
00451 Redirect();
00452 Redirect(
00453 call_traits<connection::AmqpHostUrl>::param_type host_,
00454 call_traits<connection::AmqpHostArray>::param_type knownHosts_
00455 );
00456 void accept(Visitor&);
00457 void accept(ConstVisitor&) const;
00458 template <class S> void serialize(S& s) {
00459 s(host)(knownHosts);
00460 }
00461
00462 struct Handler
00463 {
00464 void connectionRedirect(
00465 call_traits<connection::AmqpHostUrl>::param_type host_,
00466 call_traits<connection::AmqpHostArray>::param_type knownHosts_
00467 );
00468 };
00469
00470 template <class T> void invoke(T& target)const
00471 {
00472 target.connectionRedirect(host, knownHosts );
00473 }
00474 };
00475 inline Packer<Redirect> serializable(Redirect& x) { return Packer<Redirect>(x); }
00476 std::ostream& operator << (std::ostream&, const Redirect&);
00477 bool operator==(const Redirect&, const Redirect&);
00478
00479 struct Heartbeat:
00480 public Control
00481 {
00482
00483 static const char* NAME;
00484 static const uint8_t CODE=0xa;
00485 static const uint8_t CLASS_CODE=connection::CODE;
00486 static const char* CLASS_NAME;
00487 Heartbeat();
00488 void accept(Visitor&);
00489 void accept(ConstVisitor&) const;
00490 template <class S> void serialize(S&) {}
00491
00492 struct Handler
00493 {
00494 void connectionHeartbeat(
00495
00496 );
00497 };
00498
00499 template <class T> void invoke(T& target)const
00500 {
00501 target.connectionHeartbeat( );
00502 }
00503 };
00504 inline Packer<Heartbeat> serializable(Heartbeat& x) { return Packer<Heartbeat>(x); }
00505 std::ostream& operator << (std::ostream&, const Heartbeat&);
00506 bool operator==(const Heartbeat&, const Heartbeat&);
00507
00508 struct Close:
00509 public Control
00510 {
00511 CloseCode replyCode;
00512 Str8 replyText;
00513
00514 static const char* NAME;
00515 static const uint8_t CODE=0xb;
00516 static const uint8_t CLASS_CODE=connection::CODE;
00517 static const char* CLASS_NAME;
00518 Close();
00519 Close(
00520 call_traits<connection::CloseCode>::param_type replyCode_,
00521 call_traits<Str8>::param_type replyText_
00522 );
00523 void accept(Visitor&);
00524 void accept(ConstVisitor&) const;
00525 template <class S> void serialize(S& s) {
00526 s(replyCode)(replyText);
00527 }
00528
00529 struct Handler
00530 {
00531 void connectionClose(
00532 call_traits<connection::CloseCode>::param_type replyCode_,
00533 call_traits<Str8>::param_type replyText_
00534 );
00535 };
00536
00537 template <class T> void invoke(T& target)const
00538 {
00539 target.connectionClose(replyCode, replyText );
00540 }
00541 };
00542 inline Packer<Close> serializable(Close& x) { return Packer<Close>(x); }
00543 std::ostream& operator << (std::ostream&, const Close&);
00544 bool operator==(const Close&, const Close&);
00545
00546 struct CloseOk:
00547 public Control
00548 {
00549
00550 static const char* NAME;
00551 static const uint8_t CODE=0xc;
00552 static const uint8_t CLASS_CODE=connection::CODE;
00553 static const char* CLASS_NAME;
00554 CloseOk();
00555 void accept(Visitor&);
00556 void accept(ConstVisitor&) const;
00557 template <class S> void serialize(S&) {}
00558
00559 struct Handler
00560 {
00561 void connectionCloseOk(
00562
00563 );
00564 };
00565
00566 template <class T> void invoke(T& target)const
00567 {
00568 target.connectionCloseOk( );
00569 }
00570 };
00571 inline Packer<CloseOk> serializable(CloseOk& x) { return Packer<CloseOk>(x); }
00572 std::ostream& operator << (std::ostream&, const CloseOk&);
00573 bool operator==(const CloseOk&, const CloseOk&);
00574
00575 }
00576
00577
00578 namespace session {
00579
00580
00581 struct Header:
00582 public Struct
00583 {
00584 Bit sync;
00585
00586 static const char* NAME;
00587 static const uint8_t SIZE=1;
00588 static const uint8_t PACK=1;
00589 static const uint8_t CODE=0;
00590 static const uint8_t CLASS_CODE=session::CODE;
00591 static const char* CLASS_NAME;
00592 Header();
00593 Header(call_traits<Bit>::param_type sync_);
00594 void accept(Visitor&);
00595 void accept(ConstVisitor&) const;
00596 template <class S> void serialize(S& s) {
00597 s(sync);
00598 }
00599
00600 };
00601 inline Packer<Header> serializable(Header& x) { return Packer<Header>(x); }
00602 std::ostream& operator << (std::ostream&, const Header&);
00603 bool operator==(const Header&, const Header&);
00604
00605 struct Attach:
00606 public Control
00607 {
00608 Name name;
00609 Bit force;
00610
00611 static const char* NAME;
00612 static const uint8_t CODE=0x1;
00613 static const uint8_t CLASS_CODE=session::CODE;
00614 static const char* CLASS_NAME;
00615 Attach();
00616 Attach(
00617 call_traits<session::Name>::param_type name_,
00618 call_traits<Bit>::param_type force_
00619 );
00620 void accept(Visitor&);
00621 void accept(ConstVisitor&) const;
00622 template <class S> void serialize(S& s) {
00623 s(name)(force);
00624 }
00625
00626 struct Handler
00627 {
00628 void sessionAttach(
00629 call_traits<session::Name>::param_type name_,
00630 call_traits<Bit>::param_type force_
00631 );
00632 };
00633
00634 template <class T> void invoke(T& target)const
00635 {
00636 target.sessionAttach(name, force );
00637 }
00638 };
00639 inline Packer<Attach> serializable(Attach& x) { return Packer<Attach>(x); }
00640 std::ostream& operator << (std::ostream&, const Attach&);
00641 bool operator==(const Attach&, const Attach&);
00642
00643 struct Attached:
00644 public Control
00645 {
00646 Name name;
00647
00648 static const char* NAME;
00649 static const uint8_t CODE=0x2;
00650 static const uint8_t CLASS_CODE=session::CODE;
00651 static const char* CLASS_NAME;
00652 Attached();
00653 Attached(call_traits<session::Name>::param_type name_);
00654 void accept(Visitor&);
00655 void accept(ConstVisitor&) const;
00656 template <class S> void serialize(S& s) {
00657 s(name);
00658 }
00659
00660 struct Handler
00661 {
00662 void sessionAttached(
00663 call_traits<session::Name>::param_type name_
00664 );
00665 };
00666
00667 template <class T> void invoke(T& target)const
00668 {
00669 target.sessionAttached(name );
00670 }
00671 };
00672 inline Packer<Attached> serializable(Attached& x) { return Packer<Attached>(x); }
00673 std::ostream& operator << (std::ostream&, const Attached&);
00674 bool operator==(const Attached&, const Attached&);
00675
00676 struct Detach:
00677 public Control
00678 {
00679 Name name;
00680
00681 static const char* NAME;
00682 static const uint8_t CODE=0x3;
00683 static const uint8_t CLASS_CODE=session::CODE;
00684 static const char* CLASS_NAME;
00685 Detach();
00686 Detach(call_traits<session::Name>::param_type name_);
00687 void accept(Visitor&);
00688 void accept(ConstVisitor&) const;
00689 template <class S> void serialize(S& s) {
00690 s(name);
00691 }
00692
00693 struct Handler
00694 {
00695 void sessionDetach(
00696 call_traits<session::Name>::param_type name_
00697 );
00698 };
00699
00700 template <class T> void invoke(T& target)const
00701 {
00702 target.sessionDetach(name );
00703 }
00704 };
00705 inline Packer<Detach> serializable(Detach& x) { return Packer<Detach>(x); }
00706 std::ostream& operator << (std::ostream&, const Detach&);
00707 bool operator==(const Detach&, const Detach&);
00708
00709 struct Detached:
00710 public Control
00711 {
00712 Name name;
00713 DetachCode code;
00714
00715 static const char* NAME;
00716 static const uint8_t CODE=0x4;
00717 static const uint8_t CLASS_CODE=session::CODE;
00718 static const char* CLASS_NAME;
00719 Detached();
00720 Detached(
00721 call_traits<session::Name>::param_type name_,
00722 call_traits<session::DetachCode>::param_type code_
00723 );
00724 void accept(Visitor&);
00725 void accept(ConstVisitor&) const;
00726 template <class S> void serialize(S& s) {
00727 s(name)(code);
00728 }
00729
00730 struct Handler
00731 {
00732 void sessionDetached(
00733 call_traits<session::Name>::param_type name_,
00734 call_traits<session::DetachCode>::param_type code_
00735 );
00736 };
00737
00738 template <class T> void invoke(T& target)const
00739 {
00740 target.sessionDetached(name, code );
00741 }
00742 };
00743 inline Packer<Detached> serializable(Detached& x) { return Packer<Detached>(x); }
00744 std::ostream& operator << (std::ostream&, const Detached&);
00745 bool operator==(const Detached&, const Detached&);
00746
00747 struct RequestTimeout:
00748 public Control
00749 {
00750 Uint32 timeout;
00751
00752 static const char* NAME;
00753 static const uint8_t CODE=0x5;
00754 static const uint8_t CLASS_CODE=session::CODE;
00755 static const char* CLASS_NAME;
00756 RequestTimeout();
00757 RequestTimeout(call_traits<Uint32>::param_type timeout_);
00758 void accept(Visitor&);
00759 void accept(ConstVisitor&) const;
00760 template <class S> void serialize(S& s) {
00761 s(timeout);
00762 }
00763
00764 struct Handler
00765 {
00766 void sessionRequestTimeout(
00767 call_traits<Uint32>::param_type timeout_
00768 );
00769 };
00770
00771 template <class T> void invoke(T& target)const
00772 {
00773 target.sessionRequestTimeout(timeout );
00774 }
00775 };
00776 inline Packer<RequestTimeout> serializable(RequestTimeout& x) { return Packer<RequestTimeout>(x); }
00777 std::ostream& operator << (std::ostream&, const RequestTimeout&);
00778 bool operator==(const RequestTimeout&, const RequestTimeout&);
00779
00780 struct Timeout:
00781 public Control
00782 {
00783 Uint32 timeout;
00784
00785 static const char* NAME;
00786 static const uint8_t CODE=0x6;
00787 static const uint8_t CLASS_CODE=session::CODE;
00788 static const char* CLASS_NAME;
00789 Timeout();
00790 Timeout(call_traits<Uint32>::param_type timeout_);
00791 void accept(Visitor&);
00792 void accept(ConstVisitor&) const;
00793 template <class S> void serialize(S& s) {
00794 s(timeout);
00795 }
00796
00797 struct Handler
00798 {
00799 void sessionTimeout(
00800 call_traits<Uint32>::param_type timeout_
00801 );
00802 };
00803
00804 template <class T> void invoke(T& target)const
00805 {
00806 target.sessionTimeout(timeout );
00807 }
00808 };
00809 inline Packer<Timeout> serializable(Timeout& x) { return Packer<Timeout>(x); }
00810 std::ostream& operator << (std::ostream&, const Timeout&);
00811 bool operator==(const Timeout&, const Timeout&);
00812
00813 struct CommandPoint:
00814 public Control
00815 {
00816 SequenceNo commandId;
00817 Uint64 commandOffset;
00818
00819 static const char* NAME;
00820 static const uint8_t CODE=0x7;
00821 static const uint8_t CLASS_CODE=session::CODE;
00822 static const char* CLASS_NAME;
00823 CommandPoint();
00824 CommandPoint(
00825 call_traits<SequenceNo>::param_type commandId_,
00826 call_traits<Uint64>::param_type commandOffset_
00827 );
00828 void accept(Visitor&);
00829 void accept(ConstVisitor&) const;
00830 template <class S> void serialize(S& s) {
00831 s(commandId)(commandOffset);
00832 }
00833
00834 struct Handler
00835 {
00836 void sessionCommandPoint(
00837 call_traits<SequenceNo>::param_type commandId_,
00838 call_traits<Uint64>::param_type commandOffset_
00839 );
00840 };
00841
00842 template <class T> void invoke(T& target)const
00843 {
00844 target.sessionCommandPoint(commandId, commandOffset );
00845 }
00846 };
00847 inline Packer<CommandPoint> serializable(CommandPoint& x) { return Packer<CommandPoint>(x); }
00848 std::ostream& operator << (std::ostream&, const CommandPoint&);
00849 bool operator==(const CommandPoint&, const CommandPoint&);
00850
00851 struct Expected:
00852 public Control
00853 {
00854 Commands commands;
00855 CommandFragments fragments;
00856
00857 static const char* NAME;
00858 static const uint8_t CODE=0x8;
00859 static const uint8_t CLASS_CODE=session::CODE;
00860 static const char* CLASS_NAME;
00861 Expected();
00862 Expected(
00863 call_traits<session::Commands>::param_type commands_,
00864 call_traits<session::CommandFragments>::param_type fragments_
00865 );
00866 void accept(Visitor&);
00867 void accept(ConstVisitor&) const;
00868 template <class S> void serialize(S& s) {
00869 s(commands)(fragments);
00870 }
00871
00872 struct Handler
00873 {
00874 void sessionExpected(
00875 call_traits<session::Commands>::param_type commands_,
00876 call_traits<session::CommandFragments>::param_type fragments_
00877 );
00878 };
00879
00880 template <class T> void invoke(T& target)const
00881 {
00882 target.sessionExpected(commands, fragments );
00883 }
00884 };
00885 inline Packer<Expected> serializable(Expected& x) { return Packer<Expected>(x); }
00886 std::ostream& operator << (std::ostream&, const Expected&);
00887 bool operator==(const Expected&, const Expected&);
00888
00889 struct Confirmed:
00890 public Control
00891 {
00892 Commands commands;
00893 CommandFragments fragments;
00894
00895 static const char* NAME;
00896 static const uint8_t CODE=0x9;
00897 static const uint8_t CLASS_CODE=session::CODE;
00898 static const char* CLASS_NAME;
00899 Confirmed();
00900 Confirmed(
00901 call_traits<session::Commands>::param_type commands_,
00902 call_traits<session::CommandFragments>::param_type fragments_
00903 );
00904 void accept(Visitor&);
00905 void accept(ConstVisitor&) const;
00906 template <class S> void serialize(S& s) {
00907 s(commands)(fragments);
00908 }
00909
00910 struct Handler
00911 {
00912 void sessionConfirmed(
00913 call_traits<session::Commands>::param_type commands_,
00914 call_traits<session::CommandFragments>::param_type fragments_
00915 );
00916 };
00917
00918 template <class T> void invoke(T& target)const
00919 {
00920 target.sessionConfirmed(commands, fragments );
00921 }
00922 };
00923 inline Packer<Confirmed> serializable(Confirmed& x) { return Packer<Confirmed>(x); }
00924 std::ostream& operator << (std::ostream&, const Confirmed&);
00925 bool operator==(const Confirmed&, const Confirmed&);
00926
00927 struct Completed:
00928 public Control
00929 {
00930 Commands commands;
00931 Bit timelyReply;
00932
00933 static const char* NAME;
00934 static const uint8_t CODE=0xa;
00935 static const uint8_t CLASS_CODE=session::CODE;
00936 static const char* CLASS_NAME;
00937 Completed();
00938 Completed(
00939 call_traits<session::Commands>::param_type commands_,
00940 call_traits<Bit>::param_type timelyReply_
00941 );
00942 void accept(Visitor&);
00943 void accept(ConstVisitor&) const;
00944 template <class S> void serialize(S& s) {
00945 s(commands)(timelyReply);
00946 }
00947
00948 struct Handler
00949 {
00950 void sessionCompleted(
00951 call_traits<session::Commands>::param_type commands_,
00952 call_traits<Bit>::param_type timelyReply_
00953 );
00954 };
00955
00956 template <class T> void invoke(T& target)const
00957 {
00958 target.sessionCompleted(commands, timelyReply );
00959 }
00960 };
00961 inline Packer<Completed> serializable(Completed& x) { return Packer<Completed>(x); }
00962 std::ostream& operator << (std::ostream&, const Completed&);
00963 bool operator==(const Completed&, const Completed&);
00964
00965 struct KnownCompleted:
00966 public Control
00967 {
00968 Commands commands;
00969
00970 static const char* NAME;
00971 static const uint8_t CODE=0xb;
00972 static const uint8_t CLASS_CODE=session::CODE;
00973 static const char* CLASS_NAME;
00974 KnownCompleted();
00975 KnownCompleted(call_traits<session::Commands>::param_type commands_);
00976 void accept(Visitor&);
00977 void accept(ConstVisitor&) const;
00978 template <class S> void serialize(S& s) {
00979 s(commands);
00980 }
00981
00982 struct Handler
00983 {
00984 void sessionKnownCompleted(
00985 call_traits<session::Commands>::param_type commands_
00986 );
00987 };
00988
00989 template <class T> void invoke(T& target)const
00990 {
00991 target.sessionKnownCompleted(commands );
00992 }
00993 };
00994 inline Packer<KnownCompleted> serializable(KnownCompleted& x) { return Packer<KnownCompleted>(x); }
00995 std::ostream& operator << (std::ostream&, const KnownCompleted&);
00996 bool operator==(const KnownCompleted&, const KnownCompleted&);
00997
00998 struct Flush:
00999 public Control
01000 {
01001 Bit expected;
01002 Bit confirmed;
01003 Bit completed;
01004
01005 static const char* NAME;
01006 static const uint8_t CODE=0xc;
01007 static const uint8_t CLASS_CODE=session::CODE;
01008 static const char* CLASS_NAME;
01009 Flush();
01010 Flush(
01011 call_traits<Bit>::param_type expected_,
01012 call_traits<Bit>::param_type confirmed_,
01013 call_traits<Bit>::param_type completed_
01014 );
01015 void accept(Visitor&);
01016 void accept(ConstVisitor&) const;
01017 template <class S> void serialize(S& s) {
01018 s(expected)(confirmed)(completed);
01019 }
01020
01021 struct Handler
01022 {
01023 void sessionFlush(
01024 call_traits<Bit>::param_type expected_,
01025 call_traits<Bit>::param_type confirmed_,
01026 call_traits<Bit>::param_type completed_
01027 );
01028 };
01029
01030 template <class T> void invoke(T& target)const
01031 {
01032 target.sessionFlush(expected, confirmed, completed );
01033 }
01034 };
01035 inline Packer<Flush> serializable(Flush& x) { return Packer<Flush>(x); }
01036 std::ostream& operator << (std::ostream&, const Flush&);
01037 bool operator==(const Flush&, const Flush&);
01038
01039 struct Gap:
01040 public Control
01041 {
01042 Commands commands;
01043
01044 static const char* NAME;
01045 static const uint8_t CODE=0xd;
01046 static const uint8_t CLASS_CODE=session::CODE;
01047 static const char* CLASS_NAME;
01048 Gap();
01049 Gap(call_traits<session::Commands>::param_type commands_);
01050 void accept(Visitor&);
01051 void accept(ConstVisitor&) const;
01052 template <class S> void serialize(S& s) {
01053 s(commands);
01054 }
01055
01056 struct Handler
01057 {
01058 void sessionGap(
01059 call_traits<session::Commands>::param_type commands_
01060 );
01061 };
01062
01063 template <class T> void invoke(T& target)const
01064 {
01065 target.sessionGap(commands );
01066 }
01067 };
01068 inline Packer<Gap> serializable(Gap& x) { return Packer<Gap>(x); }
01069 std::ostream& operator << (std::ostream&, const Gap&);
01070 bool operator==(const Gap&, const Gap&);
01071
01072 }
01073
01074
01075 namespace execution {
01076
01077
01078 struct Sync:
01079 public Command
01080 {
01081
01082 static const char* NAME;
01083 static const uint8_t CODE=0x1;
01084 static const uint8_t CLASS_CODE=execution::CODE;
01085 static const char* CLASS_NAME;
01086 Sync();
01087 void accept(Visitor&);
01088 void accept(ConstVisitor&) const;
01089 template <class S> void serialize(S&) {}
01090
01091 struct Handler
01092 {
01093 void executionSync(
01094
01095 );
01096 };
01097
01098 template <class T> void invoke(T& target)const
01099 {
01100 target.executionSync( );
01101 }
01102 };
01103 inline Packer<Sync> serializable(Sync& x) { return Packer<Sync>(x); }
01104 std::ostream& operator << (std::ostream&, const Sync&);
01105 bool operator==(const Sync&, const Sync&);
01106
01107 struct Result:
01108 public Command
01109 {
01110 SequenceNo commandId;
01111 Struct32 value;
01112
01113 static const char* NAME;
01114 static const uint8_t CODE=0x2;
01115 static const uint8_t CLASS_CODE=execution::CODE;
01116 static const char* CLASS_NAME;
01117 Result();
01118 Result(
01119 call_traits<SequenceNo>::param_type commandId_,
01120 call_traits<Struct32>::param_type value_
01121 );
01122 void accept(Visitor&);
01123 void accept(ConstVisitor&) const;
01124 template <class S> void serialize(S& s) {
01125 s(commandId)(value);
01126 }
01127
01128 struct Handler
01129 {
01130 void executionResult(
01131 call_traits<SequenceNo>::param_type commandId_,
01132 call_traits<Struct32>::param_type value_
01133 );
01134 };
01135
01136 template <class T> void invoke(T& target)const
01137 {
01138 target.executionResult(commandId, value );
01139 }
01140 };
01141 inline Packer<Result> serializable(Result& x) { return Packer<Result>(x); }
01142 std::ostream& operator << (std::ostream&, const Result&);
01143 bool operator==(const Result&, const Result&);
01144
01145 struct Exception:
01146 public Command
01147 {
01148 ErrorCode errorCode;
01149 SequenceNo commandId;
01150 Uint8 classCode;
01151 Uint8 commandCode;
01152 Uint8 fieldIndex;
01153 Str16 description;
01154 Map errorInfo;
01155
01156 static const char* NAME;
01157 static const uint8_t CODE=0x3;
01158 static const uint8_t CLASS_CODE=execution::CODE;
01159 static const char* CLASS_NAME;
01160 Exception();
01161 Exception(
01162 call_traits<execution::ErrorCode>::param_type errorCode_,
01163 call_traits<SequenceNo>::param_type commandId_,
01164 call_traits<Uint8>::param_type classCode_,
01165 call_traits<Uint8>::param_type commandCode_,
01166 call_traits<Uint8>::param_type fieldIndex_,
01167 call_traits<Str16>::param_type description_,
01168 call_traits<Map>::param_type errorInfo_
01169 );
01170 void accept(Visitor&);
01171 void accept(ConstVisitor&) const;
01172 template <class S> void serialize(S& s) {
01173 s(errorCode)(commandId)(classCode)(commandCode)(fieldIndex)(description)(errorInfo);
01174 }
01175
01176 struct Handler
01177 {
01178 void executionException(
01179 call_traits<execution::ErrorCode>::param_type errorCode_,
01180 call_traits<SequenceNo>::param_type commandId_,
01181 call_traits<Uint8>::param_type classCode_,
01182 call_traits<Uint8>::param_type commandCode_,
01183 call_traits<Uint8>::param_type fieldIndex_,
01184 call_traits<Str16>::param_type description_,
01185 call_traits<Map>::param_type errorInfo_
01186 );
01187 };
01188
01189 template <class T> void invoke(T& target)const
01190 {
01191 target.executionException(errorCode, commandId, classCode, commandCode, fieldIndex, description, errorInfo );
01192 }
01193 };
01194 inline Packer<Exception> serializable(Exception& x) { return Packer<Exception>(x); }
01195 std::ostream& operator << (std::ostream&, const Exception&);
01196 bool operator==(const Exception&, const Exception&);
01197
01198 }
01199
01200
01201 namespace message {
01202
01203
01204 struct DeliveryProperties:
01205 public Struct
01206 {
01207 Bit discardUnroutable;
01208 Bit immediate;
01209 Bit redelivered;
01210 DeliveryPriority priority;
01211 DeliveryMode deliveryMode;
01212 Uint64 ttl;
01213 Datetime timestamp;
01214 Datetime expiration;
01215 exchange::Name exchange;
01216 Str8 routingKey;
01217 ResumeId resumeId;
01218 Uint64 resumeTtl;
01219
01220 static const char* NAME;
01221 static const uint8_t SIZE=4;
01222 static const uint8_t PACK=2;
01223 static const uint8_t CODE=0x1;
01224 static const uint8_t CLASS_CODE=message::CODE;
01225 static const char* CLASS_NAME;
01226 DeliveryProperties();
01227 DeliveryProperties(
01228 call_traits<Bit>::param_type discardUnroutable_,
01229 call_traits<Bit>::param_type immediate_,
01230 call_traits<Bit>::param_type redelivered_,
01231 call_traits<message::DeliveryPriority>::param_type priority_,
01232 call_traits<message::DeliveryMode>::param_type deliveryMode_,
01233 call_traits<Uint64>::param_type ttl_,
01234 call_traits<Datetime>::param_type timestamp_,
01235 call_traits<Datetime>::param_type expiration_,
01236 call_traits<exchange::Name>::param_type exchange_,
01237 call_traits<Str8>::param_type routingKey_,
01238 call_traits<message::ResumeId>::param_type resumeId_,
01239 call_traits<Uint64>::param_type resumeTtl_
01240 );
01241 void accept(Visitor&);
01242 void accept(ConstVisitor&) const;
01243 template <class S> void serialize(S& s) {
01244 s(discardUnroutable)(immediate)(redelivered)(priority)(deliveryMode)(ttl)(timestamp)(expiration)(exchange)(routingKey)(resumeId)(resumeTtl);
01245 }
01246
01247 };
01248 inline Packer<DeliveryProperties> serializable(DeliveryProperties& x) { return Packer<DeliveryProperties>(x); }
01249 std::ostream& operator << (std::ostream&, const DeliveryProperties&);
01250 bool operator==(const DeliveryProperties&, const DeliveryProperties&);
01251
01252 struct FragmentProperties:
01253 public Struct
01254 {
01255 Bit first;
01256 Bit last;
01257 Uint64 fragmentSize;
01258
01259 static const char* NAME;
01260 static const uint8_t SIZE=4;
01261 static const uint8_t PACK=2;
01262 static const uint8_t CODE=0x2;
01263 static const uint8_t CLASS_CODE=message::CODE;
01264 static const char* CLASS_NAME;
01265 FragmentProperties();
01266 FragmentProperties(
01267 call_traits<Bit>::param_type first_,
01268 call_traits<Bit>::param_type last_,
01269 call_traits<Uint64>::param_type fragmentSize_
01270 );
01271 void accept(Visitor&);
01272 void accept(ConstVisitor&) const;
01273 template <class S> void serialize(S& s) {
01274 s(first)(last)(fragmentSize);
01275 }
01276
01277 };
01278 inline Packer<FragmentProperties> serializable(FragmentProperties& x) { return Packer<FragmentProperties>(x); }
01279 std::ostream& operator << (std::ostream&, const FragmentProperties&);
01280 bool operator==(const FragmentProperties&, const FragmentProperties&);
01281
01282 struct ReplyTo:
01283 public Struct
01284 {
01285 exchange::Name exchange;
01286 Str8 routingKey;
01287
01288 static const char* NAME;
01289 static const uint8_t SIZE=2;
01290 static const uint8_t PACK=2;
01291 static const uint8_t CODE=0;
01292 static const uint8_t CLASS_CODE=message::CODE;
01293 static const char* CLASS_NAME;
01294 ReplyTo();
01295 ReplyTo(
01296 call_traits<exchange::Name>::param_type exchange_,
01297 call_traits<Str8>::param_type routingKey_
01298 );
01299 void accept(Visitor&);
01300 void accept(ConstVisitor&) const;
01301 template <class S> void serialize(S& s) {
01302 s(exchange)(routingKey);
01303 }
01304
01305 };
01306 inline Packer<ReplyTo> serializable(ReplyTo& x) { return Packer<ReplyTo>(x); }
01307 std::ostream& operator << (std::ostream&, const ReplyTo&);
01308 bool operator==(const ReplyTo&, const ReplyTo&);
01309
01310 struct MessageProperties:
01311 public Struct
01312 {
01313 Uint64 contentLength;
01314 Uuid messageId;
01315 Vbin16 correlationId;
01316 ReplyTo replyTo;
01317 Str8 contentType;
01318 Str8 contentEncoding;
01319 Vbin16 userId;
01320 Vbin16 appId;
01321 Map applicationHeaders;
01322
01323 static const char* NAME;
01324 static const uint8_t SIZE=4;
01325 static const uint8_t PACK=2;
01326 static const uint8_t CODE=0x3;
01327 static const uint8_t CLASS_CODE=message::CODE;
01328 static const char* CLASS_NAME;
01329 MessageProperties();
01330 MessageProperties(
01331 call_traits<Uint64>::param_type contentLength_,
01332 call_traits<Uuid>::param_type messageId_,
01333 call_traits<Vbin16>::param_type correlationId_,
01334 call_traits<message::ReplyTo>::param_type replyTo_,
01335 call_traits<Str8>::param_type contentType_,
01336 call_traits<Str8>::param_type contentEncoding_,
01337 call_traits<Vbin16>::param_type userId_,
01338 call_traits<Vbin16>::param_type appId_,
01339 call_traits<Map>::param_type applicationHeaders_
01340 );
01341 void accept(Visitor&);
01342 void accept(ConstVisitor&) const;
01343 template <class S> void serialize(S& s) {
01344 s(contentLength)(messageId)(correlationId)(replyTo)(contentType)(contentEncoding)(userId)(appId)(applicationHeaders);
01345 }
01346
01347 };
01348 inline Packer<MessageProperties> serializable(MessageProperties& x) { return Packer<MessageProperties>(x); }
01349 std::ostream& operator << (std::ostream&, const MessageProperties&);
01350 bool operator==(const MessageProperties&, const MessageProperties&);
01351
01352 struct Acquired:
01353 public Struct
01354 {
01355 session::Commands transfers;
01356
01357 static const char* NAME;
01358 static const uint8_t SIZE=4;
01359 static const uint8_t PACK=2;
01360 static const uint8_t CODE=0x4;
01361 static const uint8_t CLASS_CODE=message::CODE;
01362 static const char* CLASS_NAME;
01363 Acquired();
01364 Acquired(call_traits<session::Commands>::param_type transfers_);
01365 void accept(Visitor&);
01366 void accept(ConstVisitor&) const;
01367 template <class S> void serialize(S& s) {
01368 s(transfers);
01369 }
01370
01371 };
01372 inline Packer<Acquired> serializable(Acquired& x) { return Packer<Acquired>(x); }
01373 std::ostream& operator << (std::ostream&, const Acquired&);
01374 bool operator==(const Acquired&, const Acquired&);
01375
01376 struct MessageResumeResult:
01377 public Struct
01378 {
01379 Uint64 offset;
01380
01381 static const char* NAME;
01382 static const uint8_t SIZE=4;
01383 static const uint8_t PACK=2;
01384 static const uint8_t CODE=0x5;
01385 static const uint8_t CLASS_CODE=message::CODE;
01386 static const char* CLASS_NAME;
01387 MessageResumeResult();
01388 MessageResumeResult(call_traits<Uint64>::param_type offset_);
01389 void accept(Visitor&);
01390 void accept(ConstVisitor&) const;
01391 template <class S> void serialize(S& s) {
01392 s(offset);
01393 }
01394
01395 };
01396 inline Packer<MessageResumeResult> serializable(MessageResumeResult& x) { return Packer<MessageResumeResult>(x); }
01397 std::ostream& operator << (std::ostream&, const MessageResumeResult&);
01398 bool operator==(const MessageResumeResult&, const MessageResumeResult&);
01399
01400 struct Transfer:
01401 public Command
01402 {
01403 Destination destination;
01404 AcceptMode acceptMode;
01405 AcquireMode acquireMode;
01406
01407 static const char* NAME;
01408 static const uint8_t CODE=0x1;
01409 static const uint8_t CLASS_CODE=message::CODE;
01410 static const char* CLASS_NAME;
01411 Transfer();
01412 Transfer(
01413 call_traits<message::Destination>::param_type destination_,
01414 call_traits<message::AcceptMode>::param_type acceptMode_,
01415 call_traits<message::AcquireMode>::param_type acquireMode_
01416 );
01417 void accept(Visitor&);
01418 void accept(ConstVisitor&) const;
01419 template <class S> void serialize(S& s) {
01420 s(destination)(acceptMode)(acquireMode);
01421 }
01422
01423 struct Handler
01424 {
01425 void messageTransfer(
01426 call_traits<message::Destination>::param_type destination_,
01427 call_traits<message::AcceptMode>::param_type acceptMode_,
01428 call_traits<message::AcquireMode>::param_type acquireMode_
01429 );
01430 };
01431
01432 template <class T> void invoke(T& target)const
01433 {
01434 target.messageTransfer(destination, acceptMode, acquireMode );
01435 }
01436 };
01437 inline Packer<Transfer> serializable(Transfer& x) { return Packer<Transfer>(x); }
01438 std::ostream& operator << (std::ostream&, const Transfer&);
01439 bool operator==(const Transfer&, const Transfer&);
01440
01441 struct Accept:
01442 public Command
01443 {
01444 session::Commands transfers;
01445
01446 static const char* NAME;
01447 static const uint8_t CODE=0x2;
01448 static const uint8_t CLASS_CODE=message::CODE;
01449 static const char* CLASS_NAME;
01450 Accept();
01451 Accept(call_traits<session::Commands>::param_type transfers_);
01452 void accept(Visitor&);
01453 void accept(ConstVisitor&) const;
01454 template <class S> void serialize(S& s) {
01455 s(transfers);
01456 }
01457
01458 struct Handler
01459 {
01460 void messageAccept(
01461 call_traits<session::Commands>::param_type transfers_
01462 );
01463 };
01464
01465 template <class T> void invoke(T& target)const
01466 {
01467 target.messageAccept(transfers );
01468 }
01469 };
01470 inline Packer<Accept> serializable(Accept& x) { return Packer<Accept>(x); }
01471 std::ostream& operator << (std::ostream&, const Accept&);
01472 bool operator==(const Accept&, const Accept&);
01473
01474 struct Reject:
01475 public Command
01476 {
01477 session::Commands transfers;
01478 RejectCode code;
01479 Str8 text;
01480
01481 static const char* NAME;
01482 static const uint8_t CODE=0x3;
01483 static const uint8_t CLASS_CODE=message::CODE;
01484 static const char* CLASS_NAME;
01485 Reject();
01486 Reject(
01487 call_traits<session::Commands>::param_type transfers_,
01488 call_traits<message::RejectCode>::param_type code_,
01489 call_traits<Str8>::param_type text_
01490 );
01491 void accept(Visitor&);
01492 void accept(ConstVisitor&) const;
01493 template <class S> void serialize(S& s) {
01494 s(transfers)(code)(text);
01495 }
01496
01497 struct Handler
01498 {
01499 void messageReject(
01500 call_traits<session::Commands>::param_type transfers_,
01501 call_traits<message::RejectCode>::param_type code_,
01502 call_traits<Str8>::param_type text_
01503 );
01504 };
01505
01506 template <class T> void invoke(T& target)const
01507 {
01508 target.messageReject(transfers, code, text );
01509 }
01510 };
01511 inline Packer<Reject> serializable(Reject& x) { return Packer<Reject>(x); }
01512 std::ostream& operator << (std::ostream&, const Reject&);
01513 bool operator==(const Reject&, const Reject&);
01514
01515 struct Release:
01516 public Command
01517 {
01518 session::Commands transfers;
01519 Bit setRedelivered;
01520
01521 static const char* NAME;
01522 static const uint8_t CODE=0x4;
01523 static const uint8_t CLASS_CODE=message::CODE;
01524 static const char* CLASS_NAME;
01525 Release();
01526 Release(
01527 call_traits<session::Commands>::param_type transfers_,
01528 call_traits<Bit>::param_type setRedelivered_
01529 );
01530 void accept(Visitor&);
01531 void accept(ConstVisitor&) const;
01532 template <class S> void serialize(S& s) {
01533 s(transfers)(setRedelivered);
01534 }
01535
01536 struct Handler
01537 {
01538 void messageRelease(
01539 call_traits<session::Commands>::param_type transfers_,
01540 call_traits<Bit>::param_type setRedelivered_
01541 );
01542 };
01543
01544 template <class T> void invoke(T& target)const
01545 {
01546 target.messageRelease(transfers, setRedelivered );
01547 }
01548 };
01549 inline Packer<Release> serializable(Release& x) { return Packer<Release>(x); }
01550 std::ostream& operator << (std::ostream&, const Release&);
01551 bool operator==(const Release&, const Release&);
01552
01553 struct Acquire:
01554 public Command
01555 {
01556 session::Commands transfers;
01557
01558 static const char* NAME;
01559 static const uint8_t CODE=0x5;
01560 static const uint8_t CLASS_CODE=message::CODE;
01561 static const char* CLASS_NAME;
01562 Acquire();
01563 Acquire(call_traits<session::Commands>::param_type transfers_);
01564 void accept(Visitor&);
01565 void accept(ConstVisitor&) const;
01566 template <class S> void serialize(S& s) {
01567 s(transfers);
01568 }
01569
01570 struct Handler
01571 {
01572 void messageAcquire(
01573 call_traits<session::Commands>::param_type transfers_
01574 );
01575 };
01576
01577 template <class T> void invoke(T& target)const
01578 {
01579 target.messageAcquire(transfers );
01580 }
01581 };
01582 inline Packer<Acquire> serializable(Acquire& x) { return Packer<Acquire>(x); }
01583 std::ostream& operator << (std::ostream&, const Acquire&);
01584 bool operator==(const Acquire&, const Acquire&);
01585
01586 struct Resume:
01587 public Command
01588 {
01589 Destination destination;
01590 ResumeId resumeId;
01591
01592 static const char* NAME;
01593 static const uint8_t CODE=0x6;
01594 static const uint8_t CLASS_CODE=message::CODE;
01595 static const char* CLASS_NAME;
01596 Resume();
01597 Resume(
01598 call_traits<message::Destination>::param_type destination_,
01599 call_traits<message::ResumeId>::param_type resumeId_
01600 );
01601 void accept(Visitor&);
01602 void accept(ConstVisitor&) const;
01603 template <class S> void serialize(S& s) {
01604 s(destination)(resumeId);
01605 }
01606
01607 struct Handler
01608 {
01609 void messageResume(
01610 call_traits<message::Destination>::param_type destination_,
01611 call_traits<message::ResumeId>::param_type resumeId_
01612 );
01613 };
01614
01615 template <class T> void invoke(T& target)const
01616 {
01617 target.messageResume(destination, resumeId );
01618 }
01619 };
01620 inline Packer<Resume> serializable(Resume& x) { return Packer<Resume>(x); }
01621 std::ostream& operator << (std::ostream&, const Resume&);
01622 bool operator==(const Resume&, const Resume&);
01623
01624 struct Subscribe:
01625 public Command
01626 {
01627 queue::Name queue;
01628 Destination destination;
01629 AcceptMode acceptMode;
01630 AcquireMode acquireMode;
01631 Bit exclusive;
01632 ResumeId resumeId;
01633 Uint64 resumeTtl;
01634 Map arguments;
01635
01636 static const char* NAME;
01637 static const uint8_t CODE=0x7;
01638 static const uint8_t CLASS_CODE=message::CODE;
01639 static const char* CLASS_NAME;
01640 Subscribe();
01641 Subscribe(
01642 call_traits<queue::Name>::param_type queue_,
01643 call_traits<message::Destination>::param_type destination_,
01644 call_traits<message::AcceptMode>::param_type acceptMode_,
01645 call_traits<message::AcquireMode>::param_type acquireMode_,
01646 call_traits<Bit>::param_type exclusive_,
01647 call_traits<message::ResumeId>::param_type resumeId_,
01648 call_traits<Uint64>::param_type resumeTtl_,
01649 call_traits<Map>::param_type arguments_
01650 );
01651 void accept(Visitor&);
01652 void accept(ConstVisitor&) const;
01653 template <class S> void serialize(S& s) {
01654 s(queue)(destination)(acceptMode)(acquireMode)(exclusive)(resumeId)(resumeTtl)(arguments);
01655 }
01656
01657 struct Handler
01658 {
01659 void messageSubscribe(
01660 call_traits<queue::Name>::param_type queue_,
01661 call_traits<message::Destination>::param_type destination_,
01662 call_traits<message::AcceptMode>::param_type acceptMode_,
01663 call_traits<message::AcquireMode>::param_type acquireMode_,
01664 call_traits<Bit>::param_type exclusive_,
01665 call_traits<message::ResumeId>::param_type resumeId_,
01666 call_traits<Uint64>::param_type resumeTtl_,
01667 call_traits<Map>::param_type arguments_
01668 );
01669 };
01670
01671 template <class T> void invoke(T& target)const
01672 {
01673 target.messageSubscribe(queue, destination, acceptMode, acquireMode, exclusive, resumeId, resumeTtl, arguments );
01674 }
01675 };
01676 inline Packer<Subscribe> serializable(Subscribe& x) { return Packer<Subscribe>(x); }
01677 std::ostream& operator << (std::ostream&, const Subscribe&);
01678 bool operator==(const Subscribe&, const Subscribe&);
01679
01680 struct Cancel:
01681 public Command
01682 {
01683 Destination destination;
01684
01685 static const char* NAME;
01686 static const uint8_t CODE=0x8;
01687 static const uint8_t CLASS_CODE=message::CODE;
01688 static const char* CLASS_NAME;
01689 Cancel();
01690 Cancel(call_traits<message::Destination>::param_type destination_);
01691 void accept(Visitor&);
01692 void accept(ConstVisitor&) const;
01693 template <class S> void serialize(S& s) {
01694 s(destination);
01695 }
01696
01697 struct Handler
01698 {
01699 void messageCancel(
01700 call_traits<message::Destination>::param_type destination_
01701 );
01702 };
01703
01704 template <class T> void invoke(T& target)const
01705 {
01706 target.messageCancel(destination );
01707 }
01708 };
01709 inline Packer<Cancel> serializable(Cancel& x) { return Packer<Cancel>(x); }
01710 std::ostream& operator << (std::ostream&, const Cancel&);
01711 bool operator==(const Cancel&, const Cancel&);
01712
01713 struct SetFlowMode:
01714 public Command
01715 {
01716 Destination destination;
01717 FlowMode flowMode;
01718
01719 static const char* NAME;
01720 static const uint8_t CODE=0x9;
01721 static const uint8_t CLASS_CODE=message::CODE;
01722 static const char* CLASS_NAME;
01723 SetFlowMode();
01724 SetFlowMode(
01725 call_traits<message::Destination>::param_type destination_,
01726 call_traits<message::FlowMode>::param_type flowMode_
01727 );
01728 void accept(Visitor&);
01729 void accept(ConstVisitor&) const;
01730 template <class S> void serialize(S& s) {
01731 s(destination)(flowMode);
01732 }
01733
01734 struct Handler
01735 {
01736 void messageSetFlowMode(
01737 call_traits<message::Destination>::param_type destination_,
01738 call_traits<message::FlowMode>::param_type flowMode_
01739 );
01740 };
01741
01742 template <class T> void invoke(T& target)const
01743 {
01744 target.messageSetFlowMode(destination, flowMode );
01745 }
01746 };
01747 inline Packer<SetFlowMode> serializable(SetFlowMode& x) { return Packer<SetFlowMode>(x); }
01748 std::ostream& operator << (std::ostream&, const SetFlowMode&);
01749 bool operator==(const SetFlowMode&, const SetFlowMode&);
01750
01751 struct Flow:
01752 public Command
01753 {
01754 Destination destination;
01755 CreditUnit unit;
01756 Uint32 value;
01757
01758 static const char* NAME;
01759 static const uint8_t CODE=0xa;
01760 static const uint8_t CLASS_CODE=message::CODE;
01761 static const char* CLASS_NAME;
01762 Flow();
01763 Flow(
01764 call_traits<message::Destination>::param_type destination_,
01765 call_traits<message::CreditUnit>::param_type unit_,
01766 call_traits<Uint32>::param_type value_
01767 );
01768 void accept(Visitor&);
01769 void accept(ConstVisitor&) const;
01770 template <class S> void serialize(S& s) {
01771 s(destination)(unit)(value);
01772 }
01773
01774 struct Handler
01775 {
01776 void messageFlow(
01777 call_traits<message::Destination>::param_type destination_,
01778 call_traits<message::CreditUnit>::param_type unit_,
01779 call_traits<Uint32>::param_type value_
01780 );
01781 };
01782
01783 template <class T> void invoke(T& target)const
01784 {
01785 target.messageFlow(destination, unit, value );
01786 }
01787 };
01788 inline Packer<Flow> serializable(Flow& x) { return Packer<Flow>(x); }
01789 std::ostream& operator << (std::ostream&, const Flow&);
01790 bool operator==(const Flow&, const Flow&);
01791
01792 struct Flush:
01793 public Command
01794 {
01795 Destination destination;
01796
01797 static const char* NAME;
01798 static const uint8_t CODE=0xb;
01799 static const uint8_t CLASS_CODE=message::CODE;
01800 static const char* CLASS_NAME;
01801 Flush();
01802 Flush(call_traits<message::Destination>::param_type destination_);
01803 void accept(Visitor&);
01804 void accept(ConstVisitor&) const;
01805 template <class S> void serialize(S& s) {
01806 s(destination);
01807 }
01808
01809 struct Handler
01810 {
01811 void messageFlush(
01812 call_traits<message::Destination>::param_type destination_
01813 );
01814 };
01815
01816 template <class T> void invoke(T& target)const
01817 {
01818 target.messageFlush(destination );
01819 }
01820 };
01821 inline Packer<Flush> serializable(Flush& x) { return Packer<Flush>(x); }
01822 std::ostream& operator << (std::ostream&, const Flush&);
01823 bool operator==(const Flush&, const Flush&);
01824
01825 struct Stop:
01826 public Command
01827 {
01828 Destination destination;
01829
01830 static const char* NAME;
01831 static const uint8_t CODE=0xc;
01832 static const uint8_t CLASS_CODE=message::CODE;
01833 static const char* CLASS_NAME;
01834 Stop();
01835 Stop(call_traits<message::Destination>::param_type destination_);
01836 void accept(Visitor&);
01837 void accept(ConstVisitor&) const;
01838 template <class S> void serialize(S& s) {
01839 s(destination);
01840 }
01841
01842 struct Handler
01843 {
01844 void messageStop(
01845 call_traits<message::Destination>::param_type destination_
01846 );
01847 };
01848
01849 template <class T> void invoke(T& target)const
01850 {
01851 target.messageStop(destination );
01852 }
01853 };
01854 inline Packer<Stop> serializable(Stop& x) { return Packer<Stop>(x); }
01855 std::ostream& operator << (std::ostream&, const Stop&);
01856 bool operator==(const Stop&, const Stop&);
01857
01858 }
01859
01860
01861 namespace tx {
01862
01863
01864 struct Select:
01865 public Command
01866 {
01867
01868 static const char* NAME;
01869 static const uint8_t CODE=0x1;
01870 static const uint8_t CLASS_CODE=tx::CODE;
01871 static const char* CLASS_NAME;
01872 Select();
01873 void accept(Visitor&);
01874 void accept(ConstVisitor&) const;
01875 template <class S> void serialize(S&) {}
01876
01877 struct Handler
01878 {
01879 void txSelect(
01880
01881 );
01882 };
01883
01884 template <class T> void invoke(T& target)const
01885 {
01886 target.txSelect( );
01887 }
01888 };
01889 inline Packer<Select> serializable(Select& x) { return Packer<Select>(x); }
01890 std::ostream& operator << (std::ostream&, const Select&);
01891 bool operator==(const Select&, const Select&);
01892
01893 struct Commit:
01894 public Command
01895 {
01896
01897 static const char* NAME;
01898 static const uint8_t CODE=0x2;
01899 static const uint8_t CLASS_CODE=tx::CODE;
01900 static const char* CLASS_NAME;
01901 Commit();
01902 void accept(Visitor&);
01903 void accept(ConstVisitor&) const;
01904 template <class S> void serialize(S&) {}
01905
01906 struct Handler
01907 {
01908 void txCommit(
01909
01910 );
01911 };
01912
01913 template <class T> void invoke(T& target)const
01914 {
01915 target.txCommit( );
01916 }
01917 };
01918 inline Packer<Commit> serializable(Commit& x) { return Packer<Commit>(x); }
01919 std::ostream& operator << (std::ostream&, const Commit&);
01920 bool operator==(const Commit&, const Commit&);
01921
01922 struct Rollback:
01923 public Command
01924 {
01925
01926 static const char* NAME;
01927 static const uint8_t CODE=0x3;
01928 static const uint8_t CLASS_CODE=tx::CODE;
01929 static const char* CLASS_NAME;
01930 Rollback();
01931 void accept(Visitor&);
01932 void accept(ConstVisitor&) const;
01933 template <class S> void serialize(S&) {}
01934
01935 struct Handler
01936 {
01937 void txRollback(
01938
01939 );
01940 };
01941
01942 template <class T> void invoke(T& target)const
01943 {
01944 target.txRollback( );
01945 }
01946 };
01947 inline Packer<Rollback> serializable(Rollback& x) { return Packer<Rollback>(x); }
01948 std::ostream& operator << (std::ostream&, const Rollback&);
01949 bool operator==(const Rollback&, const Rollback&);
01950
01951 }
01952
01953
01954 namespace dtx {
01955
01956
01957 struct XaResult:
01958 public Struct
01959 {
01960 XaStatus status;
01961
01962 static const char* NAME;
01963 static const uint8_t SIZE=4;
01964 static const uint8_t PACK=2;
01965 static const uint8_t CODE=0x1;
01966 static const uint8_t CLASS_CODE=dtx::CODE;
01967 static const char* CLASS_NAME;
01968 XaResult();
01969 XaResult(call_traits<dtx::XaStatus>::param_type status_);
01970 void accept(Visitor&);
01971 void accept(ConstVisitor&) const;
01972 template <class S> void serialize(S& s) {
01973 s(status);
01974 }
01975
01976 };
01977 inline Packer<XaResult> serializable(XaResult& x) { return Packer<XaResult>(x); }
01978 std::ostream& operator << (std::ostream&, const XaResult&);
01979 bool operator==(const XaResult&, const XaResult&);
01980
01981 struct Xid:
01982 public Struct
01983 {
01984 Uint32 format;
01985 Vbin8 globalId;
01986 Vbin8 branchId;
01987
01988 static const char* NAME;
01989 static const uint8_t SIZE=2;
01990 static const uint8_t PACK=2;
01991 static const uint8_t CODE=0;
01992 static const uint8_t CLASS_CODE=dtx::CODE;
01993 static const char* CLASS_NAME;
01994 Xid();
01995 Xid(
01996 call_traits<Uint32>::param_type format_,
01997 call_traits<Vbin8>::param_type globalId_,
01998 call_traits<Vbin8>::param_type branchId_
01999 );
02000 void accept(Visitor&);
02001 void accept(ConstVisitor&) const;
02002 template <class S> void serialize(S& s) {
02003 s(format)(globalId)(branchId);
02004 }
02005
02006 };
02007 inline Packer<Xid> serializable(Xid& x) { return Packer<Xid>(x); }
02008 std::ostream& operator << (std::ostream&, const Xid&);
02009 bool operator==(const Xid&, const Xid&);
02010
02011 struct GetTimeoutResult:
02012 public Struct
02013 {
02014 Uint32 timeout;
02015
02016 static const char* NAME;
02017 static const uint8_t SIZE=4;
02018 static const uint8_t PACK=2;
02019 static const uint8_t CODE=0x2;
02020 static const uint8_t CLASS_CODE=dtx::CODE;
02021 static const char* CLASS_NAME;
02022 GetTimeoutResult();
02023 GetTimeoutResult(call_traits<Uint32>::param_type timeout_);
02024 void accept(Visitor&);
02025 void accept(ConstVisitor&) const;
02026 template <class S> void serialize(S& s) {
02027 s(timeout);
02028 }
02029
02030 };
02031 inline Packer<GetTimeoutResult> serializable(GetTimeoutResult& x) { return Packer<GetTimeoutResult>(x); }
02032 std::ostream& operator << (std::ostream&, const GetTimeoutResult&);
02033 bool operator==(const GetTimeoutResult&, const GetTimeoutResult&);
02034
02035 struct RecoverResult:
02036 public Struct
02037 {
02038 ArrayDomain<dtx::Xid> inDoubt;
02039
02040 static const char* NAME;
02041 static const uint8_t SIZE=4;
02042 static const uint8_t PACK=2;
02043 static const uint8_t CODE=0x3;
02044 static const uint8_t CLASS_CODE=dtx::CODE;
02045 static const char* CLASS_NAME;
02046 RecoverResult();
02047 RecoverResult(call_traits<ArrayDomain<dtx::Xid> >::param_type inDoubt_);
02048 void accept(Visitor&);
02049 void accept(ConstVisitor&) const;
02050 template <class S> void serialize(S& s) {
02051 s(inDoubt);
02052 }
02053
02054 };
02055 inline Packer<RecoverResult> serializable(RecoverResult& x) { return Packer<RecoverResult>(x); }
02056 std::ostream& operator << (std::ostream&, const RecoverResult&);
02057 bool operator==(const RecoverResult&, const RecoverResult&);
02058
02059 struct Select:
02060 public Command
02061 {
02062
02063 static const char* NAME;
02064 static const uint8_t CODE=0x1;
02065 static const uint8_t CLASS_CODE=dtx::CODE;
02066 static const char* CLASS_NAME;
02067 Select();
02068 void accept(Visitor&);
02069 void accept(ConstVisitor&) const;
02070 template <class S> void serialize(S&) {}
02071
02072 struct Handler
02073 {
02074 void dtxSelect(
02075
02076 );
02077 };
02078
02079 template <class T> void invoke(T& target)const
02080 {
02081 target.dtxSelect( );
02082 }
02083 };
02084 inline Packer<Select> serializable(Select& x) { return Packer<Select>(x); }
02085 std::ostream& operator << (std::ostream&, const Select&);
02086 bool operator==(const Select&, const Select&);
02087
02088 struct Start:
02089 public Command
02090 {
02091 Xid xid;
02092 Bit join;
02093 Bit resume;
02094
02095 static const char* NAME;
02096 static const uint8_t CODE=0x2;
02097 static const uint8_t CLASS_CODE=dtx::CODE;
02098 static const char* CLASS_NAME;
02099 Start();
02100 Start(
02101 call_traits<dtx::Xid>::param_type xid_,
02102 call_traits<Bit>::param_type join_,
02103 call_traits<Bit>::param_type resume_
02104 );
02105 void accept(Visitor&);
02106 void accept(ConstVisitor&) const;
02107 template <class S> void serialize(S& s) {
02108 s(xid)(join)(resume);
02109 }
02110
02111 struct Handler
02112 {
02113 void dtxStart(
02114 call_traits<dtx::Xid>::param_type xid_,
02115 call_traits<Bit>::param_type join_,
02116 call_traits<Bit>::param_type resume_
02117 );
02118 };
02119
02120 template <class T> void invoke(T& target)const
02121 {
02122 target.dtxStart(xid, join, resume );
02123 }
02124 };
02125 inline Packer<Start> serializable(Start& x) { return Packer<Start>(x); }
02126 std::ostream& operator << (std::ostream&, const Start&);
02127 bool operator==(const Start&, const Start&);
02128
02129 struct End:
02130 public Command
02131 {
02132 Xid xid;
02133 Bit fail;
02134 Bit suspend;
02135
02136 static const char* NAME;
02137 static const uint8_t CODE=0x3;
02138 static const uint8_t CLASS_CODE=dtx::CODE;
02139 static const char* CLASS_NAME;
02140 End();
02141 End(
02142 call_traits<dtx::Xid>::param_type xid_,
02143 call_traits<Bit>::param_type fail_,
02144 call_traits<Bit>::param_type suspend_
02145 );
02146 void accept(Visitor&);
02147 void accept(ConstVisitor&) const;
02148 template <class S> void serialize(S& s) {
02149 s(xid)(fail)(suspend);
02150 }
02151
02152 struct Handler
02153 {
02154 void dtxEnd(
02155 call_traits<dtx::Xid>::param_type xid_,
02156 call_traits<Bit>::param_type fail_,
02157 call_traits<Bit>::param_type suspend_
02158 );
02159 };
02160
02161 template <class T> void invoke(T& target)const
02162 {
02163 target.dtxEnd(xid, fail, suspend );
02164 }
02165 };
02166 inline Packer<End> serializable(End& x) { return Packer<End>(x); }
02167 std::ostream& operator << (std::ostream&, const End&);
02168 bool operator==(const End&, const End&);
02169
02170 struct Commit:
02171 public Command
02172 {
02173 Xid xid;
02174 Bit onePhase;
02175
02176 static const char* NAME;
02177 static const uint8_t CODE=0x4;
02178 static const uint8_t CLASS_CODE=dtx::CODE;
02179 static const char* CLASS_NAME;
02180 Commit();
02181 Commit(
02182 call_traits<dtx::Xid>::param_type xid_,
02183 call_traits<Bit>::param_type onePhase_
02184 );
02185 void accept(Visitor&);
02186 void accept(ConstVisitor&) const;
02187 template <class S> void serialize(S& s) {
02188 s(xid)(onePhase);
02189 }
02190
02191 struct Handler
02192 {
02193 void dtxCommit(
02194 call_traits<dtx::Xid>::param_type xid_,
02195 call_traits<Bit>::param_type onePhase_
02196 );
02197 };
02198
02199 template <class T> void invoke(T& target)const
02200 {
02201 target.dtxCommit(xid, onePhase );
02202 }
02203 };
02204 inline Packer<Commit> serializable(Commit& x) { return Packer<Commit>(x); }
02205 std::ostream& operator << (std::ostream&, const Commit&);
02206 bool operator==(const Commit&, const Commit&);
02207
02208 struct Forget:
02209 public Command
02210 {
02211 Xid xid;
02212
02213 static const char* NAME;
02214 static const uint8_t CODE=0x5;
02215 static const uint8_t CLASS_CODE=dtx::CODE;
02216 static const char* CLASS_NAME;
02217 Forget();
02218 Forget(call_traits<dtx::Xid>::param_type xid_);
02219 void accept(Visitor&);
02220 void accept(ConstVisitor&) const;
02221 template <class S> void serialize(S& s) {
02222 s(xid);
02223 }
02224
02225 struct Handler
02226 {
02227 void dtxForget(
02228 call_traits<dtx::Xid>::param_type xid_
02229 );
02230 };
02231
02232 template <class T> void invoke(T& target)const
02233 {
02234 target.dtxForget(xid );
02235 }
02236 };
02237 inline Packer<Forget> serializable(Forget& x) { return Packer<Forget>(x); }
02238 std::ostream& operator << (std::ostream&, const Forget&);
02239 bool operator==(const Forget&, const Forget&);
02240
02241 struct GetTimeout:
02242 public Command
02243 {
02244 Xid xid;
02245
02246 static const char* NAME;
02247 static const uint8_t CODE=0x6;
02248 static const uint8_t CLASS_CODE=dtx::CODE;
02249 static const char* CLASS_NAME;
02250 GetTimeout();
02251 GetTimeout(call_traits<dtx::Xid>::param_type xid_);
02252 void accept(Visitor&);
02253 void accept(ConstVisitor&) const;
02254 template <class S> void serialize(S& s) {
02255 s(xid);
02256 }
02257
02258 struct Handler
02259 {
02260 void dtxGetTimeout(
02261 call_traits<dtx::Xid>::param_type xid_
02262 );
02263 };
02264
02265 template <class T> void invoke(T& target)const
02266 {
02267 target.dtxGetTimeout(xid );
02268 }
02269 };
02270 inline Packer<GetTimeout> serializable(GetTimeout& x) { return Packer<GetTimeout>(x); }
02271 std::ostream& operator << (std::ostream&, const GetTimeout&);
02272 bool operator==(const GetTimeout&, const GetTimeout&);
02273
02274 struct Prepare:
02275 public Command
02276 {
02277 Xid xid;
02278
02279 static const char* NAME;
02280 static const uint8_t CODE=0x7;
02281 static const uint8_t CLASS_CODE=dtx::CODE;
02282 static const char* CLASS_NAME;
02283 Prepare();
02284 Prepare(call_traits<dtx::Xid>::param_type xid_);
02285 void accept(Visitor&);
02286 void accept(ConstVisitor&) const;
02287 template <class S> void serialize(S& s) {
02288 s(xid);
02289 }
02290
02291 struct Handler
02292 {
02293 void dtxPrepare(
02294 call_traits<dtx::Xid>::param_type xid_
02295 );
02296 };
02297
02298 template <class T> void invoke(T& target)const
02299 {
02300 target.dtxPrepare(xid );
02301 }
02302 };
02303 inline Packer<Prepare> serializable(Prepare& x) { return Packer<Prepare>(x); }
02304 std::ostream& operator << (std::ostream&, const Prepare&);
02305 bool operator==(const Prepare&, const Prepare&);
02306
02307 struct Recover:
02308 public Command
02309 {
02310
02311 static const char* NAME;
02312 static const uint8_t CODE=0x8;
02313 static const uint8_t CLASS_CODE=dtx::CODE;
02314 static const char* CLASS_NAME;
02315 Recover();
02316 void accept(Visitor&);
02317 void accept(ConstVisitor&) const;
02318 template <class S> void serialize(S&) {}
02319
02320 struct Handler
02321 {
02322 void dtxRecover(
02323
02324 );
02325 };
02326
02327 template <class T> void invoke(T& target)const
02328 {
02329 target.dtxRecover( );
02330 }
02331 };
02332 inline Packer<Recover> serializable(Recover& x) { return Packer<Recover>(x); }
02333 std::ostream& operator << (std::ostream&, const Recover&);
02334 bool operator==(const Recover&, const Recover&);
02335
02336 struct Rollback:
02337 public Command
02338 {
02339 Xid xid;
02340
02341 static const char* NAME;
02342 static const uint8_t CODE=0x9;
02343 static const uint8_t CLASS_CODE=dtx::CODE;
02344 static const char* CLASS_NAME;
02345 Rollback();
02346 Rollback(call_traits<dtx::Xid>::param_type xid_);
02347 void accept(Visitor&);
02348 void accept(ConstVisitor&) const;
02349 template <class S> void serialize(S& s) {
02350 s(xid);
02351 }
02352
02353 struct Handler
02354 {
02355 void dtxRollback(
02356 call_traits<dtx::Xid>::param_type xid_
02357 );
02358 };
02359
02360 template <class T> void invoke(T& target)const
02361 {
02362 target.dtxRollback(xid );
02363 }
02364 };
02365 inline Packer<Rollback> serializable(Rollback& x) { return Packer<Rollback>(x); }
02366 std::ostream& operator << (std::ostream&, const Rollback&);
02367 bool operator==(const Rollback&, const Rollback&);
02368
02369 struct SetTimeout:
02370 public Command
02371 {
02372 Xid xid;
02373 Uint32 timeout;
02374
02375 static const char* NAME;
02376 static const uint8_t CODE=0xa;
02377 static const uint8_t CLASS_CODE=dtx::CODE;
02378 static const char* CLASS_NAME;
02379 SetTimeout();
02380 SetTimeout(
02381 call_traits<dtx::Xid>::param_type xid_,
02382 call_traits<Uint32>::param_type timeout_
02383 );
02384 void accept(Visitor&);
02385 void accept(ConstVisitor&) const;
02386 template <class S> void serialize(S& s) {
02387 s(xid)(timeout);
02388 }
02389
02390 struct Handler
02391 {
02392 void dtxSetTimeout(
02393 call_traits<dtx::Xid>::param_type xid_,
02394 call_traits<Uint32>::param_type timeout_
02395 );
02396 };
02397
02398 template <class T> void invoke(T& target)const
02399 {
02400 target.dtxSetTimeout(xid, timeout );
02401 }
02402 };
02403 inline Packer<SetTimeout> serializable(SetTimeout& x) { return Packer<SetTimeout>(x); }
02404 std::ostream& operator << (std::ostream&, const SetTimeout&);
02405 bool operator==(const SetTimeout&, const SetTimeout&);
02406
02407 }
02408
02409
02410 namespace exchange {
02411
02412
02413 struct ExchangeQueryResult:
02414 public Struct
02415 {
02416 Str8 type;
02417 Bit durable;
02418 Bit notFound;
02419 Map arguments;
02420
02421 static const char* NAME;
02422 static const uint8_t SIZE=4;
02423 static const uint8_t PACK=2;
02424 static const uint8_t CODE=0x1;
02425 static const uint8_t CLASS_CODE=exchange::CODE;
02426 static const char* CLASS_NAME;
02427 ExchangeQueryResult();
02428 ExchangeQueryResult(
02429 call_traits<Str8>::param_type type_,
02430 call_traits<Bit>::param_type durable_,
02431 call_traits<Bit>::param_type notFound_,
02432 call_traits<Map>::param_type arguments_
02433 );
02434 void accept(Visitor&);
02435 void accept(ConstVisitor&) const;
02436 template <class S> void serialize(S& s) {
02437 s(type)(durable)(notFound)(arguments);
02438 }
02439
02440 };
02441 inline Packer<ExchangeQueryResult> serializable(ExchangeQueryResult& x) { return Packer<ExchangeQueryResult>(x); }
02442 std::ostream& operator << (std::ostream&, const ExchangeQueryResult&);
02443 bool operator==(const ExchangeQueryResult&, const ExchangeQueryResult&);
02444
02445 struct ExchangeBoundResult:
02446 public Struct
02447 {
02448 Bit exchangeNotFound;
02449 Bit queueNotFound;
02450 Bit queueNotMatched;
02451 Bit keyNotMatched;
02452 Bit argsNotMatched;
02453
02454 static const char* NAME;
02455 static const uint8_t SIZE=4;
02456 static const uint8_t PACK=2;
02457 static const uint8_t CODE=0x2;
02458 static const uint8_t CLASS_CODE=exchange::CODE;
02459 static const char* CLASS_NAME;
02460 ExchangeBoundResult();
02461 ExchangeBoundResult(
02462 call_traits<Bit>::param_type exchangeNotFound_,
02463 call_traits<Bit>::param_type queueNotFound_,
02464 call_traits<Bit>::param_type queueNotMatched_,
02465 call_traits<Bit>::param_type keyNotMatched_,
02466 call_traits<Bit>::param_type argsNotMatched_
02467 );
02468 void accept(Visitor&);
02469 void accept(ConstVisitor&) const;
02470 template <class S> void serialize(S& s) {
02471 s(exchangeNotFound)(queueNotFound)(queueNotMatched)(keyNotMatched)(argsNotMatched);
02472 }
02473
02474 };
02475 inline Packer<ExchangeBoundResult> serializable(ExchangeBoundResult& x) { return Packer<ExchangeBoundResult>(x); }
02476 std::ostream& operator << (std::ostream&, const ExchangeBoundResult&);
02477 bool operator==(const ExchangeBoundResult&, const ExchangeBoundResult&);
02478
02479 struct Declare:
02480 public Command
02481 {
02482 Name exchange;
02483 Str8 type;
02484 Name alternateExchange;
02485 Bit passive;
02486 Bit durable;
02487 Bit autoDelete;
02488 Map arguments;
02489
02490 static const char* NAME;
02491 static const uint8_t CODE=0x1;
02492 static const uint8_t CLASS_CODE=exchange::CODE;
02493 static const char* CLASS_NAME;
02494 Declare();
02495 Declare(
02496 call_traits<exchange::Name>::param_type exchange_,
02497 call_traits<Str8>::param_type type_,
02498 call_traits<exchange::Name>::param_type alternateExchange_,
02499 call_traits<Bit>::param_type passive_,
02500 call_traits<Bit>::param_type durable_,
02501 call_traits<Bit>::param_type autoDelete_,
02502 call_traits<Map>::param_type arguments_
02503 );
02504 void accept(Visitor&);
02505 void accept(ConstVisitor&) const;
02506 template <class S> void serialize(S& s) {
02507 s(exchange)(type)(alternateExchange)(passive)(durable)(autoDelete)(arguments);
02508 }
02509
02510 struct Handler
02511 {
02512 void exchangeDeclare(
02513 call_traits<exchange::Name>::param_type exchange_,
02514 call_traits<Str8>::param_type type_,
02515 call_traits<exchange::Name>::param_type alternateExchange_,
02516 call_traits<Bit>::param_type passive_,
02517 call_traits<Bit>::param_type durable_,
02518 call_traits<Bit>::param_type autoDelete_,
02519 call_traits<Map>::param_type arguments_
02520 );
02521 };
02522
02523 template <class T> void invoke(T& target)const
02524 {
02525 target.exchangeDeclare(exchange, type, alternateExchange, passive, durable, autoDelete, arguments );
02526 }
02527 };
02528 inline Packer<Declare> serializable(Declare& x) { return Packer<Declare>(x); }
02529 std::ostream& operator << (std::ostream&, const Declare&);
02530 bool operator==(const Declare&, const Declare&);
02531
02532 struct Delete:
02533 public Command
02534 {
02535 Name exchange;
02536 Bit ifUnused;
02537
02538 static const char* NAME;
02539 static const uint8_t CODE=0x2;
02540 static const uint8_t CLASS_CODE=exchange::CODE;
02541 static const char* CLASS_NAME;
02542 Delete();
02543 Delete(
02544 call_traits<exchange::Name>::param_type exchange_,
02545 call_traits<Bit>::param_type ifUnused_
02546 );
02547 void accept(Visitor&);
02548 void accept(ConstVisitor&) const;
02549 template <class S> void serialize(S& s) {
02550 s(exchange)(ifUnused);
02551 }
02552
02553 struct Handler
02554 {
02555 void exchangeDelete(
02556 call_traits<exchange::Name>::param_type exchange_,
02557 call_traits<Bit>::param_type ifUnused_
02558 );
02559 };
02560
02561 template <class T> void invoke(T& target)const
02562 {
02563 target.exchangeDelete(exchange, ifUnused );
02564 }
02565 };
02566 inline Packer<Delete> serializable(Delete& x) { return Packer<Delete>(x); }
02567 std::ostream& operator << (std::ostream&, const Delete&);
02568 bool operator==(const Delete&, const Delete&);
02569
02570 struct Query:
02571 public Command
02572 {
02573 Str8 name;
02574
02575 static const char* NAME;
02576 static const uint8_t CODE=0x3;
02577 static const uint8_t CLASS_CODE=exchange::CODE;
02578 static const char* CLASS_NAME;
02579 Query();
02580 Query(call_traits<Str8>::param_type name_);
02581 void accept(Visitor&);
02582 void accept(ConstVisitor&) const;
02583 template <class S> void serialize(S& s) {
02584 s(name);
02585 }
02586
02587 struct Handler
02588 {
02589 void exchangeQuery(
02590 call_traits<Str8>::param_type name_
02591 );
02592 };
02593
02594 template <class T> void invoke(T& target)const
02595 {
02596 target.exchangeQuery(name );
02597 }
02598 };
02599 inline Packer<Query> serializable(Query& x) { return Packer<Query>(x); }
02600 std::ostream& operator << (std::ostream&, const Query&);
02601 bool operator==(const Query&, const Query&);
02602
02603 struct Bind:
02604 public Command
02605 {
02606 queue::Name queue;
02607 Name exchange;
02608 Str8 bindingKey;
02609 Map arguments;
02610
02611 static const char* NAME;
02612 static const uint8_t CODE=0x4;
02613 static const uint8_t CLASS_CODE=exchange::CODE;
02614 static const char* CLASS_NAME;
02615 Bind();
02616 Bind(
02617 call_traits<queue::Name>::param_type queue_,
02618 call_traits<exchange::Name>::param_type exchange_,
02619 call_traits<Str8>::param_type bindingKey_,
02620 call_traits<Map>::param_type arguments_
02621 );
02622 void accept(Visitor&);
02623 void accept(ConstVisitor&) const;
02624 template <class S> void serialize(S& s) {
02625 s(queue)(exchange)(bindingKey)(arguments);
02626 }
02627
02628 struct Handler
02629 {
02630 void exchangeBind(
02631 call_traits<queue::Name>::param_type queue_,
02632 call_traits<exchange::Name>::param_type exchange_,
02633 call_traits<Str8>::param_type bindingKey_,
02634 call_traits<Map>::param_type arguments_
02635 );
02636 };
02637
02638 template <class T> void invoke(T& target)const
02639 {
02640 target.exchangeBind(queue, exchange, bindingKey, arguments );
02641 }
02642 };
02643 inline Packer<Bind> serializable(Bind& x) { return Packer<Bind>(x); }
02644 std::ostream& operator << (std::ostream&, const Bind&);
02645 bool operator==(const Bind&, const Bind&);
02646
02647 struct Unbind:
02648 public Command
02649 {
02650 queue::Name queue;
02651 Name exchange;
02652 Str8 bindingKey;
02653
02654 static const char* NAME;
02655 static const uint8_t CODE=0x5;
02656 static const uint8_t CLASS_CODE=exchange::CODE;
02657 static const char* CLASS_NAME;
02658 Unbind();
02659 Unbind(
02660 call_traits<queue::Name>::param_type queue_,
02661 call_traits<exchange::Name>::param_type exchange_,
02662 call_traits<Str8>::param_type bindingKey_
02663 );
02664 void accept(Visitor&);
02665 void accept(ConstVisitor&) const;
02666 template <class S> void serialize(S& s) {
02667 s(queue)(exchange)(bindingKey);
02668 }
02669
02670 struct Handler
02671 {
02672 void exchangeUnbind(
02673 call_traits<queue::Name>::param_type queue_,
02674 call_traits<exchange::Name>::param_type exchange_,
02675 call_traits<Str8>::param_type bindingKey_
02676 );
02677 };
02678
02679 template <class T> void invoke(T& target)const
02680 {
02681 target.exchangeUnbind(queue, exchange, bindingKey );
02682 }
02683 };
02684 inline Packer<Unbind> serializable(Unbind& x) { return Packer<Unbind>(x); }
02685 std::ostream& operator << (std::ostream&, const Unbind&);
02686 bool operator==(const Unbind&, const Unbind&);
02687
02688 struct Bound:
02689 public Command
02690 {
02691 Str8 exchange;
02692 Str8 queue;
02693 Str8 bindingKey;
02694 Map arguments;
02695
02696 static const char* NAME;
02697 static const uint8_t CODE=0x6;
02698 static const uint8_t CLASS_CODE=exchange::CODE;
02699 static const char* CLASS_NAME;
02700 Bound();
02701 Bound(
02702 call_traits<Str8>::param_type exchange_,
02703 call_traits<Str8>::param_type queue_,
02704 call_traits<Str8>::param_type bindingKey_,
02705 call_traits<Map>::param_type arguments_
02706 );
02707 void accept(Visitor&);
02708 void accept(ConstVisitor&) const;
02709 template <class S> void serialize(S& s) {
02710 s(exchange)(queue)(bindingKey)(arguments);
02711 }
02712
02713 struct Handler
02714 {
02715 void exchangeBound(
02716 call_traits<Str8>::param_type exchange_,
02717 call_traits<Str8>::param_type queue_,
02718 call_traits<Str8>::param_type bindingKey_,
02719 call_traits<Map>::param_type arguments_
02720 );
02721 };
02722
02723 template <class T> void invoke(T& target)const
02724 {
02725 target.exchangeBound(exchange, queue, bindingKey, arguments );
02726 }
02727 };
02728 inline Packer<Bound> serializable(Bound& x) { return Packer<Bound>(x); }
02729 std::ostream& operator << (std::ostream&, const Bound&);
02730 bool operator==(const Bound&, const Bound&);
02731
02732 }
02733
02734
02735 namespace queue {
02736
02737
02738 struct QueueQueryResult:
02739 public Struct
02740 {
02741 Name queue;
02742 exchange::Name alternateExchange;
02743 Bit durable;
02744 Bit exclusive;
02745 Bit autoDelete;
02746 Map arguments;
02747 Uint32 messageCount;
02748 Uint32 subscriberCount;
02749
02750 static const char* NAME;
02751 static const uint8_t SIZE=4;
02752 static const uint8_t PACK=2;
02753 static const uint8_t CODE=0x1;
02754 static const uint8_t CLASS_CODE=queue::CODE;
02755 static const char* CLASS_NAME;
02756 QueueQueryResult();
02757 QueueQueryResult(
02758 call_traits<queue::Name>::param_type queue_,
02759 call_traits<exchange::Name>::param_type alternateExchange_,
02760 call_traits<Bit>::param_type durable_,
02761 call_traits<Bit>::param_type exclusive_,
02762 call_traits<Bit>::param_type autoDelete_,
02763 call_traits<Map>::param_type arguments_,
02764 call_traits<Uint32>::param_type messageCount_,
02765 call_traits<Uint32>::param_type subscriberCount_
02766 );
02767 void accept(Visitor&);
02768 void accept(ConstVisitor&) const;
02769 template <class S> void serialize(S& s) {
02770 s(queue)(alternateExchange)(durable)(exclusive)(autoDelete)(arguments)(messageCount)(subscriberCount);
02771 }
02772
02773 };
02774 inline Packer<QueueQueryResult> serializable(QueueQueryResult& x) { return Packer<QueueQueryResult>(x); }
02775 std::ostream& operator << (std::ostream&, const QueueQueryResult&);
02776 bool operator==(const QueueQueryResult&, const QueueQueryResult&);
02777
02778 struct Declare:
02779 public Command
02780 {
02781 Name queue;
02782 exchange::Name alternateExchange;
02783 Bit passive;
02784 Bit durable;
02785 Bit exclusive;
02786 Bit autoDelete;
02787 Map arguments;
02788
02789 static const char* NAME;
02790 static const uint8_t CODE=0x1;
02791 static const uint8_t CLASS_CODE=queue::CODE;
02792 static const char* CLASS_NAME;
02793 Declare();
02794 Declare(
02795 call_traits<queue::Name>::param_type queue_,
02796 call_traits<exchange::Name>::param_type alternateExchange_,
02797 call_traits<Bit>::param_type passive_,
02798 call_traits<Bit>::param_type durable_,
02799 call_traits<Bit>::param_type exclusive_,
02800 call_traits<Bit>::param_type autoDelete_,
02801 call_traits<Map>::param_type arguments_
02802 );
02803 void accept(Visitor&);
02804 void accept(ConstVisitor&) const;
02805 template <class S> void serialize(S& s) {
02806 s(queue)(alternateExchange)(passive)(durable)(exclusive)(autoDelete)(arguments);
02807 }
02808
02809 struct Handler
02810 {
02811 void queueDeclare(
02812 call_traits<queue::Name>::param_type queue_,
02813 call_traits<exchange::Name>::param_type alternateExchange_,
02814 call_traits<Bit>::param_type passive_,
02815 call_traits<Bit>::param_type durable_,
02816 call_traits<Bit>::param_type exclusive_,
02817 call_traits<Bit>::param_type autoDelete_,
02818 call_traits<Map>::param_type arguments_
02819 );
02820 };
02821
02822 template <class T> void invoke(T& target)const
02823 {
02824 target.queueDeclare(queue, alternateExchange, passive, durable, exclusive, autoDelete, arguments );
02825 }
02826 };
02827 inline Packer<Declare> serializable(Declare& x) { return Packer<Declare>(x); }
02828 std::ostream& operator << (std::ostream&, const Declare&);
02829 bool operator==(const Declare&, const Declare&);
02830
02831 struct Delete:
02832 public Command
02833 {
02834 Name queue;
02835 Bit ifUnused;
02836 Bit ifEmpty;
02837
02838 static const char* NAME;
02839 static const uint8_t CODE=0x2;
02840 static const uint8_t CLASS_CODE=queue::CODE;
02841 static const char* CLASS_NAME;
02842 Delete();
02843 Delete(
02844 call_traits<queue::Name>::param_type queue_,
02845 call_traits<Bit>::param_type ifUnused_,
02846 call_traits<Bit>::param_type ifEmpty_
02847 );
02848 void accept(Visitor&);
02849 void accept(ConstVisitor&) const;
02850 template <class S> void serialize(S& s) {
02851 s(queue)(ifUnused)(ifEmpty);
02852 }
02853
02854 struct Handler
02855 {
02856 void queueDelete(
02857 call_traits<queue::Name>::param_type queue_,
02858 call_traits<Bit>::param_type ifUnused_,
02859 call_traits<Bit>::param_type ifEmpty_
02860 );
02861 };
02862
02863 template <class T> void invoke(T& target)const
02864 {
02865 target.queueDelete(queue, ifUnused, ifEmpty );
02866 }
02867 };
02868 inline Packer<Delete> serializable(Delete& x) { return Packer<Delete>(x); }
02869 std::ostream& operator << (std::ostream&, const Delete&);
02870 bool operator==(const Delete&, const Delete&);
02871
02872 struct Purge:
02873 public Command
02874 {
02875 Name queue;
02876
02877 static const char* NAME;
02878 static const uint8_t CODE=0x3;
02879 static const uint8_t CLASS_CODE=queue::CODE;
02880 static const char* CLASS_NAME;
02881 Purge();
02882 Purge(call_traits<queue::Name>::param_type queue_);
02883 void accept(Visitor&);
02884 void accept(ConstVisitor&) const;
02885 template <class S> void serialize(S& s) {
02886 s(queue);
02887 }
02888
02889 struct Handler
02890 {
02891 void queuePurge(
02892 call_traits<queue::Name>::param_type queue_
02893 );
02894 };
02895
02896 template <class T> void invoke(T& target)const
02897 {
02898 target.queuePurge(queue );
02899 }
02900 };
02901 inline Packer<Purge> serializable(Purge& x) { return Packer<Purge>(x); }
02902 std::ostream& operator << (std::ostream&, const Purge&);
02903 bool operator==(const Purge&, const Purge&);
02904
02905 struct Query:
02906 public Command
02907 {
02908 Name queue;
02909
02910 static const char* NAME;
02911 static const uint8_t CODE=0x4;
02912 static const uint8_t CLASS_CODE=queue::CODE;
02913 static const char* CLASS_NAME;
02914 Query();
02915 Query(call_traits<queue::Name>::param_type queue_);
02916 void accept(Visitor&);
02917 void accept(ConstVisitor&) const;
02918 template <class S> void serialize(S& s) {
02919 s(queue);
02920 }
02921
02922 struct Handler
02923 {
02924 void queueQuery(
02925 call_traits<queue::Name>::param_type queue_
02926 );
02927 };
02928
02929 template <class T> void invoke(T& target)const
02930 {
02931 target.queueQuery(queue );
02932 }
02933 };
02934 inline Packer<Query> serializable(Query& x) { return Packer<Query>(x); }
02935 std::ostream& operator << (std::ostream&, const Query&);
02936 bool operator==(const Query&, const Query&);
02937
02938 }
02939
02940
02941 namespace file {
02942
02943
02944 struct FileProperties:
02945 public Struct
02946 {
02947 Str8 contentType;
02948 Str8 contentEncoding;
02949 Map headers;
02950 Uint8 priority;
02951 Str8 replyTo;
02952 Str8 messageId;
02953 Str8 filename;
02954 Datetime timestamp;
02955 Str8 clusterId;
02956
02957 static const char* NAME;
02958 static const uint8_t SIZE=4;
02959 static const uint8_t PACK=2;
02960 static const uint8_t CODE=0x1;
02961 static const uint8_t CLASS_CODE=file::CODE;
02962 static const char* CLASS_NAME;
02963 FileProperties();
02964 FileProperties(
02965 call_traits<Str8>::param_type contentType_,
02966 call_traits<Str8>::param_type contentEncoding_,
02967 call_traits<Map>::param_type headers_,
02968 call_traits<Uint8>::param_type priority_,
02969 call_traits<Str8>::param_type replyTo_,
02970 call_traits<Str8>::param_type messageId_,
02971 call_traits<Str8>::param_type filename_,
02972 call_traits<Datetime>::param_type timestamp_,
02973 call_traits<Str8>::param_type clusterId_
02974 );
02975 void accept(Visitor&);
02976 void accept(ConstVisitor&) const;
02977 template <class S> void serialize(S& s) {
02978 s(contentType)(contentEncoding)(headers)(priority)(replyTo)(messageId)(filename)(timestamp)(clusterId);
02979 }
02980
02981 };
02982 inline Packer<FileProperties> serializable(FileProperties& x) { return Packer<FileProperties>(x); }
02983 std::ostream& operator << (std::ostream&, const FileProperties&);
02984 bool operator==(const FileProperties&, const FileProperties&);
02985
02986 struct Qos:
02987 public Command
02988 {
02989 Uint32 prefetchSize;
02990 Uint16 prefetchCount;
02991 Bit global;
02992
02993 static const char* NAME;
02994 static const uint8_t CODE=0x1;
02995 static const uint8_t CLASS_CODE=file::CODE;
02996 static const char* CLASS_NAME;
02997 Qos();
02998 Qos(
02999 call_traits<Uint32>::param_type prefetchSize_,
03000 call_traits<Uint16>::param_type prefetchCount_,
03001 call_traits<Bit>::param_type global_
03002 );
03003 void accept(Visitor&);
03004 void accept(ConstVisitor&) const;
03005 template <class S> void serialize(S& s) {
03006 s(prefetchSize)(prefetchCount)(global);
03007 }
03008
03009 struct Handler
03010 {
03011 void fileQos(
03012 call_traits<Uint32>::param_type prefetchSize_,
03013 call_traits<Uint16>::param_type prefetchCount_,
03014 call_traits<Bit>::param_type global_
03015 );
03016 };
03017
03018 template <class T> void invoke(T& target)const
03019 {
03020 target.fileQos(prefetchSize, prefetchCount, global );
03021 }
03022 };
03023 inline Packer<Qos> serializable(Qos& x) { return Packer<Qos>(x); }
03024 std::ostream& operator << (std::ostream&, const Qos&);
03025 bool operator==(const Qos&, const Qos&);
03026
03027 struct QosOk:
03028 public Command
03029 {
03030
03031 static const char* NAME;
03032 static const uint8_t CODE=0x2;
03033 static const uint8_t CLASS_CODE=file::CODE;
03034 static const char* CLASS_NAME;
03035 QosOk();
03036 void accept(Visitor&);
03037 void accept(ConstVisitor&) const;
03038 template <class S> void serialize(S&) {}
03039
03040 struct Handler
03041 {
03042 void fileQosOk(
03043
03044 );
03045 };
03046
03047 template <class T> void invoke(T& target)const
03048 {
03049 target.fileQosOk( );
03050 }
03051 };
03052 inline Packer<QosOk> serializable(QosOk& x) { return Packer<QosOk>(x); }
03053 std::ostream& operator << (std::ostream&, const QosOk&);
03054 bool operator==(const QosOk&, const QosOk&);
03055
03056 struct Consume:
03057 public Command
03058 {
03059 queue::Name queue;
03060 Str8 consumerTag;
03061 Bit noLocal;
03062 Bit noAck;
03063 Bit exclusive;
03064 Bit nowait;
03065 Map arguments;
03066
03067 static const char* NAME;
03068 static const uint8_t CODE=0x3;
03069 static const uint8_t CLASS_CODE=file::CODE;
03070 static const char* CLASS_NAME;
03071 Consume();
03072 Consume(
03073 call_traits<queue::Name>::param_type queue_,
03074 call_traits<Str8>::param_type consumerTag_,
03075 call_traits<Bit>::param_type noLocal_,
03076 call_traits<Bit>::param_type noAck_,
03077 call_traits<Bit>::param_type exclusive_,
03078 call_traits<Bit>::param_type nowait_,
03079 call_traits<Map>::param_type arguments_
03080 );
03081 void accept(Visitor&);
03082 void accept(ConstVisitor&) const;
03083 template <class S> void serialize(S& s) {
03084 s(queue)(consumerTag)(noLocal)(noAck)(exclusive)(nowait)(arguments);
03085 }
03086
03087 struct Handler
03088 {
03089 void fileConsume(
03090 call_traits<queue::Name>::param_type queue_,
03091 call_traits<Str8>::param_type consumerTag_,
03092 call_traits<Bit>::param_type noLocal_,
03093 call_traits<Bit>::param_type noAck_,
03094 call_traits<Bit>::param_type exclusive_,
03095 call_traits<Bit>::param_type nowait_,
03096 call_traits<Map>::param_type arguments_
03097 );
03098 };
03099
03100 template <class T> void invoke(T& target)const
03101 {
03102 target.fileConsume(queue, consumerTag, noLocal, noAck, exclusive, nowait, arguments );
03103 }
03104 };
03105 inline Packer<Consume> serializable(Consume& x) { return Packer<Consume>(x); }
03106 std::ostream& operator << (std::ostream&, const Consume&);
03107 bool operator==(const Consume&, const Consume&);
03108
03109 struct ConsumeOk:
03110 public Command
03111 {
03112 Str8 consumerTag;
03113
03114 static const char* NAME;
03115 static const uint8_t CODE=0x4;
03116 static const uint8_t CLASS_CODE=file::CODE;
03117 static const char* CLASS_NAME;
03118 ConsumeOk();
03119 ConsumeOk(call_traits<Str8>::param_type consumerTag_);
03120 void accept(Visitor&);
03121 void accept(ConstVisitor&) const;
03122 template <class S> void serialize(S& s) {
03123 s(consumerTag);
03124 }
03125
03126 struct Handler
03127 {
03128 void fileConsumeOk(
03129 call_traits<Str8>::param_type consumerTag_
03130 );
03131 };
03132
03133 template <class T> void invoke(T& target)const
03134 {
03135 target.fileConsumeOk(consumerTag );
03136 }
03137 };
03138 inline Packer<ConsumeOk> serializable(ConsumeOk& x) { return Packer<ConsumeOk>(x); }
03139 std::ostream& operator << (std::ostream&, const ConsumeOk&);
03140 bool operator==(const ConsumeOk&, const ConsumeOk&);
03141
03142 struct Cancel:
03143 public Command
03144 {
03145 Str8 consumerTag;
03146
03147 static const char* NAME;
03148 static const uint8_t CODE=0x5;
03149 static const uint8_t CLASS_CODE=file::CODE;
03150 static const char* CLASS_NAME;
03151 Cancel();
03152 Cancel(call_traits<Str8>::param_type consumerTag_);
03153 void accept(Visitor&);
03154 void accept(ConstVisitor&) const;
03155 template <class S> void serialize(S& s) {
03156 s(consumerTag);
03157 }
03158
03159 struct Handler
03160 {
03161 void fileCancel(
03162 call_traits<Str8>::param_type consumerTag_
03163 );
03164 };
03165
03166 template <class T> void invoke(T& target)const
03167 {
03168 target.fileCancel(consumerTag );
03169 }
03170 };
03171 inline Packer<Cancel> serializable(Cancel& x) { return Packer<Cancel>(x); }
03172 std::ostream& operator << (std::ostream&, const Cancel&);
03173 bool operator==(const Cancel&, const Cancel&);
03174
03175 struct Open:
03176 public Command
03177 {
03178 Str8 identifier;
03179 Uint64 contentSize;
03180
03181 static const char* NAME;
03182 static const uint8_t CODE=0x6;
03183 static const uint8_t CLASS_CODE=file::CODE;
03184 static const char* CLASS_NAME;
03185 Open();
03186 Open(
03187 call_traits<Str8>::param_type identifier_,
03188 call_traits<Uint64>::param_type contentSize_
03189 );
03190 void accept(Visitor&);
03191 void accept(ConstVisitor&) const;
03192 template <class S> void serialize(S& s) {
03193 s(identifier)(contentSize);
03194 }
03195
03196 struct Handler
03197 {
03198 void fileOpen(
03199 call_traits<Str8>::param_type identifier_,
03200 call_traits<Uint64>::param_type contentSize_
03201 );
03202 };
03203
03204 template <class T> void invoke(T& target)const
03205 {
03206 target.fileOpen(identifier, contentSize );
03207 }
03208 };
03209 inline Packer<Open> serializable(Open& x) { return Packer<Open>(x); }
03210 std::ostream& operator << (std::ostream&, const Open&);
03211 bool operator==(const Open&, const Open&);
03212
03213 struct OpenOk:
03214 public Command
03215 {
03216 Uint64 stagedSize;
03217
03218 static const char* NAME;
03219 static const uint8_t CODE=0x7;
03220 static const uint8_t CLASS_CODE=file::CODE;
03221 static const char* CLASS_NAME;
03222 OpenOk();
03223 OpenOk(call_traits<Uint64>::param_type stagedSize_);
03224 void accept(Visitor&);
03225 void accept(ConstVisitor&) const;
03226 template <class S> void serialize(S& s) {
03227 s(stagedSize);
03228 }
03229
03230 struct Handler
03231 {
03232 void fileOpenOk(
03233 call_traits<Uint64>::param_type stagedSize_
03234 );
03235 };
03236
03237 template <class T> void invoke(T& target)const
03238 {
03239 target.fileOpenOk(stagedSize );
03240 }
03241 };
03242 inline Packer<OpenOk> serializable(OpenOk& x) { return Packer<OpenOk>(x); }
03243 std::ostream& operator << (std::ostream&, const OpenOk&);
03244 bool operator==(const OpenOk&, const OpenOk&);
03245
03246 struct Stage:
03247 public Command
03248 {
03249
03250 static const char* NAME;
03251 static const uint8_t CODE=0x8;
03252 static const uint8_t CLASS_CODE=file::CODE;
03253 static const char* CLASS_NAME;
03254 Stage();
03255 void accept(Visitor&);
03256 void accept(ConstVisitor&) const;
03257 template <class S> void serialize(S&) {}
03258
03259 struct Handler
03260 {
03261 void fileStage(
03262
03263 );
03264 };
03265
03266 template <class T> void invoke(T& target)const
03267 {
03268 target.fileStage( );
03269 }
03270 };
03271 inline Packer<Stage> serializable(Stage& x) { return Packer<Stage>(x); }
03272 std::ostream& operator << (std::ostream&, const Stage&);
03273 bool operator==(const Stage&, const Stage&);
03274
03275 struct Publish:
03276 public Command
03277 {
03278 exchange::Name exchange;
03279 Str8 routingKey;
03280 Bit mandatory;
03281 Bit immediate;
03282 Str8 identifier;
03283
03284 static const char* NAME;
03285 static const uint8_t CODE=0x9;
03286 static const uint8_t CLASS_CODE=file::CODE;
03287 static const char* CLASS_NAME;
03288 Publish();
03289 Publish(
03290 call_traits<exchange::Name>::param_type exchange_,
03291 call_traits<Str8>::param_type routingKey_,
03292 call_traits<Bit>::param_type mandatory_,
03293 call_traits<Bit>::param_type immediate_,
03294 call_traits<Str8>::param_type identifier_
03295 );
03296 void accept(Visitor&);
03297 void accept(ConstVisitor&) const;
03298 template <class S> void serialize(S& s) {
03299 s(exchange)(routingKey)(mandatory)(immediate)(identifier);
03300 }
03301
03302 struct Handler
03303 {
03304 void filePublish(
03305 call_traits<exchange::Name>::param_type exchange_,
03306 call_traits<Str8>::param_type routingKey_,
03307 call_traits<Bit>::param_type mandatory_,
03308 call_traits<Bit>::param_type immediate_,
03309 call_traits<Str8>::param_type identifier_
03310 );
03311 };
03312
03313 template <class T> void invoke(T& target)const
03314 {
03315 target.filePublish(exchange, routingKey, mandatory, immediate, identifier );
03316 }
03317 };
03318 inline Packer<Publish> serializable(Publish& x) { return Packer<Publish>(x); }
03319 std::ostream& operator << (std::ostream&, const Publish&);
03320 bool operator==(const Publish&, const Publish&);
03321
03322 struct Return:
03323 public Command
03324 {
03325 ReturnCode replyCode;
03326 Str8 replyText;
03327 exchange::Name exchange;
03328 Str8 routingKey;
03329
03330 static const char* NAME;
03331 static const uint8_t CODE=0xa;
03332 static const uint8_t CLASS_CODE=file::CODE;
03333 static const char* CLASS_NAME;
03334 Return();
03335 Return(
03336 call_traits<file::ReturnCode>::param_type replyCode_,
03337 call_traits<Str8>::param_type replyText_,
03338 call_traits<exchange::Name>::param_type exchange_,
03339 call_traits<Str8>::param_type routingKey_
03340 );
03341 void accept(Visitor&);
03342 void accept(ConstVisitor&) const;
03343 template <class S> void serialize(S& s) {
03344 s(replyCode)(replyText)(exchange)(routingKey);
03345 }
03346
03347 struct Handler
03348 {
03349 void fileReturn(
03350 call_traits<file::ReturnCode>::param_type replyCode_,
03351 call_traits<Str8>::param_type replyText_,
03352 call_traits<exchange::Name>::param_type exchange_,
03353 call_traits<Str8>::param_type routingKey_
03354 );
03355 };
03356
03357 template <class T> void invoke(T& target)const
03358 {
03359 target.fileReturn(replyCode, replyText, exchange, routingKey );
03360 }
03361 };
03362 inline Packer<Return> serializable(Return& x) { return Packer<Return>(x); }
03363 std::ostream& operator << (std::ostream&, const Return&);
03364 bool operator==(const Return&, const Return&);
03365
03366 struct Deliver:
03367 public Command
03368 {
03369 Str8 consumerTag;
03370 Uint64 deliveryTag;
03371 Bit redelivered;
03372 exchange::Name exchange;
03373 Str8 routingKey;
03374 Str8 identifier;
03375
03376 static const char* NAME;
03377 static const uint8_t CODE=0xb;
03378 static const uint8_t CLASS_CODE=file::CODE;
03379 static const char* CLASS_NAME;
03380 Deliver();
03381 Deliver(
03382 call_traits<Str8>::param_type consumerTag_,
03383 call_traits<Uint64>::param_type deliveryTag_,
03384 call_traits<Bit>::param_type redelivered_,
03385 call_traits<exchange::Name>::param_type exchange_,
03386 call_traits<Str8>::param_type routingKey_,
03387 call_traits<Str8>::param_type identifier_
03388 );
03389 void accept(Visitor&);
03390 void accept(ConstVisitor&) const;
03391 template <class S> void serialize(S& s) {
03392 s(consumerTag)(deliveryTag)(redelivered)(exchange)(routingKey)(identifier);
03393 }
03394
03395 struct Handler
03396 {
03397 void fileDeliver(
03398 call_traits<Str8>::param_type consumerTag_,
03399 call_traits<Uint64>::param_type deliveryTag_,
03400 call_traits<Bit>::param_type redelivered_,
03401 call_traits<exchange::Name>::param_type exchange_,
03402 call_traits<Str8>::param_type routingKey_,
03403 call_traits<Str8>::param_type identifier_
03404 );
03405 };
03406
03407 template <class T> void invoke(T& target)const
03408 {
03409 target.fileDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, identifier );
03410 }
03411 };
03412 inline Packer<Deliver> serializable(Deliver& x) { return Packer<Deliver>(x); }
03413 std::ostream& operator << (std::ostream&, const Deliver&);
03414 bool operator==(const Deliver&, const Deliver&);
03415
03416 struct Ack:
03417 public Command
03418 {
03419 Uint64 deliveryTag;
03420 Bit multiple;
03421
03422 static const char* NAME;
03423 static const uint8_t CODE=0xc;
03424 static const uint8_t CLASS_CODE=file::CODE;
03425 static const char* CLASS_NAME;
03426 Ack();
03427 Ack(
03428 call_traits<Uint64>::param_type deliveryTag_,
03429 call_traits<Bit>::param_type multiple_
03430 );
03431 void accept(Visitor&);
03432 void accept(ConstVisitor&) const;
03433 template <class S> void serialize(S& s) {
03434 s(deliveryTag)(multiple);
03435 }
03436
03437 struct Handler
03438 {
03439 void fileAck(
03440 call_traits<Uint64>::param_type deliveryTag_,
03441 call_traits<Bit>::param_type multiple_
03442 );
03443 };
03444
03445 template <class T> void invoke(T& target)const
03446 {
03447 target.fileAck(deliveryTag, multiple );
03448 }
03449 };
03450 inline Packer<Ack> serializable(Ack& x) { return Packer<Ack>(x); }
03451 std::ostream& operator << (std::ostream&, const Ack&);
03452 bool operator==(const Ack&, const Ack&);
03453
03454 struct Reject:
03455 public Command
03456 {
03457 Uint64 deliveryTag;
03458 Bit requeue;
03459
03460 static const char* NAME;
03461 static const uint8_t CODE=0xd;
03462 static const uint8_t CLASS_CODE=file::CODE;
03463 static const char* CLASS_NAME;
03464 Reject();
03465 Reject(
03466 call_traits<Uint64>::param_type deliveryTag_,
03467 call_traits<Bit>::param_type requeue_
03468 );
03469 void accept(Visitor&);
03470 void accept(ConstVisitor&) const;
03471 template <class S> void serialize(S& s) {
03472 s(deliveryTag)(requeue);
03473 }
03474
03475 struct Handler
03476 {
03477 void fileReject(
03478 call_traits<Uint64>::param_type deliveryTag_,
03479 call_traits<Bit>::param_type requeue_
03480 );
03481 };
03482
03483 template <class T> void invoke(T& target)const
03484 {
03485 target.fileReject(deliveryTag, requeue );
03486 }
03487 };
03488 inline Packer<Reject> serializable(Reject& x) { return Packer<Reject>(x); }
03489 std::ostream& operator << (std::ostream&, const Reject&);
03490 bool operator==(const Reject&, const Reject&);
03491
03492 }
03493
03494
03495 namespace stream {
03496
03497
03498 struct StreamProperties:
03499 public Struct
03500 {
03501 Str8 contentType;
03502 Str8 contentEncoding;
03503 Map headers;
03504 Uint8 priority;
03505 Datetime timestamp;
03506
03507 static const char* NAME;
03508 static const uint8_t SIZE=4;
03509 static const uint8_t PACK=2;
03510 static const uint8_t CODE=0x1;
03511 static const uint8_t CLASS_CODE=stream::CODE;
03512 static const char* CLASS_NAME;
03513 StreamProperties();
03514 StreamProperties(
03515 call_traits<Str8>::param_type contentType_,
03516 call_traits<Str8>::param_type contentEncoding_,
03517 call_traits<Map>::param_type headers_,
03518 call_traits<Uint8>::param_type priority_,
03519 call_traits<Datetime>::param_type timestamp_
03520 );
03521 void accept(Visitor&);
03522 void accept(ConstVisitor&) const;
03523 template <class S> void serialize(S& s) {
03524 s(contentType)(contentEncoding)(headers)(priority)(timestamp);
03525 }
03526
03527 };
03528 inline Packer<StreamProperties> serializable(StreamProperties& x) { return Packer<StreamProperties>(x); }
03529 std::ostream& operator << (std::ostream&, const StreamProperties&);
03530 bool operator==(const StreamProperties&, const StreamProperties&);
03531
03532 struct Qos:
03533 public Command
03534 {
03535 Uint32 prefetchSize;
03536 Uint16 prefetchCount;
03537 Uint32 consumeRate;
03538 Bit global;
03539
03540 static const char* NAME;
03541 static const uint8_t CODE=0x1;
03542 static const uint8_t CLASS_CODE=stream::CODE;
03543 static const char* CLASS_NAME;
03544 Qos();
03545 Qos(
03546 call_traits<Uint32>::param_type prefetchSize_,
03547 call_traits<Uint16>::param_type prefetchCount_,
03548 call_traits<Uint32>::param_type consumeRate_,
03549 call_traits<Bit>::param_type global_
03550 );
03551 void accept(Visitor&);
03552 void accept(ConstVisitor&) const;
03553 template <class S> void serialize(S& s) {
03554 s(prefetchSize)(prefetchCount)(consumeRate)(global);
03555 }
03556
03557 struct Handler
03558 {
03559 void streamQos(
03560 call_traits<Uint32>::param_type prefetchSize_,
03561 call_traits<Uint16>::param_type prefetchCount_,
03562 call_traits<Uint32>::param_type consumeRate_,
03563 call_traits<Bit>::param_type global_
03564 );
03565 };
03566
03567 template <class T> void invoke(T& target)const
03568 {
03569 target.streamQos(prefetchSize, prefetchCount, consumeRate, global );
03570 }
03571 };
03572 inline Packer<Qos> serializable(Qos& x) { return Packer<Qos>(x); }
03573 std::ostream& operator << (std::ostream&, const Qos&);
03574 bool operator==(const Qos&, const Qos&);
03575
03576 struct QosOk:
03577 public Command
03578 {
03579
03580 static const char* NAME;
03581 static const uint8_t CODE=0x2;
03582 static const uint8_t CLASS_CODE=stream::CODE;
03583 static const char* CLASS_NAME;
03584 QosOk();
03585 void accept(Visitor&);
03586 void accept(ConstVisitor&) const;
03587 template <class S> void serialize(S&) {}
03588
03589 struct Handler
03590 {
03591 void streamQosOk(
03592
03593 );
03594 };
03595
03596 template <class T> void invoke(T& target)const
03597 {
03598 target.streamQosOk( );
03599 }
03600 };
03601 inline Packer<QosOk> serializable(QosOk& x) { return Packer<QosOk>(x); }
03602 std::ostream& operator << (std::ostream&, const QosOk&);
03603 bool operator==(const QosOk&, const QosOk&);
03604
03605 struct Consume:
03606 public Command
03607 {
03608 queue::Name queue;
03609 Str8 consumerTag;
03610 Bit noLocal;
03611 Bit exclusive;
03612 Bit nowait;
03613 Map arguments;
03614
03615 static const char* NAME;
03616 static const uint8_t CODE=0x3;
03617 static const uint8_t CLASS_CODE=stream::CODE;
03618 static const char* CLASS_NAME;
03619 Consume();
03620 Consume(
03621 call_traits<queue::Name>::param_type queue_,
03622 call_traits<Str8>::param_type consumerTag_,
03623 call_traits<Bit>::param_type noLocal_,
03624 call_traits<Bit>::param_type exclusive_,
03625 call_traits<Bit>::param_type nowait_,
03626 call_traits<Map>::param_type arguments_
03627 );
03628 void accept(Visitor&);
03629 void accept(ConstVisitor&) const;
03630 template <class S> void serialize(S& s) {
03631 s(queue)(consumerTag)(noLocal)(exclusive)(nowait)(arguments);
03632 }
03633
03634 struct Handler
03635 {
03636 void streamConsume(
03637 call_traits<queue::Name>::param_type queue_,
03638 call_traits<Str8>::param_type consumerTag_,
03639 call_traits<Bit>::param_type noLocal_,
03640 call_traits<Bit>::param_type exclusive_,
03641 call_traits<Bit>::param_type nowait_,
03642 call_traits<Map>::param_type arguments_
03643 );
03644 };
03645
03646 template <class T> void invoke(T& target)const
03647 {
03648 target.streamConsume(queue, consumerTag, noLocal, exclusive, nowait, arguments );
03649 }
03650 };
03651 inline Packer<Consume> serializable(Consume& x) { return Packer<Consume>(x); }
03652 std::ostream& operator << (std::ostream&, const Consume&);
03653 bool operator==(const Consume&, const Consume&);
03654
03655 struct ConsumeOk:
03656 public Command
03657 {
03658 Str8 consumerTag;
03659
03660 static const char* NAME;
03661 static const uint8_t CODE=0x4;
03662 static const uint8_t CLASS_CODE=stream::CODE;
03663 static const char* CLASS_NAME;
03664 ConsumeOk();
03665 ConsumeOk(call_traits<Str8>::param_type consumerTag_);
03666 void accept(Visitor&);
03667 void accept(ConstVisitor&) const;
03668 template <class S> void serialize(S& s) {
03669 s(consumerTag);
03670 }
03671
03672 struct Handler
03673 {
03674 void streamConsumeOk(
03675 call_traits<Str8>::param_type consumerTag_
03676 );
03677 };
03678
03679 template <class T> void invoke(T& target)const
03680 {
03681 target.streamConsumeOk(consumerTag );
03682 }
03683 };
03684 inline Packer<ConsumeOk> serializable(ConsumeOk& x) { return Packer<ConsumeOk>(x); }
03685 std::ostream& operator << (std::ostream&, const ConsumeOk&);
03686 bool operator==(const ConsumeOk&, const ConsumeOk&);
03687
03688 struct Cancel:
03689 public Command
03690 {
03691 Str8 consumerTag;
03692
03693 static const char* NAME;
03694 static const uint8_t CODE=0x5;
03695 static const uint8_t CLASS_CODE=stream::CODE;
03696 static const char* CLASS_NAME;
03697 Cancel();
03698 Cancel(call_traits<Str8>::param_type consumerTag_);
03699 void accept(Visitor&);
03700 void accept(ConstVisitor&) const;
03701 template <class S> void serialize(S& s) {
03702 s(consumerTag);
03703 }
03704
03705 struct Handler
03706 {
03707 void streamCancel(
03708 call_traits<Str8>::param_type consumerTag_
03709 );
03710 };
03711
03712 template <class T> void invoke(T& target)const
03713 {
03714 target.streamCancel(consumerTag );
03715 }
03716 };
03717 inline Packer<Cancel> serializable(Cancel& x) { return Packer<Cancel>(x); }
03718 std::ostream& operator << (std::ostream&, const Cancel&);
03719 bool operator==(const Cancel&, const Cancel&);
03720
03721 struct Publish:
03722 public Command
03723 {
03724 exchange::Name exchange;
03725 Str8 routingKey;
03726 Bit mandatory;
03727 Bit immediate;
03728
03729 static const char* NAME;
03730 static const uint8_t CODE=0x6;
03731 static const uint8_t CLASS_CODE=stream::CODE;
03732 static const char* CLASS_NAME;
03733 Publish();
03734 Publish(
03735 call_traits<exchange::Name>::param_type exchange_,
03736 call_traits<Str8>::param_type routingKey_,
03737 call_traits<Bit>::param_type mandatory_,
03738 call_traits<Bit>::param_type immediate_
03739 );
03740 void accept(Visitor&);
03741 void accept(ConstVisitor&) const;
03742 template <class S> void serialize(S& s) {
03743 s(exchange)(routingKey)(mandatory)(immediate);
03744 }
03745
03746 struct Handler
03747 {
03748 void streamPublish(
03749 call_traits<exchange::Name>::param_type exchange_,
03750 call_traits<Str8>::param_type routingKey_,
03751 call_traits<Bit>::param_type mandatory_,
03752 call_traits<Bit>::param_type immediate_
03753 );
03754 };
03755
03756 template <class T> void invoke(T& target)const
03757 {
03758 target.streamPublish(exchange, routingKey, mandatory, immediate );
03759 }
03760 };
03761 inline Packer<Publish> serializable(Publish& x) { return Packer<Publish>(x); }
03762 std::ostream& operator << (std::ostream&, const Publish&);
03763 bool operator==(const Publish&, const Publish&);
03764
03765 struct Return:
03766 public Command
03767 {
03768 ReturnCode replyCode;
03769 Str8 replyText;
03770 exchange::Name exchange;
03771 Str8 routingKey;
03772
03773 static const char* NAME;
03774 static const uint8_t CODE=0x7;
03775 static const uint8_t CLASS_CODE=stream::CODE;
03776 static const char* CLASS_NAME;
03777 Return();
03778 Return(
03779 call_traits<stream::ReturnCode>::param_type replyCode_,
03780 call_traits<Str8>::param_type replyText_,
03781 call_traits<exchange::Name>::param_type exchange_,
03782 call_traits<Str8>::param_type routingKey_
03783 );
03784 void accept(Visitor&);
03785 void accept(ConstVisitor&) const;
03786 template <class S> void serialize(S& s) {
03787 s(replyCode)(replyText)(exchange)(routingKey);
03788 }
03789
03790 struct Handler
03791 {
03792 void streamReturn(
03793 call_traits<stream::ReturnCode>::param_type replyCode_,
03794 call_traits<Str8>::param_type replyText_,
03795 call_traits<exchange::Name>::param_type exchange_,
03796 call_traits<Str8>::param_type routingKey_
03797 );
03798 };
03799
03800 template <class T> void invoke(T& target)const
03801 {
03802 target.streamReturn(replyCode, replyText, exchange, routingKey );
03803 }
03804 };
03805 inline Packer<Return> serializable(Return& x) { return Packer<Return>(x); }
03806 std::ostream& operator << (std::ostream&, const Return&);
03807 bool operator==(const Return&, const Return&);
03808
03809 struct Deliver:
03810 public Command
03811 {
03812 Str8 consumerTag;
03813 Uint64 deliveryTag;
03814 exchange::Name exchange;
03815 queue::Name queue;
03816
03817 static const char* NAME;
03818 static const uint8_t CODE=0x8;
03819 static const uint8_t CLASS_CODE=stream::CODE;
03820 static const char* CLASS_NAME;
03821 Deliver();
03822 Deliver(
03823 call_traits<Str8>::param_type consumerTag_,
03824 call_traits<Uint64>::param_type deliveryTag_,
03825 call_traits<exchange::Name>::param_type exchange_,
03826 call_traits<queue::Name>::param_type queue_
03827 );
03828 void accept(Visitor&);
03829 void accept(ConstVisitor&) const;
03830 template <class S> void serialize(S& s) {
03831 s(consumerTag)(deliveryTag)(exchange)(queue);
03832 }
03833
03834 struct Handler
03835 {
03836 void streamDeliver(
03837 call_traits<Str8>::param_type consumerTag_,
03838 call_traits<Uint64>::param_type deliveryTag_,
03839 call_traits<exchange::Name>::param_type exchange_,
03840 call_traits<queue::Name>::param_type queue_
03841 );
03842 };
03843
03844 template <class T> void invoke(T& target)const
03845 {
03846 target.streamDeliver(consumerTag, deliveryTag, exchange, queue );
03847 }
03848 };
03849 inline Packer<Deliver> serializable(Deliver& x) { return Packer<Deliver>(x); }
03850 std::ostream& operator << (std::ostream&, const Deliver&);
03851 bool operator==(const Deliver&, const Deliver&);
03852
03853 }
03854
03855
03856 }}
03857
03858 #endif