1 files changed, 422 insertions, 0 deletions
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.h
new file mode 100644
index 000000000..3da73420d
--- /dev/null
+++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/TracedService.h
@@ -0,0 +1,422 @@
+/**
+ * Autogenerated by Thrift Compiler (0.11.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef TracedService_H
+#define TracedService_H
+
+#include <thrift/TDispatchProcessor.h>
+#include <thrift/async/TConcurrentClientSyncInfo.h>
+#include "tracetest_types.h"
+
+namespace jaegertracing { namespace crossdock { namespace thrift {
+
+#ifdef _MSC_VER
+  #pragma warning( push )
+  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
+#endif
+
+class TracedServiceIf {
+ public:
+  virtual ~TracedServiceIf() {}
+  virtual void startTrace(TraceResponse& _return, const StartTraceRequest& request) = 0;
+  virtual void joinTrace(TraceResponse& _return, const JoinTraceRequest& request) = 0;
+};
+
+class TracedServiceIfFactory {
+ public:
+  typedef TracedServiceIf Handler;
+
+  virtual ~TracedServiceIfFactory() {}
+
+  virtual TracedServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(TracedServiceIf* /* handler */) = 0;
+};
+
+class TracedServiceIfSingletonFactory : virtual public TracedServiceIfFactory {
+ public:
+  TracedServiceIfSingletonFactory(const ::std::shared_ptr<TracedServiceIf>& iface) : iface_(iface) {}
+  virtual ~TracedServiceIfSingletonFactory() {}
+
+  virtual TracedServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(TracedServiceIf* /* handler */) {}
+
+ protected:
+  ::std::shared_ptr<TracedServiceIf> iface_;
+};
+
+class TracedServiceNull : virtual public TracedServiceIf {
+ public:
+  virtual ~TracedServiceNull() {}
+  void startTrace(TraceResponse& /* _return */, const StartTraceRequest& /* request */) {
+    return;
+  }
+  void joinTrace(TraceResponse& /* _return */, const JoinTraceRequest& /* request */) {
+    return;
+  }
+};
+
+typedef struct _TracedService_startTrace_args__isset {
+  _TracedService_startTrace_args__isset() : request(false) {}
+  bool request :1;
+} _TracedService_startTrace_args__isset;
+
+class TracedService_startTrace_args {
+ public:
+
+  TracedService_startTrace_args(const TracedService_startTrace_args&);
+  TracedService_startTrace_args& operator=(const TracedService_startTrace_args&);
+  TracedService_startTrace_args() {
+  }
+
+  virtual ~TracedService_startTrace_args() throw();
+  StartTraceRequest request;
+
+  _TracedService_startTrace_args__isset __isset;
+
+  void __set_request(const StartTraceRequest& val);
+
+  bool operator == (const TracedService_startTrace_args & rhs) const
+  {
+    if (!(request == rhs.request))
+      return false;
+    return true;
+  }
+  bool operator != (const TracedService_startTrace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TracedService_startTrace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TracedService_startTrace_pargs {
+ public:
+
+
+  virtual ~TracedService_startTrace_pargs() throw();
+  const StartTraceRequest* request;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TracedService_startTrace_result__isset {
+  _TracedService_startTrace_result__isset() : success(false) {}
+  bool success :1;
+} _TracedService_startTrace_result__isset;
+
+class TracedService_startTrace_result {
+ public:
+
+  TracedService_startTrace_result(const TracedService_startTrace_result&);
+  TracedService_startTrace_result& operator=(const TracedService_startTrace_result&);
+  TracedService_startTrace_result() {
+  }
+
+  virtual ~TracedService_startTrace_result() throw();
+  TraceResponse success;
+
+  _TracedService_startTrace_result__isset __isset;
+
+  void __set_success(const TraceResponse& val);
+
+  bool operator == (const TracedService_startTrace_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TracedService_startTrace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TracedService_startTrace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TracedService_startTrace_presult__isset {
+  _TracedService_startTrace_presult__isset() : success(false) {}
+  bool success :1;
+} _TracedService_startTrace_presult__isset;
+
+class TracedService_startTrace_presult {
+ public:
+
+
+  virtual ~TracedService_startTrace_presult() throw();
+  TraceResponse* success;
+
+  _TracedService_startTrace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TracedService_joinTrace_args__isset {
+  _TracedService_joinTrace_args__isset() : request(false) {}
+  bool request :1;
+} _TracedService_joinTrace_args__isset;
+
+class TracedService_joinTrace_args {
+ public:
+
+  TracedService_joinTrace_args(const TracedService_joinTrace_args&);
+  TracedService_joinTrace_args& operator=(const TracedService_joinTrace_args&);
+  TracedService_joinTrace_args() {
+  }
+
+  virtual ~TracedService_joinTrace_args() throw();
+  JoinTraceRequest request;
+
+  _TracedService_joinTrace_args__isset __isset;
+
+  void __set_request(const JoinTraceRequest& val);
+
+  bool operator == (const TracedService_joinTrace_args & rhs) const
+  {
+    if (!(request == rhs.request))
+      return false;
+    return true;
+  }
+  bool operator != (const TracedService_joinTrace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TracedService_joinTrace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TracedService_joinTrace_pargs {
+ public:
+
+
+  virtual ~TracedService_joinTrace_pargs() throw();
+  const JoinTraceRequest* request;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TracedService_joinTrace_result__isset {
+  _TracedService_joinTrace_result__isset() : success(false) {}
+  bool success :1;
+} _TracedService_joinTrace_result__isset;
+
+class TracedService_joinTrace_result {
+ public:
+
+  TracedService_joinTrace_result(const TracedService_joinTrace_result&);
+  TracedService_joinTrace_result& operator=(const TracedService_joinTrace_result&);
+  TracedService_joinTrace_result() {
+  }
+
+  virtual ~TracedService_joinTrace_result() throw();
+  TraceResponse success;
+
+  _TracedService_joinTrace_result__isset __isset;
+
+  void __set_success(const TraceResponse& val);
+
+  bool operator == (const TracedService_joinTrace_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TracedService_joinTrace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TracedService_joinTrace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TracedService_joinTrace_presult__isset {
+  _TracedService_joinTrace_presult__isset() : success(false) {}
+  bool success :1;
+} _TracedService_joinTrace_presult__isset;
+
+class TracedService_joinTrace_presult {
+ public:
+
+
+  virtual ~TracedService_joinTrace_presult() throw();
+  TraceResponse* success;
+
+  _TracedService_joinTrace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class TracedServiceClient : virtual public TracedServiceIf {
+ public:
+  TracedServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  TracedServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void startTrace(TraceResponse& _return, const StartTraceRequest& request);
+  void send_startTrace(const StartTraceRequest& request);
+  void recv_startTrace(TraceResponse& _return);
+  void joinTrace(TraceResponse& _return, const JoinTraceRequest& request);
+  void send_joinTrace(const JoinTraceRequest& request);
+  void recv_joinTrace(TraceResponse& _return);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class TracedServiceProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  ::std::shared_ptr<TracedServiceIf> iface_;
+  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (TracedServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  void process_startTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_joinTrace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+  TracedServiceProcessor(::std::shared_ptr<TracedServiceIf> iface) :
+    iface_(iface) {
+    processMap_["startTrace"] = &TracedServiceProcessor::process_startTrace;
+    processMap_["joinTrace"] = &TracedServiceProcessor::process_joinTrace;
+  }
+
+  virtual ~TracedServiceProcessor() {}
+};
+
+class TracedServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  TracedServiceProcessorFactory(const ::std::shared_ptr< TracedServiceIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::std::shared_ptr< TracedServiceIfFactory > handlerFactory_;
+};
+
+class TracedServiceMultiface : virtual public TracedServiceIf {
+ public:
+  TracedServiceMultiface(std::vector<std::shared_ptr<TracedServiceIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~TracedServiceMultiface() {}
+ protected:
+  std::vector<std::shared_ptr<TracedServiceIf> > ifaces_;
+  TracedServiceMultiface() {}
+  void add(::std::shared_ptr<TracedServiceIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  void startTrace(TraceResponse& _return, const StartTraceRequest& request) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->startTrace(_return, request);
+    }
+    ifaces_[i]->startTrace(_return, request);
+    return;
+  }
+
+  void joinTrace(TraceResponse& _return, const JoinTraceRequest& request) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->joinTrace(_return, request);
+    }
+    ifaces_[i]->joinTrace(_return, request);
+    return;
+  }
+
+};
+
+// The 'concurrent' client is a thread safe client that correctly handles
+// out of order responses.  It is slower than the regular client, so should
+// only be used when you need to share a connection among multiple threads
+class TracedServiceConcurrentClient : virtual public TracedServiceIf {
+ public:
+  TracedServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  TracedServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void startTrace(TraceResponse& _return, const StartTraceRequest& request);
+  int32_t send_startTrace(const StartTraceRequest& request);
+  void recv_startTrace(TraceResponse& _return, const int32_t seqid);
+  void joinTrace(TraceResponse& _return, const JoinTraceRequest& request);
+  int32_t send_joinTrace(const JoinTraceRequest& request);
+  void recv_joinTrace(TraceResponse& _return, const int32_t seqid);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+  ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
+};
+
+#ifdef _MSC_VER
+  #pragma warning( pop )
+#endif
+
+}}} // namespace
+
+#endif