/usr/share/cruisecontrol-bin-2.6.1/projects/qpid-trunk/cpp/src/gen/qpid/amqp_0_10/specification.h

00001 #ifndef QPID_AMQP_0_10_SPECIFICATION_H
00002 #define QPID_AMQP_0_10_SPECIFICATION_H
00003 /*
00004  *
00005  * Licensed to the Apache Software Foundation (ASF) under one
00006  * or more contributor license agreements.  See the NOTICE file
00007  * distributed with this work for additional information
00008  * regarding copyright ownership.  The ASF licenses this file
00009  * to you under the Apache License, Version 2.0 (the
00010  * "License"); you may not use this file except in compliance
00011  * with the License.  You may obtain a copy of the License at
00012  *
00013  *   http://www.apache.org/licenses/LICENSE-2.0
00014  *
00015  * Unless required by applicable law or agreed to in writing,
00016  * software distributed under the License is distributed on an
00017  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
00018  * KIND, either express or implied.  See the License for the
00019  * specific language governing permissions and limitations
00020  * under the License.
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 } // namespace connection
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 } // namespace session
00078 
00079 
00080 namespace execution {
00081 
00082 
00083 } // namespace execution
00084 
00085 
00086 namespace message {
00087 
00088 
00089 } // namespace message
00090 
00091 
00092 namespace tx {
00093 
00094 
00095 } // namespace tx
00096 
00097 
00098 namespace dtx {
00099 
00100 
00101 } // namespace dtx
00102 
00103 
00104 namespace exchange {
00105 
00106 
00107 } // namespace exchange
00108 
00109 
00110 namespace queue {
00111 
00112 
00113 } // namespace queue
00114 
00115 
00116 namespace file {
00117 
00118 
00119 } // namespace file
00120 
00121 
00122 namespace stream {
00123 
00124 
00125 } // namespace stream
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 } // namespace connection
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 } // namespace session
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 } // namespace execution
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 } // namespace message
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 } // namespace tx
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 } // namespace dtx
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 } // namespace exchange
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 } // namespace queue
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 } // namespace file
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 } // namespace stream
03854 
03855 
03856 }} // namespace qpid::amqp_0_10
03857 
03858 #endif  

Generated on Thu Apr 10 11:08:15 2008 for Qpid by  doxygen 1.4.7