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

00001 #ifndef QPID_FRAMING_AMQP_SERVERPROXY_H
00002 #define QPID_FRAMING_AMQP_SERVERPROXY_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_ServerProxy:
00039     public Proxy
00040 {
00041   public:
00042     AMQP_ServerProxy(FrameHandler& out);
00043     
00044     class Connection:
00045         Proxy
00046     {
00047         public:
00048         Connection(FrameHandler& f) : Proxy(f) {}
00049         static Connection& get(AMQP_ServerProxy& proxy) { return proxy.getConnection(); }
00050         virtual void startOk(const FieldTable& clientProperties,
00051                     const string& mechanism,
00052                     const string& response,
00053                     const string& locale);
00054         
00055         virtual void secureOk(const string& response);
00056         
00057         virtual void tuneOk(uint16_t channelMax,
00058                     uint32_t frameMax,
00059                     uint16_t heartbeat);
00060         
00061         virtual void open(const string& virtualHost,
00062                     const string& capabilities,
00063                     bool insist);
00064         
00065         virtual void close(uint16_t replyCode,
00066                     const string& replyText,
00067                     uint16_t classId,
00068                     uint16_t methodId);
00069         
00070         virtual void closeOk();
00071         
00072     };
00073     
00074     Connection& getConnection() { return connectionProxy; }
00075     
00076     class Session:
00077         Proxy
00078     {
00079         public:
00080         Session(FrameHandler& f) : Proxy(f) {}
00081         static Session& get(AMQP_ServerProxy& proxy) { return proxy.getSession(); }
00082         virtual void open(uint32_t detachedLifetime);
00083         
00084         virtual void flow(bool active);
00085         
00086         virtual void flowOk(bool active);
00087         
00088         virtual void close();
00089         
00090         virtual void closed(uint16_t replyCode,
00091                     const string& replyText);
00092         
00093         virtual void resume(const Uuid& sessionId);
00094         
00095         virtual void suspend();
00096         
00097         virtual void ack(uint32_t cumulativeSeenMark,
00098                     const SequenceNumberSet& seenFrameSet);
00099         
00100         virtual void highWaterMark(uint32_t lastSentMark);
00101         
00102         virtual void solicitAck();
00103         
00104     };
00105     
00106     Session& getSession() { return sessionProxy; }
00107     
00108     class Access:
00109         Proxy
00110     {
00111         public:
00112         Access(FrameHandler& f) : Proxy(f) {}
00113         static Access& get(AMQP_ServerProxy& proxy) { return proxy.getAccess(); }
00114         virtual void request(const string& realm,
00115                     bool exclusive,
00116                     bool passive,
00117                     bool active,
00118                     bool write,
00119                     bool read);
00120         
00121     };
00122     
00123     Access& getAccess() { return accessProxy; }
00124     
00125     class Exchange:
00126         Proxy
00127     {
00128         public:
00129         Exchange(FrameHandler& f) : Proxy(f) {}
00130         static Exchange& get(AMQP_ServerProxy& proxy) { return proxy.getExchange(); }
00131         virtual void declare(uint16_t ticket,
00132                     const string& exchange,
00133                     const string& type,
00134                     const string& alternateExchange,
00135                     bool passive,
00136                     bool durable,
00137                     bool autoDelete,
00138                     const FieldTable& arguments);
00139         
00140         virtual void delete_(uint16_t ticket,
00141                     const string& exchange,
00142                     bool ifUnused);
00143         
00144         virtual void query(uint16_t ticket,
00145                     const string& name);
00146         
00147     };
00148     
00149     Exchange& getExchange() { return exchangeProxy; }
00150     
00151     class Queue:
00152         Proxy
00153     {
00154         public:
00155         Queue(FrameHandler& f) : Proxy(f) {}
00156         static Queue& get(AMQP_ServerProxy& proxy) { return proxy.getQueue(); }
00157         virtual void declare(uint16_t ticket,
00158                     const string& queue,
00159                     const string& alternateExchange,
00160                     bool passive,
00161                     bool durable,
00162                     bool exclusive,
00163                     bool autoDelete,
00164                     const FieldTable& arguments);
00165         
00166         virtual void bind(uint16_t ticket,
00167                     const string& queue,
00168                     const string& exchange,
00169                     const string& routingKey,
00170                     const FieldTable& arguments);
00171         
00172         virtual void unbind(uint16_t ticket,
00173                     const string& queue,
00174                     const string& exchange,
00175                     const string& routingKey,
00176                     const FieldTable& arguments);
00177         
00178         virtual void purge(uint16_t ticket,
00179                     const string& queue);
00180         
00181         virtual void delete_(uint16_t ticket,
00182                     const string& queue,
00183                     bool ifUnused,
00184                     bool ifEmpty);
00185         
00186         virtual void query(const string& queue);
00187         
00188     };
00189     
00190     Queue& getQueue() { return queueProxy; }
00191     
00192     class Basic:
00193         Proxy
00194     {
00195         public:
00196         Basic(FrameHandler& f) : Proxy(f) {}
00197         static Basic& get(AMQP_ServerProxy& proxy) { return proxy.getBasic(); }
00198         virtual void qos(uint32_t prefetchSize,
00199                     uint16_t prefetchCount,
00200                     bool global);
00201         
00202         virtual void consume(uint16_t ticket,
00203                     const string& queue,
00204                     const string& consumerTag,
00205                     bool noLocal,
00206                     bool noAck,
00207                     bool exclusive,
00208                     bool nowait,
00209                     const FieldTable& arguments);
00210         
00211         virtual void cancel(const string& consumerTag);
00212         
00213         virtual void publish(uint16_t ticket,
00214                     const string& exchange,
00215                     const string& routingKey,
00216                     bool rejectUnroutable,
00217                     bool immediate);
00218         
00219         virtual void get(uint16_t ticket,
00220                     const string& queue,
00221                     bool noAck);
00222         
00223         virtual void ack(uint64_t deliveryTag,
00224                     bool multiple);
00225         
00226         virtual void reject(uint64_t deliveryTag,
00227                     bool requeue);
00228         
00229         virtual void recover(bool requeue);
00230         
00231     };
00232     
00233     Basic& getBasic() { return basicProxy; }
00234     
00235     class File:
00236         Proxy
00237     {
00238         public:
00239         File(FrameHandler& f) : Proxy(f) {}
00240         static File& get(AMQP_ServerProxy& proxy) { return proxy.getFile(); }
00241         virtual void qos(uint32_t prefetchSize,
00242                     uint16_t prefetchCount,
00243                     bool global);
00244         
00245         virtual void consume(uint16_t ticket,
00246                     const string& queue,
00247                     const string& consumerTag,
00248                     bool noLocal,
00249                     bool noAck,
00250                     bool exclusive,
00251                     bool nowait,
00252                     const FieldTable& filter);
00253         
00254         virtual void cancel(const string& consumerTag);
00255         
00256         virtual void open(const string& identifier,
00257                     uint64_t contentSize);
00258         
00259         virtual void openOk(uint64_t stagedSize);
00260         
00261         virtual void stage();
00262         
00263         virtual void publish(uint16_t ticket,
00264                     const string& exchange,
00265                     const string& routingKey,
00266                     bool mandatory,
00267                     bool immediate,
00268                     const string& identifier);
00269         
00270         virtual void ack(uint64_t deliveryTag,
00271                     bool multiple);
00272         
00273         virtual void reject(uint64_t deliveryTag,
00274                     bool requeue);
00275         
00276     };
00277     
00278     File& getFile() { return fileProxy; }
00279     
00280     class Stream:
00281         Proxy
00282     {
00283         public:
00284         Stream(FrameHandler& f) : Proxy(f) {}
00285         static Stream& get(AMQP_ServerProxy& proxy) { return proxy.getStream(); }
00286         virtual void qos(uint32_t prefetchSize,
00287                     uint16_t prefetchCount,
00288                     uint32_t consumeRate,
00289                     bool global);
00290         
00291         virtual void consume(uint16_t ticket,
00292                     const string& queue,
00293                     const string& consumerTag,
00294                     bool noLocal,
00295                     bool exclusive,
00296                     bool nowait,
00297                     const FieldTable& filter);
00298         
00299         virtual void cancel(const string& consumerTag);
00300         
00301         virtual void publish(uint16_t ticket,
00302                     const string& exchange,
00303                     const string& routingKey,
00304                     bool mandatory,
00305                     bool immediate);
00306         
00307     };
00308     
00309     Stream& getStream() { return streamProxy; }
00310     
00311     class Tx:
00312         Proxy
00313     {
00314         public:
00315         Tx(FrameHandler& f) : Proxy(f) {}
00316         static Tx& get(AMQP_ServerProxy& proxy) { return proxy.getTx(); }
00317         virtual void select();
00318         
00319         virtual void commit();
00320         
00321         virtual void rollback();
00322         
00323     };
00324     
00325     Tx& getTx() { return txProxy; }
00326     
00327     class DtxDemarcation:
00328         Proxy
00329     {
00330         public:
00331         DtxDemarcation(FrameHandler& f) : Proxy(f) {}
00332         static DtxDemarcation& get(AMQP_ServerProxy& proxy) { return proxy.getDtxDemarcation(); }
00333         virtual void select();
00334         
00335         virtual void start(uint16_t ticket,
00336                     const string& xid,
00337                     bool join,
00338                     bool resume);
00339         
00340         virtual void end(uint16_t ticket,
00341                     const string& xid,
00342                     bool fail,
00343                     bool suspend);
00344         
00345     };
00346     
00347     DtxDemarcation& getDtxDemarcation() { return dtxDemarcationProxy; }
00348     
00349     class DtxCoordination:
00350         Proxy
00351     {
00352         public:
00353         DtxCoordination(FrameHandler& f) : Proxy(f) {}
00354         static DtxCoordination& get(AMQP_ServerProxy& proxy) { return proxy.getDtxCoordination(); }
00355         virtual void commit(uint16_t ticket,
00356                     const string& xid,
00357                     bool onePhase);
00358         
00359         virtual void forget(uint16_t ticket,
00360                     const string& xid);
00361         
00362         virtual void getTimeout(const string& xid);
00363         
00364         virtual void prepare(uint16_t ticket,
00365                     const string& xid);
00366         
00367         virtual void recover(uint16_t ticket,
00368                     bool startscan,
00369                     bool endscan);
00370         
00371         virtual void rollback(uint16_t ticket,
00372                     const string& xid);
00373         
00374         virtual void setTimeout(uint16_t ticket,
00375                     const string& xid,
00376                     uint32_t timeout);
00377         
00378     };
00379     
00380     DtxCoordination& getDtxCoordination() { return dtxCoordinationProxy; }
00381     
00382     class Tunnel:
00383         Proxy
00384     {
00385         public:
00386         Tunnel(FrameHandler& f) : Proxy(f) {}
00387         static Tunnel& get(AMQP_ServerProxy& proxy) { return proxy.getTunnel(); }
00388         virtual void request(const FieldTable& metaData);
00389         
00390     };
00391     
00392     Tunnel& getTunnel() { return tunnelProxy; }
00393     
00394     class Message:
00395         Proxy
00396     {
00397         public:
00398         Message(FrameHandler& f) : Proxy(f) {}
00399         static Message& get(AMQP_ServerProxy& proxy) { return proxy.getMessage(); }
00400         virtual void transfer(uint16_t ticket,
00401                     const string& destination,
00402                     uint8_t confirmMode,
00403                     uint8_t acquireMode);
00404         
00405         virtual void reject(const SequenceNumberSet& transfers,
00406                     uint16_t code,
00407                     const string& text);
00408         
00409         virtual void acquire(const SequenceNumberSet& transfers,
00410                     uint8_t mode);
00411         
00412         virtual void release(const SequenceNumberSet& transfers);
00413         
00414         virtual void subscribe(uint16_t ticket,
00415                     const string& queue,
00416                     const string& destination,
00417                     bool noLocal,
00418                     uint8_t confirmMode,
00419                     uint8_t acquireMode,
00420                     bool exclusive,
00421                     const FieldTable& filter);
00422         
00423         virtual void cancel(const string& destination);
00424         
00425         virtual void get(uint16_t ticket,
00426                     const string& queue,
00427                     const string& destination,
00428                     bool noAck);
00429         
00430         virtual void recover(bool requeue);
00431         
00432         virtual void open(const string& reference);
00433         
00434         virtual void close(const string& reference);
00435         
00436         virtual void append(const string& reference,
00437                     const string& bytes);
00438         
00439         virtual void checkpoint(const string& reference,
00440                     const string& identifier);
00441         
00442         virtual void resume(const string& reference,
00443                     const string& identifier);
00444         
00445         virtual void qos(uint32_t prefetchSize,
00446                     uint16_t prefetchCount,
00447                     bool global);
00448         
00449         virtual void flowMode(const string& destination,
00450                     uint8_t mode);
00451         
00452         virtual void flow(const string& destination,
00453                     uint8_t unit,
00454                     uint32_t value);
00455         
00456         virtual void flush(const string& destination);
00457         
00458         virtual void stop(const string& destination);
00459         
00460         virtual void empty();
00461         
00462         virtual void offset(uint64_t value);
00463         
00464     };
00465     
00466     Message& getMessage() { return messageProxy; }
00467     
00468     class Binding:
00469         Proxy
00470     {
00471         public:
00472         Binding(FrameHandler& f) : Proxy(f) {}
00473         static Binding& get(AMQP_ServerProxy& proxy) { return proxy.getBinding(); }
00474         virtual void query(uint16_t ticket,
00475                     const string& exchange,
00476                     const string& queue,
00477                     const string& routingKey,
00478                     const FieldTable& arguments);
00479         
00480     };
00481     
00482     Binding& getBinding() { return bindingProxy; }
00483     
00484     class Execution:
00485         Proxy
00486     {
00487         public:
00488         Execution(FrameHandler& f) : Proxy(f) {}
00489         static Execution& get(AMQP_ServerProxy& proxy) { return proxy.getExecution(); }
00490         virtual void flush();
00491         
00492         virtual void complete(uint32_t cumulativeExecutionMark,
00493                     const SequenceNumberSet& rangedExecutionSet);
00494         
00495         virtual void noop();
00496         
00497         virtual void result(uint32_t commandId,
00498                     const string& data);
00499         
00500         virtual void sync();
00501         
00502     };
00503     
00504     Execution& getExecution() { return executionProxy; }
00505     
00506     class Connection010:
00507         Proxy
00508     {
00509         public:
00510         Connection010(FrameHandler& f) : Proxy(f) {}
00511         static Connection010& get(AMQP_ServerProxy& proxy) { return proxy.getConnection010(); }
00512         virtual void startOk(const FieldTable& clientProperties,
00513                     const string& mechanism,
00514                     const string& response,
00515                     const string& locale);
00516         
00517         virtual void secureOk(const string& response);
00518         
00519         virtual void tuneOk(uint16_t channelMax,
00520                     uint16_t frameMax,
00521                     uint16_t heartbeat);
00522         
00523         virtual void open(const string& virtualHost,
00524                     const Array& capabilities,
00525                     bool insist);
00526         
00527         virtual void heartbeat();
00528         
00529         virtual void close(uint16_t replyCode,
00530                     const string& replyText,
00531                     uint16_t classId,
00532                     uint16_t methodId);
00533         
00534         virtual void closeOk();
00535         
00536     };
00537     
00538     Connection010& getConnection010() { return connection010Proxy; }
00539     
00540     class Session010:
00541         Proxy
00542     {
00543         public:
00544         Session010(FrameHandler& f) : Proxy(f) {}
00545         static Session010& get(AMQP_ServerProxy& proxy) { return proxy.getSession010(); }
00546         virtual void attach(const string& name,
00547                     bool force);
00548         
00549         virtual void attached(const string& name);
00550         
00551         virtual void detach(const string& name);
00552         
00553         virtual void detached(const string& name,
00554                     uint8_t detachCode);
00555         
00556         virtual void requestTimeout(uint32_t timeout);
00557         
00558         virtual void timeout(uint32_t timeout);
00559         
00560         virtual void commandPoint(uint32_t commandId,
00561                     uint64_t commandOffset);
00562         
00563         virtual void expected(const SequenceSet& commands,
00564                     const Array& fragments);
00565         
00566         virtual void confirmed(const SequenceSet& commands,
00567                     const Array& fragments);
00568         
00569         virtual void completed(const SequenceSet& commands,
00570                     bool timelyReply);
00571         
00572         virtual void knownCompleted(const SequenceSet& commands);
00573         
00574         virtual void flush(bool expected,
00575                     bool confirmed,
00576                     bool completed);
00577         
00578         virtual void gap(const SequenceSet& commands);
00579         
00580     };
00581     
00582     Session010& getSession010() { return session010Proxy; }
00583     
00584     class Execution010:
00585         Proxy
00586     {
00587         public:
00588         Execution010(FrameHandler& f) : Proxy(f) {}
00589         static Execution010& get(AMQP_ServerProxy& proxy) { return proxy.getExecution010(); }
00590         virtual void sync();
00591         
00592         virtual void result(uint32_t commandId,
00593                     const string& value);
00594         
00595         virtual void exception(uint16_t errorCode,
00596                     uint32_t commandId,
00597                     uint8_t classCode,
00598                     uint8_t commandCode,
00599                     uint8_t fieldIndex,
00600                     const string& description,
00601                     const FieldTable& errorInfo);
00602         
00603     };
00604     
00605     Execution010& getExecution010() { return execution010Proxy; }
00606     
00607     class Message010:
00608         Proxy
00609     {
00610         public:
00611         Message010(FrameHandler& f) : Proxy(f) {}
00612         static Message010& get(AMQP_ServerProxy& proxy) { return proxy.getMessage010(); }
00613         virtual void transfer(const string& destination,
00614                     uint8_t acceptMode,
00615                     uint8_t acquireMode);
00616         
00617         virtual void accept(const SequenceSet& commands);
00618         
00619         virtual void reject(const SequenceSet& commands,
00620                     uint16_t code,
00621                     const string& text);
00622         
00623         virtual void release(const SequenceSet& commands,
00624                     bool setRedelivered);
00625         
00626         virtual void acquire(const SequenceSet& transfers);
00627         
00628         virtual void subscribe(const string& queue,
00629                     const string& destination,
00630                     uint8_t acceptMode,
00631                     uint8_t acquireMode,
00632                     bool exclusive,
00633                     const string& resumeId,
00634                     uint64_t resumeTtl,
00635                     const FieldTable& arguments);
00636         
00637         virtual void cancel(const string& destination);
00638         
00639         virtual void setFlowMode(const string& destination,
00640                     uint8_t flowMode);
00641         
00642         virtual void flow(const string& destination,
00643                     uint8_t unit,
00644                     uint32_t value);
00645         
00646         virtual void flush(const string& destination);
00647         
00648         virtual void stop(const string& destination);
00649         
00650     };
00651     
00652     Message010& getMessage010() { return message010Proxy; }
00653     
00654     class Tx010:
00655         Proxy
00656     {
00657         public:
00658         Tx010(FrameHandler& f) : Proxy(f) {}
00659         static Tx010& get(AMQP_ServerProxy& proxy) { return proxy.getTx010(); }
00660         virtual void select();
00661         
00662         virtual void commit();
00663         
00664         virtual void rollback();
00665         
00666     };
00667     
00668     Tx010& getTx010() { return tx010Proxy; }
00669     
00670     class Dtx010:
00671         Proxy
00672     {
00673         public:
00674         Dtx010(FrameHandler& f) : Proxy(f) {}
00675         static Dtx010& get(AMQP_ServerProxy& proxy) { return proxy.getDtx010(); }
00676         virtual void select();
00677         
00678         virtual void start(const Xid010& xid,
00679                     bool join,
00680                     bool resume);
00681         
00682         virtual void end(const Xid010& xid,
00683                     bool fail,
00684                     bool suspend);
00685         
00686         virtual void commit(const Xid010& xid,
00687                     bool onePhase);
00688         
00689         virtual void forget(const Xid010& xid);
00690         
00691         virtual void getTimeout(const Xid010& xid);
00692         
00693         virtual void prepare(const Xid010& xid);
00694         
00695         virtual void recover();
00696         
00697         virtual void rollback(const Xid010& xid);
00698         
00699         virtual void setTimeout(const Xid010& xid,
00700                     uint32_t timeout);
00701         
00702     };
00703     
00704     Dtx010& getDtx010() { return dtx010Proxy; }
00705     
00706     class Exchange010:
00707         Proxy
00708     {
00709         public:
00710         Exchange010(FrameHandler& f) : Proxy(f) {}
00711         static Exchange010& get(AMQP_ServerProxy& proxy) { return proxy.getExchange010(); }
00712         virtual void declare(const string& name,
00713                     const string& type,
00714                     const string& alternateExchange,
00715                     bool passive,
00716                     bool durable,
00717                     bool autoDelete,
00718                     const FieldTable& arguments);
00719         
00720         virtual void delete_(const string& name,
00721                     bool ifUnused);
00722         
00723         virtual void query(const string& name);
00724         
00725         virtual void bind(const string& queue,
00726                     const string& exchange,
00727                     const string& bindingKey,
00728                     const FieldTable& arguments);
00729         
00730         virtual void unbind(const string& queue,
00731                     const string& exchange,
00732                     const string& bindingKey);
00733         
00734         virtual void bound(const string& queue,
00735                     const string& exchange,
00736                     const string& bindingKey,
00737                     const FieldTable& arguments);
00738         
00739     };
00740     
00741     Exchange010& getExchange010() { return exchange010Proxy; }
00742     
00743     class Queue010:
00744         Proxy
00745     {
00746         public:
00747         Queue010(FrameHandler& f) : Proxy(f) {}
00748         static Queue010& get(AMQP_ServerProxy& proxy) { return proxy.getQueue010(); }
00749         virtual void declare(const string& name,
00750                     const string& alternateExchange,
00751                     bool passive,
00752                     bool durable,
00753                     bool exclusive,
00754                     bool autoDelete,
00755                     const FieldTable& arguments);
00756         
00757         virtual void delete_(const string& name,
00758                     bool ifUnused,
00759                     bool ifEmpty);
00760         
00761         virtual void purge(const string& name);
00762         
00763         virtual void query(const string& name);
00764         
00765     };
00766     
00767     Queue010& getQueue010() { return queue010Proxy; }
00768     
00769     class Cluster:
00770         Proxy
00771     {
00772         public:
00773         Cluster(FrameHandler& f) : Proxy(f) {}
00774         static Cluster& get(AMQP_ServerProxy& proxy) { return proxy.getCluster(); }
00775     };
00776     
00777     Cluster& getCluster() { return clusterProxy; }
00778     
00779   private:
00780     Connection connectionProxy;
00781     Session sessionProxy;
00782     Access accessProxy;
00783     Exchange exchangeProxy;
00784     Queue queueProxy;
00785     Basic basicProxy;
00786     File fileProxy;
00787     Stream streamProxy;
00788     Tx txProxy;
00789     DtxDemarcation dtxDemarcationProxy;
00790     DtxCoordination dtxCoordinationProxy;
00791     Tunnel tunnelProxy;
00792     Message messageProxy;
00793     Binding bindingProxy;
00794     Execution executionProxy;
00795     Connection010 connection010Proxy;
00796     Session010 session010Proxy;
00797     Execution010 execution010Proxy;
00798     Message010 message010Proxy;
00799     Tx010 tx010Proxy;
00800     Dtx010 dtx010Proxy;
00801     Exchange010 exchange010Proxy;
00802     Queue010 queue010Proxy;
00803     Cluster clusterProxy;
00804 };
00805 
00806 }} // namespace qpid::framing
00807 
00808 #endif  

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