ceph/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/ZipkinCollector.h

   1 /**
   2  * Autogenerated by Thrift Compiler (0.11.0)
   3  *
   4  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   5  *  @generated
   6  */
   7 #ifndef ZipkinCollector_H
   8 #define ZipkinCollector_H
   9
  10 #include <thrift/TDispatchProcessor.h>
  11 #include <thrift/async/TConcurrentClientSyncInfo.h>
  12 #include "zipkincore_types.h"
  13
  14 namespace twitter { namespace zipkin { namespace thrift {
  15
  16 #ifdef _MSC_VER
  17   #pragma warning( push )
  18   #pragma warning (disable : 4250 ) //inheriting methods via dominance
  19 #endif
  20
  21 class ZipkinCollectorIf {
  22  public:
  23   virtual ~ZipkinCollectorIf() {}
  24   virtual void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) = 0;
  25 };
  26
  27 class ZipkinCollectorIfFactory {
  28  public:
  29   typedef ZipkinCollectorIf Handler;
  30
  31   virtual ~ZipkinCollectorIfFactory() {}
  32
  33   virtual ZipkinCollectorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  34   virtual void releaseHandler(ZipkinCollectorIf* /* handler */) = 0;
  35 };
  36
  37 class ZipkinCollectorIfSingletonFactory : virtual public ZipkinCollectorIfFactory {
  38  public:
  39   ZipkinCollectorIfSingletonFactory(const ::std::shared_ptr<ZipkinCollectorIf>& iface) : iface_(iface) {}
  40   virtual ~ZipkinCollectorIfSingletonFactory() {}
  41
  42   virtual ZipkinCollectorIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
  43     return iface_.get();
  44   }
  45   virtual void releaseHandler(ZipkinCollectorIf* /* handler */) {}
  46
  47  protected:
  48   ::std::shared_ptr<ZipkinCollectorIf> iface_;
  49 };
  50
  51 class ZipkinCollectorNull : virtual public ZipkinCollectorIf {
  52  public:
  53   virtual ~ZipkinCollectorNull() {}
  54   void submitZipkinBatch(std::vector<Response> & /* _return */, const std::vector<Span> & /* spans */) {
  55     return;
  56   }
  57 };
  58
  59 typedef struct _ZipkinCollector_submitZipkinBatch_args__isset {
  60   _ZipkinCollector_submitZipkinBatch_args__isset() : spans(false) {}
  61   bool spans :1;
  62 } _ZipkinCollector_submitZipkinBatch_args__isset;
  63
  64 class ZipkinCollector_submitZipkinBatch_args {
  65  public:
  66
  67   ZipkinCollector_submitZipkinBatch_args(const ZipkinCollector_submitZipkinBatch_args&);
  68   ZipkinCollector_submitZipkinBatch_args& operator=(const ZipkinCollector_submitZipkinBatch_args&);
  69   ZipkinCollector_submitZipkinBatch_args() {
  70   }
  71
  72   virtual ~ZipkinCollector_submitZipkinBatch_args() throw();
  73   std::vector<Span>  spans;
  74
  75   _ZipkinCollector_submitZipkinBatch_args__isset __isset;
  76
  77   void __set_spans(const std::vector<Span> & val);
  78
  79   bool operator == (const ZipkinCollector_submitZipkinBatch_args & rhs) const
  80   {
  81     if (!(spans == rhs.spans))
  82       return false;
  83     return true;
  84   }
  85   bool operator != (const ZipkinCollector_submitZipkinBatch_args &rhs) const {
  86     return !(*this == rhs);
  87   }
  88
  89   bool operator < (const ZipkinCollector_submitZipkinBatch_args & ) const;
  90
  91   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  92   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  93
  94 };
  95
  96
  97 class ZipkinCollector_submitZipkinBatch_pargs {
  98  public:
  99
 100
 101   virtual ~ZipkinCollector_submitZipkinBatch_pargs() throw();
 102   const std::vector<Span> * spans;
 103
 104   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 105
 106 };
 107
 108 typedef struct _ZipkinCollector_submitZipkinBatch_result__isset {
 109   _ZipkinCollector_submitZipkinBatch_result__isset() : success(false) {}
 110   bool success :1;
 111 } _ZipkinCollector_submitZipkinBatch_result__isset;
 112
 113 class ZipkinCollector_submitZipkinBatch_result {
 114  public:
 115
 116   ZipkinCollector_submitZipkinBatch_result(const ZipkinCollector_submitZipkinBatch_result&);
 117   ZipkinCollector_submitZipkinBatch_result& operator=(const ZipkinCollector_submitZipkinBatch_result&);
 118   ZipkinCollector_submitZipkinBatch_result() {
 119   }
 120
 121   virtual ~ZipkinCollector_submitZipkinBatch_result() throw();
 122   std::vector<Response>  success;
 123
 124   _ZipkinCollector_submitZipkinBatch_result__isset __isset;
 125
 126   void __set_success(const std::vector<Response> & val);
 127
 128   bool operator == (const ZipkinCollector_submitZipkinBatch_result & rhs) const
 129   {
 130     if (!(success == rhs.success))
 131       return false;
 132     return true;
 133   }
 134   bool operator != (const ZipkinCollector_submitZipkinBatch_result &rhs) const {
 135     return !(*this == rhs);
 136   }
 137
 138   bool operator < (const ZipkinCollector_submitZipkinBatch_result & ) const;
 139
 140   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 141   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 142
 143 };
 144
 145 typedef struct _ZipkinCollector_submitZipkinBatch_presult__isset {
 146   _ZipkinCollector_submitZipkinBatch_presult__isset() : success(false) {}
 147   bool success :1;
 148 } _ZipkinCollector_submitZipkinBatch_presult__isset;
 149
 150 class ZipkinCollector_submitZipkinBatch_presult {
 151  public:
 152
 153
 154   virtual ~ZipkinCollector_submitZipkinBatch_presult() throw();
 155   std::vector<Response> * success;
 156
 157   _ZipkinCollector_submitZipkinBatch_presult__isset __isset;
 158
 159   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 160
 161 };
 162
 163 class ZipkinCollectorClient : virtual public ZipkinCollectorIf {
 164  public:
 165   ZipkinCollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
 166     setProtocol(prot);
 167   }
 168   ZipkinCollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
 169     setProtocol(iprot,oprot);
 170   }
 171  private:
 172   void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
 173   setProtocol(prot,prot);
 174   }
 175   void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
 176     piprot_=iprot;
 177     poprot_=oprot;
 178     iprot_ = iprot.get();
 179     oprot_ = oprot.get();
 180   }
 181  public:
 182   std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
 183     return piprot_;
 184   }
 185   std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
 186     return poprot_;
 187   }
 188   void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans);
 189   void send_submitZipkinBatch(const std::vector<Span> & spans);
 190   void recv_submitZipkinBatch(std::vector<Response> & _return);
 191  protected:
 192   std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
 193   std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
 194   ::apache::thrift::protocol::TProtocol* iprot_;
 195   ::apache::thrift::protocol::TProtocol* oprot_;
 196 };
 197
 198 class ZipkinCollectorProcessor : public ::apache::thrift::TDispatchProcessor {
 199  protected:
 200   ::std::shared_ptr<ZipkinCollectorIf> iface_;
 201   virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
 202  private:
 203   typedef  void (ZipkinCollectorProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
 204   typedef std::map<std::string, ProcessFunction> ProcessMap;
 205   ProcessMap processMap_;
 206   void process_submitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 207  public:
 208   ZipkinCollectorProcessor(::std::shared_ptr<ZipkinCollectorIf> iface) :
 209     iface_(iface) {
 210     processMap_["submitZipkinBatch"] = &ZipkinCollectorProcessor::process_submitZipkinBatch;
 211   }
 212
 213   virtual ~ZipkinCollectorProcessor() {}
 214 };
 215
 216 class ZipkinCollectorProcessorFactory : public ::apache::thrift::TProcessorFactory {
 217  public:
 218   ZipkinCollectorProcessorFactory(const ::std::shared_ptr< ZipkinCollectorIfFactory >& handlerFactory) :
 219       handlerFactory_(handlerFactory) {}
 220
 221   ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
 222
 223  protected:
 224   ::std::shared_ptr< ZipkinCollectorIfFactory > handlerFactory_;
 225 };
 226
 227 class ZipkinCollectorMultiface : virtual public ZipkinCollectorIf {
 228  public:
 229   ZipkinCollectorMultiface(std::vector<std::shared_ptr<ZipkinCollectorIf> >& ifaces) : ifaces_(ifaces) {
 230   }
 231   virtual ~ZipkinCollectorMultiface() {}
 232  protected:
 233   std::vector<std::shared_ptr<ZipkinCollectorIf> > ifaces_;
 234   ZipkinCollectorMultiface() {}
 235   void add(::std::shared_ptr<ZipkinCollectorIf> iface) {
 236     ifaces_.push_back(iface);
 237   }
 238  public:
 239   void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) {
 240     size_t sz = ifaces_.size();
 241     size_t i = 0;
 242     for (; i < (sz - 1); ++i) {
 243       ifaces_[i]->submitZipkinBatch(_return, spans);
 244     }
 245     ifaces_[i]->submitZipkinBatch(_return, spans);
 246     return;
 247   }
 248
 249 };
 250
 251 // The 'concurrent' client is a thread safe client that correctly handles
 252 // out of order responses.  It is slower than the regular client, so should
 253 // only be used when you need to share a connection among multiple threads
 254 class ZipkinCollectorConcurrentClient : virtual public ZipkinCollectorIf {
 255  public:
 256   ZipkinCollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
 257     setProtocol(prot);
 258   }
 259   ZipkinCollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
 260     setProtocol(iprot,oprot);
 261   }
 262  private:
 263   void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
 264   setProtocol(prot,prot);
 265   }
 266   void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
 267     piprot_=iprot;
 268     poprot_=oprot;
 269     iprot_ = iprot.get();
 270     oprot_ = oprot.get();
 271   }
 272  public:
 273   std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
 274     return piprot_;
 275   }
 276   std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
 277     return poprot_;
 278   }
 279   void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans);
 280   int32_t send_submitZipkinBatch(const std::vector<Span> & spans);
 281   void recv_submitZipkinBatch(std::vector<Response> & _return, const int32_t seqid);
 282  protected:
 283   std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
 284   std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
 285   ::apache::thrift::protocol::TProtocol* iprot_;
 286   ::apache::thrift::protocol::TProtocol* oprot_;
 287   ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
 288 };
 289
 290 #ifdef _MSC_VER
 291   #pragma warning( pop )
 292 #endif
 293
 294 }}} // namespace
 295
 296 #endif