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

00001 #ifndef QPID_AMQP_0_10_PROXYTEMPLATE_H
00002 #define QPID_AMQP_0_10_PROXYTEMPLATE_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.h"
00031 
00032 namespace qpid {
00033 namespace amqp_0_10 {
00034 
00035 template <class F, class R=typename F::result_type>
00036 class ProxyTemplate
00037 {
00038   public:
00039     ProxyTemplate(F f=F()) : functor(f) {}
00040     
00041     
00042     R connectionStart(
00043         call_traits<Map>::param_type serverProperties_,
00044         call_traits<Str16Array>::param_type mechanisms_,
00045         call_traits<Str16Array>::param_type locales_
00046     )
00047     {
00048         connection::Start start(serverProperties_, mechanisms_, locales_);
00049         return functor(start);
00050     }
00051     
00052     
00053     R connectionStartOk(
00054         call_traits<Map>::param_type clientProperties_,
00055         call_traits<Str8>::param_type mechanism_,
00056         call_traits<Vbin32>::param_type response_,
00057         call_traits<Str8>::param_type locale_
00058     )
00059     {
00060         connection::StartOk startOk(clientProperties_, mechanism_, response_, locale_);
00061         return functor(startOk);
00062     }
00063     
00064     
00065     R connectionSecure(call_traits<Vbin32>::param_type challenge_)
00066     {
00067         connection::Secure secure(challenge_);
00068         return functor(secure);
00069     }
00070     
00071     
00072     R connectionSecureOk(call_traits<Vbin32>::param_type response_)
00073     {
00074         connection::SecureOk secureOk(response_);
00075         return functor(secureOk);
00076     }
00077     
00078     
00079     R connectionTune(
00080         call_traits<Uint16>::param_type channelMax_,
00081         call_traits<Uint16>::param_type maxFrameSize_,
00082         call_traits<Uint16>::param_type heartbeatMin_,
00083         call_traits<Uint16>::param_type heartbeatMax_
00084     )
00085     {
00086         connection::Tune tune(channelMax_, maxFrameSize_, heartbeatMin_, heartbeatMax_);
00087         return functor(tune);
00088     }
00089     
00090     
00091     R connectionTuneOk(
00092         call_traits<Uint16>::param_type channelMax_,
00093         call_traits<Uint16>::param_type maxFrameSize_,
00094         call_traits<Uint16>::param_type heartbeat_
00095     )
00096     {
00097         connection::TuneOk tuneOk(channelMax_, maxFrameSize_, heartbeat_);
00098         return functor(tuneOk);
00099     }
00100     
00101     
00102     R connectionOpen(
00103         call_traits<Str8>::param_type virtualHost_,
00104         call_traits<Str16Array>::param_type capabilities_,
00105         call_traits<Bit>::param_type insist_
00106     )
00107     {
00108         connection::Open open(virtualHost_, capabilities_, insist_);
00109         return functor(open);
00110     }
00111     
00112     
00113     R connectionOpenOk(call_traits<connection::AmqpHostArray>::param_type knownHosts_)
00114     {
00115         connection::OpenOk openOk(knownHosts_);
00116         return functor(openOk);
00117     }
00118     
00119     
00120     R connectionRedirect(
00121         call_traits<connection::AmqpHostUrl>::param_type host_,
00122         call_traits<connection::AmqpHostArray>::param_type knownHosts_
00123     )
00124     {
00125         connection::Redirect redirect(host_, knownHosts_);
00126         return functor(redirect);
00127     }
00128     
00129     
00130     R connectionHeartbeat()
00131     {
00132         connection::Heartbeat heartbeat;
00133         return functor(heartbeat);
00134     }
00135     
00136     
00137     R connectionClose(
00138         call_traits<connection::CloseCode>::param_type replyCode_,
00139         call_traits<Str8>::param_type replyText_
00140     )
00141     {
00142         connection::Close close(replyCode_, replyText_);
00143         return functor(close);
00144     }
00145     
00146     
00147     R connectionCloseOk()
00148     {
00149         connection::CloseOk closeOk;
00150         return functor(closeOk);
00151     }
00152     
00153     
00154     R sessionAttach(
00155         call_traits<session::Name>::param_type name_,
00156         call_traits<Bit>::param_type force_
00157     )
00158     {
00159         session::Attach attach(name_, force_);
00160         return functor(attach);
00161     }
00162     
00163     
00164     R sessionAttached(call_traits<session::Name>::param_type name_)
00165     {
00166         session::Attached attached(name_);
00167         return functor(attached);
00168     }
00169     
00170     
00171     R sessionDetach(call_traits<session::Name>::param_type name_)
00172     {
00173         session::Detach detach(name_);
00174         return functor(detach);
00175     }
00176     
00177     
00178     R sessionDetached(
00179         call_traits<session::Name>::param_type name_,
00180         call_traits<session::DetachCode>::param_type code_
00181     )
00182     {
00183         session::Detached detached(name_, code_);
00184         return functor(detached);
00185     }
00186     
00187     
00188     R sessionRequestTimeout(call_traits<Uint32>::param_type timeout_)
00189     {
00190         session::RequestTimeout requestTimeout(timeout_);
00191         return functor(requestTimeout);
00192     }
00193     
00194     
00195     R sessionTimeout(call_traits<Uint32>::param_type timeout_)
00196     {
00197         session::Timeout timeout(timeout_);
00198         return functor(timeout);
00199     }
00200     
00201     
00202     R sessionCommandPoint(
00203         call_traits<SequenceNo>::param_type commandId_,
00204         call_traits<Uint64>::param_type commandOffset_
00205     )
00206     {
00207         session::CommandPoint commandPoint(commandId_, commandOffset_);
00208         return functor(commandPoint);
00209     }
00210     
00211     
00212     R sessionExpected(
00213         call_traits<session::Commands>::param_type commands_,
00214         call_traits<session::CommandFragments>::param_type fragments_
00215     )
00216     {
00217         session::Expected expected(commands_, fragments_);
00218         return functor(expected);
00219     }
00220     
00221     
00222     R sessionConfirmed(
00223         call_traits<session::Commands>::param_type commands_,
00224         call_traits<session::CommandFragments>::param_type fragments_
00225     )
00226     {
00227         session::Confirmed confirmed(commands_, fragments_);
00228         return functor(confirmed);
00229     }
00230     
00231     
00232     R sessionCompleted(
00233         call_traits<session::Commands>::param_type commands_,
00234         call_traits<Bit>::param_type timelyReply_
00235     )
00236     {
00237         session::Completed completed(commands_, timelyReply_);
00238         return functor(completed);
00239     }
00240     
00241     
00242     R sessionKnownCompleted(call_traits<session::Commands>::param_type commands_)
00243     {
00244         session::KnownCompleted knownCompleted(commands_);
00245         return functor(knownCompleted);
00246     }
00247     
00248     
00249     R sessionFlush(
00250         call_traits<Bit>::param_type expected_,
00251         call_traits<Bit>::param_type confirmed_,
00252         call_traits<Bit>::param_type completed_
00253     )
00254     {
00255         session::Flush flush(expected_, confirmed_, completed_);
00256         return functor(flush);
00257     }
00258     
00259     
00260     R sessionGap(call_traits<session::Commands>::param_type commands_)
00261     {
00262         session::Gap gap(commands_);
00263         return functor(gap);
00264     }
00265     
00266     
00267     R executionSync()
00268     {
00269         execution::Sync sync;
00270         return functor(sync);
00271     }
00272     
00273     
00274     R executionResult(
00275         call_traits<SequenceNo>::param_type commandId_,
00276         call_traits<Struct32>::param_type value_
00277     )
00278     {
00279         execution::Result result(commandId_, value_);
00280         return functor(result);
00281     }
00282     
00283     
00284     R executionException(
00285         call_traits<execution::ErrorCode>::param_type errorCode_,
00286         call_traits<SequenceNo>::param_type commandId_,
00287         call_traits<Uint8>::param_type classCode_,
00288         call_traits<Uint8>::param_type commandCode_,
00289         call_traits<Uint8>::param_type fieldIndex_,
00290         call_traits<Str16>::param_type description_,
00291         call_traits<Map>::param_type errorInfo_
00292     )
00293     {
00294         execution::Exception exception(errorCode_, commandId_, classCode_, commandCode_, fieldIndex_, description_, errorInfo_);
00295         return functor(exception);
00296     }
00297     
00298     
00299     R messageTransfer(
00300         call_traits<message::Destination>::param_type destination_,
00301         call_traits<message::AcceptMode>::param_type acceptMode_,
00302         call_traits<message::AcquireMode>::param_type acquireMode_
00303     )
00304     {
00305         message::Transfer transfer(destination_, acceptMode_, acquireMode_);
00306         return functor(transfer);
00307     }
00308     
00309     
00310     R messageAccept(call_traits<session::Commands>::param_type transfers_)
00311     {
00312         message::Accept accept(transfers_);
00313         return functor(accept);
00314     }
00315     
00316     
00317     R messageReject(
00318         call_traits<session::Commands>::param_type transfers_,
00319         call_traits<message::RejectCode>::param_type code_,
00320         call_traits<Str8>::param_type text_
00321     )
00322     {
00323         message::Reject reject(transfers_, code_, text_);
00324         return functor(reject);
00325     }
00326     
00327     
00328     R messageRelease(
00329         call_traits<session::Commands>::param_type transfers_,
00330         call_traits<Bit>::param_type setRedelivered_
00331     )
00332     {
00333         message::Release release(transfers_, setRedelivered_);
00334         return functor(release);
00335     }
00336     
00337     
00338     R messageAcquire(call_traits<session::Commands>::param_type transfers_)
00339     {
00340         message::Acquire acquire(transfers_);
00341         return functor(acquire);
00342     }
00343     
00344     
00345     R messageResume(
00346         call_traits<message::Destination>::param_type destination_,
00347         call_traits<message::ResumeId>::param_type resumeId_
00348     )
00349     {
00350         message::Resume resume(destination_, resumeId_);
00351         return functor(resume);
00352     }
00353     
00354     
00355     R messageSubscribe(
00356         call_traits<queue::Name>::param_type queue_,
00357         call_traits<message::Destination>::param_type destination_,
00358         call_traits<message::AcceptMode>::param_type acceptMode_,
00359         call_traits<message::AcquireMode>::param_type acquireMode_,
00360         call_traits<Bit>::param_type exclusive_,
00361         call_traits<message::ResumeId>::param_type resumeId_,
00362         call_traits<Uint64>::param_type resumeTtl_,
00363         call_traits<Map>::param_type arguments_
00364     )
00365     {
00366         message::Subscribe subscribe(queue_, destination_, acceptMode_, acquireMode_, exclusive_, resumeId_, resumeTtl_, arguments_);
00367         return functor(subscribe);
00368     }
00369     
00370     
00371     R messageCancel(call_traits<message::Destination>::param_type destination_)
00372     {
00373         message::Cancel cancel(destination_);
00374         return functor(cancel);
00375     }
00376     
00377     
00378     R messageSetFlowMode(
00379         call_traits<message::Destination>::param_type destination_,
00380         call_traits<message::FlowMode>::param_type flowMode_
00381     )
00382     {
00383         message::SetFlowMode setFlowMode(destination_, flowMode_);
00384         return functor(setFlowMode);
00385     }
00386     
00387     
00388     R messageFlow(
00389         call_traits<message::Destination>::param_type destination_,
00390         call_traits<message::CreditUnit>::param_type unit_,
00391         call_traits<Uint32>::param_type value_
00392     )
00393     {
00394         message::Flow flow(destination_, unit_, value_);
00395         return functor(flow);
00396     }
00397     
00398     
00399     R messageFlush(call_traits<message::Destination>::param_type destination_)
00400     {
00401         message::Flush flush(destination_);
00402         return functor(flush);
00403     }
00404     
00405     
00406     R messageStop(call_traits<message::Destination>::param_type destination_)
00407     {
00408         message::Stop stop(destination_);
00409         return functor(stop);
00410     }
00411     
00412     
00413     R txSelect()
00414     {
00415         tx::Select select;
00416         return functor(select);
00417     }
00418     
00419     
00420     R txCommit()
00421     {
00422         tx::Commit commit;
00423         return functor(commit);
00424     }
00425     
00426     
00427     R txRollback()
00428     {
00429         tx::Rollback rollback;
00430         return functor(rollback);
00431     }
00432     
00433     
00434     R dtxSelect()
00435     {
00436         dtx::Select select;
00437         return functor(select);
00438     }
00439     
00440     
00441     R dtxStart(
00442         call_traits<dtx::Xid>::param_type xid_,
00443         call_traits<Bit>::param_type join_,
00444         call_traits<Bit>::param_type resume_
00445     )
00446     {
00447         dtx::Start start(xid_, join_, resume_);
00448         return functor(start);
00449     }
00450     
00451     
00452     R dtxEnd(
00453         call_traits<dtx::Xid>::param_type xid_,
00454         call_traits<Bit>::param_type fail_,
00455         call_traits<Bit>::param_type suspend_
00456     )
00457     {
00458         dtx::End end(xid_, fail_, suspend_);
00459         return functor(end);
00460     }
00461     
00462     
00463     R dtxCommit(
00464         call_traits<dtx::Xid>::param_type xid_,
00465         call_traits<Bit>::param_type onePhase_
00466     )
00467     {
00468         dtx::Commit commit(xid_, onePhase_);
00469         return functor(commit);
00470     }
00471     
00472     
00473     R dtxForget(call_traits<dtx::Xid>::param_type xid_)
00474     {
00475         dtx::Forget forget(xid_);
00476         return functor(forget);
00477     }
00478     
00479     
00480     R dtxGetTimeout(call_traits<dtx::Xid>::param_type xid_)
00481     {
00482         dtx::GetTimeout getTimeout(xid_);
00483         return functor(getTimeout);
00484     }
00485     
00486     
00487     R dtxPrepare(call_traits<dtx::Xid>::param_type xid_)
00488     {
00489         dtx::Prepare prepare(xid_);
00490         return functor(prepare);
00491     }
00492     
00493     
00494     R dtxRecover()
00495     {
00496         dtx::Recover recover;
00497         return functor(recover);
00498     }
00499     
00500     
00501     R dtxRollback(call_traits<dtx::Xid>::param_type xid_)
00502     {
00503         dtx::Rollback rollback(xid_);
00504         return functor(rollback);
00505     }
00506     
00507     
00508     R dtxSetTimeout(
00509         call_traits<dtx::Xid>::param_type xid_,
00510         call_traits<Uint32>::param_type timeout_
00511     )
00512     {
00513         dtx::SetTimeout setTimeout(xid_, timeout_);
00514         return functor(setTimeout);
00515     }
00516     
00517     
00518     R exchangeDeclare(
00519         call_traits<exchange::Name>::param_type exchange_,
00520         call_traits<Str8>::param_type type_,
00521         call_traits<exchange::Name>::param_type alternateExchange_,
00522         call_traits<Bit>::param_type passive_,
00523         call_traits<Bit>::param_type durable_,
00524         call_traits<Bit>::param_type autoDelete_,
00525         call_traits<Map>::param_type arguments_
00526     )
00527     {
00528         exchange::Declare declare(exchange_, type_, alternateExchange_, passive_, durable_, autoDelete_, arguments_);
00529         return functor(declare);
00530     }
00531     
00532     
00533     R exchangeDelete(
00534         call_traits<exchange::Name>::param_type exchange_,
00535         call_traits<Bit>::param_type ifUnused_
00536     )
00537     {
00538         exchange::Delete delete_(exchange_, ifUnused_);
00539         return functor(delete_);
00540     }
00541     
00542     
00543     R exchangeQuery(call_traits<Str8>::param_type name_)
00544     {
00545         exchange::Query query(name_);
00546         return functor(query);
00547     }
00548     
00549     
00550     R exchangeBind(
00551         call_traits<queue::Name>::param_type queue_,
00552         call_traits<exchange::Name>::param_type exchange_,
00553         call_traits<Str8>::param_type bindingKey_,
00554         call_traits<Map>::param_type arguments_
00555     )
00556     {
00557         exchange::Bind bind(queue_, exchange_, bindingKey_, arguments_);
00558         return functor(bind);
00559     }
00560     
00561     
00562     R exchangeUnbind(
00563         call_traits<queue::Name>::param_type queue_,
00564         call_traits<exchange::Name>::param_type exchange_,
00565         call_traits<Str8>::param_type bindingKey_
00566     )
00567     {
00568         exchange::Unbind unbind(queue_, exchange_, bindingKey_);
00569         return functor(unbind);
00570     }
00571     
00572     
00573     R exchangeBound(
00574         call_traits<Str8>::param_type exchange_,
00575         call_traits<Str8>::param_type queue_,
00576         call_traits<Str8>::param_type bindingKey_,
00577         call_traits<Map>::param_type arguments_
00578     )
00579     {
00580         exchange::Bound bound(exchange_, queue_, bindingKey_, arguments_);
00581         return functor(bound);
00582     }
00583     
00584     
00585     R queueDeclare(
00586         call_traits<queue::Name>::param_type queue_,
00587         call_traits<exchange::Name>::param_type alternateExchange_,
00588         call_traits<Bit>::param_type passive_,
00589         call_traits<Bit>::param_type durable_,
00590         call_traits<Bit>::param_type exclusive_,
00591         call_traits<Bit>::param_type autoDelete_,
00592         call_traits<Map>::param_type arguments_
00593     )
00594     {
00595         queue::Declare declare(queue_, alternateExchange_, passive_, durable_, exclusive_, autoDelete_, arguments_);
00596         return functor(declare);
00597     }
00598     
00599     
00600     R queueDelete(
00601         call_traits<queue::Name>::param_type queue_,
00602         call_traits<Bit>::param_type ifUnused_,
00603         call_traits<Bit>::param_type ifEmpty_
00604     )
00605     {
00606         queue::Delete delete_(queue_, ifUnused_, ifEmpty_);
00607         return functor(delete_);
00608     }
00609     
00610     
00611     R queuePurge(call_traits<queue::Name>::param_type queue_)
00612     {
00613         queue::Purge purge(queue_);
00614         return functor(purge);
00615     }
00616     
00617     
00618     R queueQuery(call_traits<queue::Name>::param_type queue_)
00619     {
00620         queue::Query query(queue_);
00621         return functor(query);
00622     }
00623     
00624     
00625     R fileQos(
00626         call_traits<Uint32>::param_type prefetchSize_,
00627         call_traits<Uint16>::param_type prefetchCount_,
00628         call_traits<Bit>::param_type global_
00629     )
00630     {
00631         file::Qos qos(prefetchSize_, prefetchCount_, global_);
00632         return functor(qos);
00633     }
00634     
00635     
00636     R fileQosOk()
00637     {
00638         file::QosOk qosOk;
00639         return functor(qosOk);
00640     }
00641     
00642     
00643     R fileConsume(
00644         call_traits<queue::Name>::param_type queue_,
00645         call_traits<Str8>::param_type consumerTag_,
00646         call_traits<Bit>::param_type noLocal_,
00647         call_traits<Bit>::param_type noAck_,
00648         call_traits<Bit>::param_type exclusive_,
00649         call_traits<Bit>::param_type nowait_,
00650         call_traits<Map>::param_type arguments_
00651     )
00652     {
00653         file::Consume consume(queue_, consumerTag_, noLocal_, noAck_, exclusive_, nowait_, arguments_);
00654         return functor(consume);
00655     }
00656     
00657     
00658     R fileConsumeOk(call_traits<Str8>::param_type consumerTag_)
00659     {
00660         file::ConsumeOk consumeOk(consumerTag_);
00661         return functor(consumeOk);
00662     }
00663     
00664     
00665     R fileCancel(call_traits<Str8>::param_type consumerTag_)
00666     {
00667         file::Cancel cancel(consumerTag_);
00668         return functor(cancel);
00669     }
00670     
00671     
00672     R fileOpen(
00673         call_traits<Str8>::param_type identifier_,
00674         call_traits<Uint64>::param_type contentSize_
00675     )
00676     {
00677         file::Open open(identifier_, contentSize_);
00678         return functor(open);
00679     }
00680     
00681     
00682     R fileOpenOk(call_traits<Uint64>::param_type stagedSize_)
00683     {
00684         file::OpenOk openOk(stagedSize_);
00685         return functor(openOk);
00686     }
00687     
00688     
00689     R fileStage()
00690     {
00691         file::Stage stage;
00692         return functor(stage);
00693     }
00694     
00695     
00696     R filePublish(
00697         call_traits<exchange::Name>::param_type exchange_,
00698         call_traits<Str8>::param_type routingKey_,
00699         call_traits<Bit>::param_type mandatory_,
00700         call_traits<Bit>::param_type immediate_,
00701         call_traits<Str8>::param_type identifier_
00702     )
00703     {
00704         file::Publish publish(exchange_, routingKey_, mandatory_, immediate_, identifier_);
00705         return functor(publish);
00706     }
00707     
00708     
00709     R fileReturn(
00710         call_traits<file::ReturnCode>::param_type replyCode_,
00711         call_traits<Str8>::param_type replyText_,
00712         call_traits<exchange::Name>::param_type exchange_,
00713         call_traits<Str8>::param_type routingKey_
00714     )
00715     {
00716         file::Return return_(replyCode_, replyText_, exchange_, routingKey_);
00717         return functor(return_);
00718     }
00719     
00720     
00721     R fileDeliver(
00722         call_traits<Str8>::param_type consumerTag_,
00723         call_traits<Uint64>::param_type deliveryTag_,
00724         call_traits<Bit>::param_type redelivered_,
00725         call_traits<exchange::Name>::param_type exchange_,
00726         call_traits<Str8>::param_type routingKey_,
00727         call_traits<Str8>::param_type identifier_
00728     )
00729     {
00730         file::Deliver deliver(consumerTag_, deliveryTag_, redelivered_, exchange_, routingKey_, identifier_);
00731         return functor(deliver);
00732     }
00733     
00734     
00735     R fileAck(
00736         call_traits<Uint64>::param_type deliveryTag_,
00737         call_traits<Bit>::param_type multiple_
00738     )
00739     {
00740         file::Ack ack(deliveryTag_, multiple_);
00741         return functor(ack);
00742     }
00743     
00744     
00745     R fileReject(
00746         call_traits<Uint64>::param_type deliveryTag_,
00747         call_traits<Bit>::param_type requeue_
00748     )
00749     {
00750         file::Reject reject(deliveryTag_, requeue_);
00751         return functor(reject);
00752     }
00753     
00754     
00755     R streamQos(
00756         call_traits<Uint32>::param_type prefetchSize_,
00757         call_traits<Uint16>::param_type prefetchCount_,
00758         call_traits<Uint32>::param_type consumeRate_,
00759         call_traits<Bit>::param_type global_
00760     )
00761     {
00762         stream::Qos qos(prefetchSize_, prefetchCount_, consumeRate_, global_);
00763         return functor(qos);
00764     }
00765     
00766     
00767     R streamQosOk()
00768     {
00769         stream::QosOk qosOk;
00770         return functor(qosOk);
00771     }
00772     
00773     
00774     R streamConsume(
00775         call_traits<queue::Name>::param_type queue_,
00776         call_traits<Str8>::param_type consumerTag_,
00777         call_traits<Bit>::param_type noLocal_,
00778         call_traits<Bit>::param_type exclusive_,
00779         call_traits<Bit>::param_type nowait_,
00780         call_traits<Map>::param_type arguments_
00781     )
00782     {
00783         stream::Consume consume(queue_, consumerTag_, noLocal_, exclusive_, nowait_, arguments_);
00784         return functor(consume);
00785     }
00786     
00787     
00788     R streamConsumeOk(call_traits<Str8>::param_type consumerTag_)
00789     {
00790         stream::ConsumeOk consumeOk(consumerTag_);
00791         return functor(consumeOk);
00792     }
00793     
00794     
00795     R streamCancel(call_traits<Str8>::param_type consumerTag_)
00796     {
00797         stream::Cancel cancel(consumerTag_);
00798         return functor(cancel);
00799     }
00800     
00801     
00802     R streamPublish(
00803         call_traits<exchange::Name>::param_type exchange_,
00804         call_traits<Str8>::param_type routingKey_,
00805         call_traits<Bit>::param_type mandatory_,
00806         call_traits<Bit>::param_type immediate_
00807     )
00808     {
00809         stream::Publish publish(exchange_, routingKey_, mandatory_, immediate_);
00810         return functor(publish);
00811     }
00812     
00813     
00814     R streamReturn(
00815         call_traits<stream::ReturnCode>::param_type replyCode_,
00816         call_traits<Str8>::param_type replyText_,
00817         call_traits<exchange::Name>::param_type exchange_,
00818         call_traits<Str8>::param_type routingKey_
00819     )
00820     {
00821         stream::Return return_(replyCode_, replyText_, exchange_, routingKey_);
00822         return functor(return_);
00823     }
00824     
00825     
00826     R streamDeliver(
00827         call_traits<Str8>::param_type consumerTag_,
00828         call_traits<Uint64>::param_type deliveryTag_,
00829         call_traits<exchange::Name>::param_type exchange_,
00830         call_traits<queue::Name>::param_type queue_
00831     )
00832     {
00833         stream::Deliver deliver(consumerTag_, deliveryTag_, exchange_, queue_);
00834         return functor(deliver);
00835     }
00836   private:
00837     F functor;
00838 };
00839 
00840 }} // namespace qpid::amqp_0_10
00841 
00842 #endif  

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