Apache Qpid C++ API
Apache Qpid - AMQP Messaging for Java JMS, C++, Python, Ruby, and .NET Apache Qpid Documentation

gen/qpid/framing/AMQP_AllProxy.h

Go to the documentation of this file.
00001 #ifndef QPID_FRAMING_AMQP_ALLPROXY_H
00002 #define QPID_FRAMING_AMQP_ALLPROXY_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/framing/Proxy.h"
00031 #include "qpid/framing/Array.h"
00032 #include "qpid/framing/amqp_types.h"
00033 #include "qpid/framing/amqp_structs.h"
00034 
00035 namespace qpid {
00036 namespace framing {
00037 
00038 class AMQP_AllProxy:
00039     public Proxy
00040 {
00041   public:
00042     AMQP_AllProxy(FrameHandler& out);
00043     
00044     class Connection:
00045         public Proxy
00046     {
00047         public:
00048         Connection(FrameHandler& f) : Proxy(f) {}
00049         static Connection& get(AMQP_AllProxy& proxy) { return proxy.getConnection(); }
00050         virtual void start(const FieldTable& serverProperties,
00051                     const Array& mechanisms,
00052                     const Array& locales);
00053         
00054         virtual void startOk(const FieldTable& clientProperties,
00055                     const string& mechanism,
00056                     const string& response,
00057                     const string& locale);
00058         
00059         virtual void secure(const string& challenge);
00060         
00061         virtual void secureOk(const string& response);
00062         
00063         virtual void tune(uint16_t channelMax,
00064                     uint16_t maxFrameSize,
00065                     uint16_t heartbeatMin,
00066                     uint16_t heartbeatMax);
00067         
00068         virtual void tuneOk(uint16_t channelMax,
00069                     uint16_t maxFrameSize,
00070                     uint16_t heartbeat);
00071         
00072         virtual void open(const string& virtualHost,
00073                     const Array& capabilities,
00074                     bool insist);
00075         
00076         virtual void openOk(const Array& knownHosts);
00077         
00078         virtual void redirect(const string& host,
00079                     const Array& knownHosts);
00080         
00081         virtual void heartbeat();
00082         
00083         virtual void close(uint16_t replyCode,
00084                     const string& replyText);
00085         
00086         virtual void closeOk();
00087         
00088     };
00089     
00090     Connection& getConnection() { return connectionProxy; }
00091     
00092     class Session:
00093         public Proxy
00094     {
00095         public:
00096         Session(FrameHandler& f) : Proxy(f) {}
00097         static Session& get(AMQP_AllProxy& proxy) { return proxy.getSession(); }
00098         virtual void attach(const string& name,
00099                     bool force);
00100         
00101         virtual void attached(const string& name);
00102         
00103         virtual void detach(const string& name);
00104         
00105         virtual void detached(const string& name,
00106                     uint8_t code);
00107         
00108         virtual void requestTimeout(uint32_t timeout);
00109         
00110         virtual void timeout(uint32_t timeout);
00111         
00112         virtual void commandPoint(const SequenceNumber& commandId,
00113                     uint64_t commandOffset);
00114         
00115         virtual void expected(const SequenceSet& commands,
00116                     const Array& fragments);
00117         
00118         virtual void confirmed(const SequenceSet& commands,
00119                     const Array& fragments);
00120         
00121         virtual void completed(const SequenceSet& commands,
00122                     bool timelyReply);
00123         
00124         virtual void knownCompleted(const SequenceSet& commands);
00125         
00126         virtual void flush(bool expected,
00127                     bool confirmed,
00128                     bool completed);
00129         
00130         virtual void gap(const SequenceSet& commands);
00131         
00132     };
00133     
00134     Session& getSession() { return sessionProxy; }
00135     
00136     class Execution:
00137         public Proxy
00138     {
00139         public:
00140         Execution(FrameHandler& f) : Proxy(f) {}
00141         static Execution& get(AMQP_AllProxy& proxy) { return proxy.getExecution(); }
00142         virtual void sync();
00143         
00144         virtual void result(const SequenceNumber& commandId,
00145                     const string& value);
00146         
00147         virtual void exception(uint16_t errorCode,
00148                     const SequenceNumber& commandId,
00149                     uint8_t classCode,
00150                     uint8_t commandCode,
00151                     uint8_t fieldIndex,
00152                     const string& description,
00153                     const FieldTable& errorInfo);
00154         
00155     };
00156     
00157     Execution& getExecution() { return executionProxy; }
00158     
00159     class Message:
00160         public Proxy
00161     {
00162         public:
00163         Message(FrameHandler& f) : Proxy(f) {}
00164         static Message& get(AMQP_AllProxy& proxy) { return proxy.getMessage(); }
00165         virtual void transfer(const string& destination,
00166                     uint8_t acceptMode,
00167                     uint8_t acquireMode);
00168         
00169         virtual void accept(const SequenceSet& transfers);
00170         
00171         virtual void reject(const SequenceSet& transfers,
00172                     uint16_t code,
00173                     const string& text);
00174         
00175         virtual void release(const SequenceSet& transfers,
00176                     bool setRedelivered);
00177         
00178         virtual void acquire(const SequenceSet& transfers);
00179         
00180         virtual void resume(const string& destination,
00181                     const string& resumeId);
00182         
00183         virtual void subscribe(const string& queue,
00184                     const string& destination,
00185                     uint8_t acceptMode,
00186                     uint8_t acquireMode,
00187                     bool exclusive,
00188                     const string& resumeId,
00189                     uint64_t resumeTtl,
00190                     const FieldTable& arguments);
00191         
00192         virtual void cancel(const string& destination);
00193         
00194         virtual void setFlowMode(const string& destination,
00195                     uint8_t flowMode);
00196         
00197         virtual void flow(const string& destination,
00198                     uint8_t unit,
00199                     uint32_t value);
00200         
00201         virtual void flush(const string& destination);
00202         
00203         virtual void stop(const string& destination);
00204         
00205     };
00206     
00207     Message& getMessage() { return messageProxy; }
00208     
00209     class Tx:
00210         public Proxy
00211     {
00212         public:
00213         Tx(FrameHandler& f) : Proxy(f) {}
00214         static Tx& get(AMQP_AllProxy& proxy) { return proxy.getTx(); }
00215         virtual void select();
00216         
00217         virtual void commit();
00218         
00219         virtual void rollback();
00220         
00221     };
00222     
00223     Tx& getTx() { return txProxy; }
00224     
00225     class Dtx:
00226         public Proxy
00227     {
00228         public:
00229         Dtx(FrameHandler& f) : Proxy(f) {}
00230         static Dtx& get(AMQP_AllProxy& proxy) { return proxy.getDtx(); }
00231         virtual void select();
00232         
00233         virtual void start(const Xid& xid,
00234                     bool join,
00235                     bool resume);
00236         
00237         virtual void end(const Xid& xid,
00238                     bool fail,
00239                     bool suspend);
00240         
00241         virtual void commit(const Xid& xid,
00242                     bool onePhase);
00243         
00244         virtual void forget(const Xid& xid);
00245         
00246         virtual void getTimeout(const Xid& xid);
00247         
00248         virtual void prepare(const Xid& xid);
00249         
00250         virtual void recover();
00251         
00252         virtual void rollback(const Xid& xid);
00253         
00254         virtual void setTimeout(const Xid& xid,
00255                     uint32_t timeout);
00256         
00257     };
00258     
00259     Dtx& getDtx() { return dtxProxy; }
00260     
00261     class Exchange:
00262         public Proxy
00263     {
00264         public:
00265         Exchange(FrameHandler& f) : Proxy(f) {}
00266         static Exchange& get(AMQP_AllProxy& proxy) { return proxy.getExchange(); }
00267         virtual void declare(const string& exchange,
00268                     const string& type,
00269                     const string& alternateExchange,
00270                     bool passive,
00271                     bool durable,
00272                     bool autoDelete,
00273                     const FieldTable& arguments);
00274         
00275         virtual void delete_(const string& exchange,
00276                     bool ifUnused);
00277         
00278         virtual void query(const string& name);
00279         
00280         virtual void bind(const string& queue,
00281                     const string& exchange,
00282                     const string& bindingKey,
00283                     const FieldTable& arguments);
00284         
00285         virtual void unbind(const string& queue,
00286                     const string& exchange,
00287                     const string& bindingKey);
00288         
00289         virtual void bound(const string& exchange,
00290                     const string& queue,
00291                     const string& bindingKey,
00292                     const FieldTable& arguments);
00293         
00294     };
00295     
00296     Exchange& getExchange() { return exchangeProxy; }
00297     
00298     class Queue:
00299         public Proxy
00300     {
00301         public:
00302         Queue(FrameHandler& f) : Proxy(f) {}
00303         static Queue& get(AMQP_AllProxy& proxy) { return proxy.getQueue(); }
00304         virtual void declare(const string& queue,
00305                     const string& alternateExchange,
00306                     bool passive,
00307                     bool durable,
00308                     bool exclusive,
00309                     bool autoDelete,
00310                     const FieldTable& arguments);
00311         
00312         virtual void delete_(const string& queue,
00313                     bool ifUnused,
00314                     bool ifEmpty);
00315         
00316         virtual void purge(const string& queue);
00317         
00318         virtual void query(const string& queue);
00319         
00320     };
00321     
00322     Queue& getQueue() { return queueProxy; }
00323     
00324     class File:
00325         public Proxy
00326     {
00327         public:
00328         File(FrameHandler& f) : Proxy(f) {}
00329         static File& get(AMQP_AllProxy& proxy) { return proxy.getFile(); }
00330         virtual void qos(uint32_t prefetchSize,
00331                     uint16_t prefetchCount,
00332                     bool global);
00333         
00334         virtual void qosOk();
00335         
00336         virtual void consume(const string& queue,
00337                     const string& consumerTag,
00338                     bool noLocal,
00339                     bool noAck,
00340                     bool exclusive,
00341                     bool nowait,
00342                     const FieldTable& arguments);
00343         
00344         virtual void consumeOk(const string& consumerTag);
00345         
00346         virtual void cancel(const string& consumerTag);
00347         
00348         virtual void open(const string& identifier,
00349                     uint64_t contentSize);
00350         
00351         virtual void openOk(uint64_t stagedSize);
00352         
00353         virtual void stage();
00354         
00355         virtual void publish(const string& exchange,
00356                     const string& routingKey,
00357                     bool mandatory,
00358                     bool immediate,
00359                     const string& identifier);
00360         
00361         virtual void return_(uint16_t replyCode,
00362                     const string& replyText,
00363                     const string& exchange,
00364                     const string& routingKey);
00365         
00366         virtual void deliver(const string& consumerTag,
00367                     uint64_t deliveryTag,
00368                     bool redelivered,
00369                     const string& exchange,
00370                     const string& routingKey,
00371                     const string& identifier);
00372         
00373         virtual void ack(uint64_t deliveryTag,
00374                     bool multiple);
00375         
00376         virtual void reject(uint64_t deliveryTag,
00377                     bool requeue);
00378         
00379     };
00380     
00381     File& getFile() { return fileProxy; }
00382     
00383     class Stream:
00384         public Proxy
00385     {
00386         public:
00387         Stream(FrameHandler& f) : Proxy(f) {}
00388         static Stream& get(AMQP_AllProxy& proxy) { return proxy.getStream(); }
00389         virtual void qos(uint32_t prefetchSize,
00390                     uint16_t prefetchCount,
00391                     uint32_t consumeRate,
00392                     bool global);
00393         
00394         virtual void qosOk();
00395         
00396         virtual void consume(const string& queue,
00397                     const string& consumerTag,
00398                     bool noLocal,
00399                     bool exclusive,
00400                     bool nowait,
00401                     const FieldTable& arguments);
00402         
00403         virtual void consumeOk(const string& consumerTag);
00404         
00405         virtual void cancel(const string& consumerTag);
00406         
00407         virtual void publish(const string& exchange,
00408                     const string& routingKey,
00409                     bool mandatory,
00410                     bool immediate);
00411         
00412         virtual void return_(uint16_t replyCode,
00413                     const string& replyText,
00414                     const string& exchange,
00415                     const string& routingKey);
00416         
00417         virtual void deliver(const string& consumerTag,
00418                     uint64_t deliveryTag,
00419                     const string& exchange,
00420                     const string& queue);
00421         
00422     };
00423     
00424     Stream& getStream() { return streamProxy; }
00425     
00426     class Cluster:
00427         public Proxy
00428     {
00429         public:
00430         Cluster(FrameHandler& f) : Proxy(f) {}
00431         static Cluster& get(AMQP_AllProxy& proxy) { return proxy.getCluster(); }
00432         virtual void updateRequest(const string& url);
00433         
00434         virtual void updateOffer(uint64_t updatee,
00435                     const Uuid& clusterId,
00436                     uint32_t version);
00437         
00438         virtual void retractOffer(uint64_t updatee);
00439         
00440         virtual void ready(const string& url);
00441         
00442         virtual void configChange(const string& current);
00443         
00444         virtual void messageExpired(uint64_t id);
00445         
00446         virtual void errorCheck(uint8_t type,
00447                     const SequenceNumber& frameSeq);
00448         
00449         virtual void shutdown();
00450         
00451     };
00452     
00453     Cluster& getCluster() { return clusterProxy; }
00454     
00455     class ClusterConnection:
00456         public Proxy
00457     {
00458         public:
00459         ClusterConnection(FrameHandler& f) : Proxy(f) {}
00460         static ClusterConnection& get(AMQP_AllProxy& proxy) { return proxy.getClusterConnection(); }
00461         virtual void announce();
00462         
00463         virtual void deliverClose();
00464         
00465         virtual void deliverDoOutput(uint32_t limit);
00466         
00467         virtual void abort();
00468         
00469         virtual void consumerState(const string& name,
00470                     bool blocked,
00471                     bool notifyEnabled);
00472         
00473         virtual void deliveryRecord(const string& queue,
00474                     const SequenceNumber& position,
00475                     const string& tag,
00476                     const SequenceNumber& id,
00477                     bool acquired,
00478                     bool accepted,
00479                     bool cancelled,
00480                     bool completed,
00481                     bool ended,
00482                     bool windowing,
00483                     bool enqueued,
00484                     uint32_t credit);
00485         
00486         virtual void txStart();
00487         
00488         virtual void txAccept(const SequenceSet& commands);
00489         
00490         virtual void txDequeue(const string& queue);
00491         
00492         virtual void txEnqueue(const string& queue);
00493         
00494         virtual void txPublish(const Array& queues,
00495                     bool delivered);
00496         
00497         virtual void txEnd();
00498         
00499         virtual void accumulatedAck(const SequenceSet& commands);
00500         
00501         virtual void sessionState(const SequenceNumber& replayStart,
00502                     const SequenceNumber& commandPoint,
00503                     const SequenceSet& sentIncomplete,
00504                     const SequenceNumber& expected,
00505                     const SequenceNumber& received,
00506                     const SequenceSet& unknownCompleted,
00507                     const SequenceSet& receivedIncomplete);
00508         
00509         virtual void shadowReady(uint64_t memberId,
00510                     uint64_t connectionId,
00511                     const string& userName,
00512                     const string& fragment,
00513                     uint32_t sendMax);
00514         
00515         virtual void membership(const FieldTable& joiners,
00516                     const FieldTable& members,
00517                     const SequenceNumber& frameSeq);
00518         
00519         virtual void retractOffer();
00520         
00521         virtual void queuePosition(const string& queue,
00522                     const SequenceNumber& position);
00523         
00524         virtual void exchange(const string& encoded);
00525         
00526         virtual void queue(const string& encoded);
00527         
00528         virtual void expiryId(uint64_t expiryId);
00529         
00530         virtual void addQueueListener(const string& queue,
00531                     uint32_t consumer);
00532         
00533     };
00534     
00535     ClusterConnection& getClusterConnection() { return clusterConnectionProxy; }
00536     
00537   private:
00538     Connection connectionProxy;
00539     Session sessionProxy;
00540     Execution executionProxy;
00541     Message messageProxy;
00542     Tx txProxy;
00543     Dtx dtxProxy;
00544     Exchange exchangeProxy;
00545     Queue queueProxy;
00546     File fileProxy;
00547     Stream streamProxy;
00548     Cluster clusterProxy;
00549     ClusterConnection clusterConnectionProxy;
00550 };
00551 
00552 }} // namespace qpid::framing
00553 
00554 #endif  

Qpid C++ API Reference
Generated on Tue Dec 8 15:39:46 2009 for Qpid C++ Client API by doxygen 1.4.7