/**
 * Autogenerated by Thrift Compiler (0.14.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>

#include <functional>
#include <memory>


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);

std::string to_string(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);

std::string to_string(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() noexcept;
  std::string key;
  /**
   * 
   * @see TagType
   */
  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() noexcept;
  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() noexcept;
  /**
   * 
   * @see SpanRefType
   */
  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() noexcept;
  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() noexcept;
  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() noexcept;
  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() noexcept;
  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
