Line data Source code
1 : // Generated by the protocol buffer compiler. DO NOT EDIT!
2 : // source: test/cpp/qps/qpstest.proto
3 :
4 : #ifndef PROTOBUF_test_2fcpp_2fqps_2fqpstest_2eproto__INCLUDED
5 : #define PROTOBUF_test_2fcpp_2fqps_2fqpstest_2eproto__INCLUDED
6 :
7 : #include <string>
8 :
9 : #include <google/protobuf/stubs/common.h>
10 :
11 : #if GOOGLE_PROTOBUF_VERSION < 3000000
12 : #error This file was generated by a newer version of protoc which is
13 : #error incompatible with your Protocol Buffer headers. Please update
14 : #error your headers.
15 : #endif
16 : #if 3000000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17 : #error This file was generated by an older version of protoc which is
18 : #error incompatible with your Protocol Buffer headers. Please
19 : #error regenerate this file with a newer version of protoc.
20 : #endif
21 :
22 : #include <google/protobuf/arena.h>
23 : #include <google/protobuf/arenastring.h>
24 : #include <google/protobuf/generated_message_util.h>
25 : #include <google/protobuf/metadata.h>
26 : #include <google/protobuf/message.h>
27 : #include <google/protobuf/repeated_field.h>
28 : #include <google/protobuf/extension_set.h>
29 : #include <google/protobuf/generated_enum_reflection.h>
30 : #include <google/protobuf/unknown_field_set.h>
31 : // @@protoc_insertion_point(includes)
32 :
33 : namespace grpc {
34 : namespace testing {
35 :
36 : // Internal implementation detail -- do not call these.
37 : void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
38 : void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
39 : void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
40 :
41 : class ClientArgs;
42 : class ClientConfig;
43 : class ClientStats;
44 : class ClientStatus;
45 : class DeterministicParams;
46 : class HistogramData;
47 : class LoadParams;
48 : class Mark;
49 : class ParetoParams;
50 : class Payload;
51 : class PoissonParams;
52 : class ServerArgs;
53 : class ServerConfig;
54 : class ServerStats;
55 : class ServerStatus;
56 : class SimpleRequest;
57 : class SimpleResponse;
58 : class StatsRequest;
59 : class UniformParams;
60 :
61 : enum PayloadType {
62 : COMPRESSABLE = 0,
63 : UNCOMPRESSABLE = 1,
64 : RANDOM = 2,
65 : PayloadType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
66 : PayloadType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
67 : };
68 : bool PayloadType_IsValid(int value);
69 : const PayloadType PayloadType_MIN = COMPRESSABLE;
70 : const PayloadType PayloadType_MAX = RANDOM;
71 : const int PayloadType_ARRAYSIZE = PayloadType_MAX + 1;
72 :
73 : const ::google::protobuf::EnumDescriptor* PayloadType_descriptor();
74 : inline const ::std::string& PayloadType_Name(PayloadType value) {
75 : return ::google::protobuf::internal::NameOfEnum(
76 : PayloadType_descriptor(), value);
77 : }
78 : inline bool PayloadType_Parse(
79 : const ::std::string& name, PayloadType* value) {
80 : return ::google::protobuf::internal::ParseNamedEnum<PayloadType>(
81 : PayloadType_descriptor(), name, value);
82 : }
83 : enum ClientType {
84 : SYNCHRONOUS_CLIENT = 0,
85 : ASYNC_CLIENT = 1,
86 : ClientType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
87 : ClientType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
88 : };
89 : bool ClientType_IsValid(int value);
90 : const ClientType ClientType_MIN = SYNCHRONOUS_CLIENT;
91 : const ClientType ClientType_MAX = ASYNC_CLIENT;
92 : const int ClientType_ARRAYSIZE = ClientType_MAX + 1;
93 :
94 : const ::google::protobuf::EnumDescriptor* ClientType_descriptor();
95 : inline const ::std::string& ClientType_Name(ClientType value) {
96 : return ::google::protobuf::internal::NameOfEnum(
97 : ClientType_descriptor(), value);
98 : }
99 : inline bool ClientType_Parse(
100 : const ::std::string& name, ClientType* value) {
101 : return ::google::protobuf::internal::ParseNamedEnum<ClientType>(
102 : ClientType_descriptor(), name, value);
103 : }
104 : enum ServerType {
105 : SYNCHRONOUS_SERVER = 0,
106 : ASYNC_SERVER = 1,
107 : ServerType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
108 : ServerType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
109 : };
110 : bool ServerType_IsValid(int value);
111 : const ServerType ServerType_MIN = SYNCHRONOUS_SERVER;
112 : const ServerType ServerType_MAX = ASYNC_SERVER;
113 : const int ServerType_ARRAYSIZE = ServerType_MAX + 1;
114 :
115 : const ::google::protobuf::EnumDescriptor* ServerType_descriptor();
116 : inline const ::std::string& ServerType_Name(ServerType value) {
117 : return ::google::protobuf::internal::NameOfEnum(
118 : ServerType_descriptor(), value);
119 : }
120 : inline bool ServerType_Parse(
121 : const ::std::string& name, ServerType* value) {
122 : return ::google::protobuf::internal::ParseNamedEnum<ServerType>(
123 : ServerType_descriptor(), name, value);
124 : }
125 : enum RpcType {
126 : UNARY = 0,
127 : STREAMING = 1,
128 : RpcType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
129 : RpcType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
130 : };
131 : bool RpcType_IsValid(int value);
132 : const RpcType RpcType_MIN = UNARY;
133 : const RpcType RpcType_MAX = STREAMING;
134 : const int RpcType_ARRAYSIZE = RpcType_MAX + 1;
135 :
136 : const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
137 : inline const ::std::string& RpcType_Name(RpcType value) {
138 : return ::google::protobuf::internal::NameOfEnum(
139 : RpcType_descriptor(), value);
140 : }
141 : inline bool RpcType_Parse(
142 : const ::std::string& name, RpcType* value) {
143 : return ::google::protobuf::internal::ParseNamedEnum<RpcType>(
144 : RpcType_descriptor(), name, value);
145 : }
146 : enum LoadType {
147 : CLOSED_LOOP = 0,
148 : POISSON = 1,
149 : UNIFORM = 2,
150 : DETERMINISTIC = 3,
151 : PARETO = 4,
152 : LoadType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
153 : LoadType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
154 : };
155 : bool LoadType_IsValid(int value);
156 : const LoadType LoadType_MIN = CLOSED_LOOP;
157 : const LoadType LoadType_MAX = PARETO;
158 : const int LoadType_ARRAYSIZE = LoadType_MAX + 1;
159 :
160 : const ::google::protobuf::EnumDescriptor* LoadType_descriptor();
161 : inline const ::std::string& LoadType_Name(LoadType value) {
162 : return ::google::protobuf::internal::NameOfEnum(
163 : LoadType_descriptor(), value);
164 : }
165 : inline bool LoadType_Parse(
166 : const ::std::string& name, LoadType* value) {
167 : return ::google::protobuf::internal::ParseNamedEnum<LoadType>(
168 : LoadType_descriptor(), name, value);
169 : }
170 : // ===================================================================
171 :
172 : class StatsRequest : public ::google::protobuf::Message {
173 : public:
174 : StatsRequest();
175 : virtual ~StatsRequest();
176 :
177 : StatsRequest(const StatsRequest& from);
178 :
179 : inline StatsRequest& operator=(const StatsRequest& from) {
180 : CopyFrom(from);
181 : return *this;
182 : }
183 :
184 : static const ::google::protobuf::Descriptor* descriptor();
185 : static const StatsRequest& default_instance();
186 :
187 : void Swap(StatsRequest* other);
188 :
189 : // implements Message ----------------------------------------------
190 :
191 0 : inline StatsRequest* New() const { return New(NULL); }
192 :
193 : StatsRequest* New(::google::protobuf::Arena* arena) const;
194 : void CopyFrom(const ::google::protobuf::Message& from);
195 : void MergeFrom(const ::google::protobuf::Message& from);
196 : void CopyFrom(const StatsRequest& from);
197 : void MergeFrom(const StatsRequest& from);
198 : void Clear();
199 : bool IsInitialized() const;
200 :
201 : int ByteSize() const;
202 : bool MergePartialFromCodedStream(
203 : ::google::protobuf::io::CodedInputStream* input);
204 : void SerializeWithCachedSizes(
205 : ::google::protobuf::io::CodedOutputStream* output) const;
206 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
207 0 : int GetCachedSize() const { return _cached_size_; }
208 : private:
209 : void SharedCtor();
210 : void SharedDtor();
211 : void SetCachedSize(int size) const;
212 : void InternalSwap(StatsRequest* other);
213 : private:
214 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
215 : return _internal_metadata_.arena();
216 : }
217 : inline void* MaybeArenaPtr() const {
218 : return _internal_metadata_.raw_arena_ptr();
219 : }
220 : public:
221 :
222 : ::google::protobuf::Metadata GetMetadata() const;
223 :
224 : // nested types ----------------------------------------------------
225 :
226 : // accessors -------------------------------------------------------
227 :
228 : // optional int32 test_num = 1;
229 : void clear_test_num();
230 : static const int kTestNumFieldNumber = 1;
231 : ::google::protobuf::int32 test_num() const;
232 : void set_test_num(::google::protobuf::int32 value);
233 :
234 : // @@protoc_insertion_point(class_scope:grpc.testing.StatsRequest)
235 : private:
236 :
237 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
238 : bool _is_default_instance_;
239 : ::google::protobuf::int32 test_num_;
240 : mutable int _cached_size_;
241 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
242 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
243 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
244 :
245 : void InitAsDefaultInstance();
246 : static StatsRequest* default_instance_;
247 : };
248 : // -------------------------------------------------------------------
249 :
250 : class ServerStats : public ::google::protobuf::Message {
251 : public:
252 : ServerStats();
253 : virtual ~ServerStats();
254 :
255 : ServerStats(const ServerStats& from);
256 :
257 12 : inline ServerStats& operator=(const ServerStats& from) {
258 12 : CopyFrom(from);
259 12 : return *this;
260 : }
261 :
262 : static const ::google::protobuf::Descriptor* descriptor();
263 : static const ServerStats& default_instance();
264 :
265 : void Swap(ServerStats* other);
266 :
267 : // implements Message ----------------------------------------------
268 :
269 0 : inline ServerStats* New() const { return New(NULL); }
270 :
271 : ServerStats* New(::google::protobuf::Arena* arena) const;
272 : void CopyFrom(const ::google::protobuf::Message& from);
273 : void MergeFrom(const ::google::protobuf::Message& from);
274 : void CopyFrom(const ServerStats& from);
275 : void MergeFrom(const ServerStats& from);
276 : void Clear();
277 : bool IsInitialized() const;
278 :
279 : int ByteSize() const;
280 : bool MergePartialFromCodedStream(
281 : ::google::protobuf::io::CodedInputStream* input);
282 : void SerializeWithCachedSizes(
283 : ::google::protobuf::io::CodedOutputStream* output) const;
284 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
285 12 : int GetCachedSize() const { return _cached_size_; }
286 : private:
287 : void SharedCtor();
288 : void SharedDtor();
289 : void SetCachedSize(int size) const;
290 : void InternalSwap(ServerStats* other);
291 : private:
292 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
293 : return _internal_metadata_.arena();
294 : }
295 : inline void* MaybeArenaPtr() const {
296 : return _internal_metadata_.raw_arena_ptr();
297 : }
298 : public:
299 :
300 : ::google::protobuf::Metadata GetMetadata() const;
301 :
302 : // nested types ----------------------------------------------------
303 :
304 : // accessors -------------------------------------------------------
305 :
306 : // optional double time_elapsed = 1;
307 : void clear_time_elapsed();
308 : static const int kTimeElapsedFieldNumber = 1;
309 : double time_elapsed() const;
310 : void set_time_elapsed(double value);
311 :
312 : // optional double time_user = 2;
313 : void clear_time_user();
314 : static const int kTimeUserFieldNumber = 2;
315 : double time_user() const;
316 : void set_time_user(double value);
317 :
318 : // optional double time_system = 3;
319 : void clear_time_system();
320 : static const int kTimeSystemFieldNumber = 3;
321 : double time_system() const;
322 : void set_time_system(double value);
323 :
324 : // @@protoc_insertion_point(class_scope:grpc.testing.ServerStats)
325 : private:
326 :
327 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
328 : bool _is_default_instance_;
329 : double time_elapsed_;
330 : double time_user_;
331 : double time_system_;
332 : mutable int _cached_size_;
333 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
334 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
335 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
336 :
337 : void InitAsDefaultInstance();
338 : static ServerStats* default_instance_;
339 : };
340 : // -------------------------------------------------------------------
341 :
342 : class Payload : public ::google::protobuf::Message {
343 : public:
344 : Payload();
345 : virtual ~Payload();
346 :
347 : Payload(const Payload& from);
348 :
349 : inline Payload& operator=(const Payload& from) {
350 : CopyFrom(from);
351 : return *this;
352 : }
353 :
354 : static const ::google::protobuf::Descriptor* descriptor();
355 : static const Payload& default_instance();
356 :
357 : void Swap(Payload* other);
358 :
359 : // implements Message ----------------------------------------------
360 :
361 0 : inline Payload* New() const { return New(NULL); }
362 :
363 : Payload* New(::google::protobuf::Arena* arena) const;
364 : void CopyFrom(const ::google::protobuf::Message& from);
365 : void MergeFrom(const ::google::protobuf::Message& from);
366 : void CopyFrom(const Payload& from);
367 : void MergeFrom(const Payload& from);
368 : void Clear();
369 : bool IsInitialized() const;
370 :
371 : int ByteSize() const;
372 : bool MergePartialFromCodedStream(
373 : ::google::protobuf::io::CodedInputStream* input);
374 : void SerializeWithCachedSizes(
375 : ::google::protobuf::io::CodedOutputStream* output) const;
376 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
377 1277440 : int GetCachedSize() const { return _cached_size_; }
378 : private:
379 : void SharedCtor();
380 : void SharedDtor();
381 : void SetCachedSize(int size) const;
382 : void InternalSwap(Payload* other);
383 : private:
384 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
385 : return _internal_metadata_.arena();
386 : }
387 : inline void* MaybeArenaPtr() const {
388 : return _internal_metadata_.raw_arena_ptr();
389 : }
390 : public:
391 :
392 : ::google::protobuf::Metadata GetMetadata() const;
393 :
394 : // nested types ----------------------------------------------------
395 :
396 : // accessors -------------------------------------------------------
397 :
398 : // optional .grpc.testing.PayloadType type = 1;
399 : void clear_type();
400 : static const int kTypeFieldNumber = 1;
401 : ::grpc::testing::PayloadType type() const;
402 : void set_type(::grpc::testing::PayloadType value);
403 :
404 : // optional bytes body = 2;
405 : void clear_body();
406 : static const int kBodyFieldNumber = 2;
407 : const ::std::string& body() const;
408 : void set_body(const ::std::string& value);
409 : void set_body(const char* value);
410 : void set_body(const void* value, size_t size);
411 : ::std::string* mutable_body();
412 : ::std::string* release_body();
413 : void set_allocated_body(::std::string* body);
414 :
415 : // @@protoc_insertion_point(class_scope:grpc.testing.Payload)
416 : private:
417 :
418 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
419 : bool _is_default_instance_;
420 : ::google::protobuf::internal::ArenaStringPtr body_;
421 : int type_;
422 : mutable int _cached_size_;
423 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
424 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
425 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
426 :
427 : void InitAsDefaultInstance();
428 : static Payload* default_instance_;
429 : };
430 : // -------------------------------------------------------------------
431 :
432 : class HistogramData : public ::google::protobuf::Message {
433 : public:
434 : HistogramData();
435 : virtual ~HistogramData();
436 :
437 : HistogramData(const HistogramData& from);
438 :
439 : inline HistogramData& operator=(const HistogramData& from) {
440 : CopyFrom(from);
441 : return *this;
442 : }
443 :
444 : static const ::google::protobuf::Descriptor* descriptor();
445 : static const HistogramData& default_instance();
446 :
447 : void Swap(HistogramData* other);
448 :
449 : // implements Message ----------------------------------------------
450 :
451 0 : inline HistogramData* New() const { return New(NULL); }
452 :
453 : HistogramData* New(::google::protobuf::Arena* arena) const;
454 : void CopyFrom(const ::google::protobuf::Message& from);
455 : void MergeFrom(const ::google::protobuf::Message& from);
456 : void CopyFrom(const HistogramData& from);
457 : void MergeFrom(const HistogramData& from);
458 : void Clear();
459 : bool IsInitialized() const;
460 :
461 : int ByteSize() const;
462 : bool MergePartialFromCodedStream(
463 : ::google::protobuf::io::CodedInputStream* input);
464 : void SerializeWithCachedSizes(
465 : ::google::protobuf::io::CodedOutputStream* output) const;
466 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
467 12 : int GetCachedSize() const { return _cached_size_; }
468 : private:
469 : void SharedCtor();
470 : void SharedDtor();
471 : void SetCachedSize(int size) const;
472 : void InternalSwap(HistogramData* other);
473 : private:
474 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
475 : return _internal_metadata_.arena();
476 : }
477 : inline void* MaybeArenaPtr() const {
478 : return _internal_metadata_.raw_arena_ptr();
479 : }
480 : public:
481 :
482 : ::google::protobuf::Metadata GetMetadata() const;
483 :
484 : // nested types ----------------------------------------------------
485 :
486 : // accessors -------------------------------------------------------
487 :
488 : // repeated uint32 bucket = 1;
489 : int bucket_size() const;
490 : void clear_bucket();
491 : static const int kBucketFieldNumber = 1;
492 : ::google::protobuf::uint32 bucket(int index) const;
493 : void set_bucket(int index, ::google::protobuf::uint32 value);
494 : void add_bucket(::google::protobuf::uint32 value);
495 : const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
496 : bucket() const;
497 : ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
498 : mutable_bucket();
499 :
500 : // optional double min_seen = 2;
501 : void clear_min_seen();
502 : static const int kMinSeenFieldNumber = 2;
503 : double min_seen() const;
504 : void set_min_seen(double value);
505 :
506 : // optional double max_seen = 3;
507 : void clear_max_seen();
508 : static const int kMaxSeenFieldNumber = 3;
509 : double max_seen() const;
510 : void set_max_seen(double value);
511 :
512 : // optional double sum = 4;
513 : void clear_sum();
514 : static const int kSumFieldNumber = 4;
515 : double sum() const;
516 : void set_sum(double value);
517 :
518 : // optional double sum_of_squares = 5;
519 : void clear_sum_of_squares();
520 : static const int kSumOfSquaresFieldNumber = 5;
521 : double sum_of_squares() const;
522 : void set_sum_of_squares(double value);
523 :
524 : // optional double count = 6;
525 : void clear_count();
526 : static const int kCountFieldNumber = 6;
527 : double count() const;
528 : void set_count(double value);
529 :
530 : // @@protoc_insertion_point(class_scope:grpc.testing.HistogramData)
531 : private:
532 :
533 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
534 : bool _is_default_instance_;
535 : ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > bucket_;
536 : mutable int _bucket_cached_byte_size_;
537 : double min_seen_;
538 : double max_seen_;
539 : double sum_;
540 : double sum_of_squares_;
541 : double count_;
542 : mutable int _cached_size_;
543 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
544 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
545 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
546 :
547 : void InitAsDefaultInstance();
548 : static HistogramData* default_instance_;
549 : };
550 : // -------------------------------------------------------------------
551 :
552 : class PoissonParams : public ::google::protobuf::Message {
553 : public:
554 : PoissonParams();
555 : virtual ~PoissonParams();
556 :
557 : PoissonParams(const PoissonParams& from);
558 :
559 : inline PoissonParams& operator=(const PoissonParams& from) {
560 : CopyFrom(from);
561 : return *this;
562 : }
563 :
564 : static const ::google::protobuf::Descriptor* descriptor();
565 : static const PoissonParams& default_instance();
566 :
567 : void Swap(PoissonParams* other);
568 :
569 : // implements Message ----------------------------------------------
570 :
571 0 : inline PoissonParams* New() const { return New(NULL); }
572 :
573 : PoissonParams* New(::google::protobuf::Arena* arena) const;
574 : void CopyFrom(const ::google::protobuf::Message& from);
575 : void MergeFrom(const ::google::protobuf::Message& from);
576 : void CopyFrom(const PoissonParams& from);
577 : void MergeFrom(const PoissonParams& from);
578 : void Clear();
579 : bool IsInitialized() const;
580 :
581 : int ByteSize() const;
582 : bool MergePartialFromCodedStream(
583 : ::google::protobuf::io::CodedInputStream* input);
584 : void SerializeWithCachedSizes(
585 : ::google::protobuf::io::CodedOutputStream* output) const;
586 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
587 1 : int GetCachedSize() const { return _cached_size_; }
588 : private:
589 : void SharedCtor();
590 : void SharedDtor();
591 : void SetCachedSize(int size) const;
592 : void InternalSwap(PoissonParams* other);
593 : private:
594 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
595 : return _internal_metadata_.arena();
596 : }
597 : inline void* MaybeArenaPtr() const {
598 : return _internal_metadata_.raw_arena_ptr();
599 : }
600 : public:
601 :
602 : ::google::protobuf::Metadata GetMetadata() const;
603 :
604 : // nested types ----------------------------------------------------
605 :
606 : // accessors -------------------------------------------------------
607 :
608 : // optional double offered_load = 1;
609 : void clear_offered_load();
610 : static const int kOfferedLoadFieldNumber = 1;
611 : double offered_load() const;
612 : void set_offered_load(double value);
613 :
614 : // @@protoc_insertion_point(class_scope:grpc.testing.PoissonParams)
615 : private:
616 :
617 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
618 : bool _is_default_instance_;
619 : double offered_load_;
620 : mutable int _cached_size_;
621 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
622 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
623 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
624 :
625 : void InitAsDefaultInstance();
626 : static PoissonParams* default_instance_;
627 : };
628 : // -------------------------------------------------------------------
629 :
630 : class UniformParams : public ::google::protobuf::Message {
631 : public:
632 : UniformParams();
633 : virtual ~UniformParams();
634 :
635 : UniformParams(const UniformParams& from);
636 :
637 : inline UniformParams& operator=(const UniformParams& from) {
638 : CopyFrom(from);
639 : return *this;
640 : }
641 :
642 : static const ::google::protobuf::Descriptor* descriptor();
643 : static const UniformParams& default_instance();
644 :
645 : void Swap(UniformParams* other);
646 :
647 : // implements Message ----------------------------------------------
648 :
649 0 : inline UniformParams* New() const { return New(NULL); }
650 :
651 : UniformParams* New(::google::protobuf::Arena* arena) const;
652 : void CopyFrom(const ::google::protobuf::Message& from);
653 : void MergeFrom(const ::google::protobuf::Message& from);
654 : void CopyFrom(const UniformParams& from);
655 : void MergeFrom(const UniformParams& from);
656 : void Clear();
657 : bool IsInitialized() const;
658 :
659 : int ByteSize() const;
660 : bool MergePartialFromCodedStream(
661 : ::google::protobuf::io::CodedInputStream* input);
662 : void SerializeWithCachedSizes(
663 : ::google::protobuf::io::CodedOutputStream* output) const;
664 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
665 0 : int GetCachedSize() const { return _cached_size_; }
666 : private:
667 : void SharedCtor();
668 : void SharedDtor();
669 : void SetCachedSize(int size) const;
670 : void InternalSwap(UniformParams* other);
671 : private:
672 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
673 : return _internal_metadata_.arena();
674 : }
675 : inline void* MaybeArenaPtr() const {
676 : return _internal_metadata_.raw_arena_ptr();
677 : }
678 : public:
679 :
680 : ::google::protobuf::Metadata GetMetadata() const;
681 :
682 : // nested types ----------------------------------------------------
683 :
684 : // accessors -------------------------------------------------------
685 :
686 : // optional double interarrival_lo = 1;
687 : void clear_interarrival_lo();
688 : static const int kInterarrivalLoFieldNumber = 1;
689 : double interarrival_lo() const;
690 : void set_interarrival_lo(double value);
691 :
692 : // optional double interarrival_hi = 2;
693 : void clear_interarrival_hi();
694 : static const int kInterarrivalHiFieldNumber = 2;
695 : double interarrival_hi() const;
696 : void set_interarrival_hi(double value);
697 :
698 : // @@protoc_insertion_point(class_scope:grpc.testing.UniformParams)
699 : private:
700 :
701 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
702 : bool _is_default_instance_;
703 : double interarrival_lo_;
704 : double interarrival_hi_;
705 : mutable int _cached_size_;
706 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
707 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
708 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
709 :
710 : void InitAsDefaultInstance();
711 : static UniformParams* default_instance_;
712 : };
713 : // -------------------------------------------------------------------
714 :
715 : class DeterministicParams : public ::google::protobuf::Message {
716 : public:
717 : DeterministicParams();
718 : virtual ~DeterministicParams();
719 :
720 : DeterministicParams(const DeterministicParams& from);
721 :
722 : inline DeterministicParams& operator=(const DeterministicParams& from) {
723 : CopyFrom(from);
724 : return *this;
725 : }
726 :
727 : static const ::google::protobuf::Descriptor* descriptor();
728 : static const DeterministicParams& default_instance();
729 :
730 : void Swap(DeterministicParams* other);
731 :
732 : // implements Message ----------------------------------------------
733 :
734 0 : inline DeterministicParams* New() const { return New(NULL); }
735 :
736 : DeterministicParams* New(::google::protobuf::Arena* arena) const;
737 : void CopyFrom(const ::google::protobuf::Message& from);
738 : void MergeFrom(const ::google::protobuf::Message& from);
739 : void CopyFrom(const DeterministicParams& from);
740 : void MergeFrom(const DeterministicParams& from);
741 : void Clear();
742 : bool IsInitialized() const;
743 :
744 : int ByteSize() const;
745 : bool MergePartialFromCodedStream(
746 : ::google::protobuf::io::CodedInputStream* input);
747 : void SerializeWithCachedSizes(
748 : ::google::protobuf::io::CodedOutputStream* output) const;
749 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
750 0 : int GetCachedSize() const { return _cached_size_; }
751 : private:
752 : void SharedCtor();
753 : void SharedDtor();
754 : void SetCachedSize(int size) const;
755 : void InternalSwap(DeterministicParams* other);
756 : private:
757 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
758 : return _internal_metadata_.arena();
759 : }
760 : inline void* MaybeArenaPtr() const {
761 : return _internal_metadata_.raw_arena_ptr();
762 : }
763 : public:
764 :
765 : ::google::protobuf::Metadata GetMetadata() const;
766 :
767 : // nested types ----------------------------------------------------
768 :
769 : // accessors -------------------------------------------------------
770 :
771 : // optional double offered_load = 1;
772 : void clear_offered_load();
773 : static const int kOfferedLoadFieldNumber = 1;
774 : double offered_load() const;
775 : void set_offered_load(double value);
776 :
777 : // @@protoc_insertion_point(class_scope:grpc.testing.DeterministicParams)
778 : private:
779 :
780 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
781 : bool _is_default_instance_;
782 : double offered_load_;
783 : mutable int _cached_size_;
784 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
785 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
786 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
787 :
788 : void InitAsDefaultInstance();
789 : static DeterministicParams* default_instance_;
790 : };
791 : // -------------------------------------------------------------------
792 :
793 : class ParetoParams : public ::google::protobuf::Message {
794 : public:
795 : ParetoParams();
796 : virtual ~ParetoParams();
797 :
798 : ParetoParams(const ParetoParams& from);
799 :
800 : inline ParetoParams& operator=(const ParetoParams& from) {
801 : CopyFrom(from);
802 : return *this;
803 : }
804 :
805 : static const ::google::protobuf::Descriptor* descriptor();
806 : static const ParetoParams& default_instance();
807 :
808 : void Swap(ParetoParams* other);
809 :
810 : // implements Message ----------------------------------------------
811 :
812 0 : inline ParetoParams* New() const { return New(NULL); }
813 :
814 : ParetoParams* New(::google::protobuf::Arena* arena) const;
815 : void CopyFrom(const ::google::protobuf::Message& from);
816 : void MergeFrom(const ::google::protobuf::Message& from);
817 : void CopyFrom(const ParetoParams& from);
818 : void MergeFrom(const ParetoParams& from);
819 : void Clear();
820 : bool IsInitialized() const;
821 :
822 : int ByteSize() const;
823 : bool MergePartialFromCodedStream(
824 : ::google::protobuf::io::CodedInputStream* input);
825 : void SerializeWithCachedSizes(
826 : ::google::protobuf::io::CodedOutputStream* output) const;
827 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
828 0 : int GetCachedSize() const { return _cached_size_; }
829 : private:
830 : void SharedCtor();
831 : void SharedDtor();
832 : void SetCachedSize(int size) const;
833 : void InternalSwap(ParetoParams* other);
834 : private:
835 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
836 : return _internal_metadata_.arena();
837 : }
838 : inline void* MaybeArenaPtr() const {
839 : return _internal_metadata_.raw_arena_ptr();
840 : }
841 : public:
842 :
843 : ::google::protobuf::Metadata GetMetadata() const;
844 :
845 : // nested types ----------------------------------------------------
846 :
847 : // accessors -------------------------------------------------------
848 :
849 : // optional double interarrival_base = 1;
850 : void clear_interarrival_base();
851 : static const int kInterarrivalBaseFieldNumber = 1;
852 : double interarrival_base() const;
853 : void set_interarrival_base(double value);
854 :
855 : // optional double alpha = 2;
856 : void clear_alpha();
857 : static const int kAlphaFieldNumber = 2;
858 : double alpha() const;
859 : void set_alpha(double value);
860 :
861 : // @@protoc_insertion_point(class_scope:grpc.testing.ParetoParams)
862 : private:
863 :
864 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
865 : bool _is_default_instance_;
866 : double interarrival_base_;
867 : double alpha_;
868 : mutable int _cached_size_;
869 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
870 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
871 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
872 :
873 : void InitAsDefaultInstance();
874 : static ParetoParams* default_instance_;
875 : };
876 : // -------------------------------------------------------------------
877 :
878 : class LoadParams : public ::google::protobuf::Message {
879 : public:
880 : LoadParams();
881 : virtual ~LoadParams();
882 :
883 : LoadParams(const LoadParams& from);
884 :
885 : inline LoadParams& operator=(const LoadParams& from) {
886 : CopyFrom(from);
887 : return *this;
888 : }
889 :
890 : static const ::google::protobuf::Descriptor* descriptor();
891 : static const LoadParams& default_instance();
892 :
893 : enum LoadCase {
894 : kPoisson = 1,
895 : kUniform = 2,
896 : kDeterm = 3,
897 : kPareto = 4,
898 : LOAD_NOT_SET = 0,
899 : };
900 :
901 : void Swap(LoadParams* other);
902 :
903 : // implements Message ----------------------------------------------
904 :
905 0 : inline LoadParams* New() const { return New(NULL); }
906 :
907 : LoadParams* New(::google::protobuf::Arena* arena) const;
908 : void CopyFrom(const ::google::protobuf::Message& from);
909 : void MergeFrom(const ::google::protobuf::Message& from);
910 : void CopyFrom(const LoadParams& from);
911 : void MergeFrom(const LoadParams& from);
912 : void Clear();
913 : bool IsInitialized() const;
914 :
915 : int ByteSize() const;
916 : bool MergePartialFromCodedStream(
917 : ::google::protobuf::io::CodedInputStream* input);
918 : void SerializeWithCachedSizes(
919 : ::google::protobuf::io::CodedOutputStream* output) const;
920 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
921 1 : int GetCachedSize() const { return _cached_size_; }
922 : private:
923 : void SharedCtor();
924 : void SharedDtor();
925 : void SetCachedSize(int size) const;
926 : void InternalSwap(LoadParams* other);
927 : private:
928 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
929 : return _internal_metadata_.arena();
930 : }
931 : inline void* MaybeArenaPtr() const {
932 : return _internal_metadata_.raw_arena_ptr();
933 : }
934 : public:
935 :
936 : ::google::protobuf::Metadata GetMetadata() const;
937 :
938 : // nested types ----------------------------------------------------
939 :
940 : // accessors -------------------------------------------------------
941 :
942 : // optional .grpc.testing.PoissonParams poisson = 1;
943 : bool has_poisson() const;
944 : void clear_poisson();
945 : static const int kPoissonFieldNumber = 1;
946 : const ::grpc::testing::PoissonParams& poisson() const;
947 : ::grpc::testing::PoissonParams* mutable_poisson();
948 : ::grpc::testing::PoissonParams* release_poisson();
949 : void set_allocated_poisson(::grpc::testing::PoissonParams* poisson);
950 :
951 : // optional .grpc.testing.UniformParams uniform = 2;
952 : bool has_uniform() const;
953 : void clear_uniform();
954 : static const int kUniformFieldNumber = 2;
955 : const ::grpc::testing::UniformParams& uniform() const;
956 : ::grpc::testing::UniformParams* mutable_uniform();
957 : ::grpc::testing::UniformParams* release_uniform();
958 : void set_allocated_uniform(::grpc::testing::UniformParams* uniform);
959 :
960 : // optional .grpc.testing.DeterministicParams determ = 3;
961 : bool has_determ() const;
962 : void clear_determ();
963 : static const int kDetermFieldNumber = 3;
964 : const ::grpc::testing::DeterministicParams& determ() const;
965 : ::grpc::testing::DeterministicParams* mutable_determ();
966 : ::grpc::testing::DeterministicParams* release_determ();
967 : void set_allocated_determ(::grpc::testing::DeterministicParams* determ);
968 :
969 : // optional .grpc.testing.ParetoParams pareto = 4;
970 : bool has_pareto() const;
971 : void clear_pareto();
972 : static const int kParetoFieldNumber = 4;
973 : const ::grpc::testing::ParetoParams& pareto() const;
974 : ::grpc::testing::ParetoParams* mutable_pareto();
975 : ::grpc::testing::ParetoParams* release_pareto();
976 : void set_allocated_pareto(::grpc::testing::ParetoParams* pareto);
977 :
978 : LoadCase load_case() const;
979 : // @@protoc_insertion_point(class_scope:grpc.testing.LoadParams)
980 : private:
981 : inline void set_has_poisson();
982 : inline void set_has_uniform();
983 : inline void set_has_determ();
984 : inline void set_has_pareto();
985 :
986 : inline bool has_load() const;
987 : void clear_load();
988 : inline void clear_has_load();
989 :
990 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
991 : bool _is_default_instance_;
992 : union LoadUnion {
993 12 : LoadUnion() {}
994 : ::grpc::testing::PoissonParams* poisson_;
995 : ::grpc::testing::UniformParams* uniform_;
996 : ::grpc::testing::DeterministicParams* determ_;
997 : ::grpc::testing::ParetoParams* pareto_;
998 : } load_;
999 : mutable int _cached_size_;
1000 : ::google::protobuf::uint32 _oneof_case_[1];
1001 :
1002 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1003 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1004 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1005 :
1006 : void InitAsDefaultInstance();
1007 : static LoadParams* default_instance_;
1008 : };
1009 : // -------------------------------------------------------------------
1010 :
1011 : class ClientConfig : public ::google::protobuf::Message {
1012 : public:
1013 : ClientConfig();
1014 : virtual ~ClientConfig();
1015 :
1016 : ClientConfig(const ClientConfig& from);
1017 :
1018 18 : inline ClientConfig& operator=(const ClientConfig& from) {
1019 18 : CopyFrom(from);
1020 18 : return *this;
1021 : }
1022 :
1023 : static const ::google::protobuf::Descriptor* descriptor();
1024 : static const ClientConfig& default_instance();
1025 :
1026 : void Swap(ClientConfig* other);
1027 :
1028 : // implements Message ----------------------------------------------
1029 :
1030 0 : inline ClientConfig* New() const { return New(NULL); }
1031 :
1032 : ClientConfig* New(::google::protobuf::Arena* arena) const;
1033 : void CopyFrom(const ::google::protobuf::Message& from);
1034 : void MergeFrom(const ::google::protobuf::Message& from);
1035 : void CopyFrom(const ClientConfig& from);
1036 : void MergeFrom(const ClientConfig& from);
1037 : void Clear();
1038 : bool IsInitialized() const;
1039 :
1040 : int ByteSize() const;
1041 : bool MergePartialFromCodedStream(
1042 : ::google::protobuf::io::CodedInputStream* input);
1043 : void SerializeWithCachedSizes(
1044 : ::google::protobuf::io::CodedOutputStream* output) const;
1045 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1046 6 : int GetCachedSize() const { return _cached_size_; }
1047 : private:
1048 : void SharedCtor();
1049 : void SharedDtor();
1050 : void SetCachedSize(int size) const;
1051 : void InternalSwap(ClientConfig* other);
1052 : private:
1053 18 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1054 36 : return _internal_metadata_.arena();
1055 : }
1056 : inline void* MaybeArenaPtr() const {
1057 : return _internal_metadata_.raw_arena_ptr();
1058 : }
1059 : public:
1060 :
1061 : ::google::protobuf::Metadata GetMetadata() const;
1062 :
1063 : // nested types ----------------------------------------------------
1064 :
1065 : // accessors -------------------------------------------------------
1066 :
1067 : // repeated string server_targets = 1;
1068 : int server_targets_size() const;
1069 : void clear_server_targets();
1070 : static const int kServerTargetsFieldNumber = 1;
1071 : const ::std::string& server_targets(int index) const;
1072 : ::std::string* mutable_server_targets(int index);
1073 : void set_server_targets(int index, const ::std::string& value);
1074 : void set_server_targets(int index, const char* value);
1075 : void set_server_targets(int index, const char* value, size_t size);
1076 : ::std::string* add_server_targets();
1077 : void add_server_targets(const ::std::string& value);
1078 : void add_server_targets(const char* value);
1079 : void add_server_targets(const char* value, size_t size);
1080 : const ::google::protobuf::RepeatedPtrField< ::std::string>& server_targets() const;
1081 : ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_server_targets();
1082 :
1083 : // optional .grpc.testing.ClientType client_type = 2;
1084 : void clear_client_type();
1085 : static const int kClientTypeFieldNumber = 2;
1086 : ::grpc::testing::ClientType client_type() const;
1087 : void set_client_type(::grpc::testing::ClientType value);
1088 :
1089 : // optional bool enable_ssl = 3;
1090 : void clear_enable_ssl();
1091 : static const int kEnableSslFieldNumber = 3;
1092 : bool enable_ssl() const;
1093 : void set_enable_ssl(bool value);
1094 :
1095 : // optional int32 outstanding_rpcs_per_channel = 4;
1096 : void clear_outstanding_rpcs_per_channel();
1097 : static const int kOutstandingRpcsPerChannelFieldNumber = 4;
1098 : ::google::protobuf::int32 outstanding_rpcs_per_channel() const;
1099 : void set_outstanding_rpcs_per_channel(::google::protobuf::int32 value);
1100 :
1101 : // optional int32 client_channels = 5;
1102 : void clear_client_channels();
1103 : static const int kClientChannelsFieldNumber = 5;
1104 : ::google::protobuf::int32 client_channels() const;
1105 : void set_client_channels(::google::protobuf::int32 value);
1106 :
1107 : // optional int32 payload_size = 6;
1108 : void clear_payload_size();
1109 : static const int kPayloadSizeFieldNumber = 6;
1110 : ::google::protobuf::int32 payload_size() const;
1111 : void set_payload_size(::google::protobuf::int32 value);
1112 :
1113 : // optional int32 async_client_threads = 7;
1114 : void clear_async_client_threads();
1115 : static const int kAsyncClientThreadsFieldNumber = 7;
1116 : ::google::protobuf::int32 async_client_threads() const;
1117 : void set_async_client_threads(::google::protobuf::int32 value);
1118 :
1119 : // optional .grpc.testing.RpcType rpc_type = 8;
1120 : void clear_rpc_type();
1121 : static const int kRpcTypeFieldNumber = 8;
1122 : ::grpc::testing::RpcType rpc_type() const;
1123 : void set_rpc_type(::grpc::testing::RpcType value);
1124 :
1125 : // optional string host = 9;
1126 : void clear_host();
1127 : static const int kHostFieldNumber = 9;
1128 : const ::std::string& host() const;
1129 : void set_host(const ::std::string& value);
1130 : void set_host(const char* value);
1131 : void set_host(const char* value, size_t size);
1132 : ::std::string* mutable_host();
1133 : ::std::string* release_host();
1134 : void set_allocated_host(::std::string* host);
1135 :
1136 : // optional .grpc.testing.LoadType load_type = 10;
1137 : void clear_load_type();
1138 : static const int kLoadTypeFieldNumber = 10;
1139 : ::grpc::testing::LoadType load_type() const;
1140 : void set_load_type(::grpc::testing::LoadType value);
1141 :
1142 : // optional .grpc.testing.LoadParams load_params = 11;
1143 : bool has_load_params() const;
1144 : void clear_load_params();
1145 : static const int kLoadParamsFieldNumber = 11;
1146 : const ::grpc::testing::LoadParams& load_params() const;
1147 : ::grpc::testing::LoadParams* mutable_load_params();
1148 : ::grpc::testing::LoadParams* release_load_params();
1149 : void set_allocated_load_params(::grpc::testing::LoadParams* load_params);
1150 :
1151 : // @@protoc_insertion_point(class_scope:grpc.testing.ClientConfig)
1152 : private:
1153 :
1154 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1155 : bool _is_default_instance_;
1156 : ::google::protobuf::RepeatedPtrField< ::std::string> server_targets_;
1157 : int client_type_;
1158 : bool enable_ssl_;
1159 : ::google::protobuf::int32 outstanding_rpcs_per_channel_;
1160 : ::google::protobuf::int32 client_channels_;
1161 : ::google::protobuf::int32 payload_size_;
1162 : ::google::protobuf::int32 async_client_threads_;
1163 : ::google::protobuf::internal::ArenaStringPtr host_;
1164 : int rpc_type_;
1165 : int load_type_;
1166 : ::grpc::testing::LoadParams* load_params_;
1167 : mutable int _cached_size_;
1168 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1169 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1170 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1171 :
1172 : void InitAsDefaultInstance();
1173 : static ClientConfig* default_instance_;
1174 : };
1175 : // -------------------------------------------------------------------
1176 :
1177 : class Mark : public ::google::protobuf::Message {
1178 : public:
1179 : Mark();
1180 : virtual ~Mark();
1181 :
1182 : Mark(const Mark& from);
1183 :
1184 : inline Mark& operator=(const Mark& from) {
1185 : CopyFrom(from);
1186 : return *this;
1187 : }
1188 :
1189 : static const ::google::protobuf::Descriptor* descriptor();
1190 : static const Mark& default_instance();
1191 :
1192 : void Swap(Mark* other);
1193 :
1194 : // implements Message ----------------------------------------------
1195 :
1196 0 : inline Mark* New() const { return New(NULL); }
1197 :
1198 : Mark* New(::google::protobuf::Arena* arena) const;
1199 : void CopyFrom(const ::google::protobuf::Message& from);
1200 : void MergeFrom(const ::google::protobuf::Message& from);
1201 : void CopyFrom(const Mark& from);
1202 : void MergeFrom(const Mark& from);
1203 : void Clear();
1204 : bool IsInitialized() const;
1205 :
1206 : int ByteSize() const;
1207 : bool MergePartialFromCodedStream(
1208 : ::google::protobuf::io::CodedInputStream* input);
1209 : void SerializeWithCachedSizes(
1210 : ::google::protobuf::io::CodedOutputStream* output) const;
1211 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1212 24 : int GetCachedSize() const { return _cached_size_; }
1213 : private:
1214 : void SharedCtor();
1215 : void SharedDtor();
1216 : void SetCachedSize(int size) const;
1217 : void InternalSwap(Mark* other);
1218 : private:
1219 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1220 : return _internal_metadata_.arena();
1221 : }
1222 : inline void* MaybeArenaPtr() const {
1223 : return _internal_metadata_.raw_arena_ptr();
1224 : }
1225 : public:
1226 :
1227 : ::google::protobuf::Metadata GetMetadata() const;
1228 :
1229 : // nested types ----------------------------------------------------
1230 :
1231 : // accessors -------------------------------------------------------
1232 :
1233 : // @@protoc_insertion_point(class_scope:grpc.testing.Mark)
1234 : private:
1235 :
1236 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1237 : bool _is_default_instance_;
1238 : mutable int _cached_size_;
1239 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1240 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1241 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1242 :
1243 : void InitAsDefaultInstance();
1244 : static Mark* default_instance_;
1245 : };
1246 : // -------------------------------------------------------------------
1247 :
1248 : class ClientArgs : public ::google::protobuf::Message {
1249 : public:
1250 : ClientArgs();
1251 : virtual ~ClientArgs();
1252 :
1253 : ClientArgs(const ClientArgs& from);
1254 :
1255 : inline ClientArgs& operator=(const ClientArgs& from) {
1256 : CopyFrom(from);
1257 : return *this;
1258 : }
1259 :
1260 : static const ::google::protobuf::Descriptor* descriptor();
1261 : static const ClientArgs& default_instance();
1262 :
1263 : enum ArgtypeCase {
1264 : kSetup = 1,
1265 : kMark = 2,
1266 : ARGTYPE_NOT_SET = 0,
1267 : };
1268 :
1269 : void Swap(ClientArgs* other);
1270 :
1271 : // implements Message ----------------------------------------------
1272 :
1273 0 : inline ClientArgs* New() const { return New(NULL); }
1274 :
1275 : ClientArgs* New(::google::protobuf::Arena* arena) const;
1276 : void CopyFrom(const ::google::protobuf::Message& from);
1277 : void MergeFrom(const ::google::protobuf::Message& from);
1278 : void CopyFrom(const ClientArgs& from);
1279 : void MergeFrom(const ClientArgs& from);
1280 : void Clear();
1281 : bool IsInitialized() const;
1282 :
1283 : int ByteSize() const;
1284 : bool MergePartialFromCodedStream(
1285 : ::google::protobuf::io::CodedInputStream* input);
1286 : void SerializeWithCachedSizes(
1287 : ::google::protobuf::io::CodedOutputStream* output) const;
1288 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1289 0 : int GetCachedSize() const { return _cached_size_; }
1290 : private:
1291 : void SharedCtor();
1292 : void SharedDtor();
1293 : void SetCachedSize(int size) const;
1294 : void InternalSwap(ClientArgs* other);
1295 : private:
1296 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1297 : return _internal_metadata_.arena();
1298 : }
1299 : inline void* MaybeArenaPtr() const {
1300 : return _internal_metadata_.raw_arena_ptr();
1301 : }
1302 : public:
1303 :
1304 : ::google::protobuf::Metadata GetMetadata() const;
1305 :
1306 : // nested types ----------------------------------------------------
1307 :
1308 : // accessors -------------------------------------------------------
1309 :
1310 : // optional .grpc.testing.ClientConfig setup = 1;
1311 : bool has_setup() const;
1312 : void clear_setup();
1313 : static const int kSetupFieldNumber = 1;
1314 : const ::grpc::testing::ClientConfig& setup() const;
1315 : ::grpc::testing::ClientConfig* mutable_setup();
1316 : ::grpc::testing::ClientConfig* release_setup();
1317 : void set_allocated_setup(::grpc::testing::ClientConfig* setup);
1318 :
1319 : // optional .grpc.testing.Mark mark = 2;
1320 : bool has_mark() const;
1321 : void clear_mark();
1322 : static const int kMarkFieldNumber = 2;
1323 : const ::grpc::testing::Mark& mark() const;
1324 : ::grpc::testing::Mark* mutable_mark();
1325 : ::grpc::testing::Mark* release_mark();
1326 : void set_allocated_mark(::grpc::testing::Mark* mark);
1327 :
1328 : ArgtypeCase argtype_case() const;
1329 : // @@protoc_insertion_point(class_scope:grpc.testing.ClientArgs)
1330 : private:
1331 : inline void set_has_setup();
1332 : inline void set_has_mark();
1333 :
1334 : inline bool has_argtype() const;
1335 : void clear_argtype();
1336 : inline void clear_has_argtype();
1337 :
1338 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1339 : bool _is_default_instance_;
1340 : union ArgtypeUnion {
1341 24 : ArgtypeUnion() {}
1342 : ::grpc::testing::ClientConfig* setup_;
1343 : ::grpc::testing::Mark* mark_;
1344 : } argtype_;
1345 : mutable int _cached_size_;
1346 : ::google::protobuf::uint32 _oneof_case_[1];
1347 :
1348 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1349 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1350 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1351 :
1352 : void InitAsDefaultInstance();
1353 : static ClientArgs* default_instance_;
1354 : };
1355 : // -------------------------------------------------------------------
1356 :
1357 : class ClientStats : public ::google::protobuf::Message {
1358 : public:
1359 : ClientStats();
1360 : virtual ~ClientStats();
1361 :
1362 : ClientStats(const ClientStats& from);
1363 :
1364 12 : inline ClientStats& operator=(const ClientStats& from) {
1365 12 : CopyFrom(from);
1366 12 : return *this;
1367 : }
1368 :
1369 : static const ::google::protobuf::Descriptor* descriptor();
1370 : static const ClientStats& default_instance();
1371 :
1372 : void Swap(ClientStats* other);
1373 :
1374 : // implements Message ----------------------------------------------
1375 :
1376 0 : inline ClientStats* New() const { return New(NULL); }
1377 :
1378 : ClientStats* New(::google::protobuf::Arena* arena) const;
1379 : void CopyFrom(const ::google::protobuf::Message& from);
1380 : void MergeFrom(const ::google::protobuf::Message& from);
1381 : void CopyFrom(const ClientStats& from);
1382 : void MergeFrom(const ClientStats& from);
1383 : void Clear();
1384 : bool IsInitialized() const;
1385 :
1386 : int ByteSize() const;
1387 : bool MergePartialFromCodedStream(
1388 : ::google::protobuf::io::CodedInputStream* input);
1389 : void SerializeWithCachedSizes(
1390 : ::google::protobuf::io::CodedOutputStream* output) const;
1391 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1392 12 : int GetCachedSize() const { return _cached_size_; }
1393 : private:
1394 : void SharedCtor();
1395 : void SharedDtor();
1396 : void SetCachedSize(int size) const;
1397 : void InternalSwap(ClientStats* other);
1398 : private:
1399 12 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1400 24 : return _internal_metadata_.arena();
1401 : }
1402 : inline void* MaybeArenaPtr() const {
1403 : return _internal_metadata_.raw_arena_ptr();
1404 : }
1405 : public:
1406 :
1407 : ::google::protobuf::Metadata GetMetadata() const;
1408 :
1409 : // nested types ----------------------------------------------------
1410 :
1411 : // accessors -------------------------------------------------------
1412 :
1413 : // optional .grpc.testing.HistogramData latencies = 1;
1414 : bool has_latencies() const;
1415 : void clear_latencies();
1416 : static const int kLatenciesFieldNumber = 1;
1417 : const ::grpc::testing::HistogramData& latencies() const;
1418 : ::grpc::testing::HistogramData* mutable_latencies();
1419 : ::grpc::testing::HistogramData* release_latencies();
1420 : void set_allocated_latencies(::grpc::testing::HistogramData* latencies);
1421 :
1422 : // optional double time_elapsed = 2;
1423 : void clear_time_elapsed();
1424 : static const int kTimeElapsedFieldNumber = 2;
1425 : double time_elapsed() const;
1426 : void set_time_elapsed(double value);
1427 :
1428 : // optional double time_user = 3;
1429 : void clear_time_user();
1430 : static const int kTimeUserFieldNumber = 3;
1431 : double time_user() const;
1432 : void set_time_user(double value);
1433 :
1434 : // optional double time_system = 4;
1435 : void clear_time_system();
1436 : static const int kTimeSystemFieldNumber = 4;
1437 : double time_system() const;
1438 : void set_time_system(double value);
1439 :
1440 : // @@protoc_insertion_point(class_scope:grpc.testing.ClientStats)
1441 : private:
1442 :
1443 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1444 : bool _is_default_instance_;
1445 : ::grpc::testing::HistogramData* latencies_;
1446 : double time_elapsed_;
1447 : double time_user_;
1448 : double time_system_;
1449 : mutable int _cached_size_;
1450 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1451 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1452 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1453 :
1454 : void InitAsDefaultInstance();
1455 : static ClientStats* default_instance_;
1456 : };
1457 : // -------------------------------------------------------------------
1458 :
1459 : class ClientStatus : public ::google::protobuf::Message {
1460 : public:
1461 : ClientStatus();
1462 : virtual ~ClientStatus();
1463 :
1464 : ClientStatus(const ClientStatus& from);
1465 :
1466 : inline ClientStatus& operator=(const ClientStatus& from) {
1467 : CopyFrom(from);
1468 : return *this;
1469 : }
1470 :
1471 : static const ::google::protobuf::Descriptor* descriptor();
1472 : static const ClientStatus& default_instance();
1473 :
1474 : void Swap(ClientStatus* other);
1475 :
1476 : // implements Message ----------------------------------------------
1477 :
1478 0 : inline ClientStatus* New() const { return New(NULL); }
1479 :
1480 : ClientStatus* New(::google::protobuf::Arena* arena) const;
1481 : void CopyFrom(const ::google::protobuf::Message& from);
1482 : void MergeFrom(const ::google::protobuf::Message& from);
1483 : void CopyFrom(const ClientStatus& from);
1484 : void MergeFrom(const ClientStatus& from);
1485 : void Clear();
1486 : bool IsInitialized() const;
1487 :
1488 : int ByteSize() const;
1489 : bool MergePartialFromCodedStream(
1490 : ::google::protobuf::io::CodedInputStream* input);
1491 : void SerializeWithCachedSizes(
1492 : ::google::protobuf::io::CodedOutputStream* output) const;
1493 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1494 0 : int GetCachedSize() const { return _cached_size_; }
1495 : private:
1496 : void SharedCtor();
1497 : void SharedDtor();
1498 : void SetCachedSize(int size) const;
1499 : void InternalSwap(ClientStatus* other);
1500 : private:
1501 18 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1502 36 : return _internal_metadata_.arena();
1503 : }
1504 : inline void* MaybeArenaPtr() const {
1505 : return _internal_metadata_.raw_arena_ptr();
1506 : }
1507 : public:
1508 :
1509 : ::google::protobuf::Metadata GetMetadata() const;
1510 :
1511 : // nested types ----------------------------------------------------
1512 :
1513 : // accessors -------------------------------------------------------
1514 :
1515 : // optional .grpc.testing.ClientStats stats = 1;
1516 : bool has_stats() const;
1517 : void clear_stats();
1518 : static const int kStatsFieldNumber = 1;
1519 : const ::grpc::testing::ClientStats& stats() const;
1520 : ::grpc::testing::ClientStats* mutable_stats();
1521 : ::grpc::testing::ClientStats* release_stats();
1522 : void set_allocated_stats(::grpc::testing::ClientStats* stats);
1523 :
1524 : // @@protoc_insertion_point(class_scope:grpc.testing.ClientStatus)
1525 : private:
1526 :
1527 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1528 : bool _is_default_instance_;
1529 : ::grpc::testing::ClientStats* stats_;
1530 : mutable int _cached_size_;
1531 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1532 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1533 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1534 :
1535 : void InitAsDefaultInstance();
1536 : static ClientStatus* default_instance_;
1537 : };
1538 : // -------------------------------------------------------------------
1539 :
1540 : class ServerConfig : public ::google::protobuf::Message {
1541 : public:
1542 : ServerConfig();
1543 : virtual ~ServerConfig();
1544 :
1545 : ServerConfig(const ServerConfig& from);
1546 :
1547 18 : inline ServerConfig& operator=(const ServerConfig& from) {
1548 18 : CopyFrom(from);
1549 18 : return *this;
1550 : }
1551 :
1552 : static const ::google::protobuf::Descriptor* descriptor();
1553 : static const ServerConfig& default_instance();
1554 :
1555 : void Swap(ServerConfig* other);
1556 :
1557 : // implements Message ----------------------------------------------
1558 :
1559 0 : inline ServerConfig* New() const { return New(NULL); }
1560 :
1561 : ServerConfig* New(::google::protobuf::Arena* arena) const;
1562 : void CopyFrom(const ::google::protobuf::Message& from);
1563 : void MergeFrom(const ::google::protobuf::Message& from);
1564 : void CopyFrom(const ServerConfig& from);
1565 : void MergeFrom(const ServerConfig& from);
1566 : void Clear();
1567 : bool IsInitialized() const;
1568 :
1569 : int ByteSize() const;
1570 : bool MergePartialFromCodedStream(
1571 : ::google::protobuf::io::CodedInputStream* input);
1572 : void SerializeWithCachedSizes(
1573 : ::google::protobuf::io::CodedOutputStream* output) const;
1574 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1575 6 : int GetCachedSize() const { return _cached_size_; }
1576 : private:
1577 : void SharedCtor();
1578 : void SharedDtor();
1579 : void SetCachedSize(int size) const;
1580 : void InternalSwap(ServerConfig* other);
1581 : private:
1582 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1583 : return _internal_metadata_.arena();
1584 : }
1585 : inline void* MaybeArenaPtr() const {
1586 : return _internal_metadata_.raw_arena_ptr();
1587 : }
1588 : public:
1589 :
1590 : ::google::protobuf::Metadata GetMetadata() const;
1591 :
1592 : // nested types ----------------------------------------------------
1593 :
1594 : // accessors -------------------------------------------------------
1595 :
1596 : // optional .grpc.testing.ServerType server_type = 1;
1597 : void clear_server_type();
1598 : static const int kServerTypeFieldNumber = 1;
1599 : ::grpc::testing::ServerType server_type() const;
1600 : void set_server_type(::grpc::testing::ServerType value);
1601 :
1602 : // optional int32 threads = 2;
1603 : void clear_threads();
1604 : static const int kThreadsFieldNumber = 2;
1605 : ::google::protobuf::int32 threads() const;
1606 : void set_threads(::google::protobuf::int32 value);
1607 :
1608 : // optional bool enable_ssl = 3;
1609 : void clear_enable_ssl();
1610 : static const int kEnableSslFieldNumber = 3;
1611 : bool enable_ssl() const;
1612 : void set_enable_ssl(bool value);
1613 :
1614 : // optional string host = 4;
1615 : void clear_host();
1616 : static const int kHostFieldNumber = 4;
1617 : const ::std::string& host() const;
1618 : void set_host(const ::std::string& value);
1619 : void set_host(const char* value);
1620 : void set_host(const char* value, size_t size);
1621 : ::std::string* mutable_host();
1622 : ::std::string* release_host();
1623 : void set_allocated_host(::std::string* host);
1624 :
1625 : // @@protoc_insertion_point(class_scope:grpc.testing.ServerConfig)
1626 : private:
1627 :
1628 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1629 : bool _is_default_instance_;
1630 : int server_type_;
1631 : ::google::protobuf::int32 threads_;
1632 : ::google::protobuf::internal::ArenaStringPtr host_;
1633 : bool enable_ssl_;
1634 : mutable int _cached_size_;
1635 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1636 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1637 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1638 :
1639 : void InitAsDefaultInstance();
1640 : static ServerConfig* default_instance_;
1641 : };
1642 : // -------------------------------------------------------------------
1643 :
1644 : class ServerArgs : public ::google::protobuf::Message {
1645 : public:
1646 : ServerArgs();
1647 : virtual ~ServerArgs();
1648 :
1649 : ServerArgs(const ServerArgs& from);
1650 :
1651 : inline ServerArgs& operator=(const ServerArgs& from) {
1652 : CopyFrom(from);
1653 : return *this;
1654 : }
1655 :
1656 : static const ::google::protobuf::Descriptor* descriptor();
1657 : static const ServerArgs& default_instance();
1658 :
1659 : enum ArgtypeCase {
1660 : kSetup = 1,
1661 : kMark = 2,
1662 : ARGTYPE_NOT_SET = 0,
1663 : };
1664 :
1665 : void Swap(ServerArgs* other);
1666 :
1667 : // implements Message ----------------------------------------------
1668 :
1669 0 : inline ServerArgs* New() const { return New(NULL); }
1670 :
1671 : ServerArgs* New(::google::protobuf::Arena* arena) const;
1672 : void CopyFrom(const ::google::protobuf::Message& from);
1673 : void MergeFrom(const ::google::protobuf::Message& from);
1674 : void CopyFrom(const ServerArgs& from);
1675 : void MergeFrom(const ServerArgs& from);
1676 : void Clear();
1677 : bool IsInitialized() const;
1678 :
1679 : int ByteSize() const;
1680 : bool MergePartialFromCodedStream(
1681 : ::google::protobuf::io::CodedInputStream* input);
1682 : void SerializeWithCachedSizes(
1683 : ::google::protobuf::io::CodedOutputStream* output) const;
1684 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1685 0 : int GetCachedSize() const { return _cached_size_; }
1686 : private:
1687 : void SharedCtor();
1688 : void SharedDtor();
1689 : void SetCachedSize(int size) const;
1690 : void InternalSwap(ServerArgs* other);
1691 : private:
1692 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1693 : return _internal_metadata_.arena();
1694 : }
1695 : inline void* MaybeArenaPtr() const {
1696 : return _internal_metadata_.raw_arena_ptr();
1697 : }
1698 : public:
1699 :
1700 : ::google::protobuf::Metadata GetMetadata() const;
1701 :
1702 : // nested types ----------------------------------------------------
1703 :
1704 : // accessors -------------------------------------------------------
1705 :
1706 : // optional .grpc.testing.ServerConfig setup = 1;
1707 : bool has_setup() const;
1708 : void clear_setup();
1709 : static const int kSetupFieldNumber = 1;
1710 : const ::grpc::testing::ServerConfig& setup() const;
1711 : ::grpc::testing::ServerConfig* mutable_setup();
1712 : ::grpc::testing::ServerConfig* release_setup();
1713 : void set_allocated_setup(::grpc::testing::ServerConfig* setup);
1714 :
1715 : // optional .grpc.testing.Mark mark = 2;
1716 : bool has_mark() const;
1717 : void clear_mark();
1718 : static const int kMarkFieldNumber = 2;
1719 : const ::grpc::testing::Mark& mark() const;
1720 : ::grpc::testing::Mark* mutable_mark();
1721 : ::grpc::testing::Mark* release_mark();
1722 : void set_allocated_mark(::grpc::testing::Mark* mark);
1723 :
1724 : ArgtypeCase argtype_case() const;
1725 : // @@protoc_insertion_point(class_scope:grpc.testing.ServerArgs)
1726 : private:
1727 : inline void set_has_setup();
1728 : inline void set_has_mark();
1729 :
1730 : inline bool has_argtype() const;
1731 : void clear_argtype();
1732 : inline void clear_has_argtype();
1733 :
1734 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1735 : bool _is_default_instance_;
1736 : union ArgtypeUnion {
1737 24 : ArgtypeUnion() {}
1738 : ::grpc::testing::ServerConfig* setup_;
1739 : ::grpc::testing::Mark* mark_;
1740 : } argtype_;
1741 : mutable int _cached_size_;
1742 : ::google::protobuf::uint32 _oneof_case_[1];
1743 :
1744 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1745 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1746 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1747 :
1748 : void InitAsDefaultInstance();
1749 : static ServerArgs* default_instance_;
1750 : };
1751 : // -------------------------------------------------------------------
1752 :
1753 : class ServerStatus : public ::google::protobuf::Message {
1754 : public:
1755 : ServerStatus();
1756 : virtual ~ServerStatus();
1757 :
1758 : ServerStatus(const ServerStatus& from);
1759 :
1760 : inline ServerStatus& operator=(const ServerStatus& from) {
1761 : CopyFrom(from);
1762 : return *this;
1763 : }
1764 :
1765 : static const ::google::protobuf::Descriptor* descriptor();
1766 : static const ServerStatus& default_instance();
1767 :
1768 : void Swap(ServerStatus* other);
1769 :
1770 : // implements Message ----------------------------------------------
1771 :
1772 0 : inline ServerStatus* New() const { return New(NULL); }
1773 :
1774 : ServerStatus* New(::google::protobuf::Arena* arena) const;
1775 : void CopyFrom(const ::google::protobuf::Message& from);
1776 : void MergeFrom(const ::google::protobuf::Message& from);
1777 : void CopyFrom(const ServerStatus& from);
1778 : void MergeFrom(const ServerStatus& from);
1779 : void Clear();
1780 : bool IsInitialized() const;
1781 :
1782 : int ByteSize() const;
1783 : bool MergePartialFromCodedStream(
1784 : ::google::protobuf::io::CodedInputStream* input);
1785 : void SerializeWithCachedSizes(
1786 : ::google::protobuf::io::CodedOutputStream* output) const;
1787 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1788 0 : int GetCachedSize() const { return _cached_size_; }
1789 : private:
1790 : void SharedCtor();
1791 : void SharedDtor();
1792 : void SetCachedSize(int size) const;
1793 : void InternalSwap(ServerStatus* other);
1794 : private:
1795 18 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1796 36 : return _internal_metadata_.arena();
1797 : }
1798 : inline void* MaybeArenaPtr() const {
1799 : return _internal_metadata_.raw_arena_ptr();
1800 : }
1801 : public:
1802 :
1803 : ::google::protobuf::Metadata GetMetadata() const;
1804 :
1805 : // nested types ----------------------------------------------------
1806 :
1807 : // accessors -------------------------------------------------------
1808 :
1809 : // optional .grpc.testing.ServerStats stats = 1;
1810 : bool has_stats() const;
1811 : void clear_stats();
1812 : static const int kStatsFieldNumber = 1;
1813 : const ::grpc::testing::ServerStats& stats() const;
1814 : ::grpc::testing::ServerStats* mutable_stats();
1815 : ::grpc::testing::ServerStats* release_stats();
1816 : void set_allocated_stats(::grpc::testing::ServerStats* stats);
1817 :
1818 : // optional int32 port = 2;
1819 : void clear_port();
1820 : static const int kPortFieldNumber = 2;
1821 : ::google::protobuf::int32 port() const;
1822 : void set_port(::google::protobuf::int32 value);
1823 :
1824 : // @@protoc_insertion_point(class_scope:grpc.testing.ServerStatus)
1825 : private:
1826 :
1827 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1828 : bool _is_default_instance_;
1829 : ::grpc::testing::ServerStats* stats_;
1830 : ::google::protobuf::int32 port_;
1831 : mutable int _cached_size_;
1832 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1833 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1834 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1835 :
1836 : void InitAsDefaultInstance();
1837 : static ServerStatus* default_instance_;
1838 : };
1839 : // -------------------------------------------------------------------
1840 :
1841 : class SimpleRequest : public ::google::protobuf::Message {
1842 : public:
1843 : SimpleRequest();
1844 : virtual ~SimpleRequest();
1845 :
1846 : SimpleRequest(const SimpleRequest& from);
1847 :
1848 1165407 : inline SimpleRequest& operator=(const SimpleRequest& from) {
1849 1165407 : CopyFrom(from);
1850 1165782 : return *this;
1851 : }
1852 :
1853 : static const ::google::protobuf::Descriptor* descriptor();
1854 : static const SimpleRequest& default_instance();
1855 :
1856 : void Swap(SimpleRequest* other);
1857 :
1858 : // implements Message ----------------------------------------------
1859 :
1860 0 : inline SimpleRequest* New() const { return New(NULL); }
1861 :
1862 : SimpleRequest* New(::google::protobuf::Arena* arena) const;
1863 : void CopyFrom(const ::google::protobuf::Message& from);
1864 : void MergeFrom(const ::google::protobuf::Message& from);
1865 : void CopyFrom(const SimpleRequest& from);
1866 : void MergeFrom(const SimpleRequest& from);
1867 : void Clear();
1868 : bool IsInitialized() const;
1869 :
1870 : int ByteSize() const;
1871 : bool MergePartialFromCodedStream(
1872 : ::google::protobuf::io::CodedInputStream* input);
1873 : void SerializeWithCachedSizes(
1874 : ::google::protobuf::io::CodedOutputStream* output) const;
1875 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1876 0 : int GetCachedSize() const { return _cached_size_; }
1877 : private:
1878 : void SharedCtor();
1879 : void SharedDtor();
1880 : void SetCachedSize(int size) const;
1881 : void InternalSwap(SimpleRequest* other);
1882 : private:
1883 2442407 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1884 4885547 : return _internal_metadata_.arena();
1885 : }
1886 : inline void* MaybeArenaPtr() const {
1887 : return _internal_metadata_.raw_arena_ptr();
1888 : }
1889 : public:
1890 :
1891 : ::google::protobuf::Metadata GetMetadata() const;
1892 :
1893 : // nested types ----------------------------------------------------
1894 :
1895 : // accessors -------------------------------------------------------
1896 :
1897 : // optional .grpc.testing.PayloadType response_type = 1;
1898 : void clear_response_type();
1899 : static const int kResponseTypeFieldNumber = 1;
1900 : ::grpc::testing::PayloadType response_type() const;
1901 : void set_response_type(::grpc::testing::PayloadType value);
1902 :
1903 : // optional int32 response_size = 2;
1904 : void clear_response_size();
1905 : static const int kResponseSizeFieldNumber = 2;
1906 : ::google::protobuf::int32 response_size() const;
1907 : void set_response_size(::google::protobuf::int32 value);
1908 :
1909 : // optional .grpc.testing.Payload payload = 3;
1910 : bool has_payload() const;
1911 : void clear_payload();
1912 : static const int kPayloadFieldNumber = 3;
1913 : const ::grpc::testing::Payload& payload() const;
1914 : ::grpc::testing::Payload* mutable_payload();
1915 : ::grpc::testing::Payload* release_payload();
1916 : void set_allocated_payload(::grpc::testing::Payload* payload);
1917 :
1918 : // @@protoc_insertion_point(class_scope:grpc.testing.SimpleRequest)
1919 : private:
1920 :
1921 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1922 : bool _is_default_instance_;
1923 : int response_type_;
1924 : ::google::protobuf::int32 response_size_;
1925 : ::grpc::testing::Payload* payload_;
1926 : mutable int _cached_size_;
1927 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1928 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
1929 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
1930 :
1931 : void InitAsDefaultInstance();
1932 : static SimpleRequest* default_instance_;
1933 : };
1934 : // -------------------------------------------------------------------
1935 :
1936 : class SimpleResponse : public ::google::protobuf::Message {
1937 : public:
1938 : SimpleResponse();
1939 : virtual ~SimpleResponse();
1940 :
1941 : SimpleResponse(const SimpleResponse& from);
1942 :
1943 : inline SimpleResponse& operator=(const SimpleResponse& from) {
1944 : CopyFrom(from);
1945 : return *this;
1946 : }
1947 :
1948 : static const ::google::protobuf::Descriptor* descriptor();
1949 : static const SimpleResponse& default_instance();
1950 :
1951 : void Swap(SimpleResponse* other);
1952 :
1953 : // implements Message ----------------------------------------------
1954 :
1955 0 : inline SimpleResponse* New() const { return New(NULL); }
1956 :
1957 : SimpleResponse* New(::google::protobuf::Arena* arena) const;
1958 : void CopyFrom(const ::google::protobuf::Message& from);
1959 : void MergeFrom(const ::google::protobuf::Message& from);
1960 : void CopyFrom(const SimpleResponse& from);
1961 : void MergeFrom(const SimpleResponse& from);
1962 : void Clear();
1963 : bool IsInitialized() const;
1964 :
1965 : int ByteSize() const;
1966 : bool MergePartialFromCodedStream(
1967 : ::google::protobuf::io::CodedInputStream* input);
1968 : void SerializeWithCachedSizes(
1969 : ::google::protobuf::io::CodedOutputStream* output) const;
1970 : ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1971 0 : int GetCachedSize() const { return _cached_size_; }
1972 : private:
1973 : void SharedCtor();
1974 : void SharedDtor();
1975 : void SetCachedSize(int size) const;
1976 : void InternalSwap(SimpleResponse* other);
1977 : private:
1978 1277745 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1979 2555790 : return _internal_metadata_.arena();
1980 : }
1981 : inline void* MaybeArenaPtr() const {
1982 : return _internal_metadata_.raw_arena_ptr();
1983 : }
1984 : public:
1985 :
1986 : ::google::protobuf::Metadata GetMetadata() const;
1987 :
1988 : // nested types ----------------------------------------------------
1989 :
1990 : // accessors -------------------------------------------------------
1991 :
1992 : // optional .grpc.testing.Payload payload = 1;
1993 : bool has_payload() const;
1994 : void clear_payload();
1995 : static const int kPayloadFieldNumber = 1;
1996 : const ::grpc::testing::Payload& payload() const;
1997 : ::grpc::testing::Payload* mutable_payload();
1998 : ::grpc::testing::Payload* release_payload();
1999 : void set_allocated_payload(::grpc::testing::Payload* payload);
2000 :
2001 : // @@protoc_insertion_point(class_scope:grpc.testing.SimpleResponse)
2002 : private:
2003 :
2004 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2005 : bool _is_default_instance_;
2006 : ::grpc::testing::Payload* payload_;
2007 : mutable int _cached_size_;
2008 : friend void protobuf_AddDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
2009 : friend void protobuf_AssignDesc_test_2fcpp_2fqps_2fqpstest_2eproto();
2010 : friend void protobuf_ShutdownFile_test_2fcpp_2fqps_2fqpstest_2eproto();
2011 :
2012 : void InitAsDefaultInstance();
2013 : static SimpleResponse* default_instance_;
2014 : };
2015 : // ===================================================================
2016 :
2017 :
2018 : // ===================================================================
2019 :
2020 : #if !PROTOBUF_INLINE_NOT_IN_HEADERS
2021 : // StatsRequest
2022 :
2023 : // optional int32 test_num = 1;
2024 : inline void StatsRequest::clear_test_num() {
2025 : test_num_ = 0;
2026 : }
2027 0 : inline ::google::protobuf::int32 StatsRequest::test_num() const {
2028 : // @@protoc_insertion_point(field_get:grpc.testing.StatsRequest.test_num)
2029 0 : return test_num_;
2030 : }
2031 0 : inline void StatsRequest::set_test_num(::google::protobuf::int32 value) {
2032 :
2033 0 : test_num_ = value;
2034 : // @@protoc_insertion_point(field_set:grpc.testing.StatsRequest.test_num)
2035 0 : }
2036 :
2037 : // -------------------------------------------------------------------
2038 :
2039 : // ServerStats
2040 :
2041 : // optional double time_elapsed = 1;
2042 : inline void ServerStats::clear_time_elapsed() {
2043 : time_elapsed_ = 0;
2044 : }
2045 66 : inline double ServerStats::time_elapsed() const {
2046 : // @@protoc_insertion_point(field_get:grpc.testing.ServerStats.time_elapsed)
2047 66 : return time_elapsed_;
2048 : }
2049 24 : inline void ServerStats::set_time_elapsed(double value) {
2050 :
2051 24 : time_elapsed_ = value;
2052 : // @@protoc_insertion_point(field_set:grpc.testing.ServerStats.time_elapsed)
2053 24 : }
2054 :
2055 : // optional double time_user = 2;
2056 : inline void ServerStats::clear_time_user() {
2057 : time_user_ = 0;
2058 : }
2059 66 : inline double ServerStats::time_user() const {
2060 : // @@protoc_insertion_point(field_get:grpc.testing.ServerStats.time_user)
2061 66 : return time_user_;
2062 : }
2063 24 : inline void ServerStats::set_time_user(double value) {
2064 :
2065 24 : time_user_ = value;
2066 : // @@protoc_insertion_point(field_set:grpc.testing.ServerStats.time_user)
2067 24 : }
2068 :
2069 : // optional double time_system = 3;
2070 : inline void ServerStats::clear_time_system() {
2071 : time_system_ = 0;
2072 : }
2073 66 : inline double ServerStats::time_system() const {
2074 : // @@protoc_insertion_point(field_get:grpc.testing.ServerStats.time_system)
2075 66 : return time_system_;
2076 : }
2077 24 : inline void ServerStats::set_time_system(double value) {
2078 :
2079 24 : time_system_ = value;
2080 : // @@protoc_insertion_point(field_set:grpc.testing.ServerStats.time_system)
2081 24 : }
2082 :
2083 : // -------------------------------------------------------------------
2084 :
2085 : // Payload
2086 :
2087 : // optional .grpc.testing.PayloadType type = 1;
2088 : inline void Payload::clear_type() {
2089 : type_ = 0;
2090 : }
2091 2555189 : inline ::grpc::testing::PayloadType Payload::type() const {
2092 : // @@protoc_insertion_point(field_get:grpc.testing.Payload.type)
2093 2555189 : return static_cast< ::grpc::testing::PayloadType >(type_);
2094 : }
2095 1277555 : inline void Payload::set_type(::grpc::testing::PayloadType value) {
2096 :
2097 1277555 : type_ = value;
2098 : // @@protoc_insertion_point(field_set:grpc.testing.Payload.type)
2099 1277555 : }
2100 :
2101 : // optional bytes body = 2;
2102 : inline void Payload::clear_body() {
2103 : body_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2104 : }
2105 5106929 : inline const ::std::string& Payload::body() const {
2106 : // @@protoc_insertion_point(field_get:grpc.testing.Payload.body)
2107 5106929 : return body_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2108 : }
2109 : inline void Payload::set_body(const ::std::string& value) {
2110 :
2111 : body_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2112 : // @@protoc_insertion_point(field_set:grpc.testing.Payload.body)
2113 : }
2114 : inline void Payload::set_body(const char* value) {
2115 :
2116 : body_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2117 : // @@protoc_insertion_point(field_set_char:grpc.testing.Payload.body)
2118 : }
2119 1277934 : inline void Payload::set_body(const void* value, size_t size) {
2120 :
2121 1278006 : body_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2122 2555940 : ::std::string(reinterpret_cast<const char*>(value), size));
2123 : // @@protoc_insertion_point(field_set_pointer:grpc.testing.Payload.body)
2124 1278083 : }
2125 1277446 : inline ::std::string* Payload::mutable_body() {
2126 :
2127 : // @@protoc_insertion_point(field_mutable:grpc.testing.Payload.body)
2128 1277446 : return body_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2129 : }
2130 : inline ::std::string* Payload::release_body() {
2131 :
2132 : return body_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2133 : }
2134 : inline void Payload::set_allocated_body(::std::string* body) {
2135 : if (body != NULL) {
2136 :
2137 : } else {
2138 :
2139 : }
2140 : body_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), body);
2141 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.Payload.body)
2142 : }
2143 :
2144 : // -------------------------------------------------------------------
2145 :
2146 : // HistogramData
2147 :
2148 : // repeated uint32 bucket = 1;
2149 59922 : inline int HistogramData::bucket_size() const {
2150 59922 : return bucket_.size();
2151 : }
2152 : inline void HistogramData::clear_bucket() {
2153 : bucket_.Clear();
2154 : }
2155 59880 : inline ::google::protobuf::uint32 HistogramData::bucket(int index) const {
2156 : // @@protoc_insertion_point(field_get:grpc.testing.HistogramData.bucket)
2157 59880 : return bucket_.Get(index);
2158 : }
2159 : inline void HistogramData::set_bucket(int index, ::google::protobuf::uint32 value) {
2160 : bucket_.Set(index, value);
2161 : // @@protoc_insertion_point(field_set:grpc.testing.HistogramData.bucket)
2162 : }
2163 29940 : inline void HistogramData::add_bucket(::google::protobuf::uint32 value) {
2164 29940 : bucket_.Add(value);
2165 : // @@protoc_insertion_point(field_add:grpc.testing.HistogramData.bucket)
2166 29940 : }
2167 : inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
2168 6 : HistogramData::bucket() const {
2169 : // @@protoc_insertion_point(field_list:grpc.testing.HistogramData.bucket)
2170 6 : return bucket_;
2171 : }
2172 : inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
2173 12 : HistogramData::mutable_bucket() {
2174 : // @@protoc_insertion_point(field_mutable_list:grpc.testing.HistogramData.bucket)
2175 12 : return &bucket_;
2176 : }
2177 :
2178 : // optional double min_seen = 2;
2179 : inline void HistogramData::clear_min_seen() {
2180 : min_seen_ = 0;
2181 : }
2182 66 : inline double HistogramData::min_seen() const {
2183 : // @@protoc_insertion_point(field_get:grpc.testing.HistogramData.min_seen)
2184 66 : return min_seen_;
2185 : }
2186 24 : inline void HistogramData::set_min_seen(double value) {
2187 :
2188 24 : min_seen_ = value;
2189 : // @@protoc_insertion_point(field_set:grpc.testing.HistogramData.min_seen)
2190 24 : }
2191 :
2192 : // optional double max_seen = 3;
2193 : inline void HistogramData::clear_max_seen() {
2194 : max_seen_ = 0;
2195 : }
2196 66 : inline double HistogramData::max_seen() const {
2197 : // @@protoc_insertion_point(field_get:grpc.testing.HistogramData.max_seen)
2198 66 : return max_seen_;
2199 : }
2200 24 : inline void HistogramData::set_max_seen(double value) {
2201 :
2202 24 : max_seen_ = value;
2203 : // @@protoc_insertion_point(field_set:grpc.testing.HistogramData.max_seen)
2204 24 : }
2205 :
2206 : // optional double sum = 4;
2207 : inline void HistogramData::clear_sum() {
2208 : sum_ = 0;
2209 : }
2210 66 : inline double HistogramData::sum() const {
2211 : // @@protoc_insertion_point(field_get:grpc.testing.HistogramData.sum)
2212 66 : return sum_;
2213 : }
2214 24 : inline void HistogramData::set_sum(double value) {
2215 :
2216 24 : sum_ = value;
2217 : // @@protoc_insertion_point(field_set:grpc.testing.HistogramData.sum)
2218 24 : }
2219 :
2220 : // optional double sum_of_squares = 5;
2221 : inline void HistogramData::clear_sum_of_squares() {
2222 : sum_of_squares_ = 0;
2223 : }
2224 66 : inline double HistogramData::sum_of_squares() const {
2225 : // @@protoc_insertion_point(field_get:grpc.testing.HistogramData.sum_of_squares)
2226 66 : return sum_of_squares_;
2227 : }
2228 24 : inline void HistogramData::set_sum_of_squares(double value) {
2229 :
2230 24 : sum_of_squares_ = value;
2231 : // @@protoc_insertion_point(field_set:grpc.testing.HistogramData.sum_of_squares)
2232 24 : }
2233 :
2234 : // optional double count = 6;
2235 : inline void HistogramData::clear_count() {
2236 : count_ = 0;
2237 : }
2238 66 : inline double HistogramData::count() const {
2239 : // @@protoc_insertion_point(field_get:grpc.testing.HistogramData.count)
2240 66 : return count_;
2241 : }
2242 24 : inline void HistogramData::set_count(double value) {
2243 :
2244 24 : count_ = value;
2245 : // @@protoc_insertion_point(field_set:grpc.testing.HistogramData.count)
2246 24 : }
2247 :
2248 : // -------------------------------------------------------------------
2249 :
2250 : // PoissonParams
2251 :
2252 : // optional double offered_load = 1;
2253 : inline void PoissonParams::clear_offered_load() {
2254 : offered_load_ = 0;
2255 : }
2256 12 : inline double PoissonParams::offered_load() const {
2257 : // @@protoc_insertion_point(field_get:grpc.testing.PoissonParams.offered_load)
2258 12 : return offered_load_;
2259 : }
2260 5 : inline void PoissonParams::set_offered_load(double value) {
2261 :
2262 5 : offered_load_ = value;
2263 : // @@protoc_insertion_point(field_set:grpc.testing.PoissonParams.offered_load)
2264 5 : }
2265 :
2266 : // -------------------------------------------------------------------
2267 :
2268 : // UniformParams
2269 :
2270 : // optional double interarrival_lo = 1;
2271 : inline void UniformParams::clear_interarrival_lo() {
2272 : interarrival_lo_ = 0;
2273 : }
2274 0 : inline double UniformParams::interarrival_lo() const {
2275 : // @@protoc_insertion_point(field_get:grpc.testing.UniformParams.interarrival_lo)
2276 0 : return interarrival_lo_;
2277 : }
2278 0 : inline void UniformParams::set_interarrival_lo(double value) {
2279 :
2280 0 : interarrival_lo_ = value;
2281 : // @@protoc_insertion_point(field_set:grpc.testing.UniformParams.interarrival_lo)
2282 0 : }
2283 :
2284 : // optional double interarrival_hi = 2;
2285 : inline void UniformParams::clear_interarrival_hi() {
2286 : interarrival_hi_ = 0;
2287 : }
2288 0 : inline double UniformParams::interarrival_hi() const {
2289 : // @@protoc_insertion_point(field_get:grpc.testing.UniformParams.interarrival_hi)
2290 0 : return interarrival_hi_;
2291 : }
2292 0 : inline void UniformParams::set_interarrival_hi(double value) {
2293 :
2294 0 : interarrival_hi_ = value;
2295 : // @@protoc_insertion_point(field_set:grpc.testing.UniformParams.interarrival_hi)
2296 0 : }
2297 :
2298 : // -------------------------------------------------------------------
2299 :
2300 : // DeterministicParams
2301 :
2302 : // optional double offered_load = 1;
2303 : inline void DeterministicParams::clear_offered_load() {
2304 : offered_load_ = 0;
2305 : }
2306 0 : inline double DeterministicParams::offered_load() const {
2307 : // @@protoc_insertion_point(field_get:grpc.testing.DeterministicParams.offered_load)
2308 0 : return offered_load_;
2309 : }
2310 0 : inline void DeterministicParams::set_offered_load(double value) {
2311 :
2312 0 : offered_load_ = value;
2313 : // @@protoc_insertion_point(field_set:grpc.testing.DeterministicParams.offered_load)
2314 0 : }
2315 :
2316 : // -------------------------------------------------------------------
2317 :
2318 : // ParetoParams
2319 :
2320 : // optional double interarrival_base = 1;
2321 : inline void ParetoParams::clear_interarrival_base() {
2322 : interarrival_base_ = 0;
2323 : }
2324 0 : inline double ParetoParams::interarrival_base() const {
2325 : // @@protoc_insertion_point(field_get:grpc.testing.ParetoParams.interarrival_base)
2326 0 : return interarrival_base_;
2327 : }
2328 0 : inline void ParetoParams::set_interarrival_base(double value) {
2329 :
2330 0 : interarrival_base_ = value;
2331 : // @@protoc_insertion_point(field_set:grpc.testing.ParetoParams.interarrival_base)
2332 0 : }
2333 :
2334 : // optional double alpha = 2;
2335 : inline void ParetoParams::clear_alpha() {
2336 : alpha_ = 0;
2337 : }
2338 0 : inline double ParetoParams::alpha() const {
2339 : // @@protoc_insertion_point(field_get:grpc.testing.ParetoParams.alpha)
2340 0 : return alpha_;
2341 : }
2342 0 : inline void ParetoParams::set_alpha(double value) {
2343 :
2344 0 : alpha_ = value;
2345 : // @@protoc_insertion_point(field_set:grpc.testing.ParetoParams.alpha)
2346 0 : }
2347 :
2348 : // -------------------------------------------------------------------
2349 :
2350 : // LoadParams
2351 :
2352 : // optional .grpc.testing.PoissonParams poisson = 1;
2353 12 : inline bool LoadParams::has_poisson() const {
2354 12 : return load_case() == kPoisson;
2355 : }
2356 6 : inline void LoadParams::set_has_poisson() {
2357 6 : _oneof_case_[0] = kPoisson;
2358 6 : }
2359 : inline void LoadParams::clear_poisson() {
2360 : if (has_poisson()) {
2361 : delete load_.poisson_;
2362 : clear_has_load();
2363 : }
2364 : }
2365 5 : inline const ::grpc::testing::PoissonParams& LoadParams::poisson() const {
2366 : // @@protoc_insertion_point(field_get:grpc.testing.LoadParams.poisson)
2367 5 : return has_poisson()
2368 : ? *load_.poisson_
2369 5 : : ::grpc::testing::PoissonParams::default_instance();
2370 : }
2371 6 : inline ::grpc::testing::PoissonParams* LoadParams::mutable_poisson() {
2372 6 : if (!has_poisson()) {
2373 6 : clear_load();
2374 6 : set_has_poisson();
2375 6 : load_.poisson_ = new ::grpc::testing::PoissonParams;
2376 : }
2377 : // @@protoc_insertion_point(field_mutable:grpc.testing.LoadParams.poisson)
2378 6 : return load_.poisson_;
2379 : }
2380 : inline ::grpc::testing::PoissonParams* LoadParams::release_poisson() {
2381 : if (has_poisson()) {
2382 : clear_has_load();
2383 : ::grpc::testing::PoissonParams* temp = load_.poisson_;
2384 : load_.poisson_ = NULL;
2385 : return temp;
2386 : } else {
2387 : return NULL;
2388 : }
2389 : }
2390 : inline void LoadParams::set_allocated_poisson(::grpc::testing::PoissonParams* poisson) {
2391 : clear_load();
2392 : if (poisson) {
2393 : set_has_poisson();
2394 : load_.poisson_ = poisson;
2395 : }
2396 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.LoadParams.poisson)
2397 : }
2398 :
2399 : // optional .grpc.testing.UniformParams uniform = 2;
2400 1 : inline bool LoadParams::has_uniform() const {
2401 1 : return load_case() == kUniform;
2402 : }
2403 0 : inline void LoadParams::set_has_uniform() {
2404 0 : _oneof_case_[0] = kUniform;
2405 0 : }
2406 : inline void LoadParams::clear_uniform() {
2407 : if (has_uniform()) {
2408 : delete load_.uniform_;
2409 : clear_has_load();
2410 : }
2411 : }
2412 0 : inline const ::grpc::testing::UniformParams& LoadParams::uniform() const {
2413 : // @@protoc_insertion_point(field_get:grpc.testing.LoadParams.uniform)
2414 0 : return has_uniform()
2415 : ? *load_.uniform_
2416 0 : : ::grpc::testing::UniformParams::default_instance();
2417 : }
2418 0 : inline ::grpc::testing::UniformParams* LoadParams::mutable_uniform() {
2419 0 : if (!has_uniform()) {
2420 0 : clear_load();
2421 0 : set_has_uniform();
2422 0 : load_.uniform_ = new ::grpc::testing::UniformParams;
2423 : }
2424 : // @@protoc_insertion_point(field_mutable:grpc.testing.LoadParams.uniform)
2425 0 : return load_.uniform_;
2426 : }
2427 : inline ::grpc::testing::UniformParams* LoadParams::release_uniform() {
2428 : if (has_uniform()) {
2429 : clear_has_load();
2430 : ::grpc::testing::UniformParams* temp = load_.uniform_;
2431 : load_.uniform_ = NULL;
2432 : return temp;
2433 : } else {
2434 : return NULL;
2435 : }
2436 : }
2437 : inline void LoadParams::set_allocated_uniform(::grpc::testing::UniformParams* uniform) {
2438 : clear_load();
2439 : if (uniform) {
2440 : set_has_uniform();
2441 : load_.uniform_ = uniform;
2442 : }
2443 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.LoadParams.uniform)
2444 : }
2445 :
2446 : // optional .grpc.testing.DeterministicParams determ = 3;
2447 1 : inline bool LoadParams::has_determ() const {
2448 1 : return load_case() == kDeterm;
2449 : }
2450 0 : inline void LoadParams::set_has_determ() {
2451 0 : _oneof_case_[0] = kDeterm;
2452 0 : }
2453 : inline void LoadParams::clear_determ() {
2454 : if (has_determ()) {
2455 : delete load_.determ_;
2456 : clear_has_load();
2457 : }
2458 : }
2459 0 : inline const ::grpc::testing::DeterministicParams& LoadParams::determ() const {
2460 : // @@protoc_insertion_point(field_get:grpc.testing.LoadParams.determ)
2461 0 : return has_determ()
2462 : ? *load_.determ_
2463 0 : : ::grpc::testing::DeterministicParams::default_instance();
2464 : }
2465 0 : inline ::grpc::testing::DeterministicParams* LoadParams::mutable_determ() {
2466 0 : if (!has_determ()) {
2467 0 : clear_load();
2468 0 : set_has_determ();
2469 0 : load_.determ_ = new ::grpc::testing::DeterministicParams;
2470 : }
2471 : // @@protoc_insertion_point(field_mutable:grpc.testing.LoadParams.determ)
2472 0 : return load_.determ_;
2473 : }
2474 : inline ::grpc::testing::DeterministicParams* LoadParams::release_determ() {
2475 : if (has_determ()) {
2476 : clear_has_load();
2477 : ::grpc::testing::DeterministicParams* temp = load_.determ_;
2478 : load_.determ_ = NULL;
2479 : return temp;
2480 : } else {
2481 : return NULL;
2482 : }
2483 : }
2484 : inline void LoadParams::set_allocated_determ(::grpc::testing::DeterministicParams* determ) {
2485 : clear_load();
2486 : if (determ) {
2487 : set_has_determ();
2488 : load_.determ_ = determ;
2489 : }
2490 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.LoadParams.determ)
2491 : }
2492 :
2493 : // optional .grpc.testing.ParetoParams pareto = 4;
2494 1 : inline bool LoadParams::has_pareto() const {
2495 1 : return load_case() == kPareto;
2496 : }
2497 0 : inline void LoadParams::set_has_pareto() {
2498 0 : _oneof_case_[0] = kPareto;
2499 0 : }
2500 : inline void LoadParams::clear_pareto() {
2501 : if (has_pareto()) {
2502 : delete load_.pareto_;
2503 : clear_has_load();
2504 : }
2505 : }
2506 0 : inline const ::grpc::testing::ParetoParams& LoadParams::pareto() const {
2507 : // @@protoc_insertion_point(field_get:grpc.testing.LoadParams.pareto)
2508 0 : return has_pareto()
2509 : ? *load_.pareto_
2510 0 : : ::grpc::testing::ParetoParams::default_instance();
2511 : }
2512 0 : inline ::grpc::testing::ParetoParams* LoadParams::mutable_pareto() {
2513 0 : if (!has_pareto()) {
2514 0 : clear_load();
2515 0 : set_has_pareto();
2516 0 : load_.pareto_ = new ::grpc::testing::ParetoParams;
2517 : }
2518 : // @@protoc_insertion_point(field_mutable:grpc.testing.LoadParams.pareto)
2519 0 : return load_.pareto_;
2520 : }
2521 : inline ::grpc::testing::ParetoParams* LoadParams::release_pareto() {
2522 : if (has_pareto()) {
2523 : clear_has_load();
2524 : ::grpc::testing::ParetoParams* temp = load_.pareto_;
2525 : load_.pareto_ = NULL;
2526 : return temp;
2527 : } else {
2528 : return NULL;
2529 : }
2530 : }
2531 : inline void LoadParams::set_allocated_pareto(::grpc::testing::ParetoParams* pareto) {
2532 : clear_load();
2533 : if (pareto) {
2534 : set_has_pareto();
2535 : load_.pareto_ = pareto;
2536 : }
2537 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.LoadParams.pareto)
2538 : }
2539 :
2540 6 : inline bool LoadParams::has_load() const {
2541 6 : return load_case() != LOAD_NOT_SET;
2542 : }
2543 12 : inline void LoadParams::clear_has_load() {
2544 12 : _oneof_case_[0] = LOAD_NOT_SET;
2545 12 : }
2546 38 : inline LoadParams::LoadCase LoadParams::load_case() const {
2547 38 : return LoadParams::LoadCase(_oneof_case_[0]);
2548 : }
2549 : // -------------------------------------------------------------------
2550 :
2551 : // ClientConfig
2552 :
2553 : // repeated string server_targets = 1;
2554 62 : inline int ClientConfig::server_targets_size() const {
2555 62 : return server_targets_.size();
2556 : }
2557 : inline void ClientConfig::clear_server_targets() {
2558 : server_targets_.Clear();
2559 : }
2560 56 : inline const ::std::string& ClientConfig::server_targets(int index) const {
2561 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.server_targets)
2562 56 : return server_targets_.Get(index);
2563 : }
2564 : inline ::std::string* ClientConfig::mutable_server_targets(int index) {
2565 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientConfig.server_targets)
2566 : return server_targets_.Mutable(index);
2567 : }
2568 : inline void ClientConfig::set_server_targets(int index, const ::std::string& value) {
2569 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.server_targets)
2570 : server_targets_.Mutable(index)->assign(value);
2571 : }
2572 : inline void ClientConfig::set_server_targets(int index, const char* value) {
2573 : server_targets_.Mutable(index)->assign(value);
2574 : // @@protoc_insertion_point(field_set_char:grpc.testing.ClientConfig.server_targets)
2575 : }
2576 : inline void ClientConfig::set_server_targets(int index, const char* value, size_t size) {
2577 : server_targets_.Mutable(index)->assign(
2578 : reinterpret_cast<const char*>(value), size);
2579 : // @@protoc_insertion_point(field_set_pointer:grpc.testing.ClientConfig.server_targets)
2580 : }
2581 6 : inline ::std::string* ClientConfig::add_server_targets() {
2582 6 : return server_targets_.Add();
2583 : }
2584 : inline void ClientConfig::add_server_targets(const ::std::string& value) {
2585 : server_targets_.Add()->assign(value);
2586 : // @@protoc_insertion_point(field_add:grpc.testing.ClientConfig.server_targets)
2587 : }
2588 6 : inline void ClientConfig::add_server_targets(const char* value) {
2589 6 : server_targets_.Add()->assign(value);
2590 : // @@protoc_insertion_point(field_add_char:grpc.testing.ClientConfig.server_targets)
2591 6 : }
2592 : inline void ClientConfig::add_server_targets(const char* value, size_t size) {
2593 : server_targets_.Add()->assign(reinterpret_cast<const char*>(value), size);
2594 : // @@protoc_insertion_point(field_add_pointer:grpc.testing.ClientConfig.server_targets)
2595 : }
2596 : inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
2597 : ClientConfig::server_targets() const {
2598 : // @@protoc_insertion_point(field_list:grpc.testing.ClientConfig.server_targets)
2599 : return server_targets_;
2600 : }
2601 : inline ::google::protobuf::RepeatedPtrField< ::std::string>*
2602 : ClientConfig::mutable_server_targets() {
2603 : // @@protoc_insertion_point(field_mutable_list:grpc.testing.ClientConfig.server_targets)
2604 : return &server_targets_;
2605 : }
2606 :
2607 : // optional .grpc.testing.ClientType client_type = 2;
2608 : inline void ClientConfig::clear_client_type() {
2609 : client_type_ = 0;
2610 : }
2611 66 : inline ::grpc::testing::ClientType ClientConfig::client_type() const {
2612 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.client_type)
2613 66 : return static_cast< ::grpc::testing::ClientType >(client_type_);
2614 : }
2615 26 : inline void ClientConfig::set_client_type(::grpc::testing::ClientType value) {
2616 :
2617 26 : client_type_ = value;
2618 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.client_type)
2619 26 : }
2620 :
2621 : // optional bool enable_ssl = 3;
2622 : inline void ClientConfig::clear_enable_ssl() {
2623 : enable_ssl_ = false;
2624 : }
2625 56 : inline bool ClientConfig::enable_ssl() const {
2626 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.enable_ssl)
2627 56 : return enable_ssl_;
2628 : }
2629 6 : inline void ClientConfig::set_enable_ssl(bool value) {
2630 :
2631 6 : enable_ssl_ = value;
2632 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.enable_ssl)
2633 6 : }
2634 :
2635 : // optional int32 outstanding_rpcs_per_channel = 4;
2636 : inline void ClientConfig::clear_outstanding_rpcs_per_channel() {
2637 : outstanding_rpcs_per_channel_ = 0;
2638 : }
2639 2084 : inline ::google::protobuf::int32 ClientConfig::outstanding_rpcs_per_channel() const {
2640 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.outstanding_rpcs_per_channel)
2641 2084 : return outstanding_rpcs_per_channel_;
2642 : }
2643 30 : inline void ClientConfig::set_outstanding_rpcs_per_channel(::google::protobuf::int32 value) {
2644 :
2645 30 : outstanding_rpcs_per_channel_ = value;
2646 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.outstanding_rpcs_per_channel)
2647 30 : }
2648 :
2649 : // optional int32 client_channels = 5;
2650 : inline void ClientConfig::clear_client_channels() {
2651 : client_channels_ = 0;
2652 : }
2653 118 : inline ::google::protobuf::int32 ClientConfig::client_channels() const {
2654 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.client_channels)
2655 118 : return client_channels_;
2656 : }
2657 30 : inline void ClientConfig::set_client_channels(::google::protobuf::int32 value) {
2658 :
2659 30 : client_channels_ = value;
2660 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.client_channels)
2661 30 : }
2662 :
2663 : // optional int32 payload_size = 6;
2664 : inline void ClientConfig::clear_payload_size() {
2665 : payload_size_ = 0;
2666 : }
2667 78 : inline ::google::protobuf::int32 ClientConfig::payload_size() const {
2668 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.payload_size)
2669 78 : return payload_size_;
2670 : }
2671 30 : inline void ClientConfig::set_payload_size(::google::protobuf::int32 value) {
2672 :
2673 30 : payload_size_ = value;
2674 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.payload_size)
2675 30 : }
2676 :
2677 : // optional int32 async_client_threads = 7;
2678 : inline void ClientConfig::clear_async_client_threads() {
2679 : async_client_threads_ = 0;
2680 : }
2681 94 : inline ::google::protobuf::int32 ClientConfig::async_client_threads() const {
2682 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.async_client_threads)
2683 94 : return async_client_threads_;
2684 : }
2685 20 : inline void ClientConfig::set_async_client_threads(::google::protobuf::int32 value) {
2686 :
2687 20 : async_client_threads_ = value;
2688 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.async_client_threads)
2689 20 : }
2690 :
2691 : // optional .grpc.testing.RpcType rpc_type = 8;
2692 : inline void ClientConfig::clear_rpc_type() {
2693 : rpc_type_ = 0;
2694 : }
2695 54 : inline ::grpc::testing::RpcType ClientConfig::rpc_type() const {
2696 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.rpc_type)
2697 54 : return static_cast< ::grpc::testing::RpcType >(rpc_type_);
2698 : }
2699 16 : inline void ClientConfig::set_rpc_type(::grpc::testing::RpcType value) {
2700 :
2701 16 : rpc_type_ = value;
2702 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.rpc_type)
2703 16 : }
2704 :
2705 : // optional string host = 9;
2706 : inline void ClientConfig::clear_host() {
2707 : host_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2708 : }
2709 36 : inline const ::std::string& ClientConfig::host() const {
2710 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.host)
2711 36 : return host_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2712 : }
2713 6 : inline void ClientConfig::set_host(const ::std::string& value) {
2714 :
2715 6 : host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2716 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.host)
2717 6 : }
2718 : inline void ClientConfig::set_host(const char* value) {
2719 :
2720 : host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2721 : // @@protoc_insertion_point(field_set_char:grpc.testing.ClientConfig.host)
2722 : }
2723 : inline void ClientConfig::set_host(const char* value, size_t size) {
2724 :
2725 : host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2726 : ::std::string(reinterpret_cast<const char*>(value), size));
2727 : // @@protoc_insertion_point(field_set_pointer:grpc.testing.ClientConfig.host)
2728 : }
2729 0 : inline ::std::string* ClientConfig::mutable_host() {
2730 :
2731 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientConfig.host)
2732 0 : return host_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2733 : }
2734 : inline ::std::string* ClientConfig::release_host() {
2735 :
2736 : return host_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2737 : }
2738 : inline void ClientConfig::set_allocated_host(::std::string* host) {
2739 : if (host != NULL) {
2740 :
2741 : } else {
2742 :
2743 : }
2744 : host_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), host);
2745 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ClientConfig.host)
2746 : }
2747 :
2748 : // optional .grpc.testing.LoadType load_type = 10;
2749 : inline void ClientConfig::clear_load_type() {
2750 : load_type_ = 0;
2751 : }
2752 50 : inline ::grpc::testing::LoadType ClientConfig::load_type() const {
2753 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.load_type)
2754 50 : return static_cast< ::grpc::testing::LoadType >(load_type_);
2755 : }
2756 6 : inline void ClientConfig::set_load_type(::grpc::testing::LoadType value) {
2757 :
2758 6 : load_type_ = value;
2759 : // @@protoc_insertion_point(field_set:grpc.testing.ClientConfig.load_type)
2760 6 : }
2761 :
2762 : // optional .grpc.testing.LoadParams load_params = 11;
2763 36 : inline bool ClientConfig::has_load_params() const {
2764 36 : return !_is_default_instance_ && load_params_ != NULL;
2765 : }
2766 : inline void ClientConfig::clear_load_params() {
2767 : if (GetArenaNoVirtual() == NULL && load_params_ != NULL) delete load_params_;
2768 : load_params_ = NULL;
2769 : }
2770 5 : inline const ::grpc::testing::LoadParams& ClientConfig::load_params() const {
2771 : // @@protoc_insertion_point(field_get:grpc.testing.ClientConfig.load_params)
2772 5 : return load_params_ != NULL ? *load_params_ : *default_instance_->load_params_;
2773 : }
2774 6 : inline ::grpc::testing::LoadParams* ClientConfig::mutable_load_params() {
2775 :
2776 6 : if (load_params_ == NULL) {
2777 6 : load_params_ = new ::grpc::testing::LoadParams;
2778 : }
2779 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientConfig.load_params)
2780 6 : return load_params_;
2781 : }
2782 : inline ::grpc::testing::LoadParams* ClientConfig::release_load_params() {
2783 :
2784 : ::grpc::testing::LoadParams* temp = load_params_;
2785 : load_params_ = NULL;
2786 : return temp;
2787 : }
2788 : inline void ClientConfig::set_allocated_load_params(::grpc::testing::LoadParams* load_params) {
2789 : delete load_params_;
2790 : load_params_ = load_params;
2791 : if (load_params) {
2792 :
2793 : } else {
2794 :
2795 : }
2796 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ClientConfig.load_params)
2797 : }
2798 :
2799 : // -------------------------------------------------------------------
2800 :
2801 : // Mark
2802 :
2803 : // -------------------------------------------------------------------
2804 :
2805 : // ClientArgs
2806 :
2807 : // optional .grpc.testing.ClientConfig setup = 1;
2808 42 : inline bool ClientArgs::has_setup() const {
2809 42 : return argtype_case() == kSetup;
2810 : }
2811 12 : inline void ClientArgs::set_has_setup() {
2812 12 : _oneof_case_[0] = kSetup;
2813 12 : }
2814 : inline void ClientArgs::clear_setup() {
2815 : if (has_setup()) {
2816 : delete argtype_.setup_;
2817 : clear_has_argtype();
2818 : }
2819 : }
2820 6 : inline const ::grpc::testing::ClientConfig& ClientArgs::setup() const {
2821 : // @@protoc_insertion_point(field_get:grpc.testing.ClientArgs.setup)
2822 6 : return has_setup()
2823 : ? *argtype_.setup_
2824 6 : : ::grpc::testing::ClientConfig::default_instance();
2825 : }
2826 12 : inline ::grpc::testing::ClientConfig* ClientArgs::mutable_setup() {
2827 12 : if (!has_setup()) {
2828 12 : clear_argtype();
2829 12 : set_has_setup();
2830 12 : argtype_.setup_ = new ::grpc::testing::ClientConfig;
2831 : }
2832 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientArgs.setup)
2833 12 : return argtype_.setup_;
2834 : }
2835 : inline ::grpc::testing::ClientConfig* ClientArgs::release_setup() {
2836 : if (has_setup()) {
2837 : clear_has_argtype();
2838 : ::grpc::testing::ClientConfig* temp = argtype_.setup_;
2839 : argtype_.setup_ = NULL;
2840 : return temp;
2841 : } else {
2842 : return NULL;
2843 : }
2844 : }
2845 : inline void ClientArgs::set_allocated_setup(::grpc::testing::ClientConfig* setup) {
2846 : clear_argtype();
2847 : if (setup) {
2848 : set_has_setup();
2849 : argtype_.setup_ = setup;
2850 : }
2851 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ClientArgs.setup)
2852 : }
2853 :
2854 : // optional .grpc.testing.Mark mark = 2;
2855 48 : inline bool ClientArgs::has_mark() const {
2856 48 : return argtype_case() == kMark;
2857 : }
2858 18 : inline void ClientArgs::set_has_mark() {
2859 18 : _oneof_case_[0] = kMark;
2860 18 : }
2861 : inline void ClientArgs::clear_mark() {
2862 : if (has_mark()) {
2863 : delete argtype_.mark_;
2864 : clear_has_argtype();
2865 : }
2866 : }
2867 0 : inline const ::grpc::testing::Mark& ClientArgs::mark() const {
2868 : // @@protoc_insertion_point(field_get:grpc.testing.ClientArgs.mark)
2869 0 : return has_mark()
2870 : ? *argtype_.mark_
2871 0 : : ::grpc::testing::Mark::default_instance();
2872 : }
2873 18 : inline ::grpc::testing::Mark* ClientArgs::mutable_mark() {
2874 18 : if (!has_mark()) {
2875 18 : clear_argtype();
2876 18 : set_has_mark();
2877 18 : argtype_.mark_ = new ::grpc::testing::Mark;
2878 : }
2879 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientArgs.mark)
2880 18 : return argtype_.mark_;
2881 : }
2882 : inline ::grpc::testing::Mark* ClientArgs::release_mark() {
2883 : if (has_mark()) {
2884 : clear_has_argtype();
2885 : ::grpc::testing::Mark* temp = argtype_.mark_;
2886 : argtype_.mark_ = NULL;
2887 : return temp;
2888 : } else {
2889 : return NULL;
2890 : }
2891 : }
2892 : inline void ClientArgs::set_allocated_mark(::grpc::testing::Mark* mark) {
2893 : clear_argtype();
2894 : if (mark) {
2895 : set_has_mark();
2896 : argtype_.mark_ = mark;
2897 : }
2898 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ClientArgs.mark)
2899 : }
2900 :
2901 18 : inline bool ClientArgs::has_argtype() const {
2902 18 : return argtype_case() != ARGTYPE_NOT_SET;
2903 : }
2904 24 : inline void ClientArgs::clear_has_argtype() {
2905 24 : _oneof_case_[0] = ARGTYPE_NOT_SET;
2906 24 : }
2907 192 : inline ClientArgs::ArgtypeCase ClientArgs::argtype_case() const {
2908 192 : return ClientArgs::ArgtypeCase(_oneof_case_[0]);
2909 : }
2910 : // -------------------------------------------------------------------
2911 :
2912 : // ClientStats
2913 :
2914 : // optional .grpc.testing.HistogramData latencies = 1;
2915 36 : inline bool ClientStats::has_latencies() const {
2916 36 : return !_is_default_instance_ && latencies_ != NULL;
2917 : }
2918 : inline void ClientStats::clear_latencies() {
2919 : if (GetArenaNoVirtual() == NULL && latencies_ != NULL) delete latencies_;
2920 : latencies_ = NULL;
2921 : }
2922 18 : inline const ::grpc::testing::HistogramData& ClientStats::latencies() const {
2923 : // @@protoc_insertion_point(field_get:grpc.testing.ClientStats.latencies)
2924 18 : return latencies_ != NULL ? *latencies_ : *default_instance_->latencies_;
2925 : }
2926 36 : inline ::grpc::testing::HistogramData* ClientStats::mutable_latencies() {
2927 :
2928 36 : if (latencies_ == NULL) {
2929 36 : latencies_ = new ::grpc::testing::HistogramData;
2930 : }
2931 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientStats.latencies)
2932 36 : return latencies_;
2933 : }
2934 : inline ::grpc::testing::HistogramData* ClientStats::release_latencies() {
2935 :
2936 : ::grpc::testing::HistogramData* temp = latencies_;
2937 : latencies_ = NULL;
2938 : return temp;
2939 : }
2940 : inline void ClientStats::set_allocated_latencies(::grpc::testing::HistogramData* latencies) {
2941 : delete latencies_;
2942 : latencies_ = latencies;
2943 : if (latencies) {
2944 :
2945 : } else {
2946 :
2947 : }
2948 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ClientStats.latencies)
2949 : }
2950 :
2951 : // optional double time_elapsed = 2;
2952 : inline void ClientStats::clear_time_elapsed() {
2953 : time_elapsed_ = 0;
2954 : }
2955 66 : inline double ClientStats::time_elapsed() const {
2956 : // @@protoc_insertion_point(field_get:grpc.testing.ClientStats.time_elapsed)
2957 66 : return time_elapsed_;
2958 : }
2959 24 : inline void ClientStats::set_time_elapsed(double value) {
2960 :
2961 24 : time_elapsed_ = value;
2962 : // @@protoc_insertion_point(field_set:grpc.testing.ClientStats.time_elapsed)
2963 24 : }
2964 :
2965 : // optional double time_user = 3;
2966 : inline void ClientStats::clear_time_user() {
2967 : time_user_ = 0;
2968 : }
2969 66 : inline double ClientStats::time_user() const {
2970 : // @@protoc_insertion_point(field_get:grpc.testing.ClientStats.time_user)
2971 66 : return time_user_;
2972 : }
2973 24 : inline void ClientStats::set_time_user(double value) {
2974 :
2975 24 : time_user_ = value;
2976 : // @@protoc_insertion_point(field_set:grpc.testing.ClientStats.time_user)
2977 24 : }
2978 :
2979 : // optional double time_system = 4;
2980 : inline void ClientStats::clear_time_system() {
2981 : time_system_ = 0;
2982 : }
2983 66 : inline double ClientStats::time_system() const {
2984 : // @@protoc_insertion_point(field_get:grpc.testing.ClientStats.time_system)
2985 66 : return time_system_;
2986 : }
2987 24 : inline void ClientStats::set_time_system(double value) {
2988 :
2989 24 : time_system_ = value;
2990 : // @@protoc_insertion_point(field_set:grpc.testing.ClientStats.time_system)
2991 24 : }
2992 :
2993 : // -------------------------------------------------------------------
2994 :
2995 : // ClientStatus
2996 :
2997 : // optional .grpc.testing.ClientStats stats = 1;
2998 36 : inline bool ClientStatus::has_stats() const {
2999 36 : return !_is_default_instance_ && stats_ != NULL;
3000 : }
3001 : inline void ClientStatus::clear_stats() {
3002 : if (GetArenaNoVirtual() == NULL && stats_ != NULL) delete stats_;
3003 : stats_ = NULL;
3004 : }
3005 6 : inline const ::grpc::testing::ClientStats& ClientStatus::stats() const {
3006 : // @@protoc_insertion_point(field_get:grpc.testing.ClientStatus.stats)
3007 6 : return stats_ != NULL ? *stats_ : *default_instance_->stats_;
3008 : }
3009 24 : inline ::grpc::testing::ClientStats* ClientStatus::mutable_stats() {
3010 :
3011 24 : if (stats_ == NULL) {
3012 18 : stats_ = new ::grpc::testing::ClientStats;
3013 : }
3014 : // @@protoc_insertion_point(field_mutable:grpc.testing.ClientStatus.stats)
3015 24 : return stats_;
3016 : }
3017 : inline ::grpc::testing::ClientStats* ClientStatus::release_stats() {
3018 :
3019 : ::grpc::testing::ClientStats* temp = stats_;
3020 : stats_ = NULL;
3021 : return temp;
3022 : }
3023 : inline void ClientStatus::set_allocated_stats(::grpc::testing::ClientStats* stats) {
3024 : delete stats_;
3025 : stats_ = stats;
3026 : if (stats) {
3027 :
3028 : } else {
3029 :
3030 : }
3031 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ClientStatus.stats)
3032 : }
3033 :
3034 : // -------------------------------------------------------------------
3035 :
3036 : // ServerConfig
3037 :
3038 : // optional .grpc.testing.ServerType server_type = 1;
3039 : inline void ServerConfig::clear_server_type() {
3040 : server_type_ = 0;
3041 : }
3042 56 : inline ::grpc::testing::ServerType ServerConfig::server_type() const {
3043 : // @@protoc_insertion_point(field_get:grpc.testing.ServerConfig.server_type)
3044 56 : return static_cast< ::grpc::testing::ServerType >(server_type_);
3045 : }
3046 22 : inline void ServerConfig::set_server_type(::grpc::testing::ServerType value) {
3047 :
3048 22 : server_type_ = value;
3049 : // @@protoc_insertion_point(field_set:grpc.testing.ServerConfig.server_type)
3050 22 : }
3051 :
3052 : // optional int32 threads = 2;
3053 : inline void ServerConfig::clear_threads() {
3054 : threads_ = 0;
3055 : }
3056 87620 : inline ::google::protobuf::int32 ServerConfig::threads() const {
3057 : // @@protoc_insertion_point(field_get:grpc.testing.ServerConfig.threads)
3058 87620 : return threads_;
3059 : }
3060 24 : inline void ServerConfig::set_threads(::google::protobuf::int32 value) {
3061 :
3062 24 : threads_ = value;
3063 : // @@protoc_insertion_point(field_set:grpc.testing.ServerConfig.threads)
3064 24 : }
3065 :
3066 : // optional bool enable_ssl = 3;
3067 : inline void ServerConfig::clear_enable_ssl() {
3068 : enable_ssl_ = false;
3069 : }
3070 30 : inline bool ServerConfig::enable_ssl() const {
3071 : // @@protoc_insertion_point(field_get:grpc.testing.ServerConfig.enable_ssl)
3072 30 : return enable_ssl_;
3073 : }
3074 6 : inline void ServerConfig::set_enable_ssl(bool value) {
3075 :
3076 6 : enable_ssl_ = value;
3077 : // @@protoc_insertion_point(field_set:grpc.testing.ServerConfig.enable_ssl)
3078 6 : }
3079 :
3080 : // optional string host = 4;
3081 : inline void ServerConfig::clear_host() {
3082 : host_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3083 : }
3084 30 : inline const ::std::string& ServerConfig::host() const {
3085 : // @@protoc_insertion_point(field_get:grpc.testing.ServerConfig.host)
3086 30 : return host_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3087 : }
3088 6 : inline void ServerConfig::set_host(const ::std::string& value) {
3089 :
3090 6 : host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3091 : // @@protoc_insertion_point(field_set:grpc.testing.ServerConfig.host)
3092 6 : }
3093 : inline void ServerConfig::set_host(const char* value) {
3094 :
3095 : host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3096 : // @@protoc_insertion_point(field_set_char:grpc.testing.ServerConfig.host)
3097 : }
3098 : inline void ServerConfig::set_host(const char* value, size_t size) {
3099 :
3100 : host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3101 : ::std::string(reinterpret_cast<const char*>(value), size));
3102 : // @@protoc_insertion_point(field_set_pointer:grpc.testing.ServerConfig.host)
3103 : }
3104 0 : inline ::std::string* ServerConfig::mutable_host() {
3105 :
3106 : // @@protoc_insertion_point(field_mutable:grpc.testing.ServerConfig.host)
3107 0 : return host_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3108 : }
3109 : inline ::std::string* ServerConfig::release_host() {
3110 :
3111 : return host_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3112 : }
3113 : inline void ServerConfig::set_allocated_host(::std::string* host) {
3114 : if (host != NULL) {
3115 :
3116 : } else {
3117 :
3118 : }
3119 : host_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), host);
3120 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ServerConfig.host)
3121 : }
3122 :
3123 : // -------------------------------------------------------------------
3124 :
3125 : // ServerArgs
3126 :
3127 : // optional .grpc.testing.ServerConfig setup = 1;
3128 42 : inline bool ServerArgs::has_setup() const {
3129 42 : return argtype_case() == kSetup;
3130 : }
3131 12 : inline void ServerArgs::set_has_setup() {
3132 12 : _oneof_case_[0] = kSetup;
3133 12 : }
3134 : inline void ServerArgs::clear_setup() {
3135 : if (has_setup()) {
3136 : delete argtype_.setup_;
3137 : clear_has_argtype();
3138 : }
3139 : }
3140 6 : inline const ::grpc::testing::ServerConfig& ServerArgs::setup() const {
3141 : // @@protoc_insertion_point(field_get:grpc.testing.ServerArgs.setup)
3142 6 : return has_setup()
3143 : ? *argtype_.setup_
3144 6 : : ::grpc::testing::ServerConfig::default_instance();
3145 : }
3146 12 : inline ::grpc::testing::ServerConfig* ServerArgs::mutable_setup() {
3147 12 : if (!has_setup()) {
3148 12 : clear_argtype();
3149 12 : set_has_setup();
3150 12 : argtype_.setup_ = new ::grpc::testing::ServerConfig;
3151 : }
3152 : // @@protoc_insertion_point(field_mutable:grpc.testing.ServerArgs.setup)
3153 12 : return argtype_.setup_;
3154 : }
3155 : inline ::grpc::testing::ServerConfig* ServerArgs::release_setup() {
3156 : if (has_setup()) {
3157 : clear_has_argtype();
3158 : ::grpc::testing::ServerConfig* temp = argtype_.setup_;
3159 : argtype_.setup_ = NULL;
3160 : return temp;
3161 : } else {
3162 : return NULL;
3163 : }
3164 : }
3165 : inline void ServerArgs::set_allocated_setup(::grpc::testing::ServerConfig* setup) {
3166 : clear_argtype();
3167 : if (setup) {
3168 : set_has_setup();
3169 : argtype_.setup_ = setup;
3170 : }
3171 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ServerArgs.setup)
3172 : }
3173 :
3174 : // optional .grpc.testing.Mark mark = 2;
3175 48 : inline bool ServerArgs::has_mark() const {
3176 48 : return argtype_case() == kMark;
3177 : }
3178 18 : inline void ServerArgs::set_has_mark() {
3179 18 : _oneof_case_[0] = kMark;
3180 18 : }
3181 : inline void ServerArgs::clear_mark() {
3182 : if (has_mark()) {
3183 : delete argtype_.mark_;
3184 : clear_has_argtype();
3185 : }
3186 : }
3187 0 : inline const ::grpc::testing::Mark& ServerArgs::mark() const {
3188 : // @@protoc_insertion_point(field_get:grpc.testing.ServerArgs.mark)
3189 0 : return has_mark()
3190 : ? *argtype_.mark_
3191 0 : : ::grpc::testing::Mark::default_instance();
3192 : }
3193 18 : inline ::grpc::testing::Mark* ServerArgs::mutable_mark() {
3194 18 : if (!has_mark()) {
3195 18 : clear_argtype();
3196 18 : set_has_mark();
3197 18 : argtype_.mark_ = new ::grpc::testing::Mark;
3198 : }
3199 : // @@protoc_insertion_point(field_mutable:grpc.testing.ServerArgs.mark)
3200 18 : return argtype_.mark_;
3201 : }
3202 : inline ::grpc::testing::Mark* ServerArgs::release_mark() {
3203 : if (has_mark()) {
3204 : clear_has_argtype();
3205 : ::grpc::testing::Mark* temp = argtype_.mark_;
3206 : argtype_.mark_ = NULL;
3207 : return temp;
3208 : } else {
3209 : return NULL;
3210 : }
3211 : }
3212 : inline void ServerArgs::set_allocated_mark(::grpc::testing::Mark* mark) {
3213 : clear_argtype();
3214 : if (mark) {
3215 : set_has_mark();
3216 : argtype_.mark_ = mark;
3217 : }
3218 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ServerArgs.mark)
3219 : }
3220 :
3221 18 : inline bool ServerArgs::has_argtype() const {
3222 18 : return argtype_case() != ARGTYPE_NOT_SET;
3223 : }
3224 24 : inline void ServerArgs::clear_has_argtype() {
3225 24 : _oneof_case_[0] = ARGTYPE_NOT_SET;
3226 24 : }
3227 192 : inline ServerArgs::ArgtypeCase ServerArgs::argtype_case() const {
3228 192 : return ServerArgs::ArgtypeCase(_oneof_case_[0]);
3229 : }
3230 : // -------------------------------------------------------------------
3231 :
3232 : // ServerStatus
3233 :
3234 : // optional .grpc.testing.ServerStats stats = 1;
3235 36 : inline bool ServerStatus::has_stats() const {
3236 36 : return !_is_default_instance_ && stats_ != NULL;
3237 : }
3238 : inline void ServerStatus::clear_stats() {
3239 : if (GetArenaNoVirtual() == NULL && stats_ != NULL) delete stats_;
3240 : stats_ = NULL;
3241 : }
3242 6 : inline const ::grpc::testing::ServerStats& ServerStatus::stats() const {
3243 : // @@protoc_insertion_point(field_get:grpc.testing.ServerStatus.stats)
3244 6 : return stats_ != NULL ? *stats_ : *default_instance_->stats_;
3245 : }
3246 24 : inline ::grpc::testing::ServerStats* ServerStatus::mutable_stats() {
3247 :
3248 24 : if (stats_ == NULL) {
3249 18 : stats_ = new ::grpc::testing::ServerStats;
3250 : }
3251 : // @@protoc_insertion_point(field_mutable:grpc.testing.ServerStatus.stats)
3252 24 : return stats_;
3253 : }
3254 : inline ::grpc::testing::ServerStats* ServerStatus::release_stats() {
3255 :
3256 : ::grpc::testing::ServerStats* temp = stats_;
3257 : stats_ = NULL;
3258 : return temp;
3259 : }
3260 : inline void ServerStatus::set_allocated_stats(::grpc::testing::ServerStats* stats) {
3261 : delete stats_;
3262 : stats_ = stats;
3263 : if (stats) {
3264 :
3265 : } else {
3266 :
3267 : }
3268 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.ServerStatus.stats)
3269 : }
3270 :
3271 : // optional int32 port = 2;
3272 : inline void ServerStatus::clear_port() {
3273 : port_ = 0;
3274 : }
3275 78 : inline ::google::protobuf::int32 ServerStatus::port() const {
3276 : // @@protoc_insertion_point(field_get:grpc.testing.ServerStatus.port)
3277 78 : return port_;
3278 : }
3279 6 : inline void ServerStatus::set_port(::google::protobuf::int32 value) {
3280 :
3281 6 : port_ = value;
3282 : // @@protoc_insertion_point(field_set:grpc.testing.ServerStatus.port)
3283 6 : }
3284 :
3285 : // -------------------------------------------------------------------
3286 :
3287 : // SimpleRequest
3288 :
3289 : // optional .grpc.testing.PayloadType response_type = 1;
3290 : inline void SimpleRequest::clear_response_type() {
3291 : response_type_ = 0;
3292 : }
3293 6123580 : inline ::grpc::testing::PayloadType SimpleRequest::response_type() const {
3294 : // @@protoc_insertion_point(field_get:grpc.testing.SimpleRequest.response_type)
3295 6123580 : return static_cast< ::grpc::testing::PayloadType >(response_type_);
3296 : }
3297 6 : inline void SimpleRequest::set_response_type(::grpc::testing::PayloadType value) {
3298 :
3299 6 : response_type_ = value;
3300 : // @@protoc_insertion_point(field_set:grpc.testing.SimpleRequest.response_type)
3301 6 : }
3302 :
3303 : // optional int32 response_size = 2;
3304 : inline void SimpleRequest::clear_response_size() {
3305 : response_size_ = 0;
3306 : }
3307 11082834 : inline ::google::protobuf::int32 SimpleRequest::response_size() const {
3308 : // @@protoc_insertion_point(field_get:grpc.testing.SimpleRequest.response_size)
3309 11082834 : return response_size_;
3310 : }
3311 1139398 : inline void SimpleRequest::set_response_size(::google::protobuf::int32 value) {
3312 :
3313 1139398 : response_size_ = value;
3314 : // @@protoc_insertion_point(field_set:grpc.testing.SimpleRequest.response_size)
3315 1139398 : }
3316 :
3317 : // optional .grpc.testing.Payload payload = 3;
3318 4852782 : inline bool SimpleRequest::has_payload() const {
3319 4852782 : return !_is_default_instance_ && payload_ != NULL;
3320 : }
3321 : inline void SimpleRequest::clear_payload() {
3322 : if (GetArenaNoVirtual() == NULL && payload_ != NULL) delete payload_;
3323 : payload_ = NULL;
3324 : }
3325 0 : inline const ::grpc::testing::Payload& SimpleRequest::payload() const {
3326 : // @@protoc_insertion_point(field_get:grpc.testing.SimpleRequest.payload)
3327 0 : return payload_ != NULL ? *payload_ : *default_instance_->payload_;
3328 : }
3329 0 : inline ::grpc::testing::Payload* SimpleRequest::mutable_payload() {
3330 :
3331 0 : if (payload_ == NULL) {
3332 0 : payload_ = new ::grpc::testing::Payload;
3333 : }
3334 : // @@protoc_insertion_point(field_mutable:grpc.testing.SimpleRequest.payload)
3335 0 : return payload_;
3336 : }
3337 : inline ::grpc::testing::Payload* SimpleRequest::release_payload() {
3338 :
3339 : ::grpc::testing::Payload* temp = payload_;
3340 : payload_ = NULL;
3341 : return temp;
3342 : }
3343 : inline void SimpleRequest::set_allocated_payload(::grpc::testing::Payload* payload) {
3344 : delete payload_;
3345 : payload_ = payload;
3346 : if (payload) {
3347 :
3348 : } else {
3349 :
3350 : }
3351 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.SimpleRequest.payload)
3352 : }
3353 :
3354 : // -------------------------------------------------------------------
3355 :
3356 : // SimpleResponse
3357 :
3358 : // optional .grpc.testing.Payload payload = 1;
3359 2555352 : inline bool SimpleResponse::has_payload() const {
3360 2555352 : return !_is_default_instance_ && payload_ != NULL;
3361 : }
3362 : inline void SimpleResponse::clear_payload() {
3363 : if (GetArenaNoVirtual() == NULL && payload_ != NULL) delete payload_;
3364 : payload_ = NULL;
3365 : }
3366 0 : inline const ::grpc::testing::Payload& SimpleResponse::payload() const {
3367 : // @@protoc_insertion_point(field_get:grpc.testing.SimpleResponse.payload)
3368 0 : return payload_ != NULL ? *payload_ : *default_instance_->payload_;
3369 : }
3370 2554360 : inline ::grpc::testing::Payload* SimpleResponse::mutable_payload() {
3371 :
3372 2554360 : if (payload_ == NULL) {
3373 2554367 : payload_ = new ::grpc::testing::Payload;
3374 : }
3375 : // @@protoc_insertion_point(field_mutable:grpc.testing.SimpleResponse.payload)
3376 2554411 : return payload_;
3377 : }
3378 : inline ::grpc::testing::Payload* SimpleResponse::release_payload() {
3379 :
3380 : ::grpc::testing::Payload* temp = payload_;
3381 : payload_ = NULL;
3382 : return temp;
3383 : }
3384 : inline void SimpleResponse::set_allocated_payload(::grpc::testing::Payload* payload) {
3385 : delete payload_;
3386 : payload_ = payload;
3387 : if (payload) {
3388 :
3389 : } else {
3390 :
3391 : }
3392 : // @@protoc_insertion_point(field_set_allocated:grpc.testing.SimpleResponse.payload)
3393 : }
3394 :
3395 : #endif // !PROTOBUF_INLINE_NOT_IN_HEADERS
3396 : // -------------------------------------------------------------------
3397 :
3398 : // -------------------------------------------------------------------
3399 :
3400 : // -------------------------------------------------------------------
3401 :
3402 : // -------------------------------------------------------------------
3403 :
3404 : // -------------------------------------------------------------------
3405 :
3406 : // -------------------------------------------------------------------
3407 :
3408 : // -------------------------------------------------------------------
3409 :
3410 : // -------------------------------------------------------------------
3411 :
3412 : // -------------------------------------------------------------------
3413 :
3414 : // -------------------------------------------------------------------
3415 :
3416 : // -------------------------------------------------------------------
3417 :
3418 : // -------------------------------------------------------------------
3419 :
3420 : // -------------------------------------------------------------------
3421 :
3422 : // -------------------------------------------------------------------
3423 :
3424 : // -------------------------------------------------------------------
3425 :
3426 : // -------------------------------------------------------------------
3427 :
3428 : // -------------------------------------------------------------------
3429 :
3430 : // -------------------------------------------------------------------
3431 :
3432 :
3433 : // @@protoc_insertion_point(namespace_scope)
3434 :
3435 : } // namespace testing
3436 : } // namespace grpc
3437 :
3438 : #ifndef SWIG
3439 : namespace google {
3440 : namespace protobuf {
3441 :
3442 : template <> struct is_proto_enum< ::grpc::testing::PayloadType> : ::google::protobuf::internal::true_type {};
3443 : template <>
3444 : inline const EnumDescriptor* GetEnumDescriptor< ::grpc::testing::PayloadType>() {
3445 : return ::grpc::testing::PayloadType_descriptor();
3446 : }
3447 : template <> struct is_proto_enum< ::grpc::testing::ClientType> : ::google::protobuf::internal::true_type {};
3448 : template <>
3449 : inline const EnumDescriptor* GetEnumDescriptor< ::grpc::testing::ClientType>() {
3450 : return ::grpc::testing::ClientType_descriptor();
3451 : }
3452 : template <> struct is_proto_enum< ::grpc::testing::ServerType> : ::google::protobuf::internal::true_type {};
3453 : template <>
3454 : inline const EnumDescriptor* GetEnumDescriptor< ::grpc::testing::ServerType>() {
3455 : return ::grpc::testing::ServerType_descriptor();
3456 : }
3457 : template <> struct is_proto_enum< ::grpc::testing::RpcType> : ::google::protobuf::internal::true_type {};
3458 : template <>
3459 : inline const EnumDescriptor* GetEnumDescriptor< ::grpc::testing::RpcType>() {
3460 : return ::grpc::testing::RpcType_descriptor();
3461 : }
3462 : template <> struct is_proto_enum< ::grpc::testing::LoadType> : ::google::protobuf::internal::true_type {};
3463 : template <>
3464 : inline const EnumDescriptor* GetEnumDescriptor< ::grpc::testing::LoadType>() {
3465 : return ::grpc::testing::LoadType_descriptor();
3466 : }
3467 :
3468 : } // namespace protobuf
3469 : } // namespace google
3470 : #endif // SWIG
3471 :
3472 : // @@protoc_insertion_point(global_scope)
3473 :
3474 : #endif // PROTOBUF_test_2fcpp_2fqps_2fqpstest_2eproto__INCLUDED
|
