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

/**
 * Autogenerated by Thrift Compiler (0.11.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef SamplingManager_H
#define SamplingManager_H

#include <thrift/TDispatchProcessor.h>
#include <thrift/async/TConcurrentClientSyncInfo.h>
#include "sampling_types.h"

namespace jaegertracing { namespace sampling_manager { namespace thrift {

#ifdef _MSC_VER
  #pragma warning( push )
  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
#endif

class SamplingManagerIf {
 public:
  virtual ~SamplingManagerIf() {}
  virtual void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) = 0;
};

class SamplingManagerIfFactory {
 public:
  typedef SamplingManagerIf Handler;

  virtual ~SamplingManagerIfFactory() {}

  virtual SamplingManagerIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  virtual void releaseHandler(SamplingManagerIf* /* handler */) = 0;
};

class SamplingManagerIfSingletonFactory : virtual public SamplingManagerIfFactory {
 public:
  SamplingManagerIfSingletonFactory(const ::std::shared_ptr<SamplingManagerIf>& iface) : iface_(iface) {}
  virtual ~SamplingManagerIfSingletonFactory() {}

  virtual SamplingManagerIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
    return iface_.get();
  }
  virtual void releaseHandler(SamplingManagerIf* /* handler */) {}

 protected:
  ::std::shared_ptr<SamplingManagerIf> iface_;
};

class SamplingManagerNull : virtual public SamplingManagerIf {
 public:
  virtual ~SamplingManagerNull() {}
  void getSamplingStrategy(SamplingStrategyResponse& /* _return */, const std::string& /* serviceName */) {
    return;
  }
};

typedef struct _SamplingManager_getSamplingStrategy_args__isset {
  _SamplingManager_getSamplingStrategy_args__isset() : serviceName(false) {}
  bool serviceName :1;
} _SamplingManager_getSamplingStrategy_args__isset;

class SamplingManager_getSamplingStrategy_args {
 public:

  SamplingManager_getSamplingStrategy_args(const SamplingManager_getSamplingStrategy_args&);
  SamplingManager_getSamplingStrategy_args& operator=(const SamplingManager_getSamplingStrategy_args&);
  SamplingManager_getSamplingStrategy_args() : serviceName() {
  }

  virtual ~SamplingManager_getSamplingStrategy_args() throw();
  std::string serviceName;

  _SamplingManager_getSamplingStrategy_args__isset __isset;

  void __set_serviceName(const std::string& val);

