/usr/share/cruisecontrol-bin-2.6.1/projects/qpid-trunk/cpp/src/gen/qpid/framing/AMQP_ClientProxy.h

00001 #ifndef QPID_FRAMING_AMQP_CLIENTPROXY_H
00002 #define QPID_FRAMING_AMQP_CLIENTPROXY_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_ClientProxy:
00039     public Proxy
00040 {
00041   public:
00042     AMQP_ClientProxy(FrameHandler& out);
00043     
00044     class Connection:
00045         Proxy
00046     {
00047         public:
00048         Connection(FrameHandler& f) : Proxy(f) {}
00049         static Connection& get(AMQP_ClientProxy& proxy) { return proxy.getConnection(); }
00050         virtual void start(uint8_t versionMajor,
00051                     uint8_t versionMinor,
00052                     const FieldTable& serverProperties,
00053                     const string& mechanisms,
00054                     const string& locales);
00055         
00056         virtual void secure(const string& challenge);
00057         
00058         virtual void tune(uint16_t channelMax,
00059                     uint32_t frameMax,
00060                     uint16_t heartbeat);
00061         
00062         virtual void openOk(const string& knownHosts);
00063         
00064         virtual void redirect(const string& host,
00065                     const string& knownHosts);
00066         
00067         virtual void close(uint16_t replyCode,
00068                     const string& replyText,
00069                     uint16_t classId,
00070                     uint16_t methodId);
00071         
00072         virtual void closeOk();
00073         
00074     };
00075     
00076     Connection& getConnection() { return connectionProxy; }
00077     
00078     class Session:
00079         Proxy
00080     {
00081         public:
00082         Session(FrameHandler& f) : Proxy(f) {}
00083         static Session& get(AMQP_ClientProxy& proxy) { return proxy.getSession(); }
00084         virtual void attached(const Uuid& sessionId,
00085                     uint32_t detachedLifetime);
00086         
00087         virtual void flow(bool active);
00088         
00089         virtual void flowOk(bool active);
00090         
00091         virtual void close();
00092         
00093         virtual void closed(uint16_t replyCode,
00094                     const string& replyText);
00095         
00096         virtual void detached();
00097         
00098         virtual void ack(uint32_t cumulativeSeenMark,
00099                     const SequenceNumberSet& seenFrameSet);
00100         
00101         virtual void highWaterMark(uint32_t lastSentMark);
00102         
00103         virtual void solicitAck();
00104         
00105     };
00106     
00107     Session& getSession() { return sessionProxy; }
00108     
00109     class Access:
00110         Proxy
00111     {
00112         public:
00113         Access(FrameHandler& f) : Proxy(f) {}
00114         static Access& get(AMQP_ClientProxy& proxy) { return proxy.getAccess(); }
00115         virtual void requestOk(uint16_t ticket);
00116         
00117     };
00118     
00119     Access& getAccess() { return accessProxy; }
00120     
00121     class Exchange:
00122         Proxy
00123     {
00124         public:
00125         Exchange(FrameHandler& f) : Proxy(f) {}
00126         static Exchange& get(AMQP_ClientProxy& proxy) { return proxy.getExchange(); }
00127     };
00128     
00129     Exchange& getExchange() { return exchangeProxy; }
00130     
00131     class Queue:
00132         Proxy
00133     {
00134         public:
00135         Queue(FrameHandler& f) : Proxy(f) {}
00136         static Queue& get(AMQP_ClientProxy& proxy) { return proxy.getQueue(); }
00137     };
00138     
00139     Queue& getQueue() { return queueProxy; }
00140     
00141     class Basic:
00142         Proxy
00143     {
00144         public:
00145         Basic(FrameHandler& f) : Proxy(f) {}
00146         static Basic& get(AMQP_ClientProxy& proxy) { return proxy.getBasic(); }
00147         virtual void consumeOk(const string& consumerTag);
00148         
00149         virtual void deliver(const string& consumerTag,
00150                     uint64_t deliveryTag,
00151                     bool redelivered,
00152                     const string& exchange,
00153                     const string& routingKey);
00154         
00155         virtual void getOk(uint64_t deliveryTag,
00156                     bool redelivered,
00157                     const string& exchange,
00158                     const string& routingKey,
00159                     uint32_t messageCount);
00160         
00161         virtual void getEmpty(const string& clusterId);
00162         
00163     };
00164     
00165     Basic& getBasic() { return basicProxy; }
00166     
00167     class File:
00168         Proxy
00169     {
00170         public:
00171         File(FrameHandler& f) : Proxy(f) {}
00172         static File& get(AMQP_ClientProxy& proxy) { return proxy.getFile(); }
00173         virtual void qosOk();
00174         
00175         virtual void consumeOk(const string& consumerTag);
00176         
00177         virtual void open(const string& identifier,
00178                     uint64_t contentSize);
00179         
00180         virtual void openOk(uint64_t stagedSize);
00181         
00182         virtual void stage();
00183         
00184         virtual void return_(uint16_t replyCode,
00185                     const string& replyText,
00186                     const string& exchange,
00187                     const string& routingKey);
00188         
00189         virtual void deliver(const string& consumerTag,
00190                     uint64_t deliveryTag,
00191                     bool redelivered,
00192                     const string& exchange,
00193                     const string& routingKey,
00194                     const string& identifier);
00195         
00196     };
00197     
00198     File& getFile() { return fileProxy; }
00199     
00200     class Stream:
00201         Proxy
00202     {
00203         public:
00204         Stream(FrameHandler& f) : Proxy(f) {}
00205         static Stream& get(AMQP_ClientProxy& proxy) { return proxy.getStream(); }
00206         virtual void qosOk();
00207         
00208         virtual void consumeOk(const string& consumerTag);
00209         
00210         virtual void return_(uint16_t replyCode,
00211                     const string& replyText,
00212                     const string& exchange,
00213                     const string& routingKey);
00214         
00215         virtual void deliver(const string& consumerTag,
00216                     uint64_t deliveryTag,
00217                     const string& exchange,
00218                     const string& queue);
00219         
00220     };
00221     
00222     Stream& getStream() { return streamProxy; }
00223     
00224     class Tx:
00225         Proxy
00226     {
00227         public:
00228         Tx(FrameHandler& f) : Proxy(f) {}
00229         static Tx& get(AMQP_ClientProxy& proxy) { return proxy.getTx(); }
00230     };
00231     
00232     Tx& getTx() { return txProxy; }
00233     
00234     class DtxDemarcation:
00235         Proxy
00236     {
00237         public:
00238         DtxDemarcation(FrameHandler& f) : Proxy(f) {}
00239         static DtxDemarcation& get(AMQP_ClientProxy& proxy) { return proxy.getDtxDemarcation(); }
00240     };
00241     
00242     DtxDemarcation& getDtxDemarcation() { return dtxDemarcationProxy; }
00243     
00244     class DtxCoordination:
00245         Proxy
00246     {
00247         public:
00248         DtxCoordination(FrameHandler& f) : Proxy(f) {}
00249         static DtxCoordination& get(AMQP_ClientProxy& proxy) { return proxy.getDtxCoordination(); }
00250     };
00251     
00252     DtxCoordination& getDtxCoordination() { return dtxCoordinationProxy; }
00253     
00254     class Tunnel:
00255         Proxy
00256     {
00257         public:
00258         Tunnel(FrameHandler& f) : Proxy(f) {}
00259         static Tunnel& get(AMQP_ClientProxy& proxy) { return proxy.getTunnel(); }
00260     };
00261     
00262     Tunnel& getTunnel() { return tunnelProxy; }
00263     
00264     class Message:
00265         Proxy
00266     {
00267         public:
00268         Message(FrameHandler& f) : Proxy(f) {}
00269         static Message& get(AMQP_ClientProxy& proxy) { return proxy.getMessage(); }
00270         virtual void transfer(uint16_t ticket,
00271                     const string& destination,
00272                     uint8_t confirmMode,
00273                     uint8_t acquireMode);
00274         
00275         virtual void reject(const SequenceNumberSet& transfers,
00276                     uint16_t code,
00277                     const string& text);
00278         
00279         virtual void acquired(const SequenceNumberSet& transfers);
00280         
00281         virtual void release(const SequenceNumberSet& transfers);
00282         
00283         virtual void open(const string& reference);
00284         
00285         virtual void close(const string& reference);
00286         
00287         virtual void append(const string& reference,
00288                     const string& bytes);
00289         
00290         virtual void checkpoint(const string& reference,
00291                     const string& identifier);
00292         
00293         virtual void resume(const string& reference,
00294                     const string& identifier);
00295         
00296         virtual void flowMode(const string& destination,
00297                     uint8_t mode);
00298         
00299         virtual void flow(const string& destination,
00300                     uint8_t unit,
00301                     uint32_t value);
00302         
00303         virtual void stop(const string& destination);
00304         
00305         virtual void empty();
00306         
00307         virtual void offset(uint64_t value);
00308         
00309     };
00310     
00311     Message& getMessage() { return messageProxy; }
00312     
00313     class Binding:
00314         Proxy
00315     {
00316         public:
00317         Binding(FrameHandler& f) : Proxy(f) {}
00318         static Binding& get(AMQP_ClientProxy& proxy) { return proxy.getBinding(); }
00319     };
00320     
00321     Binding& getBinding() { return bindingProxy; }
00322     
00323     class Execution:
00324         Proxy
00325     {
00326         public:
00327         Execution(FrameHandler& f) : Proxy(f) {}
00328         static Execution& get(AMQP_ClientProxy& proxy) { return proxy.getExecution(); }
00329         virtual void flush();
00330         
00331         virtual void complete(uint32_t cumulativeExecutionMark,
00332                     const SequenceNumberSet& rangedExecutionSet);
00333         
00334         virtual void noop();
00335         
00336         virtual void result(uint32_t commandId,
00337                     const string& data);
00338         
00339         virtual void sync();
00340         
00341     };
00342     
00343     Execution& getExecution() { return executionProxy; }
00344     
00345     class Connection010:
00346         Proxy
00347     {
00348         public:
00349         Connection010(FrameHandler& f) : Proxy(f) {}
00350         static Connection010& get(AMQP_ClientProxy& proxy) { return proxy.getConnection010(); }
00351         virtual void start(const FieldTable& serverProperties,
00352                     const Array& mechanisms,
00353                     const Array& locales);
00354         
00355         virtual void secure(const string& challenge);
00356         
00357         virtual void tune(uint16_t channelMax,
00358                     uint16_t frameMax,
00359                     uint16_t heartbeatMin,
00360                     uint16_t heartbeatMax);
00361         
00362         virtual void openOk(const Array& knownHosts);
00363         
00364         virtual void redirect(const string& host,
00365                     const string& knownHosts);
00366         
00367         virtual void close(uint16_t replyCode,
00368                     const string& replyText,
00369                     uint16_t classId,
00370                     uint16_t methodId);
00371         
00372         virtual void closeOk();
00373         
00374     };
00375     
00376     Connection010& getConnection010() { return connection010Proxy; }
00377     
00378     class Session010:
00379         Proxy
00380     {
00381         public:
00382         Session010(FrameHandler& f) : Proxy(f) {}
00383         static Session010& get(AMQP_ClientProxy& proxy) { return proxy.getSession010(); }
00384         virtual void attach(const string& name,
00385                     bool force);
00386         
00387         virtual void attached(const string& name);
00388         
00389         virtual void detach(const string& name);
00390         
00391         virtual void detached(const string& name,
00392                     uint8_t detachCode);
00393         
00394         virtual void requestTimeout(uint32_t timeout);
00395         
00396         virtual void timeout(uint32_t timeout);
00397         
00398         virtual void commandPoint(uint32_t commandId,
00399                     uint64_t commandOffset);
00400         
00401         virtual void expected(const SequenceSet& commands,
00402                     const Array& fragments);
00403         
00404         virtual void confirmed(const SequenceSet& commands,
00405                     const Array& fragments);
00406         
00407         virtual void completed(const SequenceSet& commands,
00408                     bool timelyReply);
00409         
00410         virtual void knownCompleted(const SequenceSet& commands);
00411         
00412         virtual void flush(bool expected,
00413                     bool confirmed,
00414                     bool completed);
00415         
00416         virtual void gap(const SequenceSet& commands);
00417         
00418     };
00419     
00420     Session010& getSession010() { return session010Proxy; }
00421     
00422     class Execution010:
00423         Proxy
00424     {
00425         public:
00426         Execution010(FrameHandler& f) : Proxy(f) {}
00427         static Execution010& get(AMQP_ClientProxy& proxy) { return proxy.getExecution010(); }
00428         virtual void sync();
00429         
00430         virtual void result(uint32_t commandId,
00431                     const string& value);
00432         
00433         virtual void exception(uint16_t errorCode,
00434                     uint32_t commandId,
00435                     uint8_t classCode,
00436                     uint8_t commandCode,
00437                     uint8_t fieldIndex,
00438                     const string& description,
00439                     const FieldTable& errorInfo);
00440         
00441     };
00442     
00443     Execution010& getExecution010() { return execution010Proxy; }
00444     
00445     class Message010:
00446         Proxy
00447     {
00448         public:
00449         Message010(FrameHandler& f) : Proxy(f) {}
00450         static Message010& get(AMQP_ClientProxy& proxy) { return proxy.getMessage010(); }
00451         virtual void transfer(const string& destination,
00452                     uint8_t acceptMode,
00453                     uint8_t acquireMode);
00454         
00455         virtual void accept(const SequenceSet& commands);
00456         
00457         virtual void reject(const SequenceSet& commands,
00458                     uint16_t code,
00459                     const string& text);
00460         
00461     };
00462     
00463     Message010& getMessage010() { return message010Proxy; }
00464     
00465     class Tx010:
00466         Proxy
00467     {
00468         public:
00469         Tx010(FrameHandler& f) : Proxy(f) {}
00470         static Tx010& get(AMQP_ClientProxy& proxy) { return proxy.getTx010(); }
00471     };
00472     
00473     Tx010& getTx010() { return tx010Proxy; }
00474     
00475     class Dtx010:
00476         Proxy
00477     {
00478         public:
00479         Dtx010(FrameHandler& f) : Proxy(f) {}
00480         static Dtx010& get(AMQP_ClientProxy& proxy) { return proxy.getDtx010(); }
00481     };
00482     
00483     Dtx010& getDtx010() { return dtx010Proxy; }
00484     
00485     class Exchange010:
00486         Proxy
00487     {
00488         public:
00489         Exchange010(FrameHandler& f) : Proxy(f) {}
00490         static Exchange010& get(AMQP_ClientProxy& proxy) { return proxy.getExchange010(); }
00491     };
00492     
00493     Exchange010& getExchange010() { return exchange010Proxy; }
00494     
00495     class Queue010:
00496         Proxy
00497     {
00498         public:
00499         Queue010(FrameHandler& f) : Proxy(f) {}
00500         static Queue010& get(AMQP_ClientProxy& proxy) { return proxy.getQueue010(); }
00501     };
00502     
00503     Queue010& getQueue010() { return queue010Proxy; }
00504     
00505     class Cluster:
00506         Proxy
00507     {
00508         public:
00509         Cluster(FrameHandler& f) : Proxy(f) {}
00510         static Cluster& get(AMQP_ClientProxy& proxy) { return proxy.getCluster(); }
00511     };
00512     
00513     Cluster& getCluster() { return clusterProxy; }
00514     
00515   private:
00516     Connection connectionProxy;
00517     Session sessionProxy;
00518     Access accessProxy;
00519     Exchange exchangeProxy;
00520     Queue queueProxy;
00521     Basic basicProxy;
00522     File fileProxy;
00523     Stream streamProxy;
00524     Tx txProxy;
00525     DtxDemarcation dtxDemarcationProxy;
00526     DtxCoordination dtxCoordinationProxy;
00527     Tunnel tunnelProxy;
00528     Message messageProxy;
00529     Binding bindingProxy;
00530     Execution executionProxy;
00531     Connection010 connection010Proxy;
00532     Session010 session010Proxy;
00533     Execution010 execution010Proxy;
00534     Message010 message010Proxy;
00535     Tx010 tx010Proxy;
00536     Dtx010 dtx010Proxy;
00537     Exchange010 exchange010Proxy;
00538     Queue010 queue010Proxy;
00539     Cluster clusterProxy;
00540 };
00541 
00542 }} // namespace qpid::framing
00543 
00544 #endif  

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