[ceph.git] / ceph / src / jaegertracing / jaeger-client-cpp / src / jaegertracing / thrift-gen / jaeger_types.h

/**
 * 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
Commit	Line	Data
f67539c2 TL	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 jaeger_TYPES_H
	8	#define jaeger_TYPES_H
	9
	10	#include <iosfwd>
	11
	12	#include <thrift/Thrift.h>
	13	#include <thrift/TApplicationException.h>
	14	#include <thrift/TBase.h>
	15	#include <thrift/protocol/TProtocol.h>
	16	#include <thrift/transport/TTransport.h>
	17
	18	namespace jaegertracing { namespace thrift {
	19
	20	struct TagType {
	21	enum type {
	22	STRING = 0,
	23	DOUBLE = 1,
	24	BOOL = 2,
	25	LONG = 3,
	26	BINARY = 4
	27	};
	28	};
	29
	30	extern const std::map<int, const char*> _TagType_VALUES_TO_NAMES;
	31
	32	std::ostream& operator<<(std::ostream& out, const TagType::type& val);
	33
	34	struct SpanRefType {
	35	enum type {
	36	CHILD_OF = 0,
	37	FOLLOWS_FROM = 1
	38	};
	39	};
	40
	41	extern const std::map<int, const char*> _SpanRefType_VALUES_TO_NAMES;
	42
	43	std::ostream& operator<<(std::ostream& out, const SpanRefType::type& val);
	44
	45	class Tag;
	46
	47	class Log;
	48
	49	class SpanRef;
	50
	51	class Span;
	52
	53	class Process;
	54
	55	class Batch;
	56
	57	class BatchSubmitResponse;
	58
	59	typedef struct _Tag__isset {
	60	_Tag__isset() : vStr(false), vDouble(false), vBool(false), vLong(false), vBinary(false) {}
	61	bool vStr :1;
	62	bool vDouble :1;
	63	bool vBool :1;
	64	bool vLong :1;
65	bool vBinary :1;
66	} _Tag__isset;
67
68	class Tag : public virtual ::apache::thrift::TBase {
69	public:
70
71	Tag(const Tag&);
72	Tag& operator=(const Tag&);
73	Tag() : key(), vType((TagType::type)0), vStr(), vDouble(0), vBool(0), vLong(0), vBinary() {
74	}
75
76	virtual ~Tag() throw();
77	std::string key;
78	TagType::type vType;
79	std::string vStr;
80	double vDouble;
81	bool vBool;
82	int64_t vLong;
83	std::string vBinary;
84
85	_Tag__isset __isset;
86
87	void __set_key(const std::string& val);
88
89	void __set_vType(const TagType::type val);
90
91	void __set_vStr(const std::string& val);
92
93	void __set_vDouble(const double val);
94
95	void __set_vBool(const bool val);
96
97	void __set_vLong(const int64_t val);
98
99	void __set_vBinary(const std::string& val);
100
101	bool operator == (const Tag & rhs) const
102	{
103	if (!(key == rhs.key))
104	return false;
105	if (!(vType == rhs.vType))
106	return false;
107	if (__isset.vStr != rhs.__isset.vStr)
108	return false;
109	else if (__isset.vStr && !(vStr == rhs.vStr))
110	return false;
111	if (__isset.vDouble != rhs.__isset.vDouble)
112	return false;
113	else if (__isset.vDouble && !(vDouble == rhs.vDouble))
114	return false;
115	if (__isset.vBool != rhs.__isset.vBool)
116	return false;
117	else if (__isset.vBool && !(vBool == rhs.vBool))
118	return false;
119	if (__isset.vLong != rhs.__isset.vLong)
120	return false;
121	else if (__isset.vLong && !(vLong == rhs.vLong))
122	return false;
123	if (__isset.vBinary != rhs.__isset.vBinary)
124	return false;
125	else if (__isset.vBinary && !(vBinary == rhs.vBinary))
126	return false;
127	return true;
128	}
129	bool operator != (const Tag &rhs) const {
130	return !(*this == rhs);
131	}
132
133	bool operator < (const Tag & ) const;
134
135	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
136	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
137
138	virtual void printTo(std::ostream& out) const;
139	};
140
141	void swap(Tag &a, Tag &b);
142
143	std::ostream& operator<<(std::ostream& out, const Tag& obj);
144
145
146	class Log : public virtual ::apache::thrift::TBase {
147	public:
148
149	Log(const Log&);
150	Log& operator=(const Log&);
151	Log() : timestamp(0) {
152	}
153
154	virtual ~Log() throw();
155	int64_t timestamp;
156	std::vector<Tag> fields;
157
158	void __set_timestamp(const int64_t val);
159
160	void __set_fields(const std::vector<Tag> & val);
161
162	bool operator == (const Log & rhs) const
163	{
164	if (!(timestamp == rhs.timestamp))
165	return false;
166	if (!(fields == rhs.fields))
167	return false;
168	return true;
169	}
170	bool operator != (const Log &rhs) const {
171	return !(*this == rhs);
172	}
173
174	bool operator < (const Log & ) const;
175
176	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
177	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
178
179	virtual void printTo(std::ostream& out) const;
180	};
181
182	void swap(Log &a, Log &b);
183
184	std::ostream& operator<<(std::ostream& out, const Log& obj);
185
186
187	class SpanRef : public virtual ::apache::thrift::TBase {
188	public:
189
190	SpanRef(const SpanRef&);
191	SpanRef& operator=(const SpanRef&);
192	SpanRef() : refType((SpanRefType::type)0), traceIdLow(0), traceIdHigh(0), spanId(0) {
193	}
194
195	virtual ~SpanRef() throw();
196	SpanRefType::type refType;
197	int64_t traceIdLow;
198	int64_t traceIdHigh;
199	int64_t spanId;
200
201	void __set_refType(const SpanRefType::type val);
202
203	void __set_traceIdLow(const int64_t val);
204
205	void __set_traceIdHigh(const int64_t val);
206
207	void __set_spanId(const int64_t val);
208
209	bool operator == (const SpanRef & rhs) const
210	{
211	if (!(refType == rhs.refType))
212	return false;
213	if (!(traceIdLow == rhs.traceIdLow))
214	return false;
215	if (!(traceIdHigh == rhs.traceIdHigh))
216	return false;
217	if (!(spanId == rhs.spanId))
218	return false;
219	return true;
220	}
221	bool operator != (const SpanRef &rhs) const {
222	return !(*this == rhs);
223	}
224
225	bool operator < (const SpanRef & ) const;
226
227	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
228	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
229
230	virtual void printTo(std::ostream& out) const;
231	};
232
233	void swap(SpanRef &a, SpanRef &b);
234
235	std::ostream& operator<<(std::ostream& out, const SpanRef& obj);
236
237	typedef struct _Span__isset {
238	_Span__isset() : references(false), tags(false), logs(false) {}
239	bool references :1;
240	bool tags :1;
241	bool logs :1;
242	} _Span__isset;
243
244	class Span : public virtual ::apache::thrift::TBase {
245	public:
246
247	Span(const Span&);
248	Span& operator=(const Span&);
249	Span() : traceIdLow(0), traceIdHigh(0), spanId(0), parentSpanId(0), operationName(), flags(0), startTime(0), duration(0) {
250	}
251
252	virtual ~Span() throw();
253	int64_t traceIdLow;
254	int64_t traceIdHigh;
255	int64_t spanId;
256	int64_t parentSpanId;
257	std::string operationName;
258	std::vector<SpanRef> references;
259	int32_t flags;
260	int64_t startTime;
261	int64_t duration;
262	std::vector<Tag> tags;
263	std::vector<Log> logs;
264
265	_Span__isset __isset;
266
267	void __set_traceIdLow(const int64_t val);
268
269	void __set_traceIdHigh(const int64_t val);
270
271	void __set_spanId(const int64_t val);
272
273	void __set_parentSpanId(const int64_t val);
274
275	void __set_operationName(const std::string& val);
276
277	void __set_references(const std::vector<SpanRef> & val);
278
279	void __set_flags(const int32_t val);
280
281	void __set_startTime(const int64_t val);
282
283	void __set_duration(const int64_t val);
284
285	void __set_tags(const std::vector<Tag> & val);
286
287	void __set_logs(const std::vector<Log> & val);
288
289	bool operator == (const Span & rhs) const
290	{
291	if (!(traceIdLow == rhs.traceIdLow))
292	return false;
293	if (!(traceIdHigh == rhs.traceIdHigh))
294	return false;
295	if (!(spanId == rhs.spanId))
296	return false;
297	if (!(parentSpanId == rhs.parentSpanId))
298	return false;
299	if (!(operationName == rhs.operationName))
300	return false;
301	if (__isset.references != rhs.__isset.references)
302	return false;
303	else if (__isset.references && !(references == rhs.references))
304	return false;
305	if (!(flags == rhs.flags))
306	return false;
307	if (!(startTime == rhs.startTime))
308	return false;
309	if (!(duration == rhs.duration))
310	return false;
311	if (__isset.tags != rhs.__isset.tags)
312	return false;
313	else if (__isset.tags && !(tags == rhs.tags))
314	return false;
315	if (__isset.logs != rhs.__isset.logs)
316	return false;
317	else if (__isset.logs && !(logs == rhs.logs))
318	return false;
319	return true;
320	}
321	bool operator != (const Span &rhs) const {
322	return !(*this == rhs);
323	}
324
325	bool operator < (const Span & ) const;
326
327	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
328	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
329
330	virtual void printTo(std::ostream& out) const;
331	};
332
333	void swap(Span &a, Span &b);
334
335	std::ostream& operator<<(std::ostream& out, const Span& obj);
336
337	typedef struct _Process__isset {
338	_Process__isset() : tags(false) {}
339	bool tags :1;
340	} _Process__isset;
341
342	class Process : public virtual ::apache::thrift::TBase {
343	public:
344
345	Process(const Process&);
346	Process& operator=(const Process&);
347	Process() : serviceName() {
348	}
349
350	virtual ~Process() throw();
351	std::string serviceName;
352	std::vector<Tag> tags;
353
354	_Process__isset __isset;
355
356	void __set_serviceName(const std::string& val);
357
358	void __set_tags(const std::vector<Tag> & val);
359
360	bool operator == (const Process & rhs) const
361	{
362	if (!(serviceName == rhs.serviceName))
363	return false;
364	if (__isset.tags != rhs.__isset.tags)
365	return false;
366	else if (__isset.tags && !(tags == rhs.tags))
367	return false;
368	return true;
369	}
370	bool operator != (const Process &rhs) const {
371	return !(*this == rhs);
372	}
373
374	bool operator < (const Process & ) const;
375
376	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
377	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
378
379	virtual void printTo(std::ostream& out) const;
380	};
381
382	void swap(Process &a, Process &b);
383
384	std::ostream& operator<<(std::ostream& out, const Process& obj);
385
386
387	class Batch : public virtual ::apache::thrift::TBase {
388	public:
389
390	Batch(const Batch&);
391	Batch& operator=(const Batch&);
392	Batch() {
393	}
394
395	virtual ~Batch() throw();
396	Process process;
397	std::vector<Span> spans;
398
399	void __set_process(const Process& val);
400
401	void __set_spans(const std::vector<Span> & val);
402
403	bool operator == (const Batch & rhs) const
404	{
405	if (!(process == rhs.process))
406	return false;
407	if (!(spans == rhs.spans))
408	return false;
409	return true;
410	}
411	bool operator != (const Batch &rhs) const {
412	return !(*this == rhs);
413	}
414
415	bool operator < (const Batch & ) const;
416
417	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
418	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
419
420	virtual void printTo(std::ostream& out) const;
421	};
422
423	void swap(Batch &a, Batch &b);
424
425	std::ostream& operator<<(std::ostream& out, const Batch& obj);
426
427
428	class BatchSubmitResponse : public virtual ::apache::thrift::TBase {
429	public:
430
431	BatchSubmitResponse(const BatchSubmitResponse&);
432	BatchSubmitResponse& operator=(const BatchSubmitResponse&);
433	BatchSubmitResponse() : ok(0) {
434	}
435
436	virtual ~BatchSubmitResponse() throw();
437	bool ok;
438
439	void __set_ok(const bool val);
440
441	bool operator == (const BatchSubmitResponse & rhs) const
442	{
443	if (!(ok == rhs.ok))
444	return false;
445	return true;
446	}
447	bool operator != (const BatchSubmitResponse &rhs) const {
448	return !(*this == rhs);
449	}
450
451	bool operator < (const BatchSubmitResponse & ) const;
452
453	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
454	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
455
456	virtual void printTo(std::ostream& out) const;
457	};
458
459	void swap(BatchSubmitResponse &a, BatchSubmitResponse &b);
460
461	std::ostream& operator<<(std::ostream& out, const BatchSubmitResponse& obj);
462
463	}} // namespace
464
465	#endif