  bool operator == (const SamplingManager_getSamplingStrategy_args & rhs) const
  {
    if (!(serviceName == rhs.serviceName))
      return false;
    return true;
  }
  bool operator != (const SamplingManager_getSamplingStrategy_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SamplingManager_getSamplingStrategy_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class SamplingManager_getSamplingStrategy_pargs {
 public:


  virtual ~SamplingManager_getSamplingStrategy_pargs() throw();
  const std::string* serviceName;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _SamplingManager_getSamplingStrategy_result__isset {
  _SamplingManager_getSamplingStrategy_result__isset() : success(false) {}
  bool success :1;
} _SamplingManager_getSamplingStrategy_result__isset;

class SamplingManager_getSamplingStrategy_result {
 public:

  SamplingManager_getSamplingStrategy_result(const SamplingManager_getSamplingStrategy_result&);
  SamplingManager_getSamplingStrategy_result& operator=(const SamplingManager_getSamplingStrategy_result&);
  SamplingManager_getSamplingStrategy_result() {
  }

  virtual ~SamplingManager_getSamplingStrategy_result() throw();
  SamplingStrategyResponse success;

  _SamplingManager_getSamplingStrategy_result__isset __isset;

  void __set_success(const SamplingStrategyResponse& val);

  bool operator == (const SamplingManager_getSamplingStrategy_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const SamplingManager_getSamplingStrategy_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SamplingManager_getSamplingStrategy_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _SamplingManager_getSamplingStrategy_presult__isset {
  _SamplingManager_getSamplingStrategy_presult__isset() : success(false) {}
  bool success :1;
} _SamplingManager_getSamplingStrategy_presult__isset;

class SamplingManager_getSamplingStrategy_presult {
 public:


  virtual ~SamplingManager_getSamplingStrategy_presult() throw();
  SamplingStrategyResponse* success;

  _SamplingManager_getSamplingStrategy_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

class SamplingManagerClient : virtual public SamplingManagerIf {
 public:
  SamplingManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  SamplingManagerClient(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 getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName);
  void send_getSamplingStrategy(const std::string& serviceName);
  void recv_getSamplingStrategy(SamplingStrategyResponse& _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 SamplingManagerProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  ::std::shared_ptr<SamplingManagerIf> 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 (SamplingManagerProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_getSamplingStrategy(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  SamplingManagerProcessor(::std::shared_ptr<SamplingManagerIf> iface) :
    iface_(iface) {
    processMap_["getSamplingStrategy"] = &SamplingManagerProcessor::process_getSamplingStrategy;
  }

  virtual ~SamplingManagerProcessor() {}
};

class SamplingManagerProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  SamplingManagerProcessorFactory(const ::std::shared_ptr< SamplingManagerIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);

 protected:
  ::std::shared_ptr< SamplingManagerIfFactory > handlerFactory_;
};

class SamplingManagerMultiface : virtual public SamplingManagerIf {
 public:
  SamplingManagerMultiface(std::vector<std::shared_ptr<SamplingManagerIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~SamplingManagerMultiface() {}
 protected:
  std::vector<std::shared_ptr<SamplingManagerIf> > ifaces_;
  SamplingManagerMultiface() {}
  void add(::std::shared_ptr<SamplingManagerIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getSamplingStrategy(_return, serviceName);
    }
    ifaces_[i]->getSamplingStrategy(_return, serviceName);
    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 SamplingManagerConcurrentClient : virtual public SamplingManagerIf {
 public:
  SamplingManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  SamplingManagerConcurrentClient(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 getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName);
  int32_t send_getSamplingStrategy(const std::string& serviceName);
  void recv_getSamplingStrategy(SamplingStrategyResponse& _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
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 SamplingManager_H
	8	#define SamplingManager_H
	9
	10	#include <thrift/TDispatchProcessor.h>
	11	#include <thrift/async/TConcurrentClientSyncInfo.h>
	12	#include "sampling_types.h"
	13
	14	namespace jaegertracing { namespace sampling_manager { 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 SamplingManagerIf {
	22	public:
	23	virtual ~SamplingManagerIf() {}
	24	virtual void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) = 0;
	25	};
	26
	27	class SamplingManagerIfFactory {
	28	public:
	29	typedef SamplingManagerIf Handler;
	30
	31	virtual ~SamplingManagerIfFactory() {}
	32
	33	virtual SamplingManagerIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
	34	virtual void releaseHandler(SamplingManagerIf* /* handler */) = 0;
	35	};
	36
	37	class SamplingManagerIfSingletonFactory : virtual public SamplingManagerIfFactory {
	38	public:
	39	SamplingManagerIfSingletonFactory(const ::std::shared_ptr<SamplingManagerIf>& iface) : iface_(iface) {}
	40	virtual ~SamplingManagerIfSingletonFactory() {}
	41
	42	virtual SamplingManagerIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
	43	return iface_.get();
	44	}
	45	virtual void releaseHandler(SamplingManagerIf* /* handler */) {}
	46
	47	protected:
	48	::std::shared_ptr<SamplingManagerIf> iface_;
	49	};
	50
	51	class SamplingManagerNull : virtual public SamplingManagerIf {
	52	public:
	53	virtual ~SamplingManagerNull() {}
	54	void getSamplingStrategy(SamplingStrategyResponse& /* _return /, const std::string& / serviceName */) {
	55	return;
	56	}
	57	};
	58
	59	typedef struct _SamplingManager_getSamplingStrategy_args__isset {
	60	_SamplingManager_getSamplingStrategy_args__isset() : serviceName(false) {}
	61	bool serviceName :1;
	62	} _SamplingManager_getSamplingStrategy_args__isset;
	63
	64	class SamplingManager_getSamplingStrategy_args {
65	public:
66
67	SamplingManager_getSamplingStrategy_args(const SamplingManager_getSamplingStrategy_args&);
68	SamplingManager_getSamplingStrategy_args& operator=(const SamplingManager_getSamplingStrategy_args&);
69	SamplingManager_getSamplingStrategy_args() : serviceName() {
70	}
71
72	virtual ~SamplingManager_getSamplingStrategy_args() throw();
73	std::string serviceName;
74
75	_SamplingManager_getSamplingStrategy_args__isset __isset;
76
77	void __set_serviceName(const std::string& val);
78
79	bool operator == (const SamplingManager_getSamplingStrategy_args & rhs) const
80	{
81	if (!(serviceName == rhs.serviceName))
82	return false;
83	return true;
84	}
85	bool operator != (const SamplingManager_getSamplingStrategy_args &rhs) const {
86	return !(*this == rhs);
87	}
88
89	bool operator < (const SamplingManager_getSamplingStrategy_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 SamplingManager_getSamplingStrategy_pargs {
98	public:
99
100
101	virtual ~SamplingManager_getSamplingStrategy_pargs() throw();
102	const std::string* serviceName;
103
104	uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
105
106	};
107
108	typedef struct _SamplingManager_getSamplingStrategy_result__isset {
109	_SamplingManager_getSamplingStrategy_result__isset() : success(false) {}
110	bool success :1;
111	} _SamplingManager_getSamplingStrategy_result__isset;
112
113	class SamplingManager_getSamplingStrategy_result {
114	public:
115
116	SamplingManager_getSamplingStrategy_result(const SamplingManager_getSamplingStrategy_result&);
117	SamplingManager_getSamplingStrategy_result& operator=(const SamplingManager_getSamplingStrategy_result&);
118	SamplingManager_getSamplingStrategy_result() {
119	}
120
121	virtual ~SamplingManager_getSamplingStrategy_result() throw();
122	SamplingStrategyResponse success;
123
124	_SamplingManager_getSamplingStrategy_result__isset __isset;
125
126	void __set_success(const SamplingStrategyResponse& val);
127
128	bool operator == (const SamplingManager_getSamplingStrategy_result & rhs) const
129	{
130	if (!(success == rhs.success))
131	return false;
132	return true;
133	}
134	bool operator != (const SamplingManager_getSamplingStrategy_result &rhs) const {
135	return !(*this == rhs);
136	}
137
138	bool operator < (const SamplingManager_getSamplingStrategy_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 _SamplingManager_getSamplingStrategy_presult__isset {
146	_SamplingManager_getSamplingStrategy_presult__isset() : success(false) {}
147	bool success :1;
148	} _SamplingManager_getSamplingStrategy_presult__isset;
149
150	class SamplingManager_getSamplingStrategy_presult {
151	public:
152
153
154	virtual ~SamplingManager_getSamplingStrategy_presult() throw();
155	SamplingStrategyResponse* success;
156
157	_SamplingManager_getSamplingStrategy_presult__isset __isset;
158
159	uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
160
161	};
162
163	class SamplingManagerClient : virtual public SamplingManagerIf {
164	public:
165	SamplingManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
166	setProtocol(prot);
167	}
168	SamplingManagerClient(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 getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName);
189	void send_getSamplingStrategy(const std::string& serviceName);
190	void recv_getSamplingStrategy(SamplingStrategyResponse& _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 SamplingManagerProcessor : public ::apache::thrift::TDispatchProcessor {
199	protected:
200	::std::shared_ptr<SamplingManagerIf> 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 (SamplingManagerProcessor::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_getSamplingStrategy(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
207	public:
208	SamplingManagerProcessor(::std::shared_ptr<SamplingManagerIf> iface) :
209	iface_(iface) {
210	processMap_["getSamplingStrategy"] = &SamplingManagerProcessor::process_getSamplingStrategy;
211	}
212
213	virtual ~SamplingManagerProcessor() {}
214	};
215
216	class SamplingManagerProcessorFactory : public ::apache::thrift::TProcessorFactory {
217	public:
218	SamplingManagerProcessorFactory(const ::std::shared_ptr< SamplingManagerIfFactory >& 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< SamplingManagerIfFactory > handlerFactory_;
225	};
226
227	class SamplingManagerMultiface : virtual public SamplingManagerIf {
228	public:
229	SamplingManagerMultiface(std::vector<std::shared_ptr<SamplingManagerIf> >& ifaces) : ifaces_(ifaces) {
230	}
231	virtual ~SamplingManagerMultiface() {}
232	protected:
233	std::vector<std::shared_ptr<SamplingManagerIf> > ifaces_;
234	SamplingManagerMultiface() {}
235	void add(::std::shared_ptr<SamplingManagerIf> iface) {
236	ifaces_.push_back(iface);
237	}
238	public:
239	void getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName) {
240	size_t sz = ifaces_.size();
241	size_t i = 0;
242	for (; i < (sz - 1); ++i) {
243	ifaces_[i]->getSamplingStrategy(_return, serviceName);
244	}
245	ifaces_[i]->getSamplingStrategy(_return, serviceName);
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 SamplingManagerConcurrentClient : virtual public SamplingManagerIf {
255	public:
256	SamplingManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
257	setProtocol(prot);
258	}
259	SamplingManagerConcurrentClient(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 getSamplingStrategy(SamplingStrategyResponse& _return, const std::string& serviceName);
280	int32_t send_getSamplingStrategy(const std::string& serviceName);
281	void recv_getSamplingStrategy(SamplingStrategyResponse& _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