1 files changed, 465 insertions, 0 deletions
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.h
new file mode 100644
index 000000000..6e8e7fba6
--- /dev/null
+++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/jaeger_types.h
@@ -0,0 +1,465 @@
+/**
+ * Autogenerated by Thrift Compiler (0.11.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef jaeger_TYPES_H
+#define jaeger_TYPES_H
+
+#include <iosfwd>
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/TBase.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+namespace jaegertracing { namespace thrift {
+
+struct TagType {
+  enum type {
+    STRING = 0,
+    DOUBLE = 1,
+    BOOL = 2,
+    LONG = 3,
+    BINARY = 4
+  };
+};
+
+extern const std::map<int, const char*> _TagType_VALUES_TO_NAMES;
+
+std::ostream& operator<<(std::ostream& out, const TagType::type& val);
+
+struct SpanRefType {
+  enum type {
+    CHILD_OF = 0,
+    FOLLOWS_FROM = 1
+  };
+};
+
+extern const std::map<int, const char*> _SpanRefType_VALUES_TO_NAMES;
+
+std::ostream& operator<<(std::ostream& out, const SpanRefType::type& val);
+
+class Tag;
+
+class Log;
+
+class SpanRef;
+
+class Span;
+
+class Process;
+
+class Batch;
+
+class BatchSubmitResponse;
+
+typedef struct _Tag__isset {
+  _Tag__isset() : vStr(false), vDouble(false), vBool(false), vLong(false), vBinary(false) {}
+  bool vStr :1;
+  bool vDouble :1;
+  bool vBool :1;
+  bool vLong :1;
+  bool vBinary :1;
+} _Tag__isset;
+
+class Tag : public virtual ::apache::thrift::TBase {
+ public:
+
+  Tag(const Tag&);
+  Tag& operator=(const Tag&);
+  Tag() : key(), vType((TagType::type)0), vStr(), vDouble(0), vBool(0), vLong(0), vBinary() {
+  }
+
+  virtual ~Tag() throw();
+  std::string key;
+  TagType::type vType;
+  std::string vStr;
+  double vDouble;
+  bool vBool;
+  int64_t vLong;
+  std::string vBinary;
+
+  _Tag__isset __isset;
+
+  void __set_key(const std::string& val);
+
+  void __set_vType(const TagType::type val);
+
+  void __set_vStr(const std::string& val);
+
+  void __set_vDouble(const double val);
+
+  void __set_vBool(const bool val);
+
+  void __set_vLong(const int64_t val);
+
+  void __set_vBinary(const std::string& val);
+
+  bool operator == (const Tag & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(vType == rhs.vType))
+      return false;
+    if (__isset.vStr != rhs.__isset.vStr)
+      return false;
+    else if (__isset.vStr && !(vStr == rhs.vStr))
+      return false;
+    if (__isset.vDouble != rhs.__isset.vDouble)
+      return false;
+    else if (__isset.vDouble && !(vDouble == rhs.vDouble))
+      return false;
+    if (__isset.vBool != rhs.__isset.vBool)
+      return false;
+    else if (__isset.vBool && !(vBool == rhs.vBool))
+      return false;
+    if (__isset.vLong != rhs.__isset.vLong)
+      return false;
+    else if (__isset.vLong && !(vLong == rhs.vLong))
+      return false;
+    if (__isset.vBinary != rhs.__isset.vBinary)
+      return false;
+    else if (__isset.vBinary && !(vBinary == rhs.vBinary))
+      return false;
+    return true;
+  }
+  bool operator != (const Tag &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Tag & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Tag &a, Tag &b);
+
+std::ostream& operator<<(std::ostream& out, const Tag& obj);
+
+
+class Log : public virtual ::apache::thrift::TBase {
+ public:
+
+  Log(const Log&);
+  Log& operator=(const Log&);
+  Log() : timestamp(0) {
+  }
+
+  virtual ~Log() throw();
+  int64_t timestamp;
+  std::vector<Tag>  fields;
+
+  void __set_timestamp(const int64_t val);
+
+  void __set_fields(const std::vector<Tag> & val);
+
+  bool operator == (const Log & rhs) const
+  {
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(fields == rhs.fields))
+      return false;
+    return true;
+  }
+  bool operator != (const Log &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Log & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Log &a, Log &b);
+
+std::ostream& operator<<(std::ostream& out, const Log& obj);
+
+
+class SpanRef : public virtual ::apache::thrift::TBase {
+ public:
+
+  SpanRef(const SpanRef&);
+  SpanRef& operator=(const SpanRef&);
+  SpanRef() : refType((SpanRefType::type)0), traceIdLow(0), traceIdHigh(0), spanId(0) {
+  }
+
+  virtual ~SpanRef() throw();
+  SpanRefType::type refType;
+  int64_t traceIdLow;
+  int64_t traceIdHigh;
+  int64_t spanId;
+
+  void __set_refType(const SpanRefType::type val);
+
+  void __set_traceIdLow(const int64_t val);
+
+  void __set_traceIdHigh(const int64_t val);
+
+  void __set_spanId(const int64_t val);
+
+  bool operator == (const SpanRef & rhs) const
+  {
+    if (!(refType == rhs.refType))
+      return false;
+    if (!(traceIdLow == rhs.traceIdLow))
+      return false;
+    if (!(traceIdHigh == rhs.traceIdHigh))
+      return false;
+    if (!(spanId == rhs.spanId))
+      return false;
+    return true;
+  }
+  bool operator != (const SpanRef &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SpanRef & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(SpanRef &a, SpanRef &b);
+
+std::ostream& operator<<(std::ostream& out, const SpanRef& obj);
+
+typedef struct _Span__isset {
+  _Span__isset() : references(false), tags(false), logs(false) {}
+  bool references :1;
+  bool tags :1;
+  bool logs :1;
+} _Span__isset;
+
+class Span : public virtual ::apache::thrift::TBase {
+ public:
+
+  Span(const Span&);
+  Span& operator=(const Span&);
+  Span() : traceIdLow(0), traceIdHigh(0), spanId(0), parentSpanId(0), operationName(), flags(0), startTime(0), duration(0) {
+  }
+
+  virtual ~Span() throw();
+  int64_t traceIdLow;
+  int64_t traceIdHigh;
+  int64_t spanId;
+  int64_t parentSpanId;
+  std::string operationName;
+  std::vector<SpanRef>  references;
+  int32_t flags;
+  int64_t startTime;
+  int64_t duration;
+  std::vector<Tag>  tags;
+  std::vector<Log>  logs;
+
+  _Span__isset __isset;
+
+  void __set_traceIdLow(const int64_t val);
+
+  void __set_traceIdHigh(const int64_t val);
+
+  void __set_spanId(const int64_t val);
+
+  void __set_parentSpanId(const int64_t val);
+
+  void __set_operationName(const std::string& val);
+
+  void __set_references(const std::vector<SpanRef> & val);
+
+  void __set_flags(const int32_t val);
+
+  void __set_startTime(const int64_t val);
+
+  void __set_duration(const int64_t val);
+
+  void __set_tags(const std::vector<Tag> & val);
+
+  void __set_logs(const std::vector<Log> & val);
+
+  bool operator == (const Span & rhs) const
+  {
+    if (!(traceIdLow == rhs.traceIdLow))
+      return false;
+    if (!(traceIdHigh == rhs.traceIdHigh))
+      return false;
+    if (!(spanId == rhs.spanId))
+      return false;
+    if (!(parentSpanId == rhs.parentSpanId))
+      return false;
+    if (!(operationName == rhs.operationName))
+      return false;
+    if (__isset.references != rhs.__isset.references)
+      return false;
+    else if (__isset.references && !(references == rhs.references))
+      return false;
+    if (!(flags == rhs.flags))
+      return false;
+    if (!(startTime == rhs.startTime))
+      return false;
+    if (!(duration == rhs.duration))
+      return false;
+    if (__isset.tags != rhs.__isset.tags)
+      return false;
+    else if (__isset.tags && !(tags == rhs.tags))
+      return false;
+    if (__isset.logs != rhs.__isset.logs)
+      return false;
+    else if (__isset.logs && !(logs == rhs.logs))
+      return false;
+    return true;
+  }
+  bool operator != (const Span &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Span & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Span &a, Span &b);
+
+std::ostream& operator<<(std::ostream& out, const Span& obj);
+
+typedef struct _Process__isset {
+  _Process__isset() : tags(false) {}
+  bool tags :1;
+} _Process__isset;
+
+class Process : public virtual ::apache::thrift::TBase {
+ public:
+
+  Process(const Process&);
+  Process& operator=(const Process&);
+  Process() : serviceName() {
+  }
+
+  virtual ~Process() throw();
+  std::string serviceName;
+  std::vector<Tag>  tags;
+
+  _Process__isset __isset;
+
+  void __set_serviceName(const std::string& val);
+
+  void __set_tags(const std::vector<Tag> & val);
+
+  bool operator == (const Process & rhs) const
+  {
+    if (!(serviceName == rhs.serviceName))
+      return false;
+    if (__isset.tags != rhs.__isset.tags)
+      return false;
+    else if (__isset.tags && !(tags == rhs.tags))
+      return false;
+    return true;
+  }
+  bool operator != (const Process &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Process & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Process &a, Process &b);
+
+std::ostream& operator<<(std::ostream& out, const Process& obj);
+
+
+class Batch : public virtual ::apache::thrift::TBase {
+ public:
+
+  Batch(const Batch&);
+  Batch& operator=(const Batch&);
+  Batch() {
+  }
+
+  virtual ~Batch() throw();
+  Process process;
+  std::vector<Span>  spans;
+
+  void __set_process(const Process& val);
+
+  void __set_spans(const std::vector<Span> & val);
+
+  bool operator == (const Batch & rhs) const
+  {
+    if (!(process == rhs.process))
+      return false;
+    if (!(spans == rhs.spans))
+      return false;
+    return true;
+  }
+  bool operator != (const Batch &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Batch & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Batch &a, Batch &b);
+
+std::ostream& operator<<(std::ostream& out, const Batch& obj);
+
+
+class BatchSubmitResponse : public virtual ::apache::thrift::TBase {
+ public:
+
+  BatchSubmitResponse(const BatchSubmitResponse&);
+  BatchSubmitResponse& operator=(const BatchSubmitResponse&);
+  BatchSubmitResponse() : ok(0) {
+  }
+
+  virtual ~BatchSubmitResponse() throw();
+  bool ok;
+
+  void __set_ok(const bool val);
+
+  bool operator == (const BatchSubmitResponse & rhs) const
+  {
+    if (!(ok == rhs.ok))
+      return false;
+    return true;
+  }
+  bool operator != (const BatchSubmitResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const BatchSubmitResponse & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(BatchSubmitResponse &a, BatchSubmitResponse &b);
+
+std::ostream& operator<<(std::ostream& out, const BatchSubmitResponse& obj);
+
+}} // namespace
+
+#endif