rad  2.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
requests.pb.h
Go to the documentation of this file.
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: requests.proto
3 
4 #ifndef PROTOBUF_INCLUDED_requests_2eproto
5 #define PROTOBUF_INCLUDED_requests_2eproto
6 
7 #include <string>
8 
9 #include <google/protobuf/stubs/common.h>
10 
11 #if GOOGLE_PROTOBUF_VERSION < 3006000
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 3006000 < 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/io/coded_stream.h>
23 #include <google/protobuf/arena.h>
24 #include <google/protobuf/arenastring.h>
25 #include <google/protobuf/generated_message_table_driven.h>
26 #include <google/protobuf/generated_message_util.h>
27 #include <google/protobuf/inlined_string_field.h>
28 #include <google/protobuf/metadata.h>
29 #include <google/protobuf/message.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/unknown_field_set.h>
33 // @@protoc_insertion_point(includes)
34 #define PROTOBUF_INTERNAL_EXPORT_protobuf_requests_2eproto
35 
36 namespace protobuf_requests_2eproto {
37 // Internal implementation detail -- do not use these members.
38 struct TableStruct {
39  static const ::google::protobuf::internal::ParseTableField entries[];
40  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
41  static const ::google::protobuf::internal::ParseTable schema[18];
42  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
43  static const ::google::protobuf::internal::SerializationTable serialization_table[];
44  static const ::google::protobuf::uint32 offsets[];
45 };
46 void AddDescriptors();
47 } // namespace protobuf_requests_2eproto
48 namespace helloif {
49 class RepConfig;
50 class RepConfigDefaultTypeInternal;
51 extern RepConfigDefaultTypeInternal _RepConfig_default_instance_;
52 class RepDisable;
53 class RepDisableDefaultTypeInternal;
54 extern RepDisableDefaultTypeInternal _RepDisable_default_instance_;
55 class RepEnable;
56 class RepEnableDefaultTypeInternal;
57 extern RepEnableDefaultTypeInternal _RepEnable_default_instance_;
58 class RepExit;
59 class RepExitDefaultTypeInternal;
60 extern RepExitDefaultTypeInternal _RepExit_default_instance_;
61 class RepInit;
62 class RepInitDefaultTypeInternal;
63 extern RepInitDefaultTypeInternal _RepInit_default_instance_;
64 class RepReset;
65 class RepResetDefaultTypeInternal;
66 extern RepResetDefaultTypeInternal _RepReset_default_instance_;
67 class RepSetLogLevel;
68 class RepSetLogLevelDefaultTypeInternal;
69 extern RepSetLogLevelDefaultTypeInternal _RepSetLogLevel_default_instance_;
70 class RepStatus;
71 class RepStatusDefaultTypeInternal;
72 extern RepStatusDefaultTypeInternal _RepStatus_default_instance_;
73 class RepStop;
74 class RepStopDefaultTypeInternal;
75 extern RepStopDefaultTypeInternal _RepStop_default_instance_;
76 class ReqConfig;
77 class ReqConfigDefaultTypeInternal;
78 extern ReqConfigDefaultTypeInternal _ReqConfig_default_instance_;
79 class ReqDisable;
80 class ReqDisableDefaultTypeInternal;
81 extern ReqDisableDefaultTypeInternal _ReqDisable_default_instance_;
82 class ReqEnable;
83 class ReqEnableDefaultTypeInternal;
84 extern ReqEnableDefaultTypeInternal _ReqEnable_default_instance_;
85 class ReqExit;
86 class ReqExitDefaultTypeInternal;
87 extern ReqExitDefaultTypeInternal _ReqExit_default_instance_;
88 class ReqInit;
89 class ReqInitDefaultTypeInternal;
90 extern ReqInitDefaultTypeInternal _ReqInit_default_instance_;
91 class ReqReset;
92 class ReqResetDefaultTypeInternal;
93 extern ReqResetDefaultTypeInternal _ReqReset_default_instance_;
94 class ReqSetLogLevel;
95 class ReqSetLogLevelDefaultTypeInternal;
96 extern ReqSetLogLevelDefaultTypeInternal _ReqSetLogLevel_default_instance_;
97 class ReqStatus;
98 class ReqStatusDefaultTypeInternal;
99 extern ReqStatusDefaultTypeInternal _ReqStatus_default_instance_;
100 class ReqStop;
101 class ReqStopDefaultTypeInternal;
102 extern ReqStopDefaultTypeInternal _ReqStop_default_instance_;
103 } // namespace helloif
104 namespace google {
105 namespace protobuf {
106 template<> ::helloif::RepConfig* Arena::CreateMaybeMessage<::helloif::RepConfig>(Arena*);
107 template<> ::helloif::RepDisable* Arena::CreateMaybeMessage<::helloif::RepDisable>(Arena*);
108 template<> ::helloif::RepEnable* Arena::CreateMaybeMessage<::helloif::RepEnable>(Arena*);
109 template<> ::helloif::RepExit* Arena::CreateMaybeMessage<::helloif::RepExit>(Arena*);
110 template<> ::helloif::RepInit* Arena::CreateMaybeMessage<::helloif::RepInit>(Arena*);
111 template<> ::helloif::RepReset* Arena::CreateMaybeMessage<::helloif::RepReset>(Arena*);
112 template<> ::helloif::RepSetLogLevel* Arena::CreateMaybeMessage<::helloif::RepSetLogLevel>(Arena*);
113 template<> ::helloif::RepStatus* Arena::CreateMaybeMessage<::helloif::RepStatus>(Arena*);
114 template<> ::helloif::RepStop* Arena::CreateMaybeMessage<::helloif::RepStop>(Arena*);
115 template<> ::helloif::ReqConfig* Arena::CreateMaybeMessage<::helloif::ReqConfig>(Arena*);
116 template<> ::helloif::ReqDisable* Arena::CreateMaybeMessage<::helloif::ReqDisable>(Arena*);
117 template<> ::helloif::ReqEnable* Arena::CreateMaybeMessage<::helloif::ReqEnable>(Arena*);
118 template<> ::helloif::ReqExit* Arena::CreateMaybeMessage<::helloif::ReqExit>(Arena*);
119 template<> ::helloif::ReqInit* Arena::CreateMaybeMessage<::helloif::ReqInit>(Arena*);
120 template<> ::helloif::ReqReset* Arena::CreateMaybeMessage<::helloif::ReqReset>(Arena*);
121 template<> ::helloif::ReqSetLogLevel* Arena::CreateMaybeMessage<::helloif::ReqSetLogLevel>(Arena*);
122 template<> ::helloif::ReqStatus* Arena::CreateMaybeMessage<::helloif::ReqStatus>(Arena*);
123 template<> ::helloif::ReqStop* Arena::CreateMaybeMessage<::helloif::ReqStop>(Arena*);
124 } // namespace protobuf
125 } // namespace google
126 namespace helloif {
127 
128 // ===================================================================
129 
130 class ReqExit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqExit) */ {
131  public:
132  ReqExit();
133  virtual ~ReqExit();
134 
135  ReqExit(const ReqExit& from);
136 
137  inline ReqExit& operator=(const ReqExit& from) {
138  CopyFrom(from);
139  return *this;
140  }
141  #if LANG_CXX11
142  ReqExit(ReqExit&& from) noexcept
143  : ReqExit() {
144  *this = ::std::move(from);
145  }
146 
147  inline ReqExit& operator=(ReqExit&& from) noexcept {
148  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
149  if (this != &from) InternalSwap(&from);
150  } else {
151  CopyFrom(from);
152  }
153  return *this;
154  }
155  #endif
156  static const ::google::protobuf::Descriptor* descriptor();
157  static const ReqExit& default_instance();
158 
159  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
160  static inline const ReqExit* internal_default_instance() {
161  return reinterpret_cast<const ReqExit*>(
162  &_ReqExit_default_instance_);
163  }
164  static constexpr int kIndexInFileMessages =
165  0;
166 
167  void Swap(ReqExit* other);
168  friend void swap(ReqExit& a, ReqExit& b) {
169  a.Swap(&b);
170  }
171 
172  // implements Message ----------------------------------------------
173 
174  inline ReqExit* New() const final {
175  return CreateMaybeMessage<ReqExit>(NULL);
176  }
177 
178  ReqExit* New(::google::protobuf::Arena* arena) const final {
179  return CreateMaybeMessage<ReqExit>(arena);
180  }
181  void CopyFrom(const ::google::protobuf::Message& from) final;
182  void MergeFrom(const ::google::protobuf::Message& from) final;
183  void CopyFrom(const ReqExit& from);
184  void MergeFrom(const ReqExit& from);
185  void Clear() final;
186  bool IsInitialized() const final;
187 
188  size_t ByteSizeLong() const final;
189  bool MergePartialFromCodedStream(
190  ::google::protobuf::io::CodedInputStream* input) final;
191  void SerializeWithCachedSizes(
192  ::google::protobuf::io::CodedOutputStream* output) const final;
193  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
194  bool deterministic, ::google::protobuf::uint8* target) const final;
195  int GetCachedSize() const final { return _cached_size_.Get(); }
196 
197  private:
198  void SharedCtor();
199  void SharedDtor();
200  void SetCachedSize(int size) const final;
201  void InternalSwap(ReqExit* other);
202  private:
203  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
204  return NULL;
205  }
206  inline void* MaybeArenaPtr() const {
207  return NULL;
208  }
209  public:
210 
211  ::google::protobuf::Metadata GetMetadata() const final;
212 
213  // nested types ----------------------------------------------------
214 
215  // accessors -------------------------------------------------------
216 
217  // @@protoc_insertion_point(class_scope:helloif.ReqExit)
218  private:
219 
220  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
221  mutable ::google::protobuf::internal::CachedSize _cached_size_;
222  friend struct ::protobuf_requests_2eproto::TableStruct;
223 };
224 // -------------------------------------------------------------------
225 
226 class RepExit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepExit) */ {
227  public:
228  RepExit();
229  virtual ~RepExit();
230 
231  RepExit(const RepExit& from);
232 
233  inline RepExit& operator=(const RepExit& from) {
234  CopyFrom(from);
235  return *this;
236  }
237  #if LANG_CXX11
238  RepExit(RepExit&& from) noexcept
239  : RepExit() {
240  *this = ::std::move(from);
241  }
242 
243  inline RepExit& operator=(RepExit&& from) noexcept {
244  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
245  if (this != &from) InternalSwap(&from);
246  } else {
247  CopyFrom(from);
248  }
249  return *this;
250  }
251  #endif
252  static const ::google::protobuf::Descriptor* descriptor();
253  static const RepExit& default_instance();
254 
255  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
256  static inline const RepExit* internal_default_instance() {
257  return reinterpret_cast<const RepExit*>(
258  &_RepExit_default_instance_);
259  }
260  static constexpr int kIndexInFileMessages =
261  1;
262 
263  void Swap(RepExit* other);
264  friend void swap(RepExit& a, RepExit& b) {
265  a.Swap(&b);
266  }
267 
268  // implements Message ----------------------------------------------
269 
270  inline RepExit* New() const final {
271  return CreateMaybeMessage<RepExit>(NULL);
272  }
273 
274  RepExit* New(::google::protobuf::Arena* arena) const final {
275  return CreateMaybeMessage<RepExit>(arena);
276  }
277  void CopyFrom(const ::google::protobuf::Message& from) final;
278  void MergeFrom(const ::google::protobuf::Message& from) final;
279  void CopyFrom(const RepExit& from);
280  void MergeFrom(const RepExit& from);
281  void Clear() final;
282  bool IsInitialized() const final;
283 
284  size_t ByteSizeLong() const final;
285  bool MergePartialFromCodedStream(
286  ::google::protobuf::io::CodedInputStream* input) final;
287  void SerializeWithCachedSizes(
288  ::google::protobuf::io::CodedOutputStream* output) const final;
289  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
290  bool deterministic, ::google::protobuf::uint8* target) const final;
291  int GetCachedSize() const final { return _cached_size_.Get(); }
292 
293  private:
294  void SharedCtor();
295  void SharedDtor();
296  void SetCachedSize(int size) const final;
297  void InternalSwap(RepExit* other);
298  private:
299  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
300  return NULL;
301  }
302  inline void* MaybeArenaPtr() const {
303  return NULL;
304  }
305  public:
306 
307  ::google::protobuf::Metadata GetMetadata() const final;
308 
309  // nested types ----------------------------------------------------
310 
311  // accessors -------------------------------------------------------
312 
313  // string reply = 1;
314  void clear_reply();
315  static const int kReplyFieldNumber = 1;
316  const ::std::string& reply() const;
317  void set_reply(const ::std::string& value);
318  #if LANG_CXX11
319  void set_reply(::std::string&& value);
320  #endif
321  void set_reply(const char* value);
322  void set_reply(const char* value, size_t size);
323  ::std::string* mutable_reply();
324  ::std::string* release_reply();
325  void set_allocated_reply(::std::string* reply);
326 
327  // @@protoc_insertion_point(class_scope:helloif.RepExit)
328  private:
329 
330  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
331  ::google::protobuf::internal::ArenaStringPtr reply_;
332  mutable ::google::protobuf::internal::CachedSize _cached_size_;
333  friend struct ::protobuf_requests_2eproto::TableStruct;
334 };
335 // -------------------------------------------------------------------
336 
337 class ReqStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqStatus) */ {
338  public:
339  ReqStatus();
340  virtual ~ReqStatus();
341 
342  ReqStatus(const ReqStatus& from);
343 
344  inline ReqStatus& operator=(const ReqStatus& from) {
345  CopyFrom(from);
346  return *this;
347  }
348  #if LANG_CXX11
349  ReqStatus(ReqStatus&& from) noexcept
350  : ReqStatus() {
351  *this = ::std::move(from);
352  }
353 
354  inline ReqStatus& operator=(ReqStatus&& from) noexcept {
355  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
356  if (this != &from) InternalSwap(&from);
357  } else {
358  CopyFrom(from);
359  }
360  return *this;
361  }
362  #endif
363  static const ::google::protobuf::Descriptor* descriptor();
364  static const ReqStatus& default_instance();
365 
366  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
367  static inline const ReqStatus* internal_default_instance() {
368  return reinterpret_cast<const ReqStatus*>(
369  &_ReqStatus_default_instance_);
370  }
371  static constexpr int kIndexInFileMessages =
372  2;
373 
374  void Swap(ReqStatus* other);
375  friend void swap(ReqStatus& a, ReqStatus& b) {
376  a.Swap(&b);
377  }
378 
379  // implements Message ----------------------------------------------
380 
381  inline ReqStatus* New() const final {
382  return CreateMaybeMessage<ReqStatus>(NULL);
383  }
384 
385  ReqStatus* New(::google::protobuf::Arena* arena) const final {
386  return CreateMaybeMessage<ReqStatus>(arena);
387  }
388  void CopyFrom(const ::google::protobuf::Message& from) final;
389  void MergeFrom(const ::google::protobuf::Message& from) final;
390  void CopyFrom(const ReqStatus& from);
391  void MergeFrom(const ReqStatus& from);
392  void Clear() final;
393  bool IsInitialized() const final;
394 
395  size_t ByteSizeLong() const final;
396  bool MergePartialFromCodedStream(
397  ::google::protobuf::io::CodedInputStream* input) final;
398  void SerializeWithCachedSizes(
399  ::google::protobuf::io::CodedOutputStream* output) const final;
400  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
401  bool deterministic, ::google::protobuf::uint8* target) const final;
402  int GetCachedSize() const final { return _cached_size_.Get(); }
403 
404  private:
405  void SharedCtor();
406  void SharedDtor();
407  void SetCachedSize(int size) const final;
408  void InternalSwap(ReqStatus* other);
409  private:
410  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
411  return NULL;
412  }
413  inline void* MaybeArenaPtr() const {
414  return NULL;
415  }
416  public:
417 
418  ::google::protobuf::Metadata GetMetadata() const final;
419 
420  // nested types ----------------------------------------------------
421 
422  // accessors -------------------------------------------------------
423 
424  // @@protoc_insertion_point(class_scope:helloif.ReqStatus)
425  private:
426 
427  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
428  mutable ::google::protobuf::internal::CachedSize _cached_size_;
429  friend struct ::protobuf_requests_2eproto::TableStruct;
430 };
431 // -------------------------------------------------------------------
432 
433 class RepStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepStatus) */ {
434  public:
435  RepStatus();
436  virtual ~RepStatus();
437 
438  RepStatus(const RepStatus& from);
439 
440  inline RepStatus& operator=(const RepStatus& from) {
441  CopyFrom(from);
442  return *this;
443  }
444  #if LANG_CXX11
445  RepStatus(RepStatus&& from) noexcept
446  : RepStatus() {
447  *this = ::std::move(from);
448  }
449 
450  inline RepStatus& operator=(RepStatus&& from) noexcept {
451  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
452  if (this != &from) InternalSwap(&from);
453  } else {
454  CopyFrom(from);
455  }
456  return *this;
457  }
458  #endif
459  static const ::google::protobuf::Descriptor* descriptor();
460  static const RepStatus& default_instance();
461 
462  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
463  static inline const RepStatus* internal_default_instance() {
464  return reinterpret_cast<const RepStatus*>(
465  &_RepStatus_default_instance_);
466  }
467  static constexpr int kIndexInFileMessages =
468  3;
469 
470  void Swap(RepStatus* other);
471  friend void swap(RepStatus& a, RepStatus& b) {
472  a.Swap(&b);
473  }
474 
475  // implements Message ----------------------------------------------
476 
477  inline RepStatus* New() const final {
478  return CreateMaybeMessage<RepStatus>(NULL);
479  }
480 
481  RepStatus* New(::google::protobuf::Arena* arena) const final {
482  return CreateMaybeMessage<RepStatus>(arena);
483  }
484  void CopyFrom(const ::google::protobuf::Message& from) final;
485  void MergeFrom(const ::google::protobuf::Message& from) final;
486  void CopyFrom(const RepStatus& from);
487  void MergeFrom(const RepStatus& from);
488  void Clear() final;
489  bool IsInitialized() const final;
490 
491  size_t ByteSizeLong() const final;
492  bool MergePartialFromCodedStream(
493  ::google::protobuf::io::CodedInputStream* input) final;
494  void SerializeWithCachedSizes(
495  ::google::protobuf::io::CodedOutputStream* output) const final;
496  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
497  bool deterministic, ::google::protobuf::uint8* target) const final;
498  int GetCachedSize() const final { return _cached_size_.Get(); }
499 
500  private:
501  void SharedCtor();
502  void SharedDtor();
503  void SetCachedSize(int size) const final;
504  void InternalSwap(RepStatus* other);
505  private:
506  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
507  return NULL;
508  }
509  inline void* MaybeArenaPtr() const {
510  return NULL;
511  }
512  public:
513 
514  ::google::protobuf::Metadata GetMetadata() const final;
515 
516  // nested types ----------------------------------------------------
517 
518  // accessors -------------------------------------------------------
519 
520  // string reply = 1;
521  void clear_reply();
522  static const int kReplyFieldNumber = 1;
523  const ::std::string& reply() const;
524  void set_reply(const ::std::string& value);
525  #if LANG_CXX11
526  void set_reply(::std::string&& value);
527  #endif
528  void set_reply(const char* value);
529  void set_reply(const char* value, size_t size);
530  ::std::string* mutable_reply();
531  ::std::string* release_reply();
532  void set_allocated_reply(::std::string* reply);
533 
534  // @@protoc_insertion_point(class_scope:helloif.RepStatus)
535  private:
536 
537  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
538  ::google::protobuf::internal::ArenaStringPtr reply_;
539  mutable ::google::protobuf::internal::CachedSize _cached_size_;
540  friend struct ::protobuf_requests_2eproto::TableStruct;
541 };
542 // -------------------------------------------------------------------
543 
544 class ReqStop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqStop) */ {
545  public:
546  ReqStop();
547  virtual ~ReqStop();
548 
549  ReqStop(const ReqStop& from);
550 
551  inline ReqStop& operator=(const ReqStop& from) {
552  CopyFrom(from);
553  return *this;
554  }
555  #if LANG_CXX11
556  ReqStop(ReqStop&& from) noexcept
557  : ReqStop() {
558  *this = ::std::move(from);
559  }
560 
561  inline ReqStop& operator=(ReqStop&& from) noexcept {
562  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
563  if (this != &from) InternalSwap(&from);
564  } else {
565  CopyFrom(from);
566  }
567  return *this;
568  }
569  #endif
570  static const ::google::protobuf::Descriptor* descriptor();
571  static const ReqStop& default_instance();
572 
573  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
574  static inline const ReqStop* internal_default_instance() {
575  return reinterpret_cast<const ReqStop*>(
576  &_ReqStop_default_instance_);
577  }
578  static constexpr int kIndexInFileMessages =
579  4;
580 
581  void Swap(ReqStop* other);
582  friend void swap(ReqStop& a, ReqStop& b) {
583  a.Swap(&b);
584  }
585 
586  // implements Message ----------------------------------------------
587 
588  inline ReqStop* New() const final {
589  return CreateMaybeMessage<ReqStop>(NULL);
590  }
591 
592  ReqStop* New(::google::protobuf::Arena* arena) const final {
593  return CreateMaybeMessage<ReqStop>(arena);
594  }
595  void CopyFrom(const ::google::protobuf::Message& from) final;
596  void MergeFrom(const ::google::protobuf::Message& from) final;
597  void CopyFrom(const ReqStop& from);
598  void MergeFrom(const ReqStop& from);
599  void Clear() final;
600  bool IsInitialized() const final;
601 
602  size_t ByteSizeLong() const final;
603  bool MergePartialFromCodedStream(
604  ::google::protobuf::io::CodedInputStream* input) final;
605  void SerializeWithCachedSizes(
606  ::google::protobuf::io::CodedOutputStream* output) const final;
607  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
608  bool deterministic, ::google::protobuf::uint8* target) const final;
609  int GetCachedSize() const final { return _cached_size_.Get(); }
610 
611  private:
612  void SharedCtor();
613  void SharedDtor();
614  void SetCachedSize(int size) const final;
615  void InternalSwap(ReqStop* other);
616  private:
617  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
618  return NULL;
619  }
620  inline void* MaybeArenaPtr() const {
621  return NULL;
622  }
623  public:
624 
625  ::google::protobuf::Metadata GetMetadata() const final;
626 
627  // nested types ----------------------------------------------------
628 
629  // accessors -------------------------------------------------------
630 
631  // @@protoc_insertion_point(class_scope:helloif.ReqStop)
632  private:
633 
634  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
635  mutable ::google::protobuf::internal::CachedSize _cached_size_;
636  friend struct ::protobuf_requests_2eproto::TableStruct;
637 };
638 // -------------------------------------------------------------------
639 
640 class RepStop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepStop) */ {
641  public:
642  RepStop();
643  virtual ~RepStop();
644 
645  RepStop(const RepStop& from);
646 
647  inline RepStop& operator=(const RepStop& from) {
648  CopyFrom(from);
649  return *this;
650  }
651  #if LANG_CXX11
652  RepStop(RepStop&& from) noexcept
653  : RepStop() {
654  *this = ::std::move(from);
655  }
656 
657  inline RepStop& operator=(RepStop&& from) noexcept {
658  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
659  if (this != &from) InternalSwap(&from);
660  } else {
661  CopyFrom(from);
662  }
663  return *this;
664  }
665  #endif
666  static const ::google::protobuf::Descriptor* descriptor();
667  static const RepStop& default_instance();
668 
669  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
670  static inline const RepStop* internal_default_instance() {
671  return reinterpret_cast<const RepStop*>(
672  &_RepStop_default_instance_);
673  }
674  static constexpr int kIndexInFileMessages =
675  5;
676 
677  void Swap(RepStop* other);
678  friend void swap(RepStop& a, RepStop& b) {
679  a.Swap(&b);
680  }
681 
682  // implements Message ----------------------------------------------
683 
684  inline RepStop* New() const final {
685  return CreateMaybeMessage<RepStop>(NULL);
686  }
687 
688  RepStop* New(::google::protobuf::Arena* arena) const final {
689  return CreateMaybeMessage<RepStop>(arena);
690  }
691  void CopyFrom(const ::google::protobuf::Message& from) final;
692  void MergeFrom(const ::google::protobuf::Message& from) final;
693  void CopyFrom(const RepStop& from);
694  void MergeFrom(const RepStop& from);
695  void Clear() final;
696  bool IsInitialized() const final;
697 
698  size_t ByteSizeLong() const final;
699  bool MergePartialFromCodedStream(
700  ::google::protobuf::io::CodedInputStream* input) final;
701  void SerializeWithCachedSizes(
702  ::google::protobuf::io::CodedOutputStream* output) const final;
703  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
704  bool deterministic, ::google::protobuf::uint8* target) const final;
705  int GetCachedSize() const final { return _cached_size_.Get(); }
706 
707  private:
708  void SharedCtor();
709  void SharedDtor();
710  void SetCachedSize(int size) const final;
711  void InternalSwap(RepStop* other);
712  private:
713  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
714  return NULL;
715  }
716  inline void* MaybeArenaPtr() const {
717  return NULL;
718  }
719  public:
720 
721  ::google::protobuf::Metadata GetMetadata() const final;
722 
723  // nested types ----------------------------------------------------
724 
725  // accessors -------------------------------------------------------
726 
727  // string reply = 1;
728  void clear_reply();
729  static const int kReplyFieldNumber = 1;
730  const ::std::string& reply() const;
731  void set_reply(const ::std::string& value);
732  #if LANG_CXX11
733  void set_reply(::std::string&& value);
734  #endif
735  void set_reply(const char* value);
736  void set_reply(const char* value, size_t size);
737  ::std::string* mutable_reply();
738  ::std::string* release_reply();
739  void set_allocated_reply(::std::string* reply);
740 
741  // @@protoc_insertion_point(class_scope:helloif.RepStop)
742  private:
743 
744  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
745  ::google::protobuf::internal::ArenaStringPtr reply_;
746  mutable ::google::protobuf::internal::CachedSize _cached_size_;
747  friend struct ::protobuf_requests_2eproto::TableStruct;
748 };
749 // -------------------------------------------------------------------
750 
751 class ReqReset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqReset) */ {
752  public:
753  ReqReset();
754  virtual ~ReqReset();
755 
756  ReqReset(const ReqReset& from);
757 
758  inline ReqReset& operator=(const ReqReset& from) {
759  CopyFrom(from);
760  return *this;
761  }
762  #if LANG_CXX11
763  ReqReset(ReqReset&& from) noexcept
764  : ReqReset() {
765  *this = ::std::move(from);
766  }
767 
768  inline ReqReset& operator=(ReqReset&& from) noexcept {
769  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
770  if (this != &from) InternalSwap(&from);
771  } else {
772  CopyFrom(from);
773  }
774  return *this;
775  }
776  #endif
777  static const ::google::protobuf::Descriptor* descriptor();
778  static const ReqReset& default_instance();
779 
780  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
781  static inline const ReqReset* internal_default_instance() {
782  return reinterpret_cast<const ReqReset*>(
783  &_ReqReset_default_instance_);
784  }
785  static constexpr int kIndexInFileMessages =
786  6;
787 
788  void Swap(ReqReset* other);
789  friend void swap(ReqReset& a, ReqReset& b) {
790  a.Swap(&b);
791  }
792 
793  // implements Message ----------------------------------------------
794 
795  inline ReqReset* New() const final {
796  return CreateMaybeMessage<ReqReset>(NULL);
797  }
798 
799  ReqReset* New(::google::protobuf::Arena* arena) const final {
800  return CreateMaybeMessage<ReqReset>(arena);
801  }
802  void CopyFrom(const ::google::protobuf::Message& from) final;
803  void MergeFrom(const ::google::protobuf::Message& from) final;
804  void CopyFrom(const ReqReset& from);
805  void MergeFrom(const ReqReset& from);
806  void Clear() final;
807  bool IsInitialized() const final;
808 
809  size_t ByteSizeLong() const final;
810  bool MergePartialFromCodedStream(
811  ::google::protobuf::io::CodedInputStream* input) final;
812  void SerializeWithCachedSizes(
813  ::google::protobuf::io::CodedOutputStream* output) const final;
814  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
815  bool deterministic, ::google::protobuf::uint8* target) const final;
816  int GetCachedSize() const final { return _cached_size_.Get(); }
817 
818  private:
819  void SharedCtor();
820  void SharedDtor();
821  void SetCachedSize(int size) const final;
822  void InternalSwap(ReqReset* other);
823  private:
824  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
825  return NULL;
826  }
827  inline void* MaybeArenaPtr() const {
828  return NULL;
829  }
830  public:
831 
832  ::google::protobuf::Metadata GetMetadata() const final;
833 
834  // nested types ----------------------------------------------------
835 
836  // accessors -------------------------------------------------------
837 
838  // @@protoc_insertion_point(class_scope:helloif.ReqReset)
839  private:
840 
841  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
842  mutable ::google::protobuf::internal::CachedSize _cached_size_;
843  friend struct ::protobuf_requests_2eproto::TableStruct;
844 };
845 // -------------------------------------------------------------------
846 
847 class RepReset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepReset) */ {
848  public:
849  RepReset();
850  virtual ~RepReset();
851 
852  RepReset(const RepReset& from);
853 
854  inline RepReset& operator=(const RepReset& from) {
855  CopyFrom(from);
856  return *this;
857  }
858  #if LANG_CXX11
859  RepReset(RepReset&& from) noexcept
860  : RepReset() {
861  *this = ::std::move(from);
862  }
863 
864  inline RepReset& operator=(RepReset&& from) noexcept {
865  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
866  if (this != &from) InternalSwap(&from);
867  } else {
868  CopyFrom(from);
869  }
870  return *this;
871  }
872  #endif
873  static const ::google::protobuf::Descriptor* descriptor();
874  static const RepReset& default_instance();
875 
876  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
877  static inline const RepReset* internal_default_instance() {
878  return reinterpret_cast<const RepReset*>(
879  &_RepReset_default_instance_);
880  }
881  static constexpr int kIndexInFileMessages =
882  7;
883 
884  void Swap(RepReset* other);
885  friend void swap(RepReset& a, RepReset& b) {
886  a.Swap(&b);
887  }
888 
889  // implements Message ----------------------------------------------
890 
891  inline RepReset* New() const final {
892  return CreateMaybeMessage<RepReset>(NULL);
893  }
894 
895  RepReset* New(::google::protobuf::Arena* arena) const final {
896  return CreateMaybeMessage<RepReset>(arena);
897  }
898  void CopyFrom(const ::google::protobuf::Message& from) final;
899  void MergeFrom(const ::google::protobuf::Message& from) final;
900  void CopyFrom(const RepReset& from);
901  void MergeFrom(const RepReset& from);
902  void Clear() final;
903  bool IsInitialized() const final;
904 
905  size_t ByteSizeLong() const final;
906  bool MergePartialFromCodedStream(
907  ::google::protobuf::io::CodedInputStream* input) final;
908  void SerializeWithCachedSizes(
909  ::google::protobuf::io::CodedOutputStream* output) const final;
910  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
911  bool deterministic, ::google::protobuf::uint8* target) const final;
912  int GetCachedSize() const final { return _cached_size_.Get(); }
913 
914  private:
915  void SharedCtor();
916  void SharedDtor();
917  void SetCachedSize(int size) const final;
918  void InternalSwap(RepReset* other);
919  private:
920  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
921  return NULL;
922  }
923  inline void* MaybeArenaPtr() const {
924  return NULL;
925  }
926  public:
927 
928  ::google::protobuf::Metadata GetMetadata() const final;
929 
930  // nested types ----------------------------------------------------
931 
932  // accessors -------------------------------------------------------
933 
934  // string reply = 1;
935  void clear_reply();
936  static const int kReplyFieldNumber = 1;
937  const ::std::string& reply() const;
938  void set_reply(const ::std::string& value);
939  #if LANG_CXX11
940  void set_reply(::std::string&& value);
941  #endif
942  void set_reply(const char* value);
943  void set_reply(const char* value, size_t size);
944  ::std::string* mutable_reply();
945  ::std::string* release_reply();
946  void set_allocated_reply(::std::string* reply);
947 
948  // @@protoc_insertion_point(class_scope:helloif.RepReset)
949  private:
950 
951  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
952  ::google::protobuf::internal::ArenaStringPtr reply_;
953  mutable ::google::protobuf::internal::CachedSize _cached_size_;
954  friend struct ::protobuf_requests_2eproto::TableStruct;
955 };
956 // -------------------------------------------------------------------
957 
958 class ReqInit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqInit) */ {
959  public:
960  ReqInit();
961  virtual ~ReqInit();
962 
963  ReqInit(const ReqInit& from);
964 
965  inline ReqInit& operator=(const ReqInit& from) {
966  CopyFrom(from);
967  return *this;
968  }
969  #if LANG_CXX11
970  ReqInit(ReqInit&& from) noexcept
971  : ReqInit() {
972  *this = ::std::move(from);
973  }
974 
975  inline ReqInit& operator=(ReqInit&& from) noexcept {
976  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
977  if (this != &from) InternalSwap(&from);
978  } else {
979  CopyFrom(from);
980  }
981  return *this;
982  }
983  #endif
984  static const ::google::protobuf::Descriptor* descriptor();
985  static const ReqInit& default_instance();
986 
987  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
988  static inline const ReqInit* internal_default_instance() {
989  return reinterpret_cast<const ReqInit*>(
990  &_ReqInit_default_instance_);
991  }
992  static constexpr int kIndexInFileMessages =
993  8;
994 
995  void Swap(ReqInit* other);
996  friend void swap(ReqInit& a, ReqInit& b) {
997  a.Swap(&b);
998  }
999 
1000  // implements Message ----------------------------------------------
1001 
1002  inline ReqInit* New() const final {
1003  return CreateMaybeMessage<ReqInit>(NULL);
1004  }
1005 
1006  ReqInit* New(::google::protobuf::Arena* arena) const final {
1007  return CreateMaybeMessage<ReqInit>(arena);
1008  }
1009  void CopyFrom(const ::google::protobuf::Message& from) final;
1010  void MergeFrom(const ::google::protobuf::Message& from) final;
1011  void CopyFrom(const ReqInit& from);
1012  void MergeFrom(const ReqInit& from);
1013  void Clear() final;
1014  bool IsInitialized() const final;
1015 
1016  size_t ByteSizeLong() const final;
1017  bool MergePartialFromCodedStream(
1018  ::google::protobuf::io::CodedInputStream* input) final;
1019  void SerializeWithCachedSizes(
1020  ::google::protobuf::io::CodedOutputStream* output) const final;
1021  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1022  bool deterministic, ::google::protobuf::uint8* target) const final;
1023  int GetCachedSize() const final { return _cached_size_.Get(); }
1024 
1025  private:
1026  void SharedCtor();
1027  void SharedDtor();
1028  void SetCachedSize(int size) const final;
1029  void InternalSwap(ReqInit* other);
1030  private:
1031  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1032  return NULL;
1033  }
1034  inline void* MaybeArenaPtr() const {
1035  return NULL;
1036  }
1037  public:
1038 
1039  ::google::protobuf::Metadata GetMetadata() const final;
1040 
1041  // nested types ----------------------------------------------------
1042 
1043  // accessors -------------------------------------------------------
1044 
1045  // @@protoc_insertion_point(class_scope:helloif.ReqInit)
1046  private:
1047 
1048  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1049  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1050  friend struct ::protobuf_requests_2eproto::TableStruct;
1051 };
1052 // -------------------------------------------------------------------
1053 
1054 class RepInit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepInit) */ {
1055  public:
1056  RepInit();
1057  virtual ~RepInit();
1058 
1059  RepInit(const RepInit& from);
1060 
1061  inline RepInit& operator=(const RepInit& from) {
1062  CopyFrom(from);
1063  return *this;
1064  }
1065  #if LANG_CXX11
1066  RepInit(RepInit&& from) noexcept
1067  : RepInit() {
1068  *this = ::std::move(from);
1069  }
1070 
1071  inline RepInit& operator=(RepInit&& from) noexcept {
1072  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1073  if (this != &from) InternalSwap(&from);
1074  } else {
1075  CopyFrom(from);
1076  }
1077  return *this;
1078  }
1079  #endif
1080  static const ::google::protobuf::Descriptor* descriptor();
1081  static const RepInit& default_instance();
1082 
1083  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1084  static inline const RepInit* internal_default_instance() {
1085  return reinterpret_cast<const RepInit*>(
1086  &_RepInit_default_instance_);
1087  }
1088  static constexpr int kIndexInFileMessages =
1089  9;
1090 
1091  void Swap(RepInit* other);
1092  friend void swap(RepInit& a, RepInit& b) {
1093  a.Swap(&b);
1094  }
1095 
1096  // implements Message ----------------------------------------------
1097 
1098  inline RepInit* New() const final {
1099  return CreateMaybeMessage<RepInit>(NULL);
1100  }
1101 
1102  RepInit* New(::google::protobuf::Arena* arena) const final {
1103  return CreateMaybeMessage<RepInit>(arena);
1104  }
1105  void CopyFrom(const ::google::protobuf::Message& from) final;
1106  void MergeFrom(const ::google::protobuf::Message& from) final;
1107  void CopyFrom(const RepInit& from);
1108  void MergeFrom(const RepInit& from);
1109  void Clear() final;
1110  bool IsInitialized() const final;
1111 
1112  size_t ByteSizeLong() const final;
1113  bool MergePartialFromCodedStream(
1114  ::google::protobuf::io::CodedInputStream* input) final;
1115  void SerializeWithCachedSizes(
1116  ::google::protobuf::io::CodedOutputStream* output) const final;
1117  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1118  bool deterministic, ::google::protobuf::uint8* target) const final;
1119  int GetCachedSize() const final { return _cached_size_.Get(); }
1120 
1121  private:
1122  void SharedCtor();
1123  void SharedDtor();
1124  void SetCachedSize(int size) const final;
1125  void InternalSwap(RepInit* other);
1126  private:
1127  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1128  return NULL;
1129  }
1130  inline void* MaybeArenaPtr() const {
1131  return NULL;
1132  }
1133  public:
1134 
1135  ::google::protobuf::Metadata GetMetadata() const final;
1136 
1137  // nested types ----------------------------------------------------
1138 
1139  // accessors -------------------------------------------------------
1140 
1141  // string reply = 1;
1142  void clear_reply();
1143  static const int kReplyFieldNumber = 1;
1144  const ::std::string& reply() const;
1145  void set_reply(const ::std::string& value);
1146  #if LANG_CXX11
1147  void set_reply(::std::string&& value);
1148  #endif
1149  void set_reply(const char* value);
1150  void set_reply(const char* value, size_t size);
1151  ::std::string* mutable_reply();
1152  ::std::string* release_reply();
1153  void set_allocated_reply(::std::string* reply);
1154 
1155  // @@protoc_insertion_point(class_scope:helloif.RepInit)
1156  private:
1157 
1158  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1159  ::google::protobuf::internal::ArenaStringPtr reply_;
1160  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1161  friend struct ::protobuf_requests_2eproto::TableStruct;
1162 };
1163 // -------------------------------------------------------------------
1164 
1165 class ReqEnable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqEnable) */ {
1166  public:
1167  ReqEnable();
1168  virtual ~ReqEnable();
1169 
1170  ReqEnable(const ReqEnable& from);
1171 
1172  inline ReqEnable& operator=(const ReqEnable& from) {
1173  CopyFrom(from);
1174  return *this;
1175  }
1176  #if LANG_CXX11
1177  ReqEnable(ReqEnable&& from) noexcept
1178  : ReqEnable() {
1179  *this = ::std::move(from);
1180  }
1181 
1182  inline ReqEnable& operator=(ReqEnable&& from) noexcept {
1183  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1184  if (this != &from) InternalSwap(&from);
1185  } else {
1186  CopyFrom(from);
1187  }
1188  return *this;
1189  }
1190  #endif
1191  static const ::google::protobuf::Descriptor* descriptor();
1192  static const ReqEnable& default_instance();
1193 
1194  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1195  static inline const ReqEnable* internal_default_instance() {
1196  return reinterpret_cast<const ReqEnable*>(
1197  &_ReqEnable_default_instance_);
1198  }
1199  static constexpr int kIndexInFileMessages =
1200  10;
1201 
1202  void Swap(ReqEnable* other);
1203  friend void swap(ReqEnable& a, ReqEnable& b) {
1204  a.Swap(&b);
1205  }
1206 
1207  // implements Message ----------------------------------------------
1208 
1209  inline ReqEnable* New() const final {
1210  return CreateMaybeMessage<ReqEnable>(NULL);
1211  }
1212 
1213  ReqEnable* New(::google::protobuf::Arena* arena) const final {
1214  return CreateMaybeMessage<ReqEnable>(arena);
1215  }
1216  void CopyFrom(const ::google::protobuf::Message& from) final;
1217  void MergeFrom(const ::google::protobuf::Message& from) final;
1218  void CopyFrom(const ReqEnable& from);
1219  void MergeFrom(const ReqEnable& from);
1220  void Clear() final;
1221  bool IsInitialized() const final;
1222 
1223  size_t ByteSizeLong() const final;
1224  bool MergePartialFromCodedStream(
1225  ::google::protobuf::io::CodedInputStream* input) final;
1226  void SerializeWithCachedSizes(
1227  ::google::protobuf::io::CodedOutputStream* output) const final;
1228  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1229  bool deterministic, ::google::protobuf::uint8* target) const final;
1230  int GetCachedSize() const final { return _cached_size_.Get(); }
1231 
1232  private:
1233  void SharedCtor();
1234  void SharedDtor();
1235  void SetCachedSize(int size) const final;
1236  void InternalSwap(ReqEnable* other);
1237  private:
1238  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1239  return NULL;
1240  }
1241  inline void* MaybeArenaPtr() const {
1242  return NULL;
1243  }
1244  public:
1245 
1246  ::google::protobuf::Metadata GetMetadata() const final;
1247 
1248  // nested types ----------------------------------------------------
1249 
1250  // accessors -------------------------------------------------------
1251 
1252  // @@protoc_insertion_point(class_scope:helloif.ReqEnable)
1253  private:
1254 
1255  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1256  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1257  friend struct ::protobuf_requests_2eproto::TableStruct;
1258 };
1259 // -------------------------------------------------------------------
1260 
1261 class RepEnable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepEnable) */ {
1262  public:
1263  RepEnable();
1264  virtual ~RepEnable();
1265 
1266  RepEnable(const RepEnable& from);
1267 
1268  inline RepEnable& operator=(const RepEnable& from) {
1269  CopyFrom(from);
1270  return *this;
1271  }
1272  #if LANG_CXX11
1273  RepEnable(RepEnable&& from) noexcept
1274  : RepEnable() {
1275  *this = ::std::move(from);
1276  }
1277 
1278  inline RepEnable& operator=(RepEnable&& from) noexcept {
1279  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1280  if (this != &from) InternalSwap(&from);
1281  } else {
1282  CopyFrom(from);
1283  }
1284  return *this;
1285  }
1286  #endif
1287  static const ::google::protobuf::Descriptor* descriptor();
1288  static const RepEnable& default_instance();
1289 
1290  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1291  static inline const RepEnable* internal_default_instance() {
1292  return reinterpret_cast<const RepEnable*>(
1293  &_RepEnable_default_instance_);
1294  }
1295  static constexpr int kIndexInFileMessages =
1296  11;
1297 
1298  void Swap(RepEnable* other);
1299  friend void swap(RepEnable& a, RepEnable& b) {
1300  a.Swap(&b);
1301  }
1302 
1303  // implements Message ----------------------------------------------
1304 
1305  inline RepEnable* New() const final {
1306  return CreateMaybeMessage<RepEnable>(NULL);
1307  }
1308 
1309  RepEnable* New(::google::protobuf::Arena* arena) const final {
1310  return CreateMaybeMessage<RepEnable>(arena);
1311  }
1312  void CopyFrom(const ::google::protobuf::Message& from) final;
1313  void MergeFrom(const ::google::protobuf::Message& from) final;
1314  void CopyFrom(const RepEnable& from);
1315  void MergeFrom(const RepEnable& from);
1316  void Clear() final;
1317  bool IsInitialized() const final;
1318 
1319  size_t ByteSizeLong() const final;
1320  bool MergePartialFromCodedStream(
1321  ::google::protobuf::io::CodedInputStream* input) final;
1322  void SerializeWithCachedSizes(
1323  ::google::protobuf::io::CodedOutputStream* output) const final;
1324  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1325  bool deterministic, ::google::protobuf::uint8* target) const final;
1326  int GetCachedSize() const final { return _cached_size_.Get(); }
1327 
1328  private:
1329  void SharedCtor();
1330  void SharedDtor();
1331  void SetCachedSize(int size) const final;
1332  void InternalSwap(RepEnable* other);
1333  private:
1334  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1335  return NULL;
1336  }
1337  inline void* MaybeArenaPtr() const {
1338  return NULL;
1339  }
1340  public:
1341 
1342  ::google::protobuf::Metadata GetMetadata() const final;
1343 
1344  // nested types ----------------------------------------------------
1345 
1346  // accessors -------------------------------------------------------
1347 
1348  // string reply = 1;
1349  void clear_reply();
1350  static const int kReplyFieldNumber = 1;
1351  const ::std::string& reply() const;
1352  void set_reply(const ::std::string& value);
1353  #if LANG_CXX11
1354  void set_reply(::std::string&& value);
1355  #endif
1356  void set_reply(const char* value);
1357  void set_reply(const char* value, size_t size);
1358  ::std::string* mutable_reply();
1359  ::std::string* release_reply();
1360  void set_allocated_reply(::std::string* reply);
1361 
1362  // @@protoc_insertion_point(class_scope:helloif.RepEnable)
1363  private:
1364 
1365  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1366  ::google::protobuf::internal::ArenaStringPtr reply_;
1367  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1368  friend struct ::protobuf_requests_2eproto::TableStruct;
1369 };
1370 // -------------------------------------------------------------------
1371 
1372 class ReqDisable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqDisable) */ {
1373  public:
1374  ReqDisable();
1375  virtual ~ReqDisable();
1376 
1377  ReqDisable(const ReqDisable& from);
1378 
1379  inline ReqDisable& operator=(const ReqDisable& from) {
1380  CopyFrom(from);
1381  return *this;
1382  }
1383  #if LANG_CXX11
1384  ReqDisable(ReqDisable&& from) noexcept
1385  : ReqDisable() {
1386  *this = ::std::move(from);
1387  }
1388 
1389  inline ReqDisable& operator=(ReqDisable&& from) noexcept {
1390  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1391  if (this != &from) InternalSwap(&from);
1392  } else {
1393  CopyFrom(from);
1394  }
1395  return *this;
1396  }
1397  #endif
1398  static const ::google::protobuf::Descriptor* descriptor();
1399  static const ReqDisable& default_instance();
1400 
1401  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1402  static inline const ReqDisable* internal_default_instance() {
1403  return reinterpret_cast<const ReqDisable*>(
1404  &_ReqDisable_default_instance_);
1405  }
1406  static constexpr int kIndexInFileMessages =
1407  12;
1408 
1409  void Swap(ReqDisable* other);
1410  friend void swap(ReqDisable& a, ReqDisable& b) {
1411  a.Swap(&b);
1412  }
1413 
1414  // implements Message ----------------------------------------------
1415 
1416  inline ReqDisable* New() const final {
1417  return CreateMaybeMessage<ReqDisable>(NULL);
1418  }
1419 
1420  ReqDisable* New(::google::protobuf::Arena* arena) const final {
1421  return CreateMaybeMessage<ReqDisable>(arena);
1422  }
1423  void CopyFrom(const ::google::protobuf::Message& from) final;
1424  void MergeFrom(const ::google::protobuf::Message& from) final;
1425  void CopyFrom(const ReqDisable& from);
1426  void MergeFrom(const ReqDisable& from);
1427  void Clear() final;
1428  bool IsInitialized() const final;
1429 
1430  size_t ByteSizeLong() const final;
1431  bool MergePartialFromCodedStream(
1432  ::google::protobuf::io::CodedInputStream* input) final;
1433  void SerializeWithCachedSizes(
1434  ::google::protobuf::io::CodedOutputStream* output) const final;
1435  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1436  bool deterministic, ::google::protobuf::uint8* target) const final;
1437  int GetCachedSize() const final { return _cached_size_.Get(); }
1438 
1439  private:
1440  void SharedCtor();
1441  void SharedDtor();
1442  void SetCachedSize(int size) const final;
1443  void InternalSwap(ReqDisable* other);
1444  private:
1445  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1446  return NULL;
1447  }
1448  inline void* MaybeArenaPtr() const {
1449  return NULL;
1450  }
1451  public:
1452 
1453  ::google::protobuf::Metadata GetMetadata() const final;
1454 
1455  // nested types ----------------------------------------------------
1456 
1457  // accessors -------------------------------------------------------
1458 
1459  // @@protoc_insertion_point(class_scope:helloif.ReqDisable)
1460  private:
1461 
1462  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1463  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1464  friend struct ::protobuf_requests_2eproto::TableStruct;
1465 };
1466 // -------------------------------------------------------------------
1467 
1468 class RepDisable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepDisable) */ {
1469  public:
1470  RepDisable();
1471  virtual ~RepDisable();
1472 
1473  RepDisable(const RepDisable& from);
1474 
1475  inline RepDisable& operator=(const RepDisable& from) {
1476  CopyFrom(from);
1477  return *this;
1478  }
1479  #if LANG_CXX11
1480  RepDisable(RepDisable&& from) noexcept
1481  : RepDisable() {
1482  *this = ::std::move(from);
1483  }
1484 
1485  inline RepDisable& operator=(RepDisable&& from) noexcept {
1486  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1487  if (this != &from) InternalSwap(&from);
1488  } else {
1489  CopyFrom(from);
1490  }
1491  return *this;
1492  }
1493  #endif
1494  static const ::google::protobuf::Descriptor* descriptor();
1495  static const RepDisable& default_instance();
1496 
1497  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1498  static inline const RepDisable* internal_default_instance() {
1499  return reinterpret_cast<const RepDisable*>(
1500  &_RepDisable_default_instance_);
1501  }
1502  static constexpr int kIndexInFileMessages =
1503  13;
1504 
1505  void Swap(RepDisable* other);
1506  friend void swap(RepDisable& a, RepDisable& b) {
1507  a.Swap(&b);
1508  }
1509 
1510  // implements Message ----------------------------------------------
1511 
1512  inline RepDisable* New() const final {
1513  return CreateMaybeMessage<RepDisable>(NULL);
1514  }
1515 
1516  RepDisable* New(::google::protobuf::Arena* arena) const final {
1517  return CreateMaybeMessage<RepDisable>(arena);
1518  }
1519  void CopyFrom(const ::google::protobuf::Message& from) final;
1520  void MergeFrom(const ::google::protobuf::Message& from) final;
1521  void CopyFrom(const RepDisable& from);
1522  void MergeFrom(const RepDisable& from);
1523  void Clear() final;
1524  bool IsInitialized() const final;
1525 
1526  size_t ByteSizeLong() const final;
1527  bool MergePartialFromCodedStream(
1528  ::google::protobuf::io::CodedInputStream* input) final;
1529  void SerializeWithCachedSizes(
1530  ::google::protobuf::io::CodedOutputStream* output) const final;
1531  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1532  bool deterministic, ::google::protobuf::uint8* target) const final;
1533  int GetCachedSize() const final { return _cached_size_.Get(); }
1534 
1535  private:
1536  void SharedCtor();
1537  void SharedDtor();
1538  void SetCachedSize(int size) const final;
1539  void InternalSwap(RepDisable* other);
1540  private:
1541  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1542  return NULL;
1543  }
1544  inline void* MaybeArenaPtr() const {
1545  return NULL;
1546  }
1547  public:
1548 
1549  ::google::protobuf::Metadata GetMetadata() const final;
1550 
1551  // nested types ----------------------------------------------------
1552 
1553  // accessors -------------------------------------------------------
1554 
1555  // string reply = 1;
1556  void clear_reply();
1557  static const int kReplyFieldNumber = 1;
1558  const ::std::string& reply() const;
1559  void set_reply(const ::std::string& value);
1560  #if LANG_CXX11
1561  void set_reply(::std::string&& value);
1562  #endif
1563  void set_reply(const char* value);
1564  void set_reply(const char* value, size_t size);
1565  ::std::string* mutable_reply();
1566  ::std::string* release_reply();
1567  void set_allocated_reply(::std::string* reply);
1568 
1569  // @@protoc_insertion_point(class_scope:helloif.RepDisable)
1570  private:
1571 
1572  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1573  ::google::protobuf::internal::ArenaStringPtr reply_;
1574  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1575  friend struct ::protobuf_requests_2eproto::TableStruct;
1576 };
1577 // -------------------------------------------------------------------
1578 
1579 class ReqConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqConfig) */ {
1580  public:
1581  ReqConfig();
1582  virtual ~ReqConfig();
1583 
1584  ReqConfig(const ReqConfig& from);
1585 
1586  inline ReqConfig& operator=(const ReqConfig& from) {
1587  CopyFrom(from);
1588  return *this;
1589  }
1590  #if LANG_CXX11
1591  ReqConfig(ReqConfig&& from) noexcept
1592  : ReqConfig() {
1593  *this = ::std::move(from);
1594  }
1595 
1596  inline ReqConfig& operator=(ReqConfig&& from) noexcept {
1597  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1598  if (this != &from) InternalSwap(&from);
1599  } else {
1600  CopyFrom(from);
1601  }
1602  return *this;
1603  }
1604  #endif
1605  static const ::google::protobuf::Descriptor* descriptor();
1606  static const ReqConfig& default_instance();
1607 
1608  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1609  static inline const ReqConfig* internal_default_instance() {
1610  return reinterpret_cast<const ReqConfig*>(
1611  &_ReqConfig_default_instance_);
1612  }
1613  static constexpr int kIndexInFileMessages =
1614  14;
1615 
1616  void Swap(ReqConfig* other);
1617  friend void swap(ReqConfig& a, ReqConfig& b) {
1618  a.Swap(&b);
1619  }
1620 
1621  // implements Message ----------------------------------------------
1622 
1623  inline ReqConfig* New() const final {
1624  return CreateMaybeMessage<ReqConfig>(NULL);
1625  }
1626 
1627  ReqConfig* New(::google::protobuf::Arena* arena) const final {
1628  return CreateMaybeMessage<ReqConfig>(arena);
1629  }
1630  void CopyFrom(const ::google::protobuf::Message& from) final;
1631  void MergeFrom(const ::google::protobuf::Message& from) final;
1632  void CopyFrom(const ReqConfig& from);
1633  void MergeFrom(const ReqConfig& from);
1634  void Clear() final;
1635  bool IsInitialized() const final;
1636 
1637  size_t ByteSizeLong() const final;
1638  bool MergePartialFromCodedStream(
1639  ::google::protobuf::io::CodedInputStream* input) final;
1640  void SerializeWithCachedSizes(
1641  ::google::protobuf::io::CodedOutputStream* output) const final;
1642  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1643  bool deterministic, ::google::protobuf::uint8* target) const final;
1644  int GetCachedSize() const final { return _cached_size_.Get(); }
1645 
1646  private:
1647  void SharedCtor();
1648  void SharedDtor();
1649  void SetCachedSize(int size) const final;
1650  void InternalSwap(ReqConfig* other);
1651  private:
1652  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1653  return NULL;
1654  }
1655  inline void* MaybeArenaPtr() const {
1656  return NULL;
1657  }
1658  public:
1659 
1660  ::google::protobuf::Metadata GetMetadata() const final;
1661 
1662  // nested types ----------------------------------------------------
1663 
1664  // accessors -------------------------------------------------------
1665 
1666  // @@protoc_insertion_point(class_scope:helloif.ReqConfig)
1667  private:
1668 
1669  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1670  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1671  friend struct ::protobuf_requests_2eproto::TableStruct;
1672 };
1673 // -------------------------------------------------------------------
1674 
1675 class RepConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepConfig) */ {
1676  public:
1677  RepConfig();
1678  virtual ~RepConfig();
1679 
1680  RepConfig(const RepConfig& from);
1681 
1682  inline RepConfig& operator=(const RepConfig& from) {
1683  CopyFrom(from);
1684  return *this;
1685  }
1686  #if LANG_CXX11
1687  RepConfig(RepConfig&& from) noexcept
1688  : RepConfig() {
1689  *this = ::std::move(from);
1690  }
1691 
1692  inline RepConfig& operator=(RepConfig&& from) noexcept {
1693  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1694  if (this != &from) InternalSwap(&from);
1695  } else {
1696  CopyFrom(from);
1697  }
1698  return *this;
1699  }
1700  #endif
1701  static const ::google::protobuf::Descriptor* descriptor();
1702  static const RepConfig& default_instance();
1703 
1704  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1705  static inline const RepConfig* internal_default_instance() {
1706  return reinterpret_cast<const RepConfig*>(
1707  &_RepConfig_default_instance_);
1708  }
1709  static constexpr int kIndexInFileMessages =
1710  15;
1711 
1712  void Swap(RepConfig* other);
1713  friend void swap(RepConfig& a, RepConfig& b) {
1714  a.Swap(&b);
1715  }
1716 
1717  // implements Message ----------------------------------------------
1718 
1719  inline RepConfig* New() const final {
1720  return CreateMaybeMessage<RepConfig>(NULL);
1721  }
1722 
1723  RepConfig* New(::google::protobuf::Arena* arena) const final {
1724  return CreateMaybeMessage<RepConfig>(arena);
1725  }
1726  void CopyFrom(const ::google::protobuf::Message& from) final;
1727  void MergeFrom(const ::google::protobuf::Message& from) final;
1728  void CopyFrom(const RepConfig& from);
1729  void MergeFrom(const RepConfig& from);
1730  void Clear() final;
1731  bool IsInitialized() const final;
1732 
1733  size_t ByteSizeLong() const final;
1734  bool MergePartialFromCodedStream(
1735  ::google::protobuf::io::CodedInputStream* input) final;
1736  void SerializeWithCachedSizes(
1737  ::google::protobuf::io::CodedOutputStream* output) const final;
1738  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1739  bool deterministic, ::google::protobuf::uint8* target) const final;
1740  int GetCachedSize() const final { return _cached_size_.Get(); }
1741 
1742  private:
1743  void SharedCtor();
1744  void SharedDtor();
1745  void SetCachedSize(int size) const final;
1746  void InternalSwap(RepConfig* other);
1747  private:
1748  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1749  return NULL;
1750  }
1751  inline void* MaybeArenaPtr() const {
1752  return NULL;
1753  }
1754  public:
1755 
1756  ::google::protobuf::Metadata GetMetadata() const final;
1757 
1758  // nested types ----------------------------------------------------
1759 
1760  // accessors -------------------------------------------------------
1761 
1762  // string reply = 1;
1763  void clear_reply();
1764  static const int kReplyFieldNumber = 1;
1765  const ::std::string& reply() const;
1766  void set_reply(const ::std::string& value);
1767  #if LANG_CXX11
1768  void set_reply(::std::string&& value);
1769  #endif
1770  void set_reply(const char* value);
1771  void set_reply(const char* value, size_t size);
1772  ::std::string* mutable_reply();
1773  ::std::string* release_reply();
1774  void set_allocated_reply(::std::string* reply);
1775 
1776  // @@protoc_insertion_point(class_scope:helloif.RepConfig)
1777  private:
1778 
1779  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1780  ::google::protobuf::internal::ArenaStringPtr reply_;
1781  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1782  friend struct ::protobuf_requests_2eproto::TableStruct;
1783 };
1784 // -------------------------------------------------------------------
1785 
1786 class ReqSetLogLevel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.ReqSetLogLevel) */ {
1787  public:
1788  ReqSetLogLevel();
1789  virtual ~ReqSetLogLevel();
1790 
1791  ReqSetLogLevel(const ReqSetLogLevel& from);
1792 
1793  inline ReqSetLogLevel& operator=(const ReqSetLogLevel& from) {
1794  CopyFrom(from);
1795  return *this;
1796  }
1797  #if LANG_CXX11
1798  ReqSetLogLevel(ReqSetLogLevel&& from) noexcept
1799  : ReqSetLogLevel() {
1800  *this = ::std::move(from);
1801  }
1802 
1803  inline ReqSetLogLevel& operator=(ReqSetLogLevel&& from) noexcept {
1804  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1805  if (this != &from) InternalSwap(&from);
1806  } else {
1807  CopyFrom(from);
1808  }
1809  return *this;
1810  }
1811  #endif
1812  static const ::google::protobuf::Descriptor* descriptor();
1813  static const ReqSetLogLevel& default_instance();
1814 
1815  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1816  static inline const ReqSetLogLevel* internal_default_instance() {
1817  return reinterpret_cast<const ReqSetLogLevel*>(
1818  &_ReqSetLogLevel_default_instance_);
1819  }
1820  static constexpr int kIndexInFileMessages =
1821  16;
1822 
1823  void Swap(ReqSetLogLevel* other);
1824  friend void swap(ReqSetLogLevel& a, ReqSetLogLevel& b) {
1825  a.Swap(&b);
1826  }
1827 
1828  // implements Message ----------------------------------------------
1829 
1830  inline ReqSetLogLevel* New() const final {
1831  return CreateMaybeMessage<ReqSetLogLevel>(NULL);
1832  }
1833 
1834  ReqSetLogLevel* New(::google::protobuf::Arena* arena) const final {
1835  return CreateMaybeMessage<ReqSetLogLevel>(arena);
1836  }
1837  void CopyFrom(const ::google::protobuf::Message& from) final;
1838  void MergeFrom(const ::google::protobuf::Message& from) final;
1839  void CopyFrom(const ReqSetLogLevel& from);
1840  void MergeFrom(const ReqSetLogLevel& from);
1841  void Clear() final;
1842  bool IsInitialized() const final;
1843 
1844  size_t ByteSizeLong() const final;
1845  bool MergePartialFromCodedStream(
1846  ::google::protobuf::io::CodedInputStream* input) final;
1847  void SerializeWithCachedSizes(
1848  ::google::protobuf::io::CodedOutputStream* output) const final;
1849  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1850  bool deterministic, ::google::protobuf::uint8* target) const final;
1851  int GetCachedSize() const final { return _cached_size_.Get(); }
1852 
1853  private:
1854  void SharedCtor();
1855  void SharedDtor();
1856  void SetCachedSize(int size) const final;
1857  void InternalSwap(ReqSetLogLevel* other);
1858  private:
1859  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1860  return NULL;
1861  }
1862  inline void* MaybeArenaPtr() const {
1863  return NULL;
1864  }
1865  public:
1866 
1867  ::google::protobuf::Metadata GetMetadata() const final;
1868 
1869  // nested types ----------------------------------------------------
1870 
1871  // accessors -------------------------------------------------------
1872 
1873  // string loglevel = 1;
1874  void clear_loglevel();
1875  static const int kLoglevelFieldNumber = 1;
1876  const ::std::string& loglevel() const;
1877  void set_loglevel(const ::std::string& value);
1878  #if LANG_CXX11
1879  void set_loglevel(::std::string&& value);
1880  #endif
1881  void set_loglevel(const char* value);
1882  void set_loglevel(const char* value, size_t size);
1883  ::std::string* mutable_loglevel();
1884  ::std::string* release_loglevel();
1885  void set_allocated_loglevel(::std::string* loglevel);
1886 
1887  // string loggername = 2;
1888  void clear_loggername();
1889  static const int kLoggernameFieldNumber = 2;
1890  const ::std::string& loggername() const;
1891  void set_loggername(const ::std::string& value);
1892  #if LANG_CXX11
1893  void set_loggername(::std::string&& value);
1894  #endif
1895  void set_loggername(const char* value);
1896  void set_loggername(const char* value, size_t size);
1897  ::std::string* mutable_loggername();
1898  ::std::string* release_loggername();
1899  void set_allocated_loggername(::std::string* loggername);
1900 
1901  // @@protoc_insertion_point(class_scope:helloif.ReqSetLogLevel)
1902  private:
1903 
1904  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1905  ::google::protobuf::internal::ArenaStringPtr loglevel_;
1906  ::google::protobuf::internal::ArenaStringPtr loggername_;
1907  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1908  friend struct ::protobuf_requests_2eproto::TableStruct;
1909 };
1910 // -------------------------------------------------------------------
1911 
1912 class RepSetLogLevel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:helloif.RepSetLogLevel) */ {
1913  public:
1914  RepSetLogLevel();
1915  virtual ~RepSetLogLevel();
1916 
1917  RepSetLogLevel(const RepSetLogLevel& from);
1918 
1919  inline RepSetLogLevel& operator=(const RepSetLogLevel& from) {
1920  CopyFrom(from);
1921  return *this;
1922  }
1923  #if LANG_CXX11
1924  RepSetLogLevel(RepSetLogLevel&& from) noexcept
1925  : RepSetLogLevel() {
1926  *this = ::std::move(from);
1927  }
1928 
1929  inline RepSetLogLevel& operator=(RepSetLogLevel&& from) noexcept {
1930  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1931  if (this != &from) InternalSwap(&from);
1932  } else {
1933  CopyFrom(from);
1934  }
1935  return *this;
1936  }
1937  #endif
1938  static const ::google::protobuf::Descriptor* descriptor();
1939  static const RepSetLogLevel& default_instance();
1940 
1941  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1942  static inline const RepSetLogLevel* internal_default_instance() {
1943  return reinterpret_cast<const RepSetLogLevel*>(
1944  &_RepSetLogLevel_default_instance_);
1945  }
1946  static constexpr int kIndexInFileMessages =
1947  17;
1948 
1949  void Swap(RepSetLogLevel* other);
1950  friend void swap(RepSetLogLevel& a, RepSetLogLevel& b) {
1951  a.Swap(&b);
1952  }
1953 
1954  // implements Message ----------------------------------------------
1955 
1956  inline RepSetLogLevel* New() const final {
1957  return CreateMaybeMessage<RepSetLogLevel>(NULL);
1958  }
1959 
1960  RepSetLogLevel* New(::google::protobuf::Arena* arena) const final {
1961  return CreateMaybeMessage<RepSetLogLevel>(arena);
1962  }
1963  void CopyFrom(const ::google::protobuf::Message& from) final;
1964  void MergeFrom(const ::google::protobuf::Message& from) final;
1965  void CopyFrom(const RepSetLogLevel& from);
1966  void MergeFrom(const RepSetLogLevel& from);
1967  void Clear() final;
1968  bool IsInitialized() const final;
1969 
1970  size_t ByteSizeLong() const final;
1971  bool MergePartialFromCodedStream(
1972  ::google::protobuf::io::CodedInputStream* input) final;
1973  void SerializeWithCachedSizes(
1974  ::google::protobuf::io::CodedOutputStream* output) const final;
1975  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1976  bool deterministic, ::google::protobuf::uint8* target) const final;
1977  int GetCachedSize() const final { return _cached_size_.Get(); }
1978 
1979  private:
1980  void SharedCtor();
1981  void SharedDtor();
1982  void SetCachedSize(int size) const final;
1983  void InternalSwap(RepSetLogLevel* other);
1984  private:
1985  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1986  return NULL;
1987  }
1988  inline void* MaybeArenaPtr() const {
1989  return NULL;
1990  }
1991  public:
1992 
1993  ::google::protobuf::Metadata GetMetadata() const final;
1994 
1995  // nested types ----------------------------------------------------
1996 
1997  // accessors -------------------------------------------------------
1998 
1999  // string reply = 1;
2000  void clear_reply();
2001  static const int kReplyFieldNumber = 1;
2002  const ::std::string& reply() const;
2003  void set_reply(const ::std::string& value);
2004  #if LANG_CXX11
2005  void set_reply(::std::string&& value);
2006  #endif
2007  void set_reply(const char* value);
2008  void set_reply(const char* value, size_t size);
2009  ::std::string* mutable_reply();
2010  ::std::string* release_reply();
2011  void set_allocated_reply(::std::string* reply);
2012 
2013  // @@protoc_insertion_point(class_scope:helloif.RepSetLogLevel)
2014  private:
2015 
2016  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2017  ::google::protobuf::internal::ArenaStringPtr reply_;
2018  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2019  friend struct ::protobuf_requests_2eproto::TableStruct;
2020 };
2021 // ===================================================================
2022 
2023 
2024 // ===================================================================
2025 
2026 #ifdef __GNUC__
2027  #pragma GCC diagnostic push
2028  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2029 #endif // __GNUC__
2030 // ReqExit
2031 
2032 // -------------------------------------------------------------------
2033 
2034 // RepExit
2035 
2036 // string reply = 1;
2037 inline void RepExit::clear_reply() {
2038  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2039 }
2040 inline const ::std::string& RepExit::reply() const {
2041  // @@protoc_insertion_point(field_get:helloif.RepExit.reply)
2042  return reply_.GetNoArena();
2043 }
2044 inline void RepExit::set_reply(const ::std::string& value) {
2045 
2046  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2047  // @@protoc_insertion_point(field_set:helloif.RepExit.reply)
2048 }
2049 #if LANG_CXX11
2050 inline void RepExit::set_reply(::std::string&& value) {
2051 
2052  reply_.SetNoArena(
2053  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2054  // @@protoc_insertion_point(field_set_rvalue:helloif.RepExit.reply)
2055 }
2056 #endif
2057 inline void RepExit::set_reply(const char* value) {
2058  GOOGLE_DCHECK(value != NULL);
2059 
2060  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2061  // @@protoc_insertion_point(field_set_char:helloif.RepExit.reply)
2062 }
2063 inline void RepExit::set_reply(const char* value, size_t size) {
2064 
2065  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2066  ::std::string(reinterpret_cast<const char*>(value), size));
2067  // @@protoc_insertion_point(field_set_pointer:helloif.RepExit.reply)
2068 }
2069 inline ::std::string* RepExit::mutable_reply() {
2070 
2071  // @@protoc_insertion_point(field_mutable:helloif.RepExit.reply)
2072  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2073 }
2074 inline ::std::string* RepExit::release_reply() {
2075  // @@protoc_insertion_point(field_release:helloif.RepExit.reply)
2076 
2077  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2078 }
2079 inline void RepExit::set_allocated_reply(::std::string* reply) {
2080  if (reply != NULL) {
2081 
2082  } else {
2083 
2084  }
2085  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2086  // @@protoc_insertion_point(field_set_allocated:helloif.RepExit.reply)
2087 }
2088 
2089 // -------------------------------------------------------------------
2090 
2091 // ReqStatus
2092 
2093 // -------------------------------------------------------------------
2094 
2095 // RepStatus
2096 
2097 // string reply = 1;
2098 inline void RepStatus::clear_reply() {
2099  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2100 }
2101 inline const ::std::string& RepStatus::reply() const {
2102  // @@protoc_insertion_point(field_get:helloif.RepStatus.reply)
2103  return reply_.GetNoArena();
2104 }
2105 inline void RepStatus::set_reply(const ::std::string& value) {
2106 
2107  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2108  // @@protoc_insertion_point(field_set:helloif.RepStatus.reply)
2109 }
2110 #if LANG_CXX11
2111 inline void RepStatus::set_reply(::std::string&& value) {
2112 
2113  reply_.SetNoArena(
2114  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2115  // @@protoc_insertion_point(field_set_rvalue:helloif.RepStatus.reply)
2116 }
2117 #endif
2118 inline void RepStatus::set_reply(const char* value) {
2119  GOOGLE_DCHECK(value != NULL);
2120 
2121  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2122  // @@protoc_insertion_point(field_set_char:helloif.RepStatus.reply)
2123 }
2124 inline void RepStatus::set_reply(const char* value, size_t size) {
2125 
2126  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2127  ::std::string(reinterpret_cast<const char*>(value), size));
2128  // @@protoc_insertion_point(field_set_pointer:helloif.RepStatus.reply)
2129 }
2130 inline ::std::string* RepStatus::mutable_reply() {
2131 
2132  // @@protoc_insertion_point(field_mutable:helloif.RepStatus.reply)
2133  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2134 }
2135 inline ::std::string* RepStatus::release_reply() {
2136  // @@protoc_insertion_point(field_release:helloif.RepStatus.reply)
2137 
2138  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2139 }
2140 inline void RepStatus::set_allocated_reply(::std::string* reply) {
2141  if (reply != NULL) {
2142 
2143  } else {
2144 
2145  }
2146  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2147  // @@protoc_insertion_point(field_set_allocated:helloif.RepStatus.reply)
2148 }
2149 
2150 // -------------------------------------------------------------------
2151 
2152 // ReqStop
2153 
2154 // -------------------------------------------------------------------
2155 
2156 // RepStop
2157 
2158 // string reply = 1;
2159 inline void RepStop::clear_reply() {
2160  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2161 }
2162 inline const ::std::string& RepStop::reply() const {
2163  // @@protoc_insertion_point(field_get:helloif.RepStop.reply)
2164  return reply_.GetNoArena();
2165 }
2166 inline void RepStop::set_reply(const ::std::string& value) {
2167 
2168  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2169  // @@protoc_insertion_point(field_set:helloif.RepStop.reply)
2170 }
2171 #if LANG_CXX11
2172 inline void RepStop::set_reply(::std::string&& value) {
2173 
2174  reply_.SetNoArena(
2175  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2176  // @@protoc_insertion_point(field_set_rvalue:helloif.RepStop.reply)
2177 }
2178 #endif
2179 inline void RepStop::set_reply(const char* value) {
2180  GOOGLE_DCHECK(value != NULL);
2181 
2182  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2183  // @@protoc_insertion_point(field_set_char:helloif.RepStop.reply)
2184 }
2185 inline void RepStop::set_reply(const char* value, size_t size) {
2186 
2187  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2188  ::std::string(reinterpret_cast<const char*>(value), size));
2189  // @@protoc_insertion_point(field_set_pointer:helloif.RepStop.reply)
2190 }
2191 inline ::std::string* RepStop::mutable_reply() {
2192 
2193  // @@protoc_insertion_point(field_mutable:helloif.RepStop.reply)
2194  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2195 }
2196 inline ::std::string* RepStop::release_reply() {
2197  // @@protoc_insertion_point(field_release:helloif.RepStop.reply)
2198 
2199  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2200 }
2201 inline void RepStop::set_allocated_reply(::std::string* reply) {
2202  if (reply != NULL) {
2203 
2204  } else {
2205 
2206  }
2207  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2208  // @@protoc_insertion_point(field_set_allocated:helloif.RepStop.reply)
2209 }
2210 
2211 // -------------------------------------------------------------------
2212 
2213 // ReqReset
2214 
2215 // -------------------------------------------------------------------
2216 
2217 // RepReset
2218 
2219 // string reply = 1;
2220 inline void RepReset::clear_reply() {
2221  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2222 }
2223 inline const ::std::string& RepReset::reply() const {
2224  // @@protoc_insertion_point(field_get:helloif.RepReset.reply)
2225  return reply_.GetNoArena();
2226 }
2227 inline void RepReset::set_reply(const ::std::string& value) {
2228 
2229  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2230  // @@protoc_insertion_point(field_set:helloif.RepReset.reply)
2231 }
2232 #if LANG_CXX11
2233 inline void RepReset::set_reply(::std::string&& value) {
2234 
2235  reply_.SetNoArena(
2236  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2237  // @@protoc_insertion_point(field_set_rvalue:helloif.RepReset.reply)
2238 }
2239 #endif
2240 inline void RepReset::set_reply(const char* value) {
2241  GOOGLE_DCHECK(value != NULL);
2242 
2243  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2244  // @@protoc_insertion_point(field_set_char:helloif.RepReset.reply)
2245 }
2246 inline void RepReset::set_reply(const char* value, size_t size) {
2247 
2248  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2249  ::std::string(reinterpret_cast<const char*>(value), size));
2250  // @@protoc_insertion_point(field_set_pointer:helloif.RepReset.reply)
2251 }
2252 inline ::std::string* RepReset::mutable_reply() {
2253 
2254  // @@protoc_insertion_point(field_mutable:helloif.RepReset.reply)
2255  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2256 }
2257 inline ::std::string* RepReset::release_reply() {
2258  // @@protoc_insertion_point(field_release:helloif.RepReset.reply)
2259 
2260  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2261 }
2262 inline void RepReset::set_allocated_reply(::std::string* reply) {
2263  if (reply != NULL) {
2264 
2265  } else {
2266 
2267  }
2268  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2269  // @@protoc_insertion_point(field_set_allocated:helloif.RepReset.reply)
2270 }
2271 
2272 // -------------------------------------------------------------------
2273 
2274 // ReqInit
2275 
2276 // -------------------------------------------------------------------
2277 
2278 // RepInit
2279 
2280 // string reply = 1;
2281 inline void RepInit::clear_reply() {
2282  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2283 }
2284 inline const ::std::string& RepInit::reply() const {
2285  // @@protoc_insertion_point(field_get:helloif.RepInit.reply)
2286  return reply_.GetNoArena();
2287 }
2288 inline void RepInit::set_reply(const ::std::string& value) {
2289 
2290  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2291  // @@protoc_insertion_point(field_set:helloif.RepInit.reply)
2292 }
2293 #if LANG_CXX11
2294 inline void RepInit::set_reply(::std::string&& value) {
2295 
2296  reply_.SetNoArena(
2297  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2298  // @@protoc_insertion_point(field_set_rvalue:helloif.RepInit.reply)
2299 }
2300 #endif
2301 inline void RepInit::set_reply(const char* value) {
2302  GOOGLE_DCHECK(value != NULL);
2303 
2304  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2305  // @@protoc_insertion_point(field_set_char:helloif.RepInit.reply)
2306 }
2307 inline void RepInit::set_reply(const char* value, size_t size) {
2308 
2309  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2310  ::std::string(reinterpret_cast<const char*>(value), size));
2311  // @@protoc_insertion_point(field_set_pointer:helloif.RepInit.reply)
2312 }
2313 inline ::std::string* RepInit::mutable_reply() {
2314 
2315  // @@protoc_insertion_point(field_mutable:helloif.RepInit.reply)
2316  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2317 }
2318 inline ::std::string* RepInit::release_reply() {
2319  // @@protoc_insertion_point(field_release:helloif.RepInit.reply)
2320 
2321  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2322 }
2323 inline void RepInit::set_allocated_reply(::std::string* reply) {
2324  if (reply != NULL) {
2325 
2326  } else {
2327 
2328  }
2329  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2330  // @@protoc_insertion_point(field_set_allocated:helloif.RepInit.reply)
2331 }
2332 
2333 // -------------------------------------------------------------------
2334 
2335 // ReqEnable
2336 
2337 // -------------------------------------------------------------------
2338 
2339 // RepEnable
2340 
2341 // string reply = 1;
2342 inline void RepEnable::clear_reply() {
2343  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2344 }
2345 inline const ::std::string& RepEnable::reply() const {
2346  // @@protoc_insertion_point(field_get:helloif.RepEnable.reply)
2347  return reply_.GetNoArena();
2348 }
2349 inline void RepEnable::set_reply(const ::std::string& value) {
2350 
2351  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2352  // @@protoc_insertion_point(field_set:helloif.RepEnable.reply)
2353 }
2354 #if LANG_CXX11
2355 inline void RepEnable::set_reply(::std::string&& value) {
2356 
2357  reply_.SetNoArena(
2358  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2359  // @@protoc_insertion_point(field_set_rvalue:helloif.RepEnable.reply)
2360 }
2361 #endif
2362 inline void RepEnable::set_reply(const char* value) {
2363  GOOGLE_DCHECK(value != NULL);
2364 
2365  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2366  // @@protoc_insertion_point(field_set_char:helloif.RepEnable.reply)
2367 }
2368 inline void RepEnable::set_reply(const char* value, size_t size) {
2369 
2370  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2371  ::std::string(reinterpret_cast<const char*>(value), size));
2372  // @@protoc_insertion_point(field_set_pointer:helloif.RepEnable.reply)
2373 }
2374 inline ::std::string* RepEnable::mutable_reply() {
2375 
2376  // @@protoc_insertion_point(field_mutable:helloif.RepEnable.reply)
2377  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2378 }
2379 inline ::std::string* RepEnable::release_reply() {
2380  // @@protoc_insertion_point(field_release:helloif.RepEnable.reply)
2381 
2382  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2383 }
2384 inline void RepEnable::set_allocated_reply(::std::string* reply) {
2385  if (reply != NULL) {
2386 
2387  } else {
2388 
2389  }
2390  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2391  // @@protoc_insertion_point(field_set_allocated:helloif.RepEnable.reply)
2392 }
2393 
2394 // -------------------------------------------------------------------
2395 
2396 // ReqDisable
2397 
2398 // -------------------------------------------------------------------
2399 
2400 // RepDisable
2401 
2402 // string reply = 1;
2403 inline void RepDisable::clear_reply() {
2404  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2405 }
2406 inline const ::std::string& RepDisable::reply() const {
2407  // @@protoc_insertion_point(field_get:helloif.RepDisable.reply)
2408  return reply_.GetNoArena();
2409 }
2410 inline void RepDisable::set_reply(const ::std::string& value) {
2411 
2412  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2413  // @@protoc_insertion_point(field_set:helloif.RepDisable.reply)
2414 }
2415 #if LANG_CXX11
2416 inline void RepDisable::set_reply(::std::string&& value) {
2417 
2418  reply_.SetNoArena(
2419  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2420  // @@protoc_insertion_point(field_set_rvalue:helloif.RepDisable.reply)
2421 }
2422 #endif
2423 inline void RepDisable::set_reply(const char* value) {
2424  GOOGLE_DCHECK(value != NULL);
2425 
2426  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2427  // @@protoc_insertion_point(field_set_char:helloif.RepDisable.reply)
2428 }
2429 inline void RepDisable::set_reply(const char* value, size_t size) {
2430 
2431  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2432  ::std::string(reinterpret_cast<const char*>(value), size));
2433  // @@protoc_insertion_point(field_set_pointer:helloif.RepDisable.reply)
2434 }
2435 inline ::std::string* RepDisable::mutable_reply() {
2436 
2437  // @@protoc_insertion_point(field_mutable:helloif.RepDisable.reply)
2438  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2439 }
2440 inline ::std::string* RepDisable::release_reply() {
2441  // @@protoc_insertion_point(field_release:helloif.RepDisable.reply)
2442 
2443  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2444 }
2445 inline void RepDisable::set_allocated_reply(::std::string* reply) {
2446  if (reply != NULL) {
2447 
2448  } else {
2449 
2450  }
2451  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2452  // @@protoc_insertion_point(field_set_allocated:helloif.RepDisable.reply)
2453 }
2454 
2455 // -------------------------------------------------------------------
2456 
2457 // ReqConfig
2458 
2459 // -------------------------------------------------------------------
2460 
2461 // RepConfig
2462 
2463 // string reply = 1;
2464 inline void RepConfig::clear_reply() {
2465  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2466 }
2467 inline const ::std::string& RepConfig::reply() const {
2468  // @@protoc_insertion_point(field_get:helloif.RepConfig.reply)
2469  return reply_.GetNoArena();
2470 }
2471 inline void RepConfig::set_reply(const ::std::string& value) {
2472 
2473  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2474  // @@protoc_insertion_point(field_set:helloif.RepConfig.reply)
2475 }
2476 #if LANG_CXX11
2477 inline void RepConfig::set_reply(::std::string&& value) {
2478 
2479  reply_.SetNoArena(
2480  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2481  // @@protoc_insertion_point(field_set_rvalue:helloif.RepConfig.reply)
2482 }
2483 #endif
2484 inline void RepConfig::set_reply(const char* value) {
2485  GOOGLE_DCHECK(value != NULL);
2486 
2487  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2488  // @@protoc_insertion_point(field_set_char:helloif.RepConfig.reply)
2489 }
2490 inline void RepConfig::set_reply(const char* value, size_t size) {
2491 
2492  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2493  ::std::string(reinterpret_cast<const char*>(value), size));
2494  // @@protoc_insertion_point(field_set_pointer:helloif.RepConfig.reply)
2495 }
2496 inline ::std::string* RepConfig::mutable_reply() {
2497 
2498  // @@protoc_insertion_point(field_mutable:helloif.RepConfig.reply)
2499  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2500 }
2501 inline ::std::string* RepConfig::release_reply() {
2502  // @@protoc_insertion_point(field_release:helloif.RepConfig.reply)
2503 
2504  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2505 }
2506 inline void RepConfig::set_allocated_reply(::std::string* reply) {
2507  if (reply != NULL) {
2508 
2509  } else {
2510 
2511  }
2512  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2513  // @@protoc_insertion_point(field_set_allocated:helloif.RepConfig.reply)
2514 }
2515 
2516 // -------------------------------------------------------------------
2517 
2518 // ReqSetLogLevel
2519 
2520 // string loglevel = 1;
2521 inline void ReqSetLogLevel::clear_loglevel() {
2522  loglevel_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2523 }
2524 inline const ::std::string& ReqSetLogLevel::loglevel() const {
2525  // @@protoc_insertion_point(field_get:helloif.ReqSetLogLevel.loglevel)
2526  return loglevel_.GetNoArena();
2527 }
2528 inline void ReqSetLogLevel::set_loglevel(const ::std::string& value) {
2529 
2530  loglevel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2531  // @@protoc_insertion_point(field_set:helloif.ReqSetLogLevel.loglevel)
2532 }
2533 #if LANG_CXX11
2534 inline void ReqSetLogLevel::set_loglevel(::std::string&& value) {
2535 
2536  loglevel_.SetNoArena(
2537  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2538  // @@protoc_insertion_point(field_set_rvalue:helloif.ReqSetLogLevel.loglevel)
2539 }
2540 #endif
2541 inline void ReqSetLogLevel::set_loglevel(const char* value) {
2542  GOOGLE_DCHECK(value != NULL);
2543 
2544  loglevel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2545  // @@protoc_insertion_point(field_set_char:helloif.ReqSetLogLevel.loglevel)
2546 }
2547 inline void ReqSetLogLevel::set_loglevel(const char* value, size_t size) {
2548 
2549  loglevel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2550  ::std::string(reinterpret_cast<const char*>(value), size));
2551  // @@protoc_insertion_point(field_set_pointer:helloif.ReqSetLogLevel.loglevel)
2552 }
2553 inline ::std::string* ReqSetLogLevel::mutable_loglevel() {
2554 
2555  // @@protoc_insertion_point(field_mutable:helloif.ReqSetLogLevel.loglevel)
2556  return loglevel_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2557 }
2558 inline ::std::string* ReqSetLogLevel::release_loglevel() {
2559  // @@protoc_insertion_point(field_release:helloif.ReqSetLogLevel.loglevel)
2560 
2561  return loglevel_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2562 }
2563 inline void ReqSetLogLevel::set_allocated_loglevel(::std::string* loglevel) {
2564  if (loglevel != NULL) {
2565 
2566  } else {
2567 
2568  }
2569  loglevel_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), loglevel);
2570  // @@protoc_insertion_point(field_set_allocated:helloif.ReqSetLogLevel.loglevel)
2571 }
2572 
2573 // string loggername = 2;
2574 inline void ReqSetLogLevel::clear_loggername() {
2575  loggername_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2576 }
2577 inline const ::std::string& ReqSetLogLevel::loggername() const {
2578  // @@protoc_insertion_point(field_get:helloif.ReqSetLogLevel.loggername)
2579  return loggername_.GetNoArena();
2580 }
2581 inline void ReqSetLogLevel::set_loggername(const ::std::string& value) {
2582 
2583  loggername_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2584  // @@protoc_insertion_point(field_set:helloif.ReqSetLogLevel.loggername)
2585 }
2586 #if LANG_CXX11
2587 inline void ReqSetLogLevel::set_loggername(::std::string&& value) {
2588 
2589  loggername_.SetNoArena(
2590  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2591  // @@protoc_insertion_point(field_set_rvalue:helloif.ReqSetLogLevel.loggername)
2592 }
2593 #endif
2594 inline void ReqSetLogLevel::set_loggername(const char* value) {
2595  GOOGLE_DCHECK(value != NULL);
2596 
2597  loggername_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2598  // @@protoc_insertion_point(field_set_char:helloif.ReqSetLogLevel.loggername)
2599 }
2600 inline void ReqSetLogLevel::set_loggername(const char* value, size_t size) {
2601 
2602  loggername_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2603  ::std::string(reinterpret_cast<const char*>(value), size));
2604  // @@protoc_insertion_point(field_set_pointer:helloif.ReqSetLogLevel.loggername)
2605 }
2606 inline ::std::string* ReqSetLogLevel::mutable_loggername() {
2607 
2608  // @@protoc_insertion_point(field_mutable:helloif.ReqSetLogLevel.loggername)
2609  return loggername_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2610 }
2611 inline ::std::string* ReqSetLogLevel::release_loggername() {
2612  // @@protoc_insertion_point(field_release:helloif.ReqSetLogLevel.loggername)
2613 
2614  return loggername_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2615 }
2616 inline void ReqSetLogLevel::set_allocated_loggername(::std::string* loggername) {
2617  if (loggername != NULL) {
2618 
2619  } else {
2620 
2621  }
2622  loggername_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), loggername);
2623  // @@protoc_insertion_point(field_set_allocated:helloif.ReqSetLogLevel.loggername)
2624 }
2625 
2626 // -------------------------------------------------------------------
2627 
2628 // RepSetLogLevel
2629 
2630 // string reply = 1;
2631 inline void RepSetLogLevel::clear_reply() {
2632  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2633 }
2634 inline const ::std::string& RepSetLogLevel::reply() const {
2635  // @@protoc_insertion_point(field_get:helloif.RepSetLogLevel.reply)
2636  return reply_.GetNoArena();
2637 }
2638 inline void RepSetLogLevel::set_reply(const ::std::string& value) {
2639 
2640  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2641  // @@protoc_insertion_point(field_set:helloif.RepSetLogLevel.reply)
2642 }
2643 #if LANG_CXX11
2644 inline void RepSetLogLevel::set_reply(::std::string&& value) {
2645 
2646  reply_.SetNoArena(
2647  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2648  // @@protoc_insertion_point(field_set_rvalue:helloif.RepSetLogLevel.reply)
2649 }
2650 #endif
2651 inline void RepSetLogLevel::set_reply(const char* value) {
2652  GOOGLE_DCHECK(value != NULL);
2653 
2654  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2655  // @@protoc_insertion_point(field_set_char:helloif.RepSetLogLevel.reply)
2656 }
2657 inline void RepSetLogLevel::set_reply(const char* value, size_t size) {
2658 
2659  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2660  ::std::string(reinterpret_cast<const char*>(value), size));
2661  // @@protoc_insertion_point(field_set_pointer:helloif.RepSetLogLevel.reply)
2662 }
2663 inline ::std::string* RepSetLogLevel::mutable_reply() {
2664 
2665  // @@protoc_insertion_point(field_mutable:helloif.RepSetLogLevel.reply)
2666  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2667 }
2668 inline ::std::string* RepSetLogLevel::release_reply() {
2669  // @@protoc_insertion_point(field_release:helloif.RepSetLogLevel.reply)
2670 
2671  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2672 }
2673 inline void RepSetLogLevel::set_allocated_reply(::std::string* reply) {
2674  if (reply != NULL) {
2675 
2676  } else {
2677 
2678  }
2679  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
2680  // @@protoc_insertion_point(field_set_allocated:helloif.RepSetLogLevel.reply)
2681 }
2682 
2683 #ifdef __GNUC__
2684  #pragma GCC diagnostic pop
2685 #endif // __GNUC__
2686 // -------------------------------------------------------------------
2687 
2688 // -------------------------------------------------------------------
2689 
2690 // -------------------------------------------------------------------
2691 
2692 // -------------------------------------------------------------------
2693 
2694 // -------------------------------------------------------------------
2695 
2696 // -------------------------------------------------------------------
2697 
2698 // -------------------------------------------------------------------
2699 
2700 // -------------------------------------------------------------------
2701 
2702 // -------------------------------------------------------------------
2703 
2704 // -------------------------------------------------------------------
2705 
2706 // -------------------------------------------------------------------
2707 
2708 // -------------------------------------------------------------------
2709 
2710 // -------------------------------------------------------------------
2711 
2712 // -------------------------------------------------------------------
2713 
2714 // -------------------------------------------------------------------
2715 
2716 // -------------------------------------------------------------------
2717 
2718 // -------------------------------------------------------------------
2719 
2720 
2721 // @@protoc_insertion_point(namespace_scope)
2722 
2723 } // namespace helloif
2724 
2725 // @@protoc_insertion_point(global_scope)
2726 
2727 #endif // PROTOBUF_INCLUDED_requests_2eproto
helloif
package helloif
Definition: requests.proto:3
helloif::RepEnable::Swap
void Swap(RepEnable *other)
helloif::RepStatus::Swap
void Swap(RepStatus *other)
helloif::ReqStatus
Definition: requests.pb.h:337
helloif::RepSetLogLevel::clear_reply
void clear_reply()
Definition: requests.pb.h:2631
helloif::RepEnable::New
RepEnable * New() const final
Definition: requests.pb.h:1305
helloif::RepStatus::operator=
RepStatus & operator=(const RepStatus &from)
Definition: requests.pb.h:440
helloif::ReqExit::MergeFrom
void MergeFrom(const ::google::protobuf::Message &from) final
helloif::RepStop::clear_reply
void clear_reply()
Definition: requests.pb.h:2159
helloif::ReqExit::GetCachedSize
int GetCachedSize() const final
Definition: requests.pb.h:195
helloif::RepStop::swap
friend void swap(RepStop &a, RepStop &b)
Definition: requests.pb.h:678
protobuf_requests_2eproto::TableStruct::serialization_table
static const ::google::protobuf::internal::SerializationTable serialization_table[]
Definition: requests.pb.h:43
protobuf_requests_2eproto::TableStruct::offsets
static const ::google::protobuf::uint32 offsets[]
Definition: requests.pb.h:44
helloif::RepInit::Swap
void Swap(RepInit *other)
helloif::ReqExit::InternalSerializeWithCachedSizesToArray
::google::protobuf::uint8 * InternalSerializeWithCachedSizesToArray(bool deterministic,::google::protobuf::uint8 *target) const final
helloif::RepStatus::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2105
helloif::ReqSetLogLevel::mutable_loglevel
::std::string * mutable_loglevel()
Definition: requests.pb.h:2553
helloif::ReqReset::internal_default_instance
static const ReqReset * internal_default_instance()
Definition: requests.pb.h:781
helloif::RepConfig::reply
const ::std::string & reply() const
Definition: requests.pb.h:2467
helloif::RepSetLogLevel::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2673
helloif::ReqEnable::operator=
ReqEnable & operator=(const ReqEnable &from)
Definition: requests.pb.h:1172
helloif::ReqReset::Swap
void Swap(ReqReset *other)
protobuf_requests_2eproto::TableStruct::field_metadata
static const ::google::protobuf::internal::FieldMetadata field_metadata[]
Definition: requests.pb.h:42
helloif::RepInit::operator=
RepInit & operator=(const RepInit &from)
Definition: requests.pb.h:1061
helloif::ReqSetLogLevel::set_loggername
void set_loggername(const ::std::string &value)
Definition: requests.pb.h:2581
helloif::_RepExit_default_instance_
RepExitDefaultTypeInternal _RepExit_default_instance_
Definition: requests.pb.h:59
helloif::RepInit::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2323
helloif::RepConfig::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2496
helloif::RepStop
Definition: requests.pb.h:640
helloif::ReqSetLogLevel
Definition: requests.pb.h:1786
helloif::_RepConfig_default_instance_
RepConfigDefaultTypeInternal _RepConfig_default_instance_
Definition: requests.pb.h:50
helloif::ReqInit::Swap
void Swap(ReqInit *other)
helloif::RepConfig::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2506
helloif::RepEnable::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2384
helloif::RepExit::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2074
protobuf_requests_2eproto::AddDescriptors
void AddDescriptors()
helloif::_RepSetLogLevel_default_instance_
RepSetLogLevelDefaultTypeInternal _RepSetLogLevel_default_instance_
Definition: requests.pb.h:68
helloif::ReqSetLogLevel::clear_loggername
void clear_loggername()
Definition: requests.pb.h:2574
helloif::ReqSetLogLevel::swap
friend void swap(ReqSetLogLevel &a, ReqSetLogLevel &b)
Definition: requests.pb.h:1824
helloif::ReqExit::New
ReqExit * New() const final
Definition: requests.pb.h:174
helloif::RepReset::Swap
void Swap(RepReset *other)
helloif::RepSetLogLevel::New
RepSetLogLevel * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1960
helloif::RepExit::reply
const ::std::string & reply() const
Definition: requests.pb.h:2040
helloif::ReqSetLogLevel::set_allocated_loglevel
void set_allocated_loglevel(::std::string *loglevel)
Definition: requests.pb.h:2563
helloif::RepStatus::internal_default_instance
static const RepStatus * internal_default_instance()
Definition: requests.pb.h:463
helloif::RepStatus::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2130
helloif::ReqDisable::New
ReqDisable * New() const final
Definition: requests.pb.h:1416
helloif::ReqReset::New
ReqReset * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:799
helloif::ReqEnable::swap
friend void swap(ReqEnable &a, ReqEnable &b)
Definition: requests.pb.h:1203
helloif::_RepDisable_default_instance_
RepDisableDefaultTypeInternal _RepDisable_default_instance_
Definition: requests.pb.h:53
helloif::RepStop::operator=
RepStop & operator=(const RepStop &from)
Definition: requests.pb.h:647
helloif::ReqSetLogLevel::release_loglevel
::std::string * release_loglevel()
Definition: requests.pb.h:2558
helloif::_ReqEnable_default_instance_
ReqEnableDefaultTypeInternal _ReqEnable_default_instance_
Definition: requests.pb.h:83
helloif::RepSetLogLevel::New
RepSetLogLevel * New() const final
Definition: requests.pb.h:1956
helloif::_ReqStatus_default_instance_
ReqStatusDefaultTypeInternal _ReqStatus_default_instance_
Definition: requests.pb.h:98
helloif::ReqInit::New
ReqInit * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1006
helloif::ReqEnable::New
ReqEnable * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1213
helloif::RepExit::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2044
helloif::RepSetLogLevel::Swap
void Swap(RepSetLogLevel *other)
helloif::RepConfig::New
RepConfig * New() const final
Definition: requests.pb.h:1719
helloif::RepReset
Definition: requests.pb.h:847
helloif::ReqSetLogLevel::clear_loglevel
void clear_loglevel()
Definition: requests.pb.h:2521
helloif::RepReset::clear_reply
void clear_reply()
Definition: requests.pb.h:2220
helloif::RepConfig::operator=
RepConfig & operator=(const RepConfig &from)
Definition: requests.pb.h:1682
helloif::ReqStop::operator=
ReqStop & operator=(const ReqStop &from)
Definition: requests.pb.h:551
helloif::ReqSetLogLevel::New
ReqSetLogLevel * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1834
helloif::RepEnable::operator=
RepEnable & operator=(const RepEnable &from)
Definition: requests.pb.h:1268
helloif::RepInit::clear_reply
void clear_reply()
Definition: requests.pb.h:2281
helloif::RepExit::swap
friend void swap(RepExit &a, RepExit &b)
Definition: requests.pb.h:264
helloif::RepDisable::New
RepDisable * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1516
helloif::RepStatus
Definition: requests.pb.h:433
helloif::ReqStatus::operator=
ReqStatus & operator=(const ReqStatus &from)
Definition: requests.pb.h:344
helloif::RepExit
Definition: requests.pb.h:226
helloif::_ReqExit_default_instance_
ReqExitDefaultTypeInternal _ReqExit_default_instance_
Definition: requests.pb.h:86
helloif::RepStop::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2166
helloif::ReqExit::~ReqExit
virtual ~ReqExit()
helloif::ReqReset::operator=
ReqReset & operator=(const ReqReset &from)
Definition: requests.pb.h:758
helloif::_ReqReset_default_instance_
ReqResetDefaultTypeInternal _ReqReset_default_instance_
Definition: requests.pb.h:92
helloif::RepConfig::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2501
helloif::RepDisable::operator=
RepDisable & operator=(const RepDisable &from)
Definition: requests.pb.h:1475
helloif::RepConfig::swap
friend void swap(RepConfig &a, RepConfig &b)
Definition: requests.pb.h:1713
helloif::RepConfig::Swap
void Swap(RepConfig *other)
helloif::ReqSetLogLevel::set_loglevel
void set_loglevel(const ::std::string &value)
Definition: requests.pb.h:2528
helloif::RepExit::New
RepExit * New() const final
Definition: requests.pb.h:270
helloif::_RepStop_default_instance_
RepStopDefaultTypeInternal _RepStop_default_instance_
Definition: requests.pb.h:74
helloif::ReqStatus::swap
friend void swap(ReqStatus &a, ReqStatus &b)
Definition: requests.pb.h:375
helloif::ReqExit::GetMetadata
::google::protobuf::Metadata GetMetadata() const final
helloif::ReqInit::New
ReqInit * New() const final
Definition: requests.pb.h:1002
helloif::_RepReset_default_instance_
RepResetDefaultTypeInternal _RepReset_default_instance_
Definition: requests.pb.h:65
helloif::RepReset::reply
const ::std::string & reply() const
Definition: requests.pb.h:2223
helloif::ReqExit::internal_default_instance
static const ReqExit * internal_default_instance()
Definition: requests.pb.h:160
helloif::RepExit::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2079
helloif::RepDisable::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2410
helloif::RepStop::internal_default_instance
static const RepStop * internal_default_instance()
Definition: requests.pb.h:670
helloif::ReqEnable::internal_default_instance
static const ReqEnable * internal_default_instance()
Definition: requests.pb.h:1195
helloif::ReqSetLogLevel::release_loggername
::std::string * release_loggername()
Definition: requests.pb.h:2611
helloif::ReqSetLogLevel::internal_default_instance
static const ReqSetLogLevel * internal_default_instance()
Definition: requests.pb.h:1816
helloif::ReqInit::swap
friend void swap(ReqInit &a, ReqInit &b)
Definition: requests.pb.h:996
helloif::RepEnable::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2349
helloif::ReqExit::MergePartialFromCodedStream
bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream *input) final
helloif::ReqExit::kIndexInFileMessages
static constexpr int kIndexInFileMessages
Definition: requests.pb.h:164
helloif::ReqSetLogLevel::New
ReqSetLogLevel * New() const final
Definition: requests.pb.h:1830
helloif::RepReset::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2262
helloif::RepInit::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2313
helloif::ReqInit::internal_default_instance
static const ReqInit * internal_default_instance()
Definition: requests.pb.h:988
helloif::RepSetLogLevel::internal_default_instance
static const RepSetLogLevel * internal_default_instance()
Definition: requests.pb.h:1942
helloif::RepDisable::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2435
helloif::RepSetLogLevel::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2638
helloif::ReqConfig::operator=
ReqConfig & operator=(const ReqConfig &from)
Definition: requests.pb.h:1586
helloif::RepDisable::Swap
void Swap(RepDisable *other)
helloif::ReqSetLogLevel::Swap
void Swap(ReqSetLogLevel *other)
helloif::RepEnable::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2379
helloif::ReqExit::SerializeWithCachedSizes
void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream *output) const final
helloif::RepStatus::New
RepStatus * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:481
helloif::RepInit::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2318
helloif::ReqSetLogLevel::mutable_loggername
::std::string * mutable_loggername()
Definition: requests.pb.h:2606
helloif::RepStop::Swap
void Swap(RepStop *other)
helloif::RepConfig::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2471
helloif::ReqReset::New
ReqReset * New() const final
Definition: requests.pb.h:795
helloif::ReqExit::ByteSizeLong
size_t ByteSizeLong() const final
helloif::_ReqDisable_default_instance_
ReqDisableDefaultTypeInternal _ReqDisable_default_instance_
Definition: requests.pb.h:80
helloif::_ReqConfig_default_instance_
ReqConfigDefaultTypeInternal _ReqConfig_default_instance_
Definition: requests.pb.h:77
helloif::ReqStatus::New
ReqStatus * New() const final
Definition: requests.pb.h:381
helloif::ReqDisable::operator=
ReqDisable & operator=(const ReqDisable &from)
Definition: requests.pb.h:1379
helloif::RepDisable::internal_default_instance
static const RepDisable * internal_default_instance()
Definition: requests.pb.h:1498
helloif::RepEnable::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2374
helloif::RepStatus::reply
const ::std::string & reply() const
Definition: requests.pb.h:2101
helloif::ReqDisable
Definition: requests.pb.h:1372
helloif::RepConfig::internal_default_instance
static const RepConfig * internal_default_instance()
Definition: requests.pb.h:1705
helloif::RepConfig::clear_reply
void clear_reply()
Definition: requests.pb.h:2464
helloif::ReqEnable
Definition: requests.pb.h:1165
helloif::ReqInit
Definition: requests.pb.h:958
helloif::ReqStatus::internal_default_instance
static const ReqStatus * internal_default_instance()
Definition: requests.pb.h:367
helloif::ReqConfig
Definition: requests.pb.h:1579
helloif::ReqStop::internal_default_instance
static const ReqStop * internal_default_instance()
Definition: requests.pb.h:574
helloif::RepSetLogLevel
Definition: requests.pb.h:1912
helloif::ReqStatus::New
ReqStatus * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:385
helloif::RepDisable::swap
friend void swap(RepDisable &a, RepDisable &b)
Definition: requests.pb.h:1506
helloif::ReqConfig::Swap
void Swap(ReqConfig *other)
helloif::RepEnable::reply
const ::std::string & reply() const
Definition: requests.pb.h:2345
helloif::ReqSetLogLevel::operator=
ReqSetLogLevel & operator=(const ReqSetLogLevel &from)
Definition: requests.pb.h:1793
helloif::RepDisable::New
RepDisable * New() const final
Definition: requests.pb.h:1512
helloif::ReqSetLogLevel::loggername
const ::std::string & loggername() const
Definition: requests.pb.h:2577
helloif::ReqConfig::New
ReqConfig * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1627
helloif::RepStatus::New
RepStatus * New() const final
Definition: requests.pb.h:477
helloif::RepStop::reply
const ::std::string & reply() const
Definition: requests.pb.h:2162
helloif::RepStatus::clear_reply
void clear_reply()
Definition: requests.pb.h:2098
helloif::ReqConfig::internal_default_instance
static const ReqConfig * internal_default_instance()
Definition: requests.pb.h:1609
helloif::RepExit::operator=
RepExit & operator=(const RepExit &from)
Definition: requests.pb.h:233
helloif::RepEnable::New
RepEnable * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1309
helloif::RepStop::New
RepStop * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:688
helloif::RepEnable::internal_default_instance
static const RepEnable * internal_default_instance()
Definition: requests.pb.h:1291
helloif::RepStop::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2196
helloif::RepReset::operator=
RepReset & operator=(const RepReset &from)
Definition: requests.pb.h:854
protobuf_requests_2eproto::TableStruct::entries
static const ::google::protobuf::internal::ParseTableField entries[]
Definition: requests.pb.h:39
helloif::RepReset::internal_default_instance
static const RepReset * internal_default_instance()
Definition: requests.pb.h:877
helloif::RepExit::clear_reply
void clear_reply()
Definition: requests.pb.h:2037
helloif::RepDisable::reply
const ::std::string & reply() const
Definition: requests.pb.h:2406
helloif::_ReqStop_default_instance_
ReqStopDefaultTypeInternal _ReqStop_default_instance_
Definition: requests.pb.h:101
helloif::RepReset::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2227
helloif::RepStatus::swap
friend void swap(RepStatus &a, RepStatus &b)
Definition: requests.pb.h:471
helloif::RepInit::New
RepInit * New() const final
Definition: requests.pb.h:1098
helloif::RepDisable::clear_reply
void clear_reply()
Definition: requests.pb.h:2403
helloif::RepInit::New
RepInit * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1102
helloif::ReqDisable::internal_default_instance
static const ReqDisable * internal_default_instance()
Definition: requests.pb.h:1402
helloif::ReqStop
Definition: requests.pb.h:544
helloif::ReqEnable::Swap
void Swap(ReqEnable *other)
helloif::RepInit::set_reply
void set_reply(const ::std::string &value)
Definition: requests.pb.h:2288
helloif::RepStop::New
RepStop * New() const final
Definition: requests.pb.h:684
helloif::RepInit::swap
friend void swap(RepInit &a, RepInit &b)
Definition: requests.pb.h:1092
helloif::RepReset::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2252
helloif::ReqStatus::Swap
void Swap(ReqStatus *other)
helloif::ReqExit::CopyFrom
void CopyFrom(const ::google::protobuf::Message &from) final
helloif::ReqReset::swap
friend void swap(ReqReset &a, ReqReset &b)
Definition: requests.pb.h:789
helloif::ReqStop::New
ReqStop * New() const final
Definition: requests.pb.h:588
helloif::ReqExit::descriptor
static const ::google::protobuf::Descriptor * descriptor()
helloif::RepReset::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2257
helloif::RepStatus::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2135
helloif::RepDisable::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2445
helloif::RepEnable
Definition: requests.pb.h:1261
helloif::ReqSetLogLevel::loglevel
const ::std::string & loglevel() const
Definition: requests.pb.h:2524
helloif::RepConfig
Definition: requests.pb.h:1675
helloif::RepStop::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2201
protobuf_requests_2eproto::TableStruct::aux
static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
Definition: requests.pb.h:40
helloif::ReqExit::swap
friend void swap(ReqExit &a, ReqExit &b)
Definition: requests.pb.h:168
helloif::ReqDisable::New
ReqDisable * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1420
helloif::RepSetLogLevel::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2668
helloif::ReqExit::IsInitialized
bool IsInitialized() const final
helloif::ReqInit::operator=
ReqInit & operator=(const ReqInit &from)
Definition: requests.pb.h:965
helloif::RepEnable::swap
friend void swap(RepEnable &a, RepEnable &b)
Definition: requests.pb.h:1299
helloif::ReqExit::default_instance
static const ReqExit & default_instance()
helloif::RepReset::New
RepReset * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:895
helloif::ReqConfig::New
ReqConfig * New() const final
Definition: requests.pb.h:1623
helloif::RepInit::internal_default_instance
static const RepInit * internal_default_instance()
Definition: requests.pb.h:1084
protobuf_requests_2eproto::TableStruct::schema
static const ::google::protobuf::internal::ParseTable schema[24]
Definition: requests.pb.h:41
helloif::RepReset::swap
friend void swap(RepReset &a, RepReset &b)
Definition: requests.pb.h:885
helloif::ReqStop::swap
friend void swap(ReqStop &a, ReqStop &b)
Definition: requests.pb.h:582
helloif::ReqExit
Definition: requests.pb.h:130
helloif::RepStatus::set_allocated_reply
void set_allocated_reply(::std::string *reply)
Definition: requests.pb.h:2140
helloif::RepExit::Swap
void Swap(RepExit *other)
helloif::ReqStop::Swap
void Swap(ReqStop *other)
helloif::RepDisable::release_reply
::std::string * release_reply()
Definition: requests.pb.h:2440
helloif::ReqReset
Definition: requests.pb.h:751
helloif::ReqEnable::New
ReqEnable * New() const final
Definition: requests.pb.h:1209
helloif::RepConfig::New
RepConfig * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:1723
helloif::ReqSetLogLevel::set_allocated_loggername
void set_allocated_loggername(::std::string *loggername)
Definition: requests.pb.h:2616
helloif::ReqDisable::swap
friend void swap(ReqDisable &a, ReqDisable &b)
Definition: requests.pb.h:1410
helloif::_RepInit_default_instance_
RepInitDefaultTypeInternal _RepInit_default_instance_
Definition: requests.pb.h:62
helloif::RepEnable::clear_reply
void clear_reply()
Definition: requests.pb.h:2342
helloif::RepSetLogLevel::swap
friend void swap(RepSetLogLevel &a, RepSetLogLevel &b)
Definition: requests.pb.h:1950
helloif::RepExit::internal_default_instance
static const RepExit * internal_default_instance()
Definition: requests.pb.h:256
helloif::_ReqInit_default_instance_
ReqInitDefaultTypeInternal _ReqInit_default_instance_
Definition: requests.pb.h:89
helloif::_RepEnable_default_instance_
RepEnableDefaultTypeInternal _RepEnable_default_instance_
Definition: requests.pb.h:56
helloif::RepInit::reply
const ::std::string & reply() const
Definition: requests.pb.h:2284
helloif::_RepStatus_default_instance_
RepStatusDefaultTypeInternal _RepStatus_default_instance_
Definition: requests.pb.h:71
helloif::RepExit::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2069
helloif::_ReqSetLogLevel_default_instance_
ReqSetLogLevelDefaultTypeInternal _ReqSetLogLevel_default_instance_
Definition: requests.pb.h:95
helloif::ReqExit::Swap
void Swap(ReqExit *other)
helloif::ReqConfig::swap
friend void swap(ReqConfig &a, ReqConfig &b)
Definition: requests.pb.h:1617
helloif::RepSetLogLevel::reply
const ::std::string & reply() const
Definition: requests.pb.h:2634
helloif::RepInit
Definition: requests.pb.h:1054
helloif::ReqExit::New
ReqExit * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:178
helloif::RepDisable
Definition: requests.pb.h:1468
helloif::RepExit::New
RepExit * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:274
helloif::ReqExit::Clear
void Clear() final
helloif::RepSetLogLevel::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2663
helloif::ReqExit::InitAsDefaultInstance
static void InitAsDefaultInstance()
helloif::ReqDisable::Swap
void Swap(ReqDisable *other)
helloif::RepStop::mutable_reply
::std::string * mutable_reply()
Definition: requests.pb.h:2191
helloif::RepSetLogLevel::operator=
RepSetLogLevel & operator=(const RepSetLogLevel &from)
Definition: requests.pb.h:1919
helloif::ReqStop::New
ReqStop * New(::google::protobuf::Arena *arena) const final
Definition: requests.pb.h:592
helloif::ReqExit::operator=
ReqExit & operator=(const ReqExit &from)
Definition: requests.pb.h:137
helloif::RepReset::New
RepReset * New() const final
Definition: requests.pb.h:891
Generated by   doxygen 1.8.5