rad  2.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
hellomalif.pb.h
Go to the documentation of this file.
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: hellomalif.proto
3 
4 #ifndef PROTOBUF_INCLUDED_hellomalif_2eproto
5 #define PROTOBUF_INCLUDED_hellomalif_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 #include "zpb.pb.h"
34 #include "malTypes.pb.h"
35 // @@protoc_insertion_point(includes)
36 #define PROTOBUF_INTERNAL_EXPORT_protobuf_hellomalif_2eproto
37 
38 namespace protobuf_hellomalif_2eproto {
39 // Internal implementation detail -- do not use these members.
40 struct TableStruct {
41  static const ::google::protobuf::internal::ParseTableField entries[];
42  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
43  static const ::google::protobuf::internal::ParseTable schema[24];
44  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
45  static const ::google::protobuf::internal::SerializationTable serialization_table[];
46  static const ::google::protobuf::uint32 offsets[];
47 };
48 void AddDescriptors();
49 } // namespace protobuf_hellomalif_2eproto
50 namespace generated {
51 namespace zpb {
52 namespace hellomalif {
53 class ExceptionErr;
54 class ExceptionErrDefaultTypeInternal;
55 extern ExceptionErrDefaultTypeInternal _ExceptionErr_default_instance_;
56 class LogInfo;
57 class LogInfoDefaultTypeInternal;
58 extern LogInfoDefaultTypeInternal _LogInfo_default_instance_;
59 class StdCmds_Call;
60 class StdCmds_CallDefaultTypeInternal;
61 extern StdCmds_CallDefaultTypeInternal _StdCmds_Call_default_instance_;
62 class StdCmds_Config_In;
63 class StdCmds_Config_InDefaultTypeInternal;
64 extern StdCmds_Config_InDefaultTypeInternal _StdCmds_Config_In_default_instance_;
65 class StdCmds_Config_Out;
66 class StdCmds_Config_OutDefaultTypeInternal;
67 extern StdCmds_Config_OutDefaultTypeInternal _StdCmds_Config_Out_default_instance_;
68 class StdCmds_Disable_In;
69 class StdCmds_Disable_InDefaultTypeInternal;
70 extern StdCmds_Disable_InDefaultTypeInternal _StdCmds_Disable_In_default_instance_;
71 class StdCmds_Disable_Out;
72 class StdCmds_Disable_OutDefaultTypeInternal;
73 extern StdCmds_Disable_OutDefaultTypeInternal _StdCmds_Disable_Out_default_instance_;
74 class StdCmds_Enable_In;
75 class StdCmds_Enable_InDefaultTypeInternal;
76 extern StdCmds_Enable_InDefaultTypeInternal _StdCmds_Enable_In_default_instance_;
77 class StdCmds_Enable_Out;
78 class StdCmds_Enable_OutDefaultTypeInternal;
79 extern StdCmds_Enable_OutDefaultTypeInternal _StdCmds_Enable_Out_default_instance_;
80 class StdCmds_Exit_In;
81 class StdCmds_Exit_InDefaultTypeInternal;
82 extern StdCmds_Exit_InDefaultTypeInternal _StdCmds_Exit_In_default_instance_;
83 class StdCmds_Exit_Out;
84 class StdCmds_Exit_OutDefaultTypeInternal;
85 extern StdCmds_Exit_OutDefaultTypeInternal _StdCmds_Exit_Out_default_instance_;
86 class StdCmds_Init_In;
87 class StdCmds_Init_InDefaultTypeInternal;
88 extern StdCmds_Init_InDefaultTypeInternal _StdCmds_Init_In_default_instance_;
89 class StdCmds_Init_Out;
90 class StdCmds_Init_OutDefaultTypeInternal;
91 extern StdCmds_Init_OutDefaultTypeInternal _StdCmds_Init_Out_default_instance_;
92 class StdCmds_Reply;
93 class StdCmds_ReplyDefaultTypeInternal;
94 extern StdCmds_ReplyDefaultTypeInternal _StdCmds_Reply_default_instance_;
95 class StdCmds_Request;
96 class StdCmds_RequestDefaultTypeInternal;
97 extern StdCmds_RequestDefaultTypeInternal _StdCmds_Request_default_instance_;
98 class StdCmds_Reset_In;
99 class StdCmds_Reset_InDefaultTypeInternal;
100 extern StdCmds_Reset_InDefaultTypeInternal _StdCmds_Reset_In_default_instance_;
101 class StdCmds_Reset_Out;
102 class StdCmds_Reset_OutDefaultTypeInternal;
103 extern StdCmds_Reset_OutDefaultTypeInternal _StdCmds_Reset_Out_default_instance_;
104 class StdCmds_Return;
105 class StdCmds_ReturnDefaultTypeInternal;
106 extern StdCmds_ReturnDefaultTypeInternal _StdCmds_Return_default_instance_;
107 class StdCmds_SetLogLevel_In;
108 class StdCmds_SetLogLevel_InDefaultTypeInternal;
109 extern StdCmds_SetLogLevel_InDefaultTypeInternal _StdCmds_SetLogLevel_In_default_instance_;
110 class StdCmds_SetLogLevel_Out;
111 class StdCmds_SetLogLevel_OutDefaultTypeInternal;
112 extern StdCmds_SetLogLevel_OutDefaultTypeInternal _StdCmds_SetLogLevel_Out_default_instance_;
113 class StdCmds_Status_In;
114 class StdCmds_Status_InDefaultTypeInternal;
115 extern StdCmds_Status_InDefaultTypeInternal _StdCmds_Status_In_default_instance_;
116 class StdCmds_Status_Out;
117 class StdCmds_Status_OutDefaultTypeInternal;
118 extern StdCmds_Status_OutDefaultTypeInternal _StdCmds_Status_Out_default_instance_;
119 class StdCmds_Stop_In;
120 class StdCmds_Stop_InDefaultTypeInternal;
121 extern StdCmds_Stop_InDefaultTypeInternal _StdCmds_Stop_In_default_instance_;
122 class StdCmds_Stop_Out;
123 class StdCmds_Stop_OutDefaultTypeInternal;
124 extern StdCmds_Stop_OutDefaultTypeInternal _StdCmds_Stop_Out_default_instance_;
125 } // namespace hellomalif
126 } // namespace zpb
127 } // namespace generated
128 namespace google {
129 namespace protobuf {
130 template<> ::generated::zpb::hellomalif::ExceptionErr* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(Arena*);
131 template<> ::generated::zpb::hellomalif::LogInfo* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::LogInfo>(Arena*);
132 template<> ::generated::zpb::hellomalif::StdCmds_Call* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Call>(Arena*);
133 template<> ::generated::zpb::hellomalif::StdCmds_Config_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Config_In>(Arena*);
134 template<> ::generated::zpb::hellomalif::StdCmds_Config_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Config_Out>(Arena*);
135 template<> ::generated::zpb::hellomalif::StdCmds_Disable_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Disable_In>(Arena*);
136 template<> ::generated::zpb::hellomalif::StdCmds_Disable_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Disable_Out>(Arena*);
137 template<> ::generated::zpb::hellomalif::StdCmds_Enable_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Enable_In>(Arena*);
138 template<> ::generated::zpb::hellomalif::StdCmds_Enable_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Enable_Out>(Arena*);
139 template<> ::generated::zpb::hellomalif::StdCmds_Exit_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Exit_In>(Arena*);
140 template<> ::generated::zpb::hellomalif::StdCmds_Exit_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Exit_Out>(Arena*);
141 template<> ::generated::zpb::hellomalif::StdCmds_Init_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Init_In>(Arena*);
142 template<> ::generated::zpb::hellomalif::StdCmds_Init_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Init_Out>(Arena*);
143 template<> ::generated::zpb::hellomalif::StdCmds_Reply* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Reply>(Arena*);
144 template<> ::generated::zpb::hellomalif::StdCmds_Request* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Request>(Arena*);
145 template<> ::generated::zpb::hellomalif::StdCmds_Reset_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Reset_In>(Arena*);
146 template<> ::generated::zpb::hellomalif::StdCmds_Reset_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Reset_Out>(Arena*);
147 template<> ::generated::zpb::hellomalif::StdCmds_Return* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Return>(Arena*);
148 template<> ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_SetLogLevel_In>(Arena*);
149 template<> ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out>(Arena*);
150 template<> ::generated::zpb::hellomalif::StdCmds_Status_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Status_In>(Arena*);
151 template<> ::generated::zpb::hellomalif::StdCmds_Status_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Status_Out>(Arena*);
152 template<> ::generated::zpb::hellomalif::StdCmds_Stop_In* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Stop_In>(Arena*);
153 template<> ::generated::zpb::hellomalif::StdCmds_Stop_Out* Arena::CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Stop_Out>(Arena*);
154 } // namespace protobuf
155 } // namespace google
156 namespace generated {
157 namespace zpb {
158 namespace hellomalif {
159 
160 // ===================================================================
161 
162 class ExceptionErr : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.ExceptionErr) */ {
163  public:
164  ExceptionErr();
165  virtual ~ExceptionErr();
166 
167  ExceptionErr(const ExceptionErr& from);
168 
169  inline ExceptionErr& operator=(const ExceptionErr& from) {
170  CopyFrom(from);
171  return *this;
172  }
173  #if LANG_CXX11
174  ExceptionErr(ExceptionErr&& from) noexcept
175  : ExceptionErr() {
176  *this = ::std::move(from);
177  }
178 
179  inline ExceptionErr& operator=(ExceptionErr&& from) noexcept {
180  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
181  if (this != &from) InternalSwap(&from);
182  } else {
183  CopyFrom(from);
184  }
185  return *this;
186  }
187  #endif
188  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
189  return _internal_metadata_.unknown_fields();
190  }
191  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
192  return _internal_metadata_.mutable_unknown_fields();
193  }
194 
195  static const ::google::protobuf::Descriptor* descriptor();
196  static const ExceptionErr& default_instance();
197 
198  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
199  static inline const ExceptionErr* internal_default_instance() {
200  return reinterpret_cast<const ExceptionErr*>(
201  &_ExceptionErr_default_instance_);
202  }
203  static constexpr int kIndexInFileMessages =
204  0;
205 
206  void Swap(ExceptionErr* other);
207  friend void swap(ExceptionErr& a, ExceptionErr& b) {
208  a.Swap(&b);
209  }
210 
211  // implements Message ----------------------------------------------
212 
213  inline ExceptionErr* New() const final {
214  return CreateMaybeMessage<ExceptionErr>(NULL);
215  }
216 
217  ExceptionErr* New(::google::protobuf::Arena* arena) const final {
218  return CreateMaybeMessage<ExceptionErr>(arena);
219  }
220  void CopyFrom(const ::google::protobuf::Message& from) final;
221  void MergeFrom(const ::google::protobuf::Message& from) final;
222  void CopyFrom(const ExceptionErr& from);
223  void MergeFrom(const ExceptionErr& from);
224  void Clear() final;
225  bool IsInitialized() const final;
226 
227  size_t ByteSizeLong() const final;
228  bool MergePartialFromCodedStream(
229  ::google::protobuf::io::CodedInputStream* input) final;
230  void SerializeWithCachedSizes(
231  ::google::protobuf::io::CodedOutputStream* output) const final;
232  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
233  bool deterministic, ::google::protobuf::uint8* target) const final;
234  int GetCachedSize() const final { return _cached_size_.Get(); }
235 
236  private:
237  void SharedCtor();
238  void SharedDtor();
239  void SetCachedSize(int size) const final;
240  void InternalSwap(ExceptionErr* other);
241  private:
242  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
243  return NULL;
244  }
245  inline void* MaybeArenaPtr() const {
246  return NULL;
247  }
248  public:
249 
250  ::google::protobuf::Metadata GetMetadata() const final;
251 
252  // nested types ----------------------------------------------------
253 
254  // accessors -------------------------------------------------------
255 
256  // required string desc = 1;
257  bool has_desc() const;
258  void clear_desc();
259  static const int kDescFieldNumber = 1;
260  const ::std::string& desc() const;
261  void set_desc(const ::std::string& value);
262  #if LANG_CXX11
263  void set_desc(::std::string&& value);
264  #endif
265  void set_desc(const char* value);
266  void set_desc(const char* value, size_t size);
267  ::std::string* mutable_desc();
268  ::std::string* release_desc();
269  void set_allocated_desc(::std::string* desc);
270 
271  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.ExceptionErr)
272  private:
273  void set_has_desc();
274  void clear_has_desc();
275 
276  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
277  ::google::protobuf::internal::HasBits<1> _has_bits_;
278  mutable ::google::protobuf::internal::CachedSize _cached_size_;
279  ::google::protobuf::internal::ArenaStringPtr desc_;
280  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
281 };
282 // -------------------------------------------------------------------
283 
284 class LogInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.LogInfo) */ {
285  public:
286  LogInfo();
287  virtual ~LogInfo();
288 
289  LogInfo(const LogInfo& from);
290 
291  inline LogInfo& operator=(const LogInfo& from) {
292  CopyFrom(from);
293  return *this;
294  }
295  #if LANG_CXX11
296  LogInfo(LogInfo&& from) noexcept
297  : LogInfo() {
298  *this = ::std::move(from);
299  }
300 
301  inline LogInfo& operator=(LogInfo&& from) noexcept {
302  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
303  if (this != &from) InternalSwap(&from);
304  } else {
305  CopyFrom(from);
306  }
307  return *this;
308  }
309  #endif
310  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
311  return _internal_metadata_.unknown_fields();
312  }
313  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
314  return _internal_metadata_.mutable_unknown_fields();
315  }
316 
317  static const ::google::protobuf::Descriptor* descriptor();
318  static const LogInfo& default_instance();
319 
320  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
321  static inline const LogInfo* internal_default_instance() {
322  return reinterpret_cast<const LogInfo*>(
323  &_LogInfo_default_instance_);
324  }
325  static constexpr int kIndexInFileMessages =
326  1;
327 
328  void Swap(LogInfo* other);
329  friend void swap(LogInfo& a, LogInfo& b) {
330  a.Swap(&b);
331  }
332 
333  // implements Message ----------------------------------------------
334 
335  inline LogInfo* New() const final {
336  return CreateMaybeMessage<LogInfo>(NULL);
337  }
338 
339  LogInfo* New(::google::protobuf::Arena* arena) const final {
340  return CreateMaybeMessage<LogInfo>(arena);
341  }
342  void CopyFrom(const ::google::protobuf::Message& from) final;
343  void MergeFrom(const ::google::protobuf::Message& from) final;
344  void CopyFrom(const LogInfo& from);
345  void MergeFrom(const LogInfo& from);
346  void Clear() final;
347  bool IsInitialized() const final;
348 
349  size_t ByteSizeLong() const final;
350  bool MergePartialFromCodedStream(
351  ::google::protobuf::io::CodedInputStream* input) final;
352  void SerializeWithCachedSizes(
353  ::google::protobuf::io::CodedOutputStream* output) const final;
354  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
355  bool deterministic, ::google::protobuf::uint8* target) const final;
356  int GetCachedSize() const final { return _cached_size_.Get(); }
357 
358  private:
359  void SharedCtor();
360  void SharedDtor();
361  void SetCachedSize(int size) const final;
362  void InternalSwap(LogInfo* other);
363  private:
364  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
365  return NULL;
366  }
367  inline void* MaybeArenaPtr() const {
368  return NULL;
369  }
370  public:
371 
372  ::google::protobuf::Metadata GetMetadata() const final;
373 
374  // nested types ----------------------------------------------------
375 
376  // accessors -------------------------------------------------------
377 
378  // required string level = 1;
379  bool has_level() const;
380  void clear_level();
381  static const int kLevelFieldNumber = 1;
382  const ::std::string& level() const;
383  void set_level(const ::std::string& value);
384  #if LANG_CXX11
385  void set_level(::std::string&& value);
386  #endif
387  void set_level(const char* value);
388  void set_level(const char* value, size_t size);
389  ::std::string* mutable_level();
390  ::std::string* release_level();
391  void set_allocated_level(::std::string* level);
392 
393  // required string logger = 2;
394  bool has_logger() const;
395  void clear_logger();
396  static const int kLoggerFieldNumber = 2;
397  const ::std::string& logger() const;
398  void set_logger(const ::std::string& value);
399  #if LANG_CXX11
400  void set_logger(::std::string&& value);
401  #endif
402  void set_logger(const char* value);
403  void set_logger(const char* value, size_t size);
404  ::std::string* mutable_logger();
405  ::std::string* release_logger();
406  void set_allocated_logger(::std::string* logger);
407 
408  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.LogInfo)
409  private:
410  void set_has_level();
411  void clear_has_level();
412  void set_has_logger();
413  void clear_has_logger();
414 
415  // helper for ByteSizeLong()
416  size_t RequiredFieldsByteSizeFallback() const;
417 
418  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
419  ::google::protobuf::internal::HasBits<1> _has_bits_;
420  mutable ::google::protobuf::internal::CachedSize _cached_size_;
421  ::google::protobuf::internal::ArenaStringPtr level_;
422  ::google::protobuf::internal::ArenaStringPtr logger_;
423  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
424 };
425 // -------------------------------------------------------------------
426 
427 class StdCmds_Init_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Init_In) */ {
428  public:
429  StdCmds_Init_In();
430  virtual ~StdCmds_Init_In();
431 
432  StdCmds_Init_In(const StdCmds_Init_In& from);
433 
434  inline StdCmds_Init_In& operator=(const StdCmds_Init_In& from) {
435  CopyFrom(from);
436  return *this;
437  }
438  #if LANG_CXX11
439  StdCmds_Init_In(StdCmds_Init_In&& from) noexcept
440  : StdCmds_Init_In() {
441  *this = ::std::move(from);
442  }
443 
444  inline StdCmds_Init_In& operator=(StdCmds_Init_In&& from) noexcept {
445  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
446  if (this != &from) InternalSwap(&from);
447  } else {
448  CopyFrom(from);
449  }
450  return *this;
451  }
452  #endif
453  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
454  return _internal_metadata_.unknown_fields();
455  }
456  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
457  return _internal_metadata_.mutable_unknown_fields();
458  }
459 
460  static const ::google::protobuf::Descriptor* descriptor();
461  static const StdCmds_Init_In& default_instance();
462 
463  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
464  static inline const StdCmds_Init_In* internal_default_instance() {
465  return reinterpret_cast<const StdCmds_Init_In*>(
466  &_StdCmds_Init_In_default_instance_);
467  }
468  static constexpr int kIndexInFileMessages =
469  2;
470 
471  void Swap(StdCmds_Init_In* other);
472  friend void swap(StdCmds_Init_In& a, StdCmds_Init_In& b) {
473  a.Swap(&b);
474  }
475 
476  // implements Message ----------------------------------------------
477 
478  inline StdCmds_Init_In* New() const final {
479  return CreateMaybeMessage<StdCmds_Init_In>(NULL);
480  }
481 
482  StdCmds_Init_In* New(::google::protobuf::Arena* arena) const final {
483  return CreateMaybeMessage<StdCmds_Init_In>(arena);
484  }
485  void CopyFrom(const ::google::protobuf::Message& from) final;
486  void MergeFrom(const ::google::protobuf::Message& from) final;
487  void CopyFrom(const StdCmds_Init_In& from);
488  void MergeFrom(const StdCmds_Init_In& from);
489  void Clear() final;
490  bool IsInitialized() const final;
491 
492  size_t ByteSizeLong() const final;
493  bool MergePartialFromCodedStream(
494  ::google::protobuf::io::CodedInputStream* input) final;
495  void SerializeWithCachedSizes(
496  ::google::protobuf::io::CodedOutputStream* output) const final;
497  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
498  bool deterministic, ::google::protobuf::uint8* target) const final;
499  int GetCachedSize() const final { return _cached_size_.Get(); }
500 
501  private:
502  void SharedCtor();
503  void SharedDtor();
504  void SetCachedSize(int size) const final;
505  void InternalSwap(StdCmds_Init_In* other);
506  private:
507  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
508  return NULL;
509  }
510  inline void* MaybeArenaPtr() const {
511  return NULL;
512  }
513  public:
514 
515  ::google::protobuf::Metadata GetMetadata() const final;
516 
517  // nested types ----------------------------------------------------
518 
519  // accessors -------------------------------------------------------
520 
521  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Init_In)
522  private:
523 
524  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
525  ::google::protobuf::internal::HasBits<1> _has_bits_;
526  mutable ::google::protobuf::internal::CachedSize _cached_size_;
527  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
528 };
529 // -------------------------------------------------------------------
530 
531 class StdCmds_Reset_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Reset_In) */ {
532  public:
533  StdCmds_Reset_In();
534  virtual ~StdCmds_Reset_In();
535 
536  StdCmds_Reset_In(const StdCmds_Reset_In& from);
537 
538  inline StdCmds_Reset_In& operator=(const StdCmds_Reset_In& from) {
539  CopyFrom(from);
540  return *this;
541  }
542  #if LANG_CXX11
543  StdCmds_Reset_In(StdCmds_Reset_In&& from) noexcept
544  : StdCmds_Reset_In() {
545  *this = ::std::move(from);
546  }
547 
548  inline StdCmds_Reset_In& operator=(StdCmds_Reset_In&& from) noexcept {
549  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
550  if (this != &from) InternalSwap(&from);
551  } else {
552  CopyFrom(from);
553  }
554  return *this;
555  }
556  #endif
557  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
558  return _internal_metadata_.unknown_fields();
559  }
560  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
561  return _internal_metadata_.mutable_unknown_fields();
562  }
563 
564  static const ::google::protobuf::Descriptor* descriptor();
565  static const StdCmds_Reset_In& default_instance();
566 
567  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
568  static inline const StdCmds_Reset_In* internal_default_instance() {
569  return reinterpret_cast<const StdCmds_Reset_In*>(
570  &_StdCmds_Reset_In_default_instance_);
571  }
572  static constexpr int kIndexInFileMessages =
573  3;
574 
575  void Swap(StdCmds_Reset_In* other);
576  friend void swap(StdCmds_Reset_In& a, StdCmds_Reset_In& b) {
577  a.Swap(&b);
578  }
579 
580  // implements Message ----------------------------------------------
581 
582  inline StdCmds_Reset_In* New() const final {
583  return CreateMaybeMessage<StdCmds_Reset_In>(NULL);
584  }
585 
586  StdCmds_Reset_In* New(::google::protobuf::Arena* arena) const final {
587  return CreateMaybeMessage<StdCmds_Reset_In>(arena);
588  }
589  void CopyFrom(const ::google::protobuf::Message& from) final;
590  void MergeFrom(const ::google::protobuf::Message& from) final;
591  void CopyFrom(const StdCmds_Reset_In& from);
592  void MergeFrom(const StdCmds_Reset_In& from);
593  void Clear() final;
594  bool IsInitialized() const final;
595 
596  size_t ByteSizeLong() const final;
597  bool MergePartialFromCodedStream(
598  ::google::protobuf::io::CodedInputStream* input) final;
599  void SerializeWithCachedSizes(
600  ::google::protobuf::io::CodedOutputStream* output) const final;
601  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
602  bool deterministic, ::google::protobuf::uint8* target) const final;
603  int GetCachedSize() const final { return _cached_size_.Get(); }
604 
605  private:
606  void SharedCtor();
607  void SharedDtor();
608  void SetCachedSize(int size) const final;
609  void InternalSwap(StdCmds_Reset_In* other);
610  private:
611  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
612  return NULL;
613  }
614  inline void* MaybeArenaPtr() const {
615  return NULL;
616  }
617  public:
618 
619  ::google::protobuf::Metadata GetMetadata() const final;
620 
621  // nested types ----------------------------------------------------
622 
623  // accessors -------------------------------------------------------
624 
625  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Reset_In)
626  private:
627 
628  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
629  ::google::protobuf::internal::HasBits<1> _has_bits_;
630  mutable ::google::protobuf::internal::CachedSize _cached_size_;
631  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
632 };
633 // -------------------------------------------------------------------
634 
635 class StdCmds_Enable_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Enable_In) */ {
636  public:
637  StdCmds_Enable_In();
638  virtual ~StdCmds_Enable_In();
639 
640  StdCmds_Enable_In(const StdCmds_Enable_In& from);
641 
642  inline StdCmds_Enable_In& operator=(const StdCmds_Enable_In& from) {
643  CopyFrom(from);
644  return *this;
645  }
646  #if LANG_CXX11
647  StdCmds_Enable_In(StdCmds_Enable_In&& from) noexcept
648  : StdCmds_Enable_In() {
649  *this = ::std::move(from);
650  }
651 
652  inline StdCmds_Enable_In& operator=(StdCmds_Enable_In&& from) noexcept {
653  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
654  if (this != &from) InternalSwap(&from);
655  } else {
656  CopyFrom(from);
657  }
658  return *this;
659  }
660  #endif
661  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
662  return _internal_metadata_.unknown_fields();
663  }
664  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
665  return _internal_metadata_.mutable_unknown_fields();
666  }
667 
668  static const ::google::protobuf::Descriptor* descriptor();
669  static const StdCmds_Enable_In& default_instance();
670 
671  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
672  static inline const StdCmds_Enable_In* internal_default_instance() {
673  return reinterpret_cast<const StdCmds_Enable_In*>(
674  &_StdCmds_Enable_In_default_instance_);
675  }
676  static constexpr int kIndexInFileMessages =
677  4;
678 
679  void Swap(StdCmds_Enable_In* other);
680  friend void swap(StdCmds_Enable_In& a, StdCmds_Enable_In& b) {
681  a.Swap(&b);
682  }
683 
684  // implements Message ----------------------------------------------
685 
686  inline StdCmds_Enable_In* New() const final {
687  return CreateMaybeMessage<StdCmds_Enable_In>(NULL);
688  }
689 
690  StdCmds_Enable_In* New(::google::protobuf::Arena* arena) const final {
691  return CreateMaybeMessage<StdCmds_Enable_In>(arena);
692  }
693  void CopyFrom(const ::google::protobuf::Message& from) final;
694  void MergeFrom(const ::google::protobuf::Message& from) final;
695  void CopyFrom(const StdCmds_Enable_In& from);
696  void MergeFrom(const StdCmds_Enable_In& from);
697  void Clear() final;
698  bool IsInitialized() const final;
699 
700  size_t ByteSizeLong() const final;
701  bool MergePartialFromCodedStream(
702  ::google::protobuf::io::CodedInputStream* input) final;
703  void SerializeWithCachedSizes(
704  ::google::protobuf::io::CodedOutputStream* output) const final;
705  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
706  bool deterministic, ::google::protobuf::uint8* target) const final;
707  int GetCachedSize() const final { return _cached_size_.Get(); }
708 
709  private:
710  void SharedCtor();
711  void SharedDtor();
712  void SetCachedSize(int size) const final;
713  void InternalSwap(StdCmds_Enable_In* other);
714  private:
715  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
716  return NULL;
717  }
718  inline void* MaybeArenaPtr() const {
719  return NULL;
720  }
721  public:
722 
723  ::google::protobuf::Metadata GetMetadata() const final;
724 
725  // nested types ----------------------------------------------------
726 
727  // accessors -------------------------------------------------------
728 
729  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Enable_In)
730  private:
731 
732  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
733  ::google::protobuf::internal::HasBits<1> _has_bits_;
734  mutable ::google::protobuf::internal::CachedSize _cached_size_;
735  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
736 };
737 // -------------------------------------------------------------------
738 
739 class StdCmds_Disable_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Disable_In) */ {
740  public:
741  StdCmds_Disable_In();
742  virtual ~StdCmds_Disable_In();
743 
744  StdCmds_Disable_In(const StdCmds_Disable_In& from);
745 
746  inline StdCmds_Disable_In& operator=(const StdCmds_Disable_In& from) {
747  CopyFrom(from);
748  return *this;
749  }
750  #if LANG_CXX11
751  StdCmds_Disable_In(StdCmds_Disable_In&& from) noexcept
752  : StdCmds_Disable_In() {
753  *this = ::std::move(from);
754  }
755 
756  inline StdCmds_Disable_In& operator=(StdCmds_Disable_In&& from) noexcept {
757  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
758  if (this != &from) InternalSwap(&from);
759  } else {
760  CopyFrom(from);
761  }
762  return *this;
763  }
764  #endif
765  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
766  return _internal_metadata_.unknown_fields();
767  }
768  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
769  return _internal_metadata_.mutable_unknown_fields();
770  }
771 
772  static const ::google::protobuf::Descriptor* descriptor();
773  static const StdCmds_Disable_In& default_instance();
774 
775  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
776  static inline const StdCmds_Disable_In* internal_default_instance() {
777  return reinterpret_cast<const StdCmds_Disable_In*>(
778  &_StdCmds_Disable_In_default_instance_);
779  }
780  static constexpr int kIndexInFileMessages =
781  5;
782 
783  void Swap(StdCmds_Disable_In* other);
784  friend void swap(StdCmds_Disable_In& a, StdCmds_Disable_In& b) {
785  a.Swap(&b);
786  }
787 
788  // implements Message ----------------------------------------------
789 
790  inline StdCmds_Disable_In* New() const final {
791  return CreateMaybeMessage<StdCmds_Disable_In>(NULL);
792  }
793 
794  StdCmds_Disable_In* New(::google::protobuf::Arena* arena) const final {
795  return CreateMaybeMessage<StdCmds_Disable_In>(arena);
796  }
797  void CopyFrom(const ::google::protobuf::Message& from) final;
798  void MergeFrom(const ::google::protobuf::Message& from) final;
799  void CopyFrom(const StdCmds_Disable_In& from);
800  void MergeFrom(const StdCmds_Disable_In& from);
801  void Clear() final;
802  bool IsInitialized() const final;
803 
804  size_t ByteSizeLong() const final;
805  bool MergePartialFromCodedStream(
806  ::google::protobuf::io::CodedInputStream* input) final;
807  void SerializeWithCachedSizes(
808  ::google::protobuf::io::CodedOutputStream* output) const final;
809  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
810  bool deterministic, ::google::protobuf::uint8* target) const final;
811  int GetCachedSize() const final { return _cached_size_.Get(); }
812 
813  private:
814  void SharedCtor();
815  void SharedDtor();
816  void SetCachedSize(int size) const final;
817  void InternalSwap(StdCmds_Disable_In* other);
818  private:
819  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
820  return NULL;
821  }
822  inline void* MaybeArenaPtr() const {
823  return NULL;
824  }
825  public:
826 
827  ::google::protobuf::Metadata GetMetadata() const final;
828 
829  // nested types ----------------------------------------------------
830 
831  // accessors -------------------------------------------------------
832 
833  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Disable_In)
834  private:
835 
836  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
837  ::google::protobuf::internal::HasBits<1> _has_bits_;
838  mutable ::google::protobuf::internal::CachedSize _cached_size_;
839  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
840 };
841 // -------------------------------------------------------------------
842 
843 class StdCmds_Status_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Status_In) */ {
844  public:
845  StdCmds_Status_In();
846  virtual ~StdCmds_Status_In();
847 
848  StdCmds_Status_In(const StdCmds_Status_In& from);
849 
850  inline StdCmds_Status_In& operator=(const StdCmds_Status_In& from) {
851  CopyFrom(from);
852  return *this;
853  }
854  #if LANG_CXX11
855  StdCmds_Status_In(StdCmds_Status_In&& from) noexcept
856  : StdCmds_Status_In() {
857  *this = ::std::move(from);
858  }
859 
860  inline StdCmds_Status_In& operator=(StdCmds_Status_In&& from) noexcept {
861  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
862  if (this != &from) InternalSwap(&from);
863  } else {
864  CopyFrom(from);
865  }
866  return *this;
867  }
868  #endif
869  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
870  return _internal_metadata_.unknown_fields();
871  }
872  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
873  return _internal_metadata_.mutable_unknown_fields();
874  }
875 
876  static const ::google::protobuf::Descriptor* descriptor();
877  static const StdCmds_Status_In& default_instance();
878 
879  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
880  static inline const StdCmds_Status_In* internal_default_instance() {
881  return reinterpret_cast<const StdCmds_Status_In*>(
882  &_StdCmds_Status_In_default_instance_);
883  }
884  static constexpr int kIndexInFileMessages =
885  6;
886 
887  void Swap(StdCmds_Status_In* other);
888  friend void swap(StdCmds_Status_In& a, StdCmds_Status_In& b) {
889  a.Swap(&b);
890  }
891 
892  // implements Message ----------------------------------------------
893 
894  inline StdCmds_Status_In* New() const final {
895  return CreateMaybeMessage<StdCmds_Status_In>(NULL);
896  }
897 
898  StdCmds_Status_In* New(::google::protobuf::Arena* arena) const final {
899  return CreateMaybeMessage<StdCmds_Status_In>(arena);
900  }
901  void CopyFrom(const ::google::protobuf::Message& from) final;
902  void MergeFrom(const ::google::protobuf::Message& from) final;
903  void CopyFrom(const StdCmds_Status_In& from);
904  void MergeFrom(const StdCmds_Status_In& from);
905  void Clear() final;
906  bool IsInitialized() const final;
907 
908  size_t ByteSizeLong() const final;
909  bool MergePartialFromCodedStream(
910  ::google::protobuf::io::CodedInputStream* input) final;
911  void SerializeWithCachedSizes(
912  ::google::protobuf::io::CodedOutputStream* output) const final;
913  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
914  bool deterministic, ::google::protobuf::uint8* target) const final;
915  int GetCachedSize() const final { return _cached_size_.Get(); }
916 
917  private:
918  void SharedCtor();
919  void SharedDtor();
920  void SetCachedSize(int size) const final;
921  void InternalSwap(StdCmds_Status_In* other);
922  private:
923  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
924  return NULL;
925  }
926  inline void* MaybeArenaPtr() const {
927  return NULL;
928  }
929  public:
930 
931  ::google::protobuf::Metadata GetMetadata() const final;
932 
933  // nested types ----------------------------------------------------
934 
935  // accessors -------------------------------------------------------
936 
937  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Status_In)
938  private:
939 
940  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
941  ::google::protobuf::internal::HasBits<1> _has_bits_;
942  mutable ::google::protobuf::internal::CachedSize _cached_size_;
943  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
944 };
945 // -------------------------------------------------------------------
946 
947 class StdCmds_Config_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Config_In) */ {
948  public:
949  StdCmds_Config_In();
950  virtual ~StdCmds_Config_In();
951 
952  StdCmds_Config_In(const StdCmds_Config_In& from);
953 
954  inline StdCmds_Config_In& operator=(const StdCmds_Config_In& from) {
955  CopyFrom(from);
956  return *this;
957  }
958  #if LANG_CXX11
959  StdCmds_Config_In(StdCmds_Config_In&& from) noexcept
960  : StdCmds_Config_In() {
961  *this = ::std::move(from);
962  }
963 
964  inline StdCmds_Config_In& operator=(StdCmds_Config_In&& from) noexcept {
965  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
966  if (this != &from) InternalSwap(&from);
967  } else {
968  CopyFrom(from);
969  }
970  return *this;
971  }
972  #endif
973  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
974  return _internal_metadata_.unknown_fields();
975  }
976  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
977  return _internal_metadata_.mutable_unknown_fields();
978  }
979 
980  static const ::google::protobuf::Descriptor* descriptor();
981  static const StdCmds_Config_In& default_instance();
982 
983  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
984  static inline const StdCmds_Config_In* internal_default_instance() {
985  return reinterpret_cast<const StdCmds_Config_In*>(
986  &_StdCmds_Config_In_default_instance_);
987  }
988  static constexpr int kIndexInFileMessages =
989  7;
990 
991  void Swap(StdCmds_Config_In* other);
992  friend void swap(StdCmds_Config_In& a, StdCmds_Config_In& b) {
993  a.Swap(&b);
994  }
995 
996  // implements Message ----------------------------------------------
997 
998  inline StdCmds_Config_In* New() const final {
999  return CreateMaybeMessage<StdCmds_Config_In>(NULL);
1000  }
1001 
1002  StdCmds_Config_In* New(::google::protobuf::Arena* arena) const final {
1003  return CreateMaybeMessage<StdCmds_Config_In>(arena);
1004  }
1005  void CopyFrom(const ::google::protobuf::Message& from) final;
1006  void MergeFrom(const ::google::protobuf::Message& from) final;
1007  void CopyFrom(const StdCmds_Config_In& from);
1008  void MergeFrom(const StdCmds_Config_In& from);
1009  void Clear() final;
1010  bool IsInitialized() const final;
1011 
1012  size_t ByteSizeLong() const final;
1013  bool MergePartialFromCodedStream(
1014  ::google::protobuf::io::CodedInputStream* input) final;
1015  void SerializeWithCachedSizes(
1016  ::google::protobuf::io::CodedOutputStream* output) const final;
1017  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1018  bool deterministic, ::google::protobuf::uint8* target) const final;
1019  int GetCachedSize() const final { return _cached_size_.Get(); }
1020 
1021  private:
1022  void SharedCtor();
1023  void SharedDtor();
1024  void SetCachedSize(int size) const final;
1025  void InternalSwap(StdCmds_Config_In* other);
1026  private:
1027  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1028  return NULL;
1029  }
1030  inline void* MaybeArenaPtr() const {
1031  return NULL;
1032  }
1033  public:
1034 
1035  ::google::protobuf::Metadata GetMetadata() const final;
1036 
1037  // nested types ----------------------------------------------------
1038 
1039  // accessors -------------------------------------------------------
1040 
1041  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Config_In)
1042  private:
1043 
1044  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1045  ::google::protobuf::internal::HasBits<1> _has_bits_;
1046  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1047  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1048 };
1049 // -------------------------------------------------------------------
1050 
1051 class StdCmds_Stop_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Stop_In) */ {
1052  public:
1053  StdCmds_Stop_In();
1054  virtual ~StdCmds_Stop_In();
1055 
1056  StdCmds_Stop_In(const StdCmds_Stop_In& from);
1057 
1058  inline StdCmds_Stop_In& operator=(const StdCmds_Stop_In& from) {
1059  CopyFrom(from);
1060  return *this;
1061  }
1062  #if LANG_CXX11
1063  StdCmds_Stop_In(StdCmds_Stop_In&& from) noexcept
1064  : StdCmds_Stop_In() {
1065  *this = ::std::move(from);
1066  }
1067 
1068  inline StdCmds_Stop_In& operator=(StdCmds_Stop_In&& from) noexcept {
1069  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1070  if (this != &from) InternalSwap(&from);
1071  } else {
1072  CopyFrom(from);
1073  }
1074  return *this;
1075  }
1076  #endif
1077  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1078  return _internal_metadata_.unknown_fields();
1079  }
1080  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1081  return _internal_metadata_.mutable_unknown_fields();
1082  }
1083 
1084  static const ::google::protobuf::Descriptor* descriptor();
1085  static const StdCmds_Stop_In& default_instance();
1086 
1087  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1088  static inline const StdCmds_Stop_In* internal_default_instance() {
1089  return reinterpret_cast<const StdCmds_Stop_In*>(
1090  &_StdCmds_Stop_In_default_instance_);
1091  }
1092  static constexpr int kIndexInFileMessages =
1093  8;
1094 
1095  void Swap(StdCmds_Stop_In* other);
1096  friend void swap(StdCmds_Stop_In& a, StdCmds_Stop_In& b) {
1097  a.Swap(&b);
1098  }
1099 
1100  // implements Message ----------------------------------------------
1101 
1102  inline StdCmds_Stop_In* New() const final {
1103  return CreateMaybeMessage<StdCmds_Stop_In>(NULL);
1104  }
1105 
1106  StdCmds_Stop_In* New(::google::protobuf::Arena* arena) const final {
1107  return CreateMaybeMessage<StdCmds_Stop_In>(arena);
1108  }
1109  void CopyFrom(const ::google::protobuf::Message& from) final;
1110  void MergeFrom(const ::google::protobuf::Message& from) final;
1111  void CopyFrom(const StdCmds_Stop_In& from);
1112  void MergeFrom(const StdCmds_Stop_In& from);
1113  void Clear() final;
1114  bool IsInitialized() const final;
1115 
1116  size_t ByteSizeLong() const final;
1117  bool MergePartialFromCodedStream(
1118  ::google::protobuf::io::CodedInputStream* input) final;
1119  void SerializeWithCachedSizes(
1120  ::google::protobuf::io::CodedOutputStream* output) const final;
1121  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1122  bool deterministic, ::google::protobuf::uint8* target) const final;
1123  int GetCachedSize() const final { return _cached_size_.Get(); }
1124 
1125  private:
1126  void SharedCtor();
1127  void SharedDtor();
1128  void SetCachedSize(int size) const final;
1129  void InternalSwap(StdCmds_Stop_In* other);
1130  private:
1131  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1132  return NULL;
1133  }
1134  inline void* MaybeArenaPtr() const {
1135  return NULL;
1136  }
1137  public:
1138 
1139  ::google::protobuf::Metadata GetMetadata() const final;
1140 
1141  // nested types ----------------------------------------------------
1142 
1143  // accessors -------------------------------------------------------
1144 
1145  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Stop_In)
1146  private:
1147 
1148  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1149  ::google::protobuf::internal::HasBits<1> _has_bits_;
1150  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1151  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1152 };
1153 // -------------------------------------------------------------------
1154 
1155 class StdCmds_Exit_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Exit_In) */ {
1156  public:
1157  StdCmds_Exit_In();
1158  virtual ~StdCmds_Exit_In();
1159 
1160  StdCmds_Exit_In(const StdCmds_Exit_In& from);
1161 
1162  inline StdCmds_Exit_In& operator=(const StdCmds_Exit_In& from) {
1163  CopyFrom(from);
1164  return *this;
1165  }
1166  #if LANG_CXX11
1167  StdCmds_Exit_In(StdCmds_Exit_In&& from) noexcept
1168  : StdCmds_Exit_In() {
1169  *this = ::std::move(from);
1170  }
1171 
1172  inline StdCmds_Exit_In& operator=(StdCmds_Exit_In&& from) noexcept {
1173  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1174  if (this != &from) InternalSwap(&from);
1175  } else {
1176  CopyFrom(from);
1177  }
1178  return *this;
1179  }
1180  #endif
1181  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1182  return _internal_metadata_.unknown_fields();
1183  }
1184  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1185  return _internal_metadata_.mutable_unknown_fields();
1186  }
1187 
1188  static const ::google::protobuf::Descriptor* descriptor();
1189  static const StdCmds_Exit_In& default_instance();
1190 
1191  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1192  static inline const StdCmds_Exit_In* internal_default_instance() {
1193  return reinterpret_cast<const StdCmds_Exit_In*>(
1194  &_StdCmds_Exit_In_default_instance_);
1195  }
1196  static constexpr int kIndexInFileMessages =
1197  9;
1198 
1199  void Swap(StdCmds_Exit_In* other);
1200  friend void swap(StdCmds_Exit_In& a, StdCmds_Exit_In& b) {
1201  a.Swap(&b);
1202  }
1203 
1204  // implements Message ----------------------------------------------
1205 
1206  inline StdCmds_Exit_In* New() const final {
1207  return CreateMaybeMessage<StdCmds_Exit_In>(NULL);
1208  }
1209 
1210  StdCmds_Exit_In* New(::google::protobuf::Arena* arena) const final {
1211  return CreateMaybeMessage<StdCmds_Exit_In>(arena);
1212  }
1213  void CopyFrom(const ::google::protobuf::Message& from) final;
1214  void MergeFrom(const ::google::protobuf::Message& from) final;
1215  void CopyFrom(const StdCmds_Exit_In& from);
1216  void MergeFrom(const StdCmds_Exit_In& from);
1217  void Clear() final;
1218  bool IsInitialized() const final;
1219 
1220  size_t ByteSizeLong() const final;
1221  bool MergePartialFromCodedStream(
1222  ::google::protobuf::io::CodedInputStream* input) final;
1223  void SerializeWithCachedSizes(
1224  ::google::protobuf::io::CodedOutputStream* output) const final;
1225  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1226  bool deterministic, ::google::protobuf::uint8* target) const final;
1227  int GetCachedSize() const final { return _cached_size_.Get(); }
1228 
1229  private:
1230  void SharedCtor();
1231  void SharedDtor();
1232  void SetCachedSize(int size) const final;
1233  void InternalSwap(StdCmds_Exit_In* other);
1234  private:
1235  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1236  return NULL;
1237  }
1238  inline void* MaybeArenaPtr() const {
1239  return NULL;
1240  }
1241  public:
1242 
1243  ::google::protobuf::Metadata GetMetadata() const final;
1244 
1245  // nested types ----------------------------------------------------
1246 
1247  // accessors -------------------------------------------------------
1248 
1249  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Exit_In)
1250  private:
1251 
1252  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1253  ::google::protobuf::internal::HasBits<1> _has_bits_;
1254  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1255  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1256 };
1257 // -------------------------------------------------------------------
1258 
1259 class StdCmds_SetLogLevel_In : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_SetLogLevel_In) */ {
1260  public:
1261  StdCmds_SetLogLevel_In();
1262  virtual ~StdCmds_SetLogLevel_In();
1263 
1264  StdCmds_SetLogLevel_In(const StdCmds_SetLogLevel_In& from);
1265 
1266  inline StdCmds_SetLogLevel_In& operator=(const StdCmds_SetLogLevel_In& from) {
1267  CopyFrom(from);
1268  return *this;
1269  }
1270  #if LANG_CXX11
1271  StdCmds_SetLogLevel_In(StdCmds_SetLogLevel_In&& from) noexcept
1272  : StdCmds_SetLogLevel_In() {
1273  *this = ::std::move(from);
1274  }
1275 
1276  inline StdCmds_SetLogLevel_In& operator=(StdCmds_SetLogLevel_In&& from) noexcept {
1277  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1278  if (this != &from) InternalSwap(&from);
1279  } else {
1280  CopyFrom(from);
1281  }
1282  return *this;
1283  }
1284  #endif
1285  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1286  return _internal_metadata_.unknown_fields();
1287  }
1288  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1289  return _internal_metadata_.mutable_unknown_fields();
1290  }
1291 
1292  static const ::google::protobuf::Descriptor* descriptor();
1293  static const StdCmds_SetLogLevel_In& default_instance();
1294 
1295  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1296  static inline const StdCmds_SetLogLevel_In* internal_default_instance() {
1297  return reinterpret_cast<const StdCmds_SetLogLevel_In*>(
1298  &_StdCmds_SetLogLevel_In_default_instance_);
1299  }
1300  static constexpr int kIndexInFileMessages =
1301  10;
1302 
1303  void Swap(StdCmds_SetLogLevel_In* other);
1304  friend void swap(StdCmds_SetLogLevel_In& a, StdCmds_SetLogLevel_In& b) {
1305  a.Swap(&b);
1306  }
1307 
1308  // implements Message ----------------------------------------------
1309 
1310  inline StdCmds_SetLogLevel_In* New() const final {
1311  return CreateMaybeMessage<StdCmds_SetLogLevel_In>(NULL);
1312  }
1313 
1314  StdCmds_SetLogLevel_In* New(::google::protobuf::Arena* arena) const final {
1315  return CreateMaybeMessage<StdCmds_SetLogLevel_In>(arena);
1316  }
1317  void CopyFrom(const ::google::protobuf::Message& from) final;
1318  void MergeFrom(const ::google::protobuf::Message& from) final;
1319  void CopyFrom(const StdCmds_SetLogLevel_In& from);
1320  void MergeFrom(const StdCmds_SetLogLevel_In& from);
1321  void Clear() final;
1322  bool IsInitialized() const final;
1323 
1324  size_t ByteSizeLong() const final;
1325  bool MergePartialFromCodedStream(
1326  ::google::protobuf::io::CodedInputStream* input) final;
1327  void SerializeWithCachedSizes(
1328  ::google::protobuf::io::CodedOutputStream* output) const final;
1329  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1330  bool deterministic, ::google::protobuf::uint8* target) const final;
1331  int GetCachedSize() const final { return _cached_size_.Get(); }
1332 
1333  private:
1334  void SharedCtor();
1335  void SharedDtor();
1336  void SetCachedSize(int size) const final;
1337  void InternalSwap(StdCmds_SetLogLevel_In* other);
1338  private:
1339  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1340  return NULL;
1341  }
1342  inline void* MaybeArenaPtr() const {
1343  return NULL;
1344  }
1345  public:
1346 
1347  ::google::protobuf::Metadata GetMetadata() const final;
1348 
1349  // nested types ----------------------------------------------------
1350 
1351  // accessors -------------------------------------------------------
1352 
1353  // required .generated.zpb.hellomalif.LogInfo info = 1;
1354  bool has_info() const;
1355  void clear_info();
1356  static const int kInfoFieldNumber = 1;
1357  private:
1358  const ::generated::zpb::hellomalif::LogInfo& _internal_info() const;
1359  public:
1360  const ::generated::zpb::hellomalif::LogInfo& info() const;
1361  ::generated::zpb::hellomalif::LogInfo* release_info();
1362  ::generated::zpb::hellomalif::LogInfo* mutable_info();
1363  void set_allocated_info(::generated::zpb::hellomalif::LogInfo* info);
1364 
1365  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_SetLogLevel_In)
1366  private:
1367  void set_has_info();
1368  void clear_has_info();
1369 
1370  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1371  ::google::protobuf::internal::HasBits<1> _has_bits_;
1372  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1373  ::generated::zpb::hellomalif::LogInfo* info_;
1374  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1375 };
1376 // -------------------------------------------------------------------
1377 
1378 class StdCmds_Call : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Call) */ {
1379  public:
1380  StdCmds_Call();
1381  virtual ~StdCmds_Call();
1382 
1383  StdCmds_Call(const StdCmds_Call& from);
1384 
1385  inline StdCmds_Call& operator=(const StdCmds_Call& from) {
1386  CopyFrom(from);
1387  return *this;
1388  }
1389  #if LANG_CXX11
1390  StdCmds_Call(StdCmds_Call&& from) noexcept
1391  : StdCmds_Call() {
1392  *this = ::std::move(from);
1393  }
1394 
1395  inline StdCmds_Call& operator=(StdCmds_Call&& from) noexcept {
1396  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1397  if (this != &from) InternalSwap(&from);
1398  } else {
1399  CopyFrom(from);
1400  }
1401  return *this;
1402  }
1403  #endif
1404  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1405  return _internal_metadata_.unknown_fields();
1406  }
1407  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1408  return _internal_metadata_.mutable_unknown_fields();
1409  }
1410 
1411  static const ::google::protobuf::Descriptor* descriptor();
1412  static const StdCmds_Call& default_instance();
1413 
1414  enum RequestCase {
1415  kInit = 1,
1416  kReset = 2,
1417  kEnable = 3,
1418  kDisable = 4,
1419  kStatus = 5,
1420  kConfig = 6,
1421  kStop = 7,
1422  kExit = 8,
1423  kSetLogLevel = 9,
1424  REQUEST_NOT_SET = 0,
1425  };
1426 
1427  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1428  static inline const StdCmds_Call* internal_default_instance() {
1429  return reinterpret_cast<const StdCmds_Call*>(
1430  &_StdCmds_Call_default_instance_);
1431  }
1432  static constexpr int kIndexInFileMessages =
1433  11;
1434 
1435  void Swap(StdCmds_Call* other);
1436  friend void swap(StdCmds_Call& a, StdCmds_Call& b) {
1437  a.Swap(&b);
1438  }
1439 
1440  // implements Message ----------------------------------------------
1441 
1442  inline StdCmds_Call* New() const final {
1443  return CreateMaybeMessage<StdCmds_Call>(NULL);
1444  }
1445 
1446  StdCmds_Call* New(::google::protobuf::Arena* arena) const final {
1447  return CreateMaybeMessage<StdCmds_Call>(arena);
1448  }
1449  void CopyFrom(const ::google::protobuf::Message& from) final;
1450  void MergeFrom(const ::google::protobuf::Message& from) final;
1451  void CopyFrom(const StdCmds_Call& from);
1452  void MergeFrom(const StdCmds_Call& from);
1453  void Clear() final;
1454  bool IsInitialized() const final;
1455 
1456  size_t ByteSizeLong() const final;
1457  bool MergePartialFromCodedStream(
1458  ::google::protobuf::io::CodedInputStream* input) final;
1459  void SerializeWithCachedSizes(
1460  ::google::protobuf::io::CodedOutputStream* output) const final;
1461  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1462  bool deterministic, ::google::protobuf::uint8* target) const final;
1463  int GetCachedSize() const final { return _cached_size_.Get(); }
1464 
1465  private:
1466  void SharedCtor();
1467  void SharedDtor();
1468  void SetCachedSize(int size) const final;
1469  void InternalSwap(StdCmds_Call* other);
1470  private:
1471  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1472  return NULL;
1473  }
1474  inline void* MaybeArenaPtr() const {
1475  return NULL;
1476  }
1477  public:
1478 
1479  ::google::protobuf::Metadata GetMetadata() const final;
1480 
1481  // nested types ----------------------------------------------------
1482 
1483  // accessors -------------------------------------------------------
1484 
1485  // optional .generated.zpb.hellomalif.StdCmds_Init_In Init = 1;
1486  bool has_init() const;
1487  void clear_init();
1488  static const int kInitFieldNumber = 1;
1489  private:
1490  const ::generated::zpb::hellomalif::StdCmds_Init_In& _internal_init() const;
1491  public:
1492  const ::generated::zpb::hellomalif::StdCmds_Init_In& init() const;
1493  ::generated::zpb::hellomalif::StdCmds_Init_In* release_init();
1494  ::generated::zpb::hellomalif::StdCmds_Init_In* mutable_init();
1495  void set_allocated_init(::generated::zpb::hellomalif::StdCmds_Init_In* init);
1496 
1497  // optional .generated.zpb.hellomalif.StdCmds_Reset_In Reset = 2;
1498  bool has_reset() const;
1499  void clear_reset();
1500  static const int kResetFieldNumber = 2;
1501  private:
1502  const ::generated::zpb::hellomalif::StdCmds_Reset_In& _internal_reset() const;
1503  public:
1504  const ::generated::zpb::hellomalif::StdCmds_Reset_In& reset() const;
1505  ::generated::zpb::hellomalif::StdCmds_Reset_In* release_reset();
1506  ::generated::zpb::hellomalif::StdCmds_Reset_In* mutable_reset();
1507  void set_allocated_reset(::generated::zpb::hellomalif::StdCmds_Reset_In* reset);
1508 
1509  // optional .generated.zpb.hellomalif.StdCmds_Enable_In Enable = 3;
1510  bool has_enable() const;
1511  void clear_enable();
1512  static const int kEnableFieldNumber = 3;
1513  private:
1514  const ::generated::zpb::hellomalif::StdCmds_Enable_In& _internal_enable() const;
1515  public:
1516  const ::generated::zpb::hellomalif::StdCmds_Enable_In& enable() const;
1517  ::generated::zpb::hellomalif::StdCmds_Enable_In* release_enable();
1518  ::generated::zpb::hellomalif::StdCmds_Enable_In* mutable_enable();
1519  void set_allocated_enable(::generated::zpb::hellomalif::StdCmds_Enable_In* enable);
1520 
1521  // optional .generated.zpb.hellomalif.StdCmds_Disable_In Disable = 4;
1522  bool has_disable() const;
1523  void clear_disable();
1524  static const int kDisableFieldNumber = 4;
1525  private:
1526  const ::generated::zpb::hellomalif::StdCmds_Disable_In& _internal_disable() const;
1527  public:
1528  const ::generated::zpb::hellomalif::StdCmds_Disable_In& disable() const;
1529  ::generated::zpb::hellomalif::StdCmds_Disable_In* release_disable();
1530  ::generated::zpb::hellomalif::StdCmds_Disable_In* mutable_disable();
1531  void set_allocated_disable(::generated::zpb::hellomalif::StdCmds_Disable_In* disable);
1532 
1533  // optional .generated.zpb.hellomalif.StdCmds_Status_In Status = 5;
1534  bool has_status() const;
1535  void clear_status();
1536  static const int kStatusFieldNumber = 5;
1537  private:
1538  const ::generated::zpb::hellomalif::StdCmds_Status_In& _internal_status() const;
1539  public:
1540  const ::generated::zpb::hellomalif::StdCmds_Status_In& status() const;
1541  ::generated::zpb::hellomalif::StdCmds_Status_In* release_status();
1542  ::generated::zpb::hellomalif::StdCmds_Status_In* mutable_status();
1543  void set_allocated_status(::generated::zpb::hellomalif::StdCmds_Status_In* status);
1544 
1545  // optional .generated.zpb.hellomalif.StdCmds_Config_In Config = 6;
1546  bool has_config() const;
1547  void clear_config();
1548  static const int kConfigFieldNumber = 6;
1549  private:
1550  const ::generated::zpb::hellomalif::StdCmds_Config_In& _internal_config() const;
1551  public:
1552  const ::generated::zpb::hellomalif::StdCmds_Config_In& config() const;
1553  ::generated::zpb::hellomalif::StdCmds_Config_In* release_config();
1554  ::generated::zpb::hellomalif::StdCmds_Config_In* mutable_config();
1555  void set_allocated_config(::generated::zpb::hellomalif::StdCmds_Config_In* config);
1556 
1557  // optional .generated.zpb.hellomalif.StdCmds_Stop_In Stop = 7;
1558  bool has_stop() const;
1559  void clear_stop();
1560  static const int kStopFieldNumber = 7;
1561  private:
1562  const ::generated::zpb::hellomalif::StdCmds_Stop_In& _internal_stop() const;
1563  public:
1564  const ::generated::zpb::hellomalif::StdCmds_Stop_In& stop() const;
1565  ::generated::zpb::hellomalif::StdCmds_Stop_In* release_stop();
1566  ::generated::zpb::hellomalif::StdCmds_Stop_In* mutable_stop();
1567  void set_allocated_stop(::generated::zpb::hellomalif::StdCmds_Stop_In* stop);
1568 
1569  // optional .generated.zpb.hellomalif.StdCmds_Exit_In Exit = 8;
1570  bool has_exit() const;
1571  void clear_exit();
1572  static const int kExitFieldNumber = 8;
1573  private:
1574  const ::generated::zpb::hellomalif::StdCmds_Exit_In& _internal_exit() const;
1575  public:
1576  const ::generated::zpb::hellomalif::StdCmds_Exit_In& exit() const;
1577  ::generated::zpb::hellomalif::StdCmds_Exit_In* release_exit();
1578  ::generated::zpb::hellomalif::StdCmds_Exit_In* mutable_exit();
1579  void set_allocated_exit(::generated::zpb::hellomalif::StdCmds_Exit_In* exit);
1580 
1581  // optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_In SetLogLevel = 9;
1582  bool has_setloglevel() const;
1583  void clear_setloglevel();
1584  static const int kSetLogLevelFieldNumber = 9;
1585  private:
1586  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& _internal_setloglevel() const;
1587  public:
1588  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& setloglevel() const;
1589  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* release_setloglevel();
1590  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* mutable_setloglevel();
1591  void set_allocated_setloglevel(::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* setloglevel);
1592 
1593  void clear_request();
1594  RequestCase request_case() const;
1595  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Call)
1596  private:
1597  void set_has_init();
1598  void set_has_reset();
1599  void set_has_enable();
1600  void set_has_disable();
1601  void set_has_status();
1602  void set_has_config();
1603  void set_has_stop();
1604  void set_has_exit();
1605  void set_has_setloglevel();
1606 
1607  inline bool has_request() const;
1608  inline void clear_has_request();
1609 
1610  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1611  ::google::protobuf::internal::HasBits<1> _has_bits_;
1612  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1613  union RequestUnion {
1614  RequestUnion() {}
1615  ::generated::zpb::hellomalif::StdCmds_Init_In* init_;
1616  ::generated::zpb::hellomalif::StdCmds_Reset_In* reset_;
1617  ::generated::zpb::hellomalif::StdCmds_Enable_In* enable_;
1618  ::generated::zpb::hellomalif::StdCmds_Disable_In* disable_;
1619  ::generated::zpb::hellomalif::StdCmds_Status_In* status_;
1620  ::generated::zpb::hellomalif::StdCmds_Config_In* config_;
1621  ::generated::zpb::hellomalif::StdCmds_Stop_In* stop_;
1622  ::generated::zpb::hellomalif::StdCmds_Exit_In* exit_;
1623  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* setloglevel_;
1624  } request_;
1625  ::google::protobuf::uint32 _oneof_case_[1];
1626 
1627  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1628 };
1629 // -------------------------------------------------------------------
1630 
1631 class StdCmds_Request : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Request) */ {
1632  public:
1633  StdCmds_Request();
1634  virtual ~StdCmds_Request();
1635 
1636  StdCmds_Request(const StdCmds_Request& from);
1637 
1638  inline StdCmds_Request& operator=(const StdCmds_Request& from) {
1639  CopyFrom(from);
1640  return *this;
1641  }
1642  #if LANG_CXX11
1643  StdCmds_Request(StdCmds_Request&& from) noexcept
1644  : StdCmds_Request() {
1645  *this = ::std::move(from);
1646  }
1647 
1648  inline StdCmds_Request& operator=(StdCmds_Request&& from) noexcept {
1649  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1650  if (this != &from) InternalSwap(&from);
1651  } else {
1652  CopyFrom(from);
1653  }
1654  return *this;
1655  }
1656  #endif
1657  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1658  return _internal_metadata_.unknown_fields();
1659  }
1660  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1661  return _internal_metadata_.mutable_unknown_fields();
1662  }
1663 
1664  static const ::google::protobuf::Descriptor* descriptor();
1665  static const StdCmds_Request& default_instance();
1666 
1667  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1668  static inline const StdCmds_Request* internal_default_instance() {
1669  return reinterpret_cast<const StdCmds_Request*>(
1670  &_StdCmds_Request_default_instance_);
1671  }
1672  static constexpr int kIndexInFileMessages =
1673  12;
1674 
1675  void Swap(StdCmds_Request* other);
1676  friend void swap(StdCmds_Request& a, StdCmds_Request& b) {
1677  a.Swap(&b);
1678  }
1679 
1680  // implements Message ----------------------------------------------
1681 
1682  inline StdCmds_Request* New() const final {
1683  return CreateMaybeMessage<StdCmds_Request>(NULL);
1684  }
1685 
1686  StdCmds_Request* New(::google::protobuf::Arena* arena) const final {
1687  return CreateMaybeMessage<StdCmds_Request>(arena);
1688  }
1689  void CopyFrom(const ::google::protobuf::Message& from) final;
1690  void MergeFrom(const ::google::protobuf::Message& from) final;
1691  void CopyFrom(const StdCmds_Request& from);
1692  void MergeFrom(const StdCmds_Request& from);
1693  void Clear() final;
1694  bool IsInitialized() const final;
1695 
1696  size_t ByteSizeLong() const final;
1697  bool MergePartialFromCodedStream(
1698  ::google::protobuf::io::CodedInputStream* input) final;
1699  void SerializeWithCachedSizes(
1700  ::google::protobuf::io::CodedOutputStream* output) const final;
1701  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1702  bool deterministic, ::google::protobuf::uint8* target) const final;
1703  int GetCachedSize() const final { return _cached_size_.Get(); }
1704 
1705  private:
1706  void SharedCtor();
1707  void SharedDtor();
1708  void SetCachedSize(int size) const final;
1709  void InternalSwap(StdCmds_Request* other);
1710  private:
1711  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1712  return NULL;
1713  }
1714  inline void* MaybeArenaPtr() const {
1715  return NULL;
1716  }
1717  public:
1718 
1719  ::google::protobuf::Metadata GetMetadata() const final;
1720 
1721  // nested types ----------------------------------------------------
1722 
1723  // accessors -------------------------------------------------------
1724 
1725  // required .elt.mal.zpb.rr.RequestHeader header = 1;
1726  bool has_header() const;
1727  void clear_header();
1728  static const int kHeaderFieldNumber = 1;
1729  private:
1730  const ::elt::mal::zpb::rr::RequestHeader& _internal_header() const;
1731  public:
1732  const ::elt::mal::zpb::rr::RequestHeader& header() const;
1733  ::elt::mal::zpb::rr::RequestHeader* release_header();
1734  ::elt::mal::zpb::rr::RequestHeader* mutable_header();
1735  void set_allocated_header(::elt::mal::zpb::rr::RequestHeader* header);
1736 
1737  // required .generated.zpb.hellomalif.StdCmds_Call data = 2;
1738  bool has_data() const;
1739  void clear_data();
1740  static const int kDataFieldNumber = 2;
1741  private:
1742  const ::generated::zpb::hellomalif::StdCmds_Call& _internal_data() const;
1743  public:
1744  const ::generated::zpb::hellomalif::StdCmds_Call& data() const;
1745  ::generated::zpb::hellomalif::StdCmds_Call* release_data();
1746  ::generated::zpb::hellomalif::StdCmds_Call* mutable_data();
1747  void set_allocated_data(::generated::zpb::hellomalif::StdCmds_Call* data);
1748 
1749  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Request)
1750  private:
1751  void set_has_header();
1752  void clear_has_header();
1753  void set_has_data();
1754  void clear_has_data();
1755 
1756  // helper for ByteSizeLong()
1757  size_t RequiredFieldsByteSizeFallback() const;
1758 
1759  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1760  ::google::protobuf::internal::HasBits<1> _has_bits_;
1761  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1762  ::elt::mal::zpb::rr::RequestHeader* header_;
1763  ::generated::zpb::hellomalif::StdCmds_Call* data_;
1764  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1765 };
1766 // -------------------------------------------------------------------
1767 
1768 class StdCmds_Init_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Init_Out) */ {
1769  public:
1770  StdCmds_Init_Out();
1771  virtual ~StdCmds_Init_Out();
1772 
1773  StdCmds_Init_Out(const StdCmds_Init_Out& from);
1774 
1775  inline StdCmds_Init_Out& operator=(const StdCmds_Init_Out& from) {
1776  CopyFrom(from);
1777  return *this;
1778  }
1779  #if LANG_CXX11
1780  StdCmds_Init_Out(StdCmds_Init_Out&& from) noexcept
1781  : StdCmds_Init_Out() {
1782  *this = ::std::move(from);
1783  }
1784 
1785  inline StdCmds_Init_Out& operator=(StdCmds_Init_Out&& from) noexcept {
1786  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1787  if (this != &from) InternalSwap(&from);
1788  } else {
1789  CopyFrom(from);
1790  }
1791  return *this;
1792  }
1793  #endif
1794  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1795  return _internal_metadata_.unknown_fields();
1796  }
1797  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1798  return _internal_metadata_.mutable_unknown_fields();
1799  }
1800 
1801  static const ::google::protobuf::Descriptor* descriptor();
1802  static const StdCmds_Init_Out& default_instance();
1803 
1804  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1805  static inline const StdCmds_Init_Out* internal_default_instance() {
1806  return reinterpret_cast<const StdCmds_Init_Out*>(
1807  &_StdCmds_Init_Out_default_instance_);
1808  }
1809  static constexpr int kIndexInFileMessages =
1810  13;
1811 
1812  void Swap(StdCmds_Init_Out* other);
1813  friend void swap(StdCmds_Init_Out& a, StdCmds_Init_Out& b) {
1814  a.Swap(&b);
1815  }
1816 
1817  // implements Message ----------------------------------------------
1818 
1819  inline StdCmds_Init_Out* New() const final {
1820  return CreateMaybeMessage<StdCmds_Init_Out>(NULL);
1821  }
1822 
1823  StdCmds_Init_Out* New(::google::protobuf::Arena* arena) const final {
1824  return CreateMaybeMessage<StdCmds_Init_Out>(arena);
1825  }
1826  void CopyFrom(const ::google::protobuf::Message& from) final;
1827  void MergeFrom(const ::google::protobuf::Message& from) final;
1828  void CopyFrom(const StdCmds_Init_Out& from);
1829  void MergeFrom(const StdCmds_Init_Out& from);
1830  void Clear() final;
1831  bool IsInitialized() const final;
1832 
1833  size_t ByteSizeLong() const final;
1834  bool MergePartialFromCodedStream(
1835  ::google::protobuf::io::CodedInputStream* input) final;
1836  void SerializeWithCachedSizes(
1837  ::google::protobuf::io::CodedOutputStream* output) const final;
1838  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1839  bool deterministic, ::google::protobuf::uint8* target) const final;
1840  int GetCachedSize() const final { return _cached_size_.Get(); }
1841 
1842  private:
1843  void SharedCtor();
1844  void SharedDtor();
1845  void SetCachedSize(int size) const final;
1846  void InternalSwap(StdCmds_Init_Out* other);
1847  private:
1848  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1849  return NULL;
1850  }
1851  inline void* MaybeArenaPtr() const {
1852  return NULL;
1853  }
1854  public:
1855 
1856  ::google::protobuf::Metadata GetMetadata() const final;
1857 
1858  // nested types ----------------------------------------------------
1859 
1860  // accessors -------------------------------------------------------
1861 
1862  // required string retval = 1;
1863  bool has_retval() const;
1864  void clear_retval();
1865  static const int kRetvalFieldNumber = 1;
1866  const ::std::string& retval() const;
1867  void set_retval(const ::std::string& value);
1868  #if LANG_CXX11
1869  void set_retval(::std::string&& value);
1870  #endif
1871  void set_retval(const char* value);
1872  void set_retval(const char* value, size_t size);
1873  ::std::string* mutable_retval();
1874  ::std::string* release_retval();
1875  void set_allocated_retval(::std::string* retval);
1876 
1877  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Init_Out)
1878  private:
1879  void set_has_retval();
1880  void clear_has_retval();
1881 
1882  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1883  ::google::protobuf::internal::HasBits<1> _has_bits_;
1884  mutable ::google::protobuf::internal::CachedSize _cached_size_;
1885  ::google::protobuf::internal::ArenaStringPtr retval_;
1886  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
1887 };
1888 // -------------------------------------------------------------------
1889 
1890 class StdCmds_Reset_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Reset_Out) */ {
1891  public:
1892  StdCmds_Reset_Out();
1893  virtual ~StdCmds_Reset_Out();
1894 
1895  StdCmds_Reset_Out(const StdCmds_Reset_Out& from);
1896 
1897  inline StdCmds_Reset_Out& operator=(const StdCmds_Reset_Out& from) {
1898  CopyFrom(from);
1899  return *this;
1900  }
1901  #if LANG_CXX11
1902  StdCmds_Reset_Out(StdCmds_Reset_Out&& from) noexcept
1903  : StdCmds_Reset_Out() {
1904  *this = ::std::move(from);
1905  }
1906 
1907  inline StdCmds_Reset_Out& operator=(StdCmds_Reset_Out&& from) noexcept {
1908  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1909  if (this != &from) InternalSwap(&from);
1910  } else {
1911  CopyFrom(from);
1912  }
1913  return *this;
1914  }
1915  #endif
1916  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1917  return _internal_metadata_.unknown_fields();
1918  }
1919  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1920  return _internal_metadata_.mutable_unknown_fields();
1921  }
1922 
1923  static const ::google::protobuf::Descriptor* descriptor();
1924  static const StdCmds_Reset_Out& default_instance();
1925 
1926  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1927  static inline const StdCmds_Reset_Out* internal_default_instance() {
1928  return reinterpret_cast<const StdCmds_Reset_Out*>(
1929  &_StdCmds_Reset_Out_default_instance_);
1930  }
1931  static constexpr int kIndexInFileMessages =
1932  14;
1933 
1934  void Swap(StdCmds_Reset_Out* other);
1935  friend void swap(StdCmds_Reset_Out& a, StdCmds_Reset_Out& b) {
1936  a.Swap(&b);
1937  }
1938 
1939  // implements Message ----------------------------------------------
1940 
1941  inline StdCmds_Reset_Out* New() const final {
1942  return CreateMaybeMessage<StdCmds_Reset_Out>(NULL);
1943  }
1944 
1945  StdCmds_Reset_Out* New(::google::protobuf::Arena* arena) const final {
1946  return CreateMaybeMessage<StdCmds_Reset_Out>(arena);
1947  }
1948  void CopyFrom(const ::google::protobuf::Message& from) final;
1949  void MergeFrom(const ::google::protobuf::Message& from) final;
1950  void CopyFrom(const StdCmds_Reset_Out& from);
1951  void MergeFrom(const StdCmds_Reset_Out& from);
1952  void Clear() final;
1953  bool IsInitialized() const final;
1954 
1955  size_t ByteSizeLong() const final;
1956  bool MergePartialFromCodedStream(
1957  ::google::protobuf::io::CodedInputStream* input) final;
1958  void SerializeWithCachedSizes(
1959  ::google::protobuf::io::CodedOutputStream* output) const final;
1960  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1961  bool deterministic, ::google::protobuf::uint8* target) const final;
1962  int GetCachedSize() const final { return _cached_size_.Get(); }
1963 
1964  private:
1965  void SharedCtor();
1966  void SharedDtor();
1967  void SetCachedSize(int size) const final;
1968  void InternalSwap(StdCmds_Reset_Out* other);
1969  private:
1970  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1971  return NULL;
1972  }
1973  inline void* MaybeArenaPtr() const {
1974  return NULL;
1975  }
1976  public:
1977 
1978  ::google::protobuf::Metadata GetMetadata() const final;
1979 
1980  // nested types ----------------------------------------------------
1981 
1982  // accessors -------------------------------------------------------
1983 
1984  // required string retval = 1;
1985  bool has_retval() const;
1986  void clear_retval();
1987  static const int kRetvalFieldNumber = 1;
1988  const ::std::string& retval() const;
1989  void set_retval(const ::std::string& value);
1990  #if LANG_CXX11
1991  void set_retval(::std::string&& value);
1992  #endif
1993  void set_retval(const char* value);
1994  void set_retval(const char* value, size_t size);
1995  ::std::string* mutable_retval();
1996  ::std::string* release_retval();
1997  void set_allocated_retval(::std::string* retval);
1998 
1999  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Reset_Out)
2000  private:
2001  void set_has_retval();
2002  void clear_has_retval();
2003 
2004  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2005  ::google::protobuf::internal::HasBits<1> _has_bits_;
2006  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2007  ::google::protobuf::internal::ArenaStringPtr retval_;
2008  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2009 };
2010 // -------------------------------------------------------------------
2011 
2012 class StdCmds_Enable_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Enable_Out) */ {
2013  public:
2014  StdCmds_Enable_Out();
2015  virtual ~StdCmds_Enable_Out();
2016 
2017  StdCmds_Enable_Out(const StdCmds_Enable_Out& from);
2018 
2019  inline StdCmds_Enable_Out& operator=(const StdCmds_Enable_Out& from) {
2020  CopyFrom(from);
2021  return *this;
2022  }
2023  #if LANG_CXX11
2024  StdCmds_Enable_Out(StdCmds_Enable_Out&& from) noexcept
2025  : StdCmds_Enable_Out() {
2026  *this = ::std::move(from);
2027  }
2028 
2029  inline StdCmds_Enable_Out& operator=(StdCmds_Enable_Out&& from) noexcept {
2030  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2031  if (this != &from) InternalSwap(&from);
2032  } else {
2033  CopyFrom(from);
2034  }
2035  return *this;
2036  }
2037  #endif
2038  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2039  return _internal_metadata_.unknown_fields();
2040  }
2041  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2042  return _internal_metadata_.mutable_unknown_fields();
2043  }
2044 
2045  static const ::google::protobuf::Descriptor* descriptor();
2046  static const StdCmds_Enable_Out& default_instance();
2047 
2048  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2049  static inline const StdCmds_Enable_Out* internal_default_instance() {
2050  return reinterpret_cast<const StdCmds_Enable_Out*>(
2051  &_StdCmds_Enable_Out_default_instance_);
2052  }
2053  static constexpr int kIndexInFileMessages =
2054  15;
2055 
2056  void Swap(StdCmds_Enable_Out* other);
2057  friend void swap(StdCmds_Enable_Out& a, StdCmds_Enable_Out& b) {
2058  a.Swap(&b);
2059  }
2060 
2061  // implements Message ----------------------------------------------
2062 
2063  inline StdCmds_Enable_Out* New() const final {
2064  return CreateMaybeMessage<StdCmds_Enable_Out>(NULL);
2065  }
2066 
2067  StdCmds_Enable_Out* New(::google::protobuf::Arena* arena) const final {
2068  return CreateMaybeMessage<StdCmds_Enable_Out>(arena);
2069  }
2070  void CopyFrom(const ::google::protobuf::Message& from) final;
2071  void MergeFrom(const ::google::protobuf::Message& from) final;
2072  void CopyFrom(const StdCmds_Enable_Out& from);
2073  void MergeFrom(const StdCmds_Enable_Out& from);
2074  void Clear() final;
2075  bool IsInitialized() const final;
2076 
2077  size_t ByteSizeLong() const final;
2078  bool MergePartialFromCodedStream(
2079  ::google::protobuf::io::CodedInputStream* input) final;
2080  void SerializeWithCachedSizes(
2081  ::google::protobuf::io::CodedOutputStream* output) const final;
2082  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2083  bool deterministic, ::google::protobuf::uint8* target) const final;
2084  int GetCachedSize() const final { return _cached_size_.Get(); }
2085 
2086  private:
2087  void SharedCtor();
2088  void SharedDtor();
2089  void SetCachedSize(int size) const final;
2090  void InternalSwap(StdCmds_Enable_Out* other);
2091  private:
2092  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2093  return NULL;
2094  }
2095  inline void* MaybeArenaPtr() const {
2096  return NULL;
2097  }
2098  public:
2099 
2100  ::google::protobuf::Metadata GetMetadata() const final;
2101 
2102  // nested types ----------------------------------------------------
2103 
2104  // accessors -------------------------------------------------------
2105 
2106  // required string retval = 1;
2107  bool has_retval() const;
2108  void clear_retval();
2109  static const int kRetvalFieldNumber = 1;
2110  const ::std::string& retval() const;
2111  void set_retval(const ::std::string& value);
2112  #if LANG_CXX11
2113  void set_retval(::std::string&& value);
2114  #endif
2115  void set_retval(const char* value);
2116  void set_retval(const char* value, size_t size);
2117  ::std::string* mutable_retval();
2118  ::std::string* release_retval();
2119  void set_allocated_retval(::std::string* retval);
2120 
2121  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Enable_Out)
2122  private:
2123  void set_has_retval();
2124  void clear_has_retval();
2125 
2126  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2127  ::google::protobuf::internal::HasBits<1> _has_bits_;
2128  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2129  ::google::protobuf::internal::ArenaStringPtr retval_;
2130  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2131 };
2132 // -------------------------------------------------------------------
2133 
2134 class StdCmds_Disable_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Disable_Out) */ {
2135  public:
2136  StdCmds_Disable_Out();
2137  virtual ~StdCmds_Disable_Out();
2138 
2139  StdCmds_Disable_Out(const StdCmds_Disable_Out& from);
2140 
2141  inline StdCmds_Disable_Out& operator=(const StdCmds_Disable_Out& from) {
2142  CopyFrom(from);
2143  return *this;
2144  }
2145  #if LANG_CXX11
2146  StdCmds_Disable_Out(StdCmds_Disable_Out&& from) noexcept
2147  : StdCmds_Disable_Out() {
2148  *this = ::std::move(from);
2149  }
2150 
2151  inline StdCmds_Disable_Out& operator=(StdCmds_Disable_Out&& from) noexcept {
2152  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2153  if (this != &from) InternalSwap(&from);
2154  } else {
2155  CopyFrom(from);
2156  }
2157  return *this;
2158  }
2159  #endif
2160  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2161  return _internal_metadata_.unknown_fields();
2162  }
2163  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2164  return _internal_metadata_.mutable_unknown_fields();
2165  }
2166 
2167  static const ::google::protobuf::Descriptor* descriptor();
2168  static const StdCmds_Disable_Out& default_instance();
2169 
2170  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2171  static inline const StdCmds_Disable_Out* internal_default_instance() {
2172  return reinterpret_cast<const StdCmds_Disable_Out*>(
2173  &_StdCmds_Disable_Out_default_instance_);
2174  }
2175  static constexpr int kIndexInFileMessages =
2176  16;
2177 
2178  void Swap(StdCmds_Disable_Out* other);
2179  friend void swap(StdCmds_Disable_Out& a, StdCmds_Disable_Out& b) {
2180  a.Swap(&b);
2181  }
2182 
2183  // implements Message ----------------------------------------------
2184 
2185  inline StdCmds_Disable_Out* New() const final {
2186  return CreateMaybeMessage<StdCmds_Disable_Out>(NULL);
2187  }
2188 
2189  StdCmds_Disable_Out* New(::google::protobuf::Arena* arena) const final {
2190  return CreateMaybeMessage<StdCmds_Disable_Out>(arena);
2191  }
2192  void CopyFrom(const ::google::protobuf::Message& from) final;
2193  void MergeFrom(const ::google::protobuf::Message& from) final;
2194  void CopyFrom(const StdCmds_Disable_Out& from);
2195  void MergeFrom(const StdCmds_Disable_Out& from);
2196  void Clear() final;
2197  bool IsInitialized() const final;
2198 
2199  size_t ByteSizeLong() const final;
2200  bool MergePartialFromCodedStream(
2201  ::google::protobuf::io::CodedInputStream* input) final;
2202  void SerializeWithCachedSizes(
2203  ::google::protobuf::io::CodedOutputStream* output) const final;
2204  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2205  bool deterministic, ::google::protobuf::uint8* target) const final;
2206  int GetCachedSize() const final { return _cached_size_.Get(); }
2207 
2208  private:
2209  void SharedCtor();
2210  void SharedDtor();
2211  void SetCachedSize(int size) const final;
2212  void InternalSwap(StdCmds_Disable_Out* other);
2213  private:
2214  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2215  return NULL;
2216  }
2217  inline void* MaybeArenaPtr() const {
2218  return NULL;
2219  }
2220  public:
2221 
2222  ::google::protobuf::Metadata GetMetadata() const final;
2223 
2224  // nested types ----------------------------------------------------
2225 
2226  // accessors -------------------------------------------------------
2227 
2228  // required string retval = 1;
2229  bool has_retval() const;
2230  void clear_retval();
2231  static const int kRetvalFieldNumber = 1;
2232  const ::std::string& retval() const;
2233  void set_retval(const ::std::string& value);
2234  #if LANG_CXX11
2235  void set_retval(::std::string&& value);
2236  #endif
2237  void set_retval(const char* value);
2238  void set_retval(const char* value, size_t size);
2239  ::std::string* mutable_retval();
2240  ::std::string* release_retval();
2241  void set_allocated_retval(::std::string* retval);
2242 
2243  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Disable_Out)
2244  private:
2245  void set_has_retval();
2246  void clear_has_retval();
2247 
2248  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2249  ::google::protobuf::internal::HasBits<1> _has_bits_;
2250  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2251  ::google::protobuf::internal::ArenaStringPtr retval_;
2252  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2253 };
2254 // -------------------------------------------------------------------
2255 
2256 class StdCmds_Status_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Status_Out) */ {
2257  public:
2258  StdCmds_Status_Out();
2259  virtual ~StdCmds_Status_Out();
2260 
2261  StdCmds_Status_Out(const StdCmds_Status_Out& from);
2262 
2263  inline StdCmds_Status_Out& operator=(const StdCmds_Status_Out& from) {
2264  CopyFrom(from);
2265  return *this;
2266  }
2267  #if LANG_CXX11
2268  StdCmds_Status_Out(StdCmds_Status_Out&& from) noexcept
2269  : StdCmds_Status_Out() {
2270  *this = ::std::move(from);
2271  }
2272 
2273  inline StdCmds_Status_Out& operator=(StdCmds_Status_Out&& from) noexcept {
2274  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2275  if (this != &from) InternalSwap(&from);
2276  } else {
2277  CopyFrom(from);
2278  }
2279  return *this;
2280  }
2281  #endif
2282  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2283  return _internal_metadata_.unknown_fields();
2284  }
2285  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2286  return _internal_metadata_.mutable_unknown_fields();
2287  }
2288 
2289  static const ::google::protobuf::Descriptor* descriptor();
2290  static const StdCmds_Status_Out& default_instance();
2291 
2292  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2293  static inline const StdCmds_Status_Out* internal_default_instance() {
2294  return reinterpret_cast<const StdCmds_Status_Out*>(
2295  &_StdCmds_Status_Out_default_instance_);
2296  }
2297  static constexpr int kIndexInFileMessages =
2298  17;
2299 
2300  void Swap(StdCmds_Status_Out* other);
2301  friend void swap(StdCmds_Status_Out& a, StdCmds_Status_Out& b) {
2302  a.Swap(&b);
2303  }
2304 
2305  // implements Message ----------------------------------------------
2306 
2307  inline StdCmds_Status_Out* New() const final {
2308  return CreateMaybeMessage<StdCmds_Status_Out>(NULL);
2309  }
2310 
2311  StdCmds_Status_Out* New(::google::protobuf::Arena* arena) const final {
2312  return CreateMaybeMessage<StdCmds_Status_Out>(arena);
2313  }
2314  void CopyFrom(const ::google::protobuf::Message& from) final;
2315  void MergeFrom(const ::google::protobuf::Message& from) final;
2316  void CopyFrom(const StdCmds_Status_Out& from);
2317  void MergeFrom(const StdCmds_Status_Out& from);
2318  void Clear() final;
2319  bool IsInitialized() const final;
2320 
2321  size_t ByteSizeLong() const final;
2322  bool MergePartialFromCodedStream(
2323  ::google::protobuf::io::CodedInputStream* input) final;
2324  void SerializeWithCachedSizes(
2325  ::google::protobuf::io::CodedOutputStream* output) const final;
2326  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2327  bool deterministic, ::google::protobuf::uint8* target) const final;
2328  int GetCachedSize() const final { return _cached_size_.Get(); }
2329 
2330  private:
2331  void SharedCtor();
2332  void SharedDtor();
2333  void SetCachedSize(int size) const final;
2334  void InternalSwap(StdCmds_Status_Out* other);
2335  private:
2336  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2337  return NULL;
2338  }
2339  inline void* MaybeArenaPtr() const {
2340  return NULL;
2341  }
2342  public:
2343 
2344  ::google::protobuf::Metadata GetMetadata() const final;
2345 
2346  // nested types ----------------------------------------------------
2347 
2348  // accessors -------------------------------------------------------
2349 
2350  // required string retval = 1;
2351  bool has_retval() const;
2352  void clear_retval();
2353  static const int kRetvalFieldNumber = 1;
2354  const ::std::string& retval() const;
2355  void set_retval(const ::std::string& value);
2356  #if LANG_CXX11
2357  void set_retval(::std::string&& value);
2358  #endif
2359  void set_retval(const char* value);
2360  void set_retval(const char* value, size_t size);
2361  ::std::string* mutable_retval();
2362  ::std::string* release_retval();
2363  void set_allocated_retval(::std::string* retval);
2364 
2365  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Status_Out)
2366  private:
2367  void set_has_retval();
2368  void clear_has_retval();
2369 
2370  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2371  ::google::protobuf::internal::HasBits<1> _has_bits_;
2372  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2373  ::google::protobuf::internal::ArenaStringPtr retval_;
2374  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2375 };
2376 // -------------------------------------------------------------------
2377 
2378 class StdCmds_Config_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Config_Out) */ {
2379  public:
2380  StdCmds_Config_Out();
2381  virtual ~StdCmds_Config_Out();
2382 
2383  StdCmds_Config_Out(const StdCmds_Config_Out& from);
2384 
2385  inline StdCmds_Config_Out& operator=(const StdCmds_Config_Out& from) {
2386  CopyFrom(from);
2387  return *this;
2388  }
2389  #if LANG_CXX11
2390  StdCmds_Config_Out(StdCmds_Config_Out&& from) noexcept
2391  : StdCmds_Config_Out() {
2392  *this = ::std::move(from);
2393  }
2394 
2395  inline StdCmds_Config_Out& operator=(StdCmds_Config_Out&& from) noexcept {
2396  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2397  if (this != &from) InternalSwap(&from);
2398  } else {
2399  CopyFrom(from);
2400  }
2401  return *this;
2402  }
2403  #endif
2404  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2405  return _internal_metadata_.unknown_fields();
2406  }
2407  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2408  return _internal_metadata_.mutable_unknown_fields();
2409  }
2410 
2411  static const ::google::protobuf::Descriptor* descriptor();
2412  static const StdCmds_Config_Out& default_instance();
2413 
2414  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2415  static inline const StdCmds_Config_Out* internal_default_instance() {
2416  return reinterpret_cast<const StdCmds_Config_Out*>(
2417  &_StdCmds_Config_Out_default_instance_);
2418  }
2419  static constexpr int kIndexInFileMessages =
2420  18;
2421 
2422  void Swap(StdCmds_Config_Out* other);
2423  friend void swap(StdCmds_Config_Out& a, StdCmds_Config_Out& b) {
2424  a.Swap(&b);
2425  }
2426 
2427  // implements Message ----------------------------------------------
2428 
2429  inline StdCmds_Config_Out* New() const final {
2430  return CreateMaybeMessage<StdCmds_Config_Out>(NULL);
2431  }
2432 
2433  StdCmds_Config_Out* New(::google::protobuf::Arena* arena) const final {
2434  return CreateMaybeMessage<StdCmds_Config_Out>(arena);
2435  }
2436  void CopyFrom(const ::google::protobuf::Message& from) final;
2437  void MergeFrom(const ::google::protobuf::Message& from) final;
2438  void CopyFrom(const StdCmds_Config_Out& from);
2439  void MergeFrom(const StdCmds_Config_Out& from);
2440  void Clear() final;
2441  bool IsInitialized() const final;
2442 
2443  size_t ByteSizeLong() const final;
2444  bool MergePartialFromCodedStream(
2445  ::google::protobuf::io::CodedInputStream* input) final;
2446  void SerializeWithCachedSizes(
2447  ::google::protobuf::io::CodedOutputStream* output) const final;
2448  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2449  bool deterministic, ::google::protobuf::uint8* target) const final;
2450  int GetCachedSize() const final { return _cached_size_.Get(); }
2451 
2452  private:
2453  void SharedCtor();
2454  void SharedDtor();
2455  void SetCachedSize(int size) const final;
2456  void InternalSwap(StdCmds_Config_Out* other);
2457  private:
2458  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2459  return NULL;
2460  }
2461  inline void* MaybeArenaPtr() const {
2462  return NULL;
2463  }
2464  public:
2465 
2466  ::google::protobuf::Metadata GetMetadata() const final;
2467 
2468  // nested types ----------------------------------------------------
2469 
2470  // accessors -------------------------------------------------------
2471 
2472  // required string retval = 1;
2473  bool has_retval() const;
2474  void clear_retval();
2475  static const int kRetvalFieldNumber = 1;
2476  const ::std::string& retval() const;
2477  void set_retval(const ::std::string& value);
2478  #if LANG_CXX11
2479  void set_retval(::std::string&& value);
2480  #endif
2481  void set_retval(const char* value);
2482  void set_retval(const char* value, size_t size);
2483  ::std::string* mutable_retval();
2484  ::std::string* release_retval();
2485  void set_allocated_retval(::std::string* retval);
2486 
2487  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Config_Out)
2488  private:
2489  void set_has_retval();
2490  void clear_has_retval();
2491 
2492  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2493  ::google::protobuf::internal::HasBits<1> _has_bits_;
2494  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2495  ::google::protobuf::internal::ArenaStringPtr retval_;
2496  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2497 };
2498 // -------------------------------------------------------------------
2499 
2500 class StdCmds_Stop_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Stop_Out) */ {
2501  public:
2502  StdCmds_Stop_Out();
2503  virtual ~StdCmds_Stop_Out();
2504 
2505  StdCmds_Stop_Out(const StdCmds_Stop_Out& from);
2506 
2507  inline StdCmds_Stop_Out& operator=(const StdCmds_Stop_Out& from) {
2508  CopyFrom(from);
2509  return *this;
2510  }
2511  #if LANG_CXX11
2512  StdCmds_Stop_Out(StdCmds_Stop_Out&& from) noexcept
2513  : StdCmds_Stop_Out() {
2514  *this = ::std::move(from);
2515  }
2516 
2517  inline StdCmds_Stop_Out& operator=(StdCmds_Stop_Out&& from) noexcept {
2518  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2519  if (this != &from) InternalSwap(&from);
2520  } else {
2521  CopyFrom(from);
2522  }
2523  return *this;
2524  }
2525  #endif
2526  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2527  return _internal_metadata_.unknown_fields();
2528  }
2529  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2530  return _internal_metadata_.mutable_unknown_fields();
2531  }
2532 
2533  static const ::google::protobuf::Descriptor* descriptor();
2534  static const StdCmds_Stop_Out& default_instance();
2535 
2536  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2537  static inline const StdCmds_Stop_Out* internal_default_instance() {
2538  return reinterpret_cast<const StdCmds_Stop_Out*>(
2539  &_StdCmds_Stop_Out_default_instance_);
2540  }
2541  static constexpr int kIndexInFileMessages =
2542  19;
2543 
2544  void Swap(StdCmds_Stop_Out* other);
2545  friend void swap(StdCmds_Stop_Out& a, StdCmds_Stop_Out& b) {
2546  a.Swap(&b);
2547  }
2548 
2549  // implements Message ----------------------------------------------
2550 
2551  inline StdCmds_Stop_Out* New() const final {
2552  return CreateMaybeMessage<StdCmds_Stop_Out>(NULL);
2553  }
2554 
2555  StdCmds_Stop_Out* New(::google::protobuf::Arena* arena) const final {
2556  return CreateMaybeMessage<StdCmds_Stop_Out>(arena);
2557  }
2558  void CopyFrom(const ::google::protobuf::Message& from) final;
2559  void MergeFrom(const ::google::protobuf::Message& from) final;
2560  void CopyFrom(const StdCmds_Stop_Out& from);
2561  void MergeFrom(const StdCmds_Stop_Out& from);
2562  void Clear() final;
2563  bool IsInitialized() const final;
2564 
2565  size_t ByteSizeLong() const final;
2566  bool MergePartialFromCodedStream(
2567  ::google::protobuf::io::CodedInputStream* input) final;
2568  void SerializeWithCachedSizes(
2569  ::google::protobuf::io::CodedOutputStream* output) const final;
2570  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2571  bool deterministic, ::google::protobuf::uint8* target) const final;
2572  int GetCachedSize() const final { return _cached_size_.Get(); }
2573 
2574  private:
2575  void SharedCtor();
2576  void SharedDtor();
2577  void SetCachedSize(int size) const final;
2578  void InternalSwap(StdCmds_Stop_Out* other);
2579  private:
2580  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2581  return NULL;
2582  }
2583  inline void* MaybeArenaPtr() const {
2584  return NULL;
2585  }
2586  public:
2587 
2588  ::google::protobuf::Metadata GetMetadata() const final;
2589 
2590  // nested types ----------------------------------------------------
2591 
2592  // accessors -------------------------------------------------------
2593 
2594  // required string retval = 1;
2595  bool has_retval() const;
2596  void clear_retval();
2597  static const int kRetvalFieldNumber = 1;
2598  const ::std::string& retval() const;
2599  void set_retval(const ::std::string& value);
2600  #if LANG_CXX11
2601  void set_retval(::std::string&& value);
2602  #endif
2603  void set_retval(const char* value);
2604  void set_retval(const char* value, size_t size);
2605  ::std::string* mutable_retval();
2606  ::std::string* release_retval();
2607  void set_allocated_retval(::std::string* retval);
2608 
2609  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Stop_Out)
2610  private:
2611  void set_has_retval();
2612  void clear_has_retval();
2613 
2614  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2615  ::google::protobuf::internal::HasBits<1> _has_bits_;
2616  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2617  ::google::protobuf::internal::ArenaStringPtr retval_;
2618  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2619 };
2620 // -------------------------------------------------------------------
2621 
2622 class StdCmds_Exit_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Exit_Out) */ {
2623  public:
2624  StdCmds_Exit_Out();
2625  virtual ~StdCmds_Exit_Out();
2626 
2627  StdCmds_Exit_Out(const StdCmds_Exit_Out& from);
2628 
2629  inline StdCmds_Exit_Out& operator=(const StdCmds_Exit_Out& from) {
2630  CopyFrom(from);
2631  return *this;
2632  }
2633  #if LANG_CXX11
2634  StdCmds_Exit_Out(StdCmds_Exit_Out&& from) noexcept
2635  : StdCmds_Exit_Out() {
2636  *this = ::std::move(from);
2637  }
2638 
2639  inline StdCmds_Exit_Out& operator=(StdCmds_Exit_Out&& from) noexcept {
2640  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2641  if (this != &from) InternalSwap(&from);
2642  } else {
2643  CopyFrom(from);
2644  }
2645  return *this;
2646  }
2647  #endif
2648  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2649  return _internal_metadata_.unknown_fields();
2650  }
2651  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2652  return _internal_metadata_.mutable_unknown_fields();
2653  }
2654 
2655  static const ::google::protobuf::Descriptor* descriptor();
2656  static const StdCmds_Exit_Out& default_instance();
2657 
2658  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2659  static inline const StdCmds_Exit_Out* internal_default_instance() {
2660  return reinterpret_cast<const StdCmds_Exit_Out*>(
2661  &_StdCmds_Exit_Out_default_instance_);
2662  }
2663  static constexpr int kIndexInFileMessages =
2664  20;
2665 
2666  void Swap(StdCmds_Exit_Out* other);
2667  friend void swap(StdCmds_Exit_Out& a, StdCmds_Exit_Out& b) {
2668  a.Swap(&b);
2669  }
2670 
2671  // implements Message ----------------------------------------------
2672 
2673  inline StdCmds_Exit_Out* New() const final {
2674  return CreateMaybeMessage<StdCmds_Exit_Out>(NULL);
2675  }
2676 
2677  StdCmds_Exit_Out* New(::google::protobuf::Arena* arena) const final {
2678  return CreateMaybeMessage<StdCmds_Exit_Out>(arena);
2679  }
2680  void CopyFrom(const ::google::protobuf::Message& from) final;
2681  void MergeFrom(const ::google::protobuf::Message& from) final;
2682  void CopyFrom(const StdCmds_Exit_Out& from);
2683  void MergeFrom(const StdCmds_Exit_Out& from);
2684  void Clear() final;
2685  bool IsInitialized() const final;
2686 
2687  size_t ByteSizeLong() const final;
2688  bool MergePartialFromCodedStream(
2689  ::google::protobuf::io::CodedInputStream* input) final;
2690  void SerializeWithCachedSizes(
2691  ::google::protobuf::io::CodedOutputStream* output) const final;
2692  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2693  bool deterministic, ::google::protobuf::uint8* target) const final;
2694  int GetCachedSize() const final { return _cached_size_.Get(); }
2695 
2696  private:
2697  void SharedCtor();
2698  void SharedDtor();
2699  void SetCachedSize(int size) const final;
2700  void InternalSwap(StdCmds_Exit_Out* other);
2701  private:
2702  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2703  return NULL;
2704  }
2705  inline void* MaybeArenaPtr() const {
2706  return NULL;
2707  }
2708  public:
2709 
2710  ::google::protobuf::Metadata GetMetadata() const final;
2711 
2712  // nested types ----------------------------------------------------
2713 
2714  // accessors -------------------------------------------------------
2715 
2716  // required string retval = 1;
2717  bool has_retval() const;
2718  void clear_retval();
2719  static const int kRetvalFieldNumber = 1;
2720  const ::std::string& retval() const;
2721  void set_retval(const ::std::string& value);
2722  #if LANG_CXX11
2723  void set_retval(::std::string&& value);
2724  #endif
2725  void set_retval(const char* value);
2726  void set_retval(const char* value, size_t size);
2727  ::std::string* mutable_retval();
2728  ::std::string* release_retval();
2729  void set_allocated_retval(::std::string* retval);
2730 
2731  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Exit_Out)
2732  private:
2733  void set_has_retval();
2734  void clear_has_retval();
2735 
2736  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2737  ::google::protobuf::internal::HasBits<1> _has_bits_;
2738  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2739  ::google::protobuf::internal::ArenaStringPtr retval_;
2740  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2741 };
2742 // -------------------------------------------------------------------
2743 
2744 class StdCmds_SetLogLevel_Out : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out) */ {
2745  public:
2746  StdCmds_SetLogLevel_Out();
2747  virtual ~StdCmds_SetLogLevel_Out();
2748 
2749  StdCmds_SetLogLevel_Out(const StdCmds_SetLogLevel_Out& from);
2750 
2751  inline StdCmds_SetLogLevel_Out& operator=(const StdCmds_SetLogLevel_Out& from) {
2752  CopyFrom(from);
2753  return *this;
2754  }
2755  #if LANG_CXX11
2756  StdCmds_SetLogLevel_Out(StdCmds_SetLogLevel_Out&& from) noexcept
2757  : StdCmds_SetLogLevel_Out() {
2758  *this = ::std::move(from);
2759  }
2760 
2761  inline StdCmds_SetLogLevel_Out& operator=(StdCmds_SetLogLevel_Out&& from) noexcept {
2762  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2763  if (this != &from) InternalSwap(&from);
2764  } else {
2765  CopyFrom(from);
2766  }
2767  return *this;
2768  }
2769  #endif
2770  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2771  return _internal_metadata_.unknown_fields();
2772  }
2773  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2774  return _internal_metadata_.mutable_unknown_fields();
2775  }
2776 
2777  static const ::google::protobuf::Descriptor* descriptor();
2778  static const StdCmds_SetLogLevel_Out& default_instance();
2779 
2780  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2781  static inline const StdCmds_SetLogLevel_Out* internal_default_instance() {
2782  return reinterpret_cast<const StdCmds_SetLogLevel_Out*>(
2783  &_StdCmds_SetLogLevel_Out_default_instance_);
2784  }
2785  static constexpr int kIndexInFileMessages =
2786  21;
2787 
2788  void Swap(StdCmds_SetLogLevel_Out* other);
2789  friend void swap(StdCmds_SetLogLevel_Out& a, StdCmds_SetLogLevel_Out& b) {
2790  a.Swap(&b);
2791  }
2792 
2793  // implements Message ----------------------------------------------
2794 
2795  inline StdCmds_SetLogLevel_Out* New() const final {
2796  return CreateMaybeMessage<StdCmds_SetLogLevel_Out>(NULL);
2797  }
2798 
2799  StdCmds_SetLogLevel_Out* New(::google::protobuf::Arena* arena) const final {
2800  return CreateMaybeMessage<StdCmds_SetLogLevel_Out>(arena);
2801  }
2802  void CopyFrom(const ::google::protobuf::Message& from) final;
2803  void MergeFrom(const ::google::protobuf::Message& from) final;
2804  void CopyFrom(const StdCmds_SetLogLevel_Out& from);
2805  void MergeFrom(const StdCmds_SetLogLevel_Out& from);
2806  void Clear() final;
2807  bool IsInitialized() const final;
2808 
2809  size_t ByteSizeLong() const final;
2810  bool MergePartialFromCodedStream(
2811  ::google::protobuf::io::CodedInputStream* input) final;
2812  void SerializeWithCachedSizes(
2813  ::google::protobuf::io::CodedOutputStream* output) const final;
2814  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2815  bool deterministic, ::google::protobuf::uint8* target) const final;
2816  int GetCachedSize() const final { return _cached_size_.Get(); }
2817 
2818  private:
2819  void SharedCtor();
2820  void SharedDtor();
2821  void SetCachedSize(int size) const final;
2822  void InternalSwap(StdCmds_SetLogLevel_Out* other);
2823  private:
2824  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2825  return NULL;
2826  }
2827  inline void* MaybeArenaPtr() const {
2828  return NULL;
2829  }
2830  public:
2831 
2832  ::google::protobuf::Metadata GetMetadata() const final;
2833 
2834  // nested types ----------------------------------------------------
2835 
2836  // accessors -------------------------------------------------------
2837 
2838  // optional string retval = 1;
2839  bool has_retval() const;
2840  void clear_retval();
2841  static const int kRetvalFieldNumber = 1;
2842  const ::std::string& retval() const;
2843  void set_retval(const ::std::string& value);
2844  #if LANG_CXX11
2845  void set_retval(::std::string&& value);
2846  #endif
2847  void set_retval(const char* value);
2848  void set_retval(const char* value, size_t size);
2849  ::std::string* mutable_retval();
2850  ::std::string* release_retval();
2851  void set_allocated_retval(::std::string* retval);
2852 
2853  // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
2854  bool has_exexceptionerr() const;
2855  void clear_exexceptionerr();
2856  static const int kExExceptionErrFieldNumber = 2;
2857  private:
2858  const ::generated::zpb::hellomalif::ExceptionErr& _internal_exexceptionerr() const;
2859  public:
2860  const ::generated::zpb::hellomalif::ExceptionErr& exexceptionerr() const;
2861  ::generated::zpb::hellomalif::ExceptionErr* release_exexceptionerr();
2862  ::generated::zpb::hellomalif::ExceptionErr* mutable_exexceptionerr();
2863  void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr);
2864 
2865  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out)
2866  private:
2867  void set_has_retval();
2868  void clear_has_retval();
2869  void set_has_exexceptionerr();
2870  void clear_has_exexceptionerr();
2871 
2872  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2873  ::google::protobuf::internal::HasBits<1> _has_bits_;
2874  mutable ::google::protobuf::internal::CachedSize _cached_size_;
2875  ::google::protobuf::internal::ArenaStringPtr retval_;
2876  ::generated::zpb::hellomalif::ExceptionErr* exexceptionerr_;
2877  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
2878 };
2879 // -------------------------------------------------------------------
2880 
2881 class StdCmds_Return : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Return) */ {
2882  public:
2883  StdCmds_Return();
2884  virtual ~StdCmds_Return();
2885 
2886  StdCmds_Return(const StdCmds_Return& from);
2887 
2888  inline StdCmds_Return& operator=(const StdCmds_Return& from) {
2889  CopyFrom(from);
2890  return *this;
2891  }
2892  #if LANG_CXX11
2893  StdCmds_Return(StdCmds_Return&& from) noexcept
2894  : StdCmds_Return() {
2895  *this = ::std::move(from);
2896  }
2897 
2898  inline StdCmds_Return& operator=(StdCmds_Return&& from) noexcept {
2899  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2900  if (this != &from) InternalSwap(&from);
2901  } else {
2902  CopyFrom(from);
2903  }
2904  return *this;
2905  }
2906  #endif
2907  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2908  return _internal_metadata_.unknown_fields();
2909  }
2910  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2911  return _internal_metadata_.mutable_unknown_fields();
2912  }
2913 
2914  static const ::google::protobuf::Descriptor* descriptor();
2915  static const StdCmds_Return& default_instance();
2916 
2917  enum ReplyCase {
2918  kInit = 1,
2919  kReset = 2,
2920  kEnable = 3,
2921  kDisable = 4,
2922  kStatus = 5,
2923  kConfig = 6,
2924  kStop = 7,
2925  kExit = 8,
2926  kSetLogLevel = 9,
2927  REPLY_NOT_SET = 0,
2928  };
2929 
2930  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2931  static inline const StdCmds_Return* internal_default_instance() {
2932  return reinterpret_cast<const StdCmds_Return*>(
2933  &_StdCmds_Return_default_instance_);
2934  }
2935  static constexpr int kIndexInFileMessages =
2936  22;
2937 
2938  void Swap(StdCmds_Return* other);
2939  friend void swap(StdCmds_Return& a, StdCmds_Return& b) {
2940  a.Swap(&b);
2941  }
2942 
2943  // implements Message ----------------------------------------------
2944 
2945  inline StdCmds_Return* New() const final {
2946  return CreateMaybeMessage<StdCmds_Return>(NULL);
2947  }
2948 
2949  StdCmds_Return* New(::google::protobuf::Arena* arena) const final {
2950  return CreateMaybeMessage<StdCmds_Return>(arena);
2951  }
2952  void CopyFrom(const ::google::protobuf::Message& from) final;
2953  void MergeFrom(const ::google::protobuf::Message& from) final;
2954  void CopyFrom(const StdCmds_Return& from);
2955  void MergeFrom(const StdCmds_Return& from);
2956  void Clear() final;
2957  bool IsInitialized() const final;
2958 
2959  size_t ByteSizeLong() const final;
2960  bool MergePartialFromCodedStream(
2961  ::google::protobuf::io::CodedInputStream* input) final;
2962  void SerializeWithCachedSizes(
2963  ::google::protobuf::io::CodedOutputStream* output) const final;
2964  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2965  bool deterministic, ::google::protobuf::uint8* target) const final;
2966  int GetCachedSize() const final { return _cached_size_.Get(); }
2967 
2968  private:
2969  void SharedCtor();
2970  void SharedDtor();
2971  void SetCachedSize(int size) const final;
2972  void InternalSwap(StdCmds_Return* other);
2973  private:
2974  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2975  return NULL;
2976  }
2977  inline void* MaybeArenaPtr() const {
2978  return NULL;
2979  }
2980  public:
2981 
2982  ::google::protobuf::Metadata GetMetadata() const final;
2983 
2984  // nested types ----------------------------------------------------
2985 
2986  // accessors -------------------------------------------------------
2987 
2988  // optional .generated.zpb.hellomalif.StdCmds_Init_Out Init = 1;
2989  bool has_init() const;
2990  void clear_init();
2991  static const int kInitFieldNumber = 1;
2992  private:
2993  const ::generated::zpb::hellomalif::StdCmds_Init_Out& _internal_init() const;
2994  public:
2995  const ::generated::zpb::hellomalif::StdCmds_Init_Out& init() const;
2996  ::generated::zpb::hellomalif::StdCmds_Init_Out* release_init();
2997  ::generated::zpb::hellomalif::StdCmds_Init_Out* mutable_init();
2998  void set_allocated_init(::generated::zpb::hellomalif::StdCmds_Init_Out* init);
2999 
3000  // optional .generated.zpb.hellomalif.StdCmds_Reset_Out Reset = 2;
3001  bool has_reset() const;
3002  void clear_reset();
3003  static const int kResetFieldNumber = 2;
3004  private:
3005  const ::generated::zpb::hellomalif::StdCmds_Reset_Out& _internal_reset() const;
3006  public:
3007  const ::generated::zpb::hellomalif::StdCmds_Reset_Out& reset() const;
3008  ::generated::zpb::hellomalif::StdCmds_Reset_Out* release_reset();
3009  ::generated::zpb::hellomalif::StdCmds_Reset_Out* mutable_reset();
3010  void set_allocated_reset(::generated::zpb::hellomalif::StdCmds_Reset_Out* reset);
3011 
3012  // optional .generated.zpb.hellomalif.StdCmds_Enable_Out Enable = 3;
3013  bool has_enable() const;
3014  void clear_enable();
3015  static const int kEnableFieldNumber = 3;
3016  private:
3017  const ::generated::zpb::hellomalif::StdCmds_Enable_Out& _internal_enable() const;
3018  public:
3019  const ::generated::zpb::hellomalif::StdCmds_Enable_Out& enable() const;
3020  ::generated::zpb::hellomalif::StdCmds_Enable_Out* release_enable();
3021  ::generated::zpb::hellomalif::StdCmds_Enable_Out* mutable_enable();
3022  void set_allocated_enable(::generated::zpb::hellomalif::StdCmds_Enable_Out* enable);
3023 
3024  // optional .generated.zpb.hellomalif.StdCmds_Disable_Out Disable = 4;
3025  bool has_disable() const;
3026  void clear_disable();
3027  static const int kDisableFieldNumber = 4;
3028  private:
3029  const ::generated::zpb::hellomalif::StdCmds_Disable_Out& _internal_disable() const;
3030  public:
3031  const ::generated::zpb::hellomalif::StdCmds_Disable_Out& disable() const;
3032  ::generated::zpb::hellomalif::StdCmds_Disable_Out* release_disable();
3033  ::generated::zpb::hellomalif::StdCmds_Disable_Out* mutable_disable();
3034  void set_allocated_disable(::generated::zpb::hellomalif::StdCmds_Disable_Out* disable);
3035 
3036  // optional .generated.zpb.hellomalif.StdCmds_Status_Out Status = 5;
3037  bool has_status() const;
3038  void clear_status();
3039  static const int kStatusFieldNumber = 5;
3040  private:
3041  const ::generated::zpb::hellomalif::StdCmds_Status_Out& _internal_status() const;
3042  public:
3043  const ::generated::zpb::hellomalif::StdCmds_Status_Out& status() const;
3044  ::generated::zpb::hellomalif::StdCmds_Status_Out* release_status();
3045  ::generated::zpb::hellomalif::StdCmds_Status_Out* mutable_status();
3046  void set_allocated_status(::generated::zpb::hellomalif::StdCmds_Status_Out* status);
3047 
3048  // optional .generated.zpb.hellomalif.StdCmds_Config_Out Config = 6;
3049  bool has_config() const;
3050  void clear_config();
3051  static const int kConfigFieldNumber = 6;
3052  private:
3053  const ::generated::zpb::hellomalif::StdCmds_Config_Out& _internal_config() const;
3054  public:
3055  const ::generated::zpb::hellomalif::StdCmds_Config_Out& config() const;
3056  ::generated::zpb::hellomalif::StdCmds_Config_Out* release_config();
3057  ::generated::zpb::hellomalif::StdCmds_Config_Out* mutable_config();
3058  void set_allocated_config(::generated::zpb::hellomalif::StdCmds_Config_Out* config);
3059 
3060  // optional .generated.zpb.hellomalif.StdCmds_Stop_Out Stop = 7;
3061  bool has_stop() const;
3062  void clear_stop();
3063  static const int kStopFieldNumber = 7;
3064  private:
3065  const ::generated::zpb::hellomalif::StdCmds_Stop_Out& _internal_stop() const;
3066  public:
3067  const ::generated::zpb::hellomalif::StdCmds_Stop_Out& stop() const;
3068  ::generated::zpb::hellomalif::StdCmds_Stop_Out* release_stop();
3069  ::generated::zpb::hellomalif::StdCmds_Stop_Out* mutable_stop();
3070  void set_allocated_stop(::generated::zpb::hellomalif::StdCmds_Stop_Out* stop);
3071 
3072  // optional .generated.zpb.hellomalif.StdCmds_Exit_Out Exit = 8;
3073  bool has_exit() const;
3074  void clear_exit();
3075  static const int kExitFieldNumber = 8;
3076  private:
3077  const ::generated::zpb::hellomalif::StdCmds_Exit_Out& _internal_exit() const;
3078  public:
3079  const ::generated::zpb::hellomalif::StdCmds_Exit_Out& exit() const;
3080  ::generated::zpb::hellomalif::StdCmds_Exit_Out* release_exit();
3081  ::generated::zpb::hellomalif::StdCmds_Exit_Out* mutable_exit();
3082  void set_allocated_exit(::generated::zpb::hellomalif::StdCmds_Exit_Out* exit);
3083 
3084  // optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_Out SetLogLevel = 9;
3085  bool has_setloglevel() const;
3086  void clear_setloglevel();
3087  static const int kSetLogLevelFieldNumber = 9;
3088  private:
3089  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& _internal_setloglevel() const;
3090  public:
3091  const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& setloglevel() const;
3092  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* release_setloglevel();
3093  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* mutable_setloglevel();
3094  void set_allocated_setloglevel(::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* setloglevel);
3095 
3096  void clear_reply();
3097  ReplyCase reply_case() const;
3098  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Return)
3099  private:
3100  void set_has_init();
3101  void set_has_reset();
3102  void set_has_enable();
3103  void set_has_disable();
3104  void set_has_status();
3105  void set_has_config();
3106  void set_has_stop();
3107  void set_has_exit();
3108  void set_has_setloglevel();
3109 
3110  inline bool has_reply() const;
3111  inline void clear_has_reply();
3112 
3113  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3114  ::google::protobuf::internal::HasBits<1> _has_bits_;
3115  mutable ::google::protobuf::internal::CachedSize _cached_size_;
3116  union ReplyUnion {
3117  ReplyUnion() {}
3118  ::generated::zpb::hellomalif::StdCmds_Init_Out* init_;
3119  ::generated::zpb::hellomalif::StdCmds_Reset_Out* reset_;
3120  ::generated::zpb::hellomalif::StdCmds_Enable_Out* enable_;
3121  ::generated::zpb::hellomalif::StdCmds_Disable_Out* disable_;
3122  ::generated::zpb::hellomalif::StdCmds_Status_Out* status_;
3123  ::generated::zpb::hellomalif::StdCmds_Config_Out* config_;
3124  ::generated::zpb::hellomalif::StdCmds_Stop_Out* stop_;
3125  ::generated::zpb::hellomalif::StdCmds_Exit_Out* exit_;
3126  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* setloglevel_;
3127  } reply_;
3128  ::google::protobuf::uint32 _oneof_case_[1];
3129 
3130  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
3131 };
3132 // -------------------------------------------------------------------
3133 
3134 class StdCmds_Reply : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:generated.zpb.hellomalif.StdCmds_Reply) */ {
3135  public:
3136  StdCmds_Reply();
3137  virtual ~StdCmds_Reply();
3138 
3139  StdCmds_Reply(const StdCmds_Reply& from);
3140 
3141  inline StdCmds_Reply& operator=(const StdCmds_Reply& from) {
3142  CopyFrom(from);
3143  return *this;
3144  }
3145  #if LANG_CXX11
3146  StdCmds_Reply(StdCmds_Reply&& from) noexcept
3147  : StdCmds_Reply() {
3148  *this = ::std::move(from);
3149  }
3150 
3151  inline StdCmds_Reply& operator=(StdCmds_Reply&& from) noexcept {
3152  if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3153  if (this != &from) InternalSwap(&from);
3154  } else {
3155  CopyFrom(from);
3156  }
3157  return *this;
3158  }
3159  #endif
3160  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3161  return _internal_metadata_.unknown_fields();
3162  }
3163  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3164  return _internal_metadata_.mutable_unknown_fields();
3165  }
3166 
3167  static const ::google::protobuf::Descriptor* descriptor();
3168  static const StdCmds_Reply& default_instance();
3169 
3170  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3171  static inline const StdCmds_Reply* internal_default_instance() {
3172  return reinterpret_cast<const StdCmds_Reply*>(
3173  &_StdCmds_Reply_default_instance_);
3174  }
3175  static constexpr int kIndexInFileMessages =
3176  23;
3177 
3178  void Swap(StdCmds_Reply* other);
3179  friend void swap(StdCmds_Reply& a, StdCmds_Reply& b) {
3180  a.Swap(&b);
3181  }
3182 
3183  // implements Message ----------------------------------------------
3184 
3185  inline StdCmds_Reply* New() const final {
3186  return CreateMaybeMessage<StdCmds_Reply>(NULL);
3187  }
3188 
3189  StdCmds_Reply* New(::google::protobuf::Arena* arena) const final {
3190  return CreateMaybeMessage<StdCmds_Reply>(arena);
3191  }
3192  void CopyFrom(const ::google::protobuf::Message& from) final;
3193  void MergeFrom(const ::google::protobuf::Message& from) final;
3194  void CopyFrom(const StdCmds_Reply& from);
3195  void MergeFrom(const StdCmds_Reply& from);
3196  void Clear() final;
3197  bool IsInitialized() const final;
3198 
3199  size_t ByteSizeLong() const final;
3200  bool MergePartialFromCodedStream(
3201  ::google::protobuf::io::CodedInputStream* input) final;
3202  void SerializeWithCachedSizes(
3203  ::google::protobuf::io::CodedOutputStream* output) const final;
3204  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3205  bool deterministic, ::google::protobuf::uint8* target) const final;
3206  int GetCachedSize() const final { return _cached_size_.Get(); }
3207 
3208  private:
3209  void SharedCtor();
3210  void SharedDtor();
3211  void SetCachedSize(int size) const final;
3212  void InternalSwap(StdCmds_Reply* other);
3213  private:
3214  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3215  return NULL;
3216  }
3217  inline void* MaybeArenaPtr() const {
3218  return NULL;
3219  }
3220  public:
3221 
3222  ::google::protobuf::Metadata GetMetadata() const final;
3223 
3224  // nested types ----------------------------------------------------
3225 
3226  // accessors -------------------------------------------------------
3227 
3228  // required .elt.mal.zpb.rr.ReplyHeader header = 1;
3229  bool has_header() const;
3230  void clear_header();
3231  static const int kHeaderFieldNumber = 1;
3232  private:
3233  const ::elt::mal::zpb::rr::ReplyHeader& _internal_header() const;
3234  public:
3235  const ::elt::mal::zpb::rr::ReplyHeader& header() const;
3236  ::elt::mal::zpb::rr::ReplyHeader* release_header();
3237  ::elt::mal::zpb::rr::ReplyHeader* mutable_header();
3238  void set_allocated_header(::elt::mal::zpb::rr::ReplyHeader* header);
3239 
3240  // optional .generated.zpb.hellomalif.StdCmds_Return data = 2;
3241  bool has_data() const;
3242  void clear_data();
3243  static const int kDataFieldNumber = 2;
3244  private:
3245  const ::generated::zpb::hellomalif::StdCmds_Return& _internal_data() const;
3246  public:
3247  const ::generated::zpb::hellomalif::StdCmds_Return& data() const;
3248  ::generated::zpb::hellomalif::StdCmds_Return* release_data();
3249  ::generated::zpb::hellomalif::StdCmds_Return* mutable_data();
3250  void set_allocated_data(::generated::zpb::hellomalif::StdCmds_Return* data);
3251 
3252  // @@protoc_insertion_point(class_scope:generated.zpb.hellomalif.StdCmds_Reply)
3253  private:
3254  void set_has_header();
3255  void clear_has_header();
3256  void set_has_data();
3257  void clear_has_data();
3258 
3259  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3260  ::google::protobuf::internal::HasBits<1> _has_bits_;
3261  mutable ::google::protobuf::internal::CachedSize _cached_size_;
3262  ::elt::mal::zpb::rr::ReplyHeader* header_;
3263  ::generated::zpb::hellomalif::StdCmds_Return* data_;
3264  friend struct ::protobuf_hellomalif_2eproto::TableStruct;
3265 };
3266 // ===================================================================
3267 
3268 
3269 // ===================================================================
3270 
3271 #ifdef __GNUC__
3272  #pragma GCC diagnostic push
3273  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3274 #endif // __GNUC__
3275 // ExceptionErr
3276 
3277 // required string desc = 1;
3278 inline bool ExceptionErr::has_desc() const {
3279  return (_has_bits_[0] & 0x00000001u) != 0;
3280 }
3281 inline void ExceptionErr::set_has_desc() {
3282  _has_bits_[0] |= 0x00000001u;
3283 }
3284 inline void ExceptionErr::clear_has_desc() {
3285  _has_bits_[0] &= ~0x00000001u;
3286 }
3287 inline void ExceptionErr::clear_desc() {
3288  desc_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3289  clear_has_desc();
3290 }
3291 inline const ::std::string& ExceptionErr::desc() const {
3292  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.ExceptionErr.desc)
3293  return desc_.GetNoArena();
3294 }
3295 inline void ExceptionErr::set_desc(const ::std::string& value) {
3296  set_has_desc();
3297  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3298  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.ExceptionErr.desc)
3299 }
3300 #if LANG_CXX11
3301 inline void ExceptionErr::set_desc(::std::string&& value) {
3302  set_has_desc();
3303  desc_.SetNoArena(
3304  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3305  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.ExceptionErr.desc)
3306 }
3307 #endif
3308 inline void ExceptionErr::set_desc(const char* value) {
3309  GOOGLE_DCHECK(value != NULL);
3310  set_has_desc();
3311  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3312  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.ExceptionErr.desc)
3313 }
3314 inline void ExceptionErr::set_desc(const char* value, size_t size) {
3315  set_has_desc();
3316  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3317  ::std::string(reinterpret_cast<const char*>(value), size));
3318  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.ExceptionErr.desc)
3319 }
3320 inline ::std::string* ExceptionErr::mutable_desc() {
3321  set_has_desc();
3322  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.ExceptionErr.desc)
3323  return desc_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3324 }
3325 inline ::std::string* ExceptionErr::release_desc() {
3326  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.ExceptionErr.desc)
3327  if (!has_desc()) {
3328  return NULL;
3329  }
3330  clear_has_desc();
3331  return desc_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3332 }
3333 inline void ExceptionErr::set_allocated_desc(::std::string* desc) {
3334  if (desc != NULL) {
3335  set_has_desc();
3336  } else {
3337  clear_has_desc();
3338  }
3339  desc_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), desc);
3340  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.ExceptionErr.desc)
3341 }
3342 
3343 // -------------------------------------------------------------------
3344 
3345 // LogInfo
3346 
3347 // required string level = 1;
3348 inline bool LogInfo::has_level() const {
3349  return (_has_bits_[0] & 0x00000001u) != 0;
3350 }
3351 inline void LogInfo::set_has_level() {
3352  _has_bits_[0] |= 0x00000001u;
3353 }
3354 inline void LogInfo::clear_has_level() {
3355  _has_bits_[0] &= ~0x00000001u;
3356 }
3357 inline void LogInfo::clear_level() {
3358  level_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3359  clear_has_level();
3360 }
3361 inline const ::std::string& LogInfo::level() const {
3362  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.LogInfo.level)
3363  return level_.GetNoArena();
3364 }
3365 inline void LogInfo::set_level(const ::std::string& value) {
3366  set_has_level();
3367  level_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3368  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.LogInfo.level)
3369 }
3370 #if LANG_CXX11
3371 inline void LogInfo::set_level(::std::string&& value) {
3372  set_has_level();
3373  level_.SetNoArena(
3374  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3375  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.LogInfo.level)
3376 }
3377 #endif
3378 inline void LogInfo::set_level(const char* value) {
3379  GOOGLE_DCHECK(value != NULL);
3380  set_has_level();
3381  level_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3382  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.LogInfo.level)
3383 }
3384 inline void LogInfo::set_level(const char* value, size_t size) {
3385  set_has_level();
3386  level_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3387  ::std::string(reinterpret_cast<const char*>(value), size));
3388  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.LogInfo.level)
3389 }
3390 inline ::std::string* LogInfo::mutable_level() {
3391  set_has_level();
3392  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.LogInfo.level)
3393  return level_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3394 }
3395 inline ::std::string* LogInfo::release_level() {
3396  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.LogInfo.level)
3397  if (!has_level()) {
3398  return NULL;
3399  }
3400  clear_has_level();
3401  return level_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3402 }
3403 inline void LogInfo::set_allocated_level(::std::string* level) {
3404  if (level != NULL) {
3405  set_has_level();
3406  } else {
3407  clear_has_level();
3408  }
3409  level_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), level);
3410  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.LogInfo.level)
3411 }
3412 
3413 // required string logger = 2;
3414 inline bool LogInfo::has_logger() const {
3415  return (_has_bits_[0] & 0x00000002u) != 0;
3416 }
3417 inline void LogInfo::set_has_logger() {
3418  _has_bits_[0] |= 0x00000002u;
3419 }
3420 inline void LogInfo::clear_has_logger() {
3421  _has_bits_[0] &= ~0x00000002u;
3422 }
3423 inline void LogInfo::clear_logger() {
3424  logger_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3425  clear_has_logger();
3426 }
3427 inline const ::std::string& LogInfo::logger() const {
3428  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.LogInfo.logger)
3429  return logger_.GetNoArena();
3430 }
3431 inline void LogInfo::set_logger(const ::std::string& value) {
3432  set_has_logger();
3433  logger_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3434  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.LogInfo.logger)
3435 }
3436 #if LANG_CXX11
3437 inline void LogInfo::set_logger(::std::string&& value) {
3438  set_has_logger();
3439  logger_.SetNoArena(
3440  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3441  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.LogInfo.logger)
3442 }
3443 #endif
3444 inline void LogInfo::set_logger(const char* value) {
3445  GOOGLE_DCHECK(value != NULL);
3446  set_has_logger();
3447  logger_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3448  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.LogInfo.logger)
3449 }
3450 inline void LogInfo::set_logger(const char* value, size_t size) {
3451  set_has_logger();
3452  logger_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3453  ::std::string(reinterpret_cast<const char*>(value), size));
3454  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.LogInfo.logger)
3455 }
3456 inline ::std::string* LogInfo::mutable_logger() {
3457  set_has_logger();
3458  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.LogInfo.logger)
3459  return logger_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3460 }
3461 inline ::std::string* LogInfo::release_logger() {
3462  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.LogInfo.logger)
3463  if (!has_logger()) {
3464  return NULL;
3465  }
3466  clear_has_logger();
3467  return logger_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3468 }
3469 inline void LogInfo::set_allocated_logger(::std::string* logger) {
3470  if (logger != NULL) {
3471  set_has_logger();
3472  } else {
3473  clear_has_logger();
3474  }
3475  logger_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), logger);
3476  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.LogInfo.logger)
3477 }
3478 
3479 // -------------------------------------------------------------------
3480 
3481 // StdCmds_Init_In
3482 
3483 // -------------------------------------------------------------------
3484 
3485 // StdCmds_Reset_In
3486 
3487 // -------------------------------------------------------------------
3488 
3489 // StdCmds_Enable_In
3490 
3491 // -------------------------------------------------------------------
3492 
3493 // StdCmds_Disable_In
3494 
3495 // -------------------------------------------------------------------
3496 
3497 // StdCmds_Status_In
3498 
3499 // -------------------------------------------------------------------
3500 
3501 // StdCmds_Config_In
3502 
3503 // -------------------------------------------------------------------
3504 
3505 // StdCmds_Stop_In
3506 
3507 // -------------------------------------------------------------------
3508 
3509 // StdCmds_Exit_In
3510 
3511 // -------------------------------------------------------------------
3512 
3513 // StdCmds_SetLogLevel_In
3514 
3515 // required .generated.zpb.hellomalif.LogInfo info = 1;
3516 inline bool StdCmds_SetLogLevel_In::has_info() const {
3517  return (_has_bits_[0] & 0x00000001u) != 0;
3518 }
3519 inline void StdCmds_SetLogLevel_In::set_has_info() {
3520  _has_bits_[0] |= 0x00000001u;
3521 }
3522 inline void StdCmds_SetLogLevel_In::clear_has_info() {
3523  _has_bits_[0] &= ~0x00000001u;
3524 }
3525 inline void StdCmds_SetLogLevel_In::clear_info() {
3526  if (info_ != NULL) info_->Clear();
3527  clear_has_info();
3528 }
3529 inline const ::generated::zpb::hellomalif::LogInfo& StdCmds_SetLogLevel_In::_internal_info() const {
3530  return *info_;
3531 }
3532 inline const ::generated::zpb::hellomalif::LogInfo& StdCmds_SetLogLevel_In::info() const {
3533  const ::generated::zpb::hellomalif::LogInfo* p = info_;
3534  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
3535  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::LogInfo*>(
3536  &::generated::zpb::hellomalif::_LogInfo_default_instance_);
3537 }
3538 inline ::generated::zpb::hellomalif::LogInfo* StdCmds_SetLogLevel_In::release_info() {
3539  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
3540  clear_has_info();
3541  ::generated::zpb::hellomalif::LogInfo* temp = info_;
3542  info_ = NULL;
3543  return temp;
3544 }
3545 inline ::generated::zpb::hellomalif::LogInfo* StdCmds_SetLogLevel_In::mutable_info() {
3546  set_has_info();
3547  if (info_ == NULL) {
3548  auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::LogInfo>(GetArenaNoVirtual());
3549  info_ = p;
3550  }
3551  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
3552  return info_;
3553 }
3554 inline void StdCmds_SetLogLevel_In::set_allocated_info(::generated::zpb::hellomalif::LogInfo* info) {
3555  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3556  if (message_arena == NULL) {
3557  delete info_;
3558  }
3559  if (info) {
3560  ::google::protobuf::Arena* submessage_arena = NULL;
3561  if (message_arena != submessage_arena) {
3562  info = ::google::protobuf::internal::GetOwnedMessage(
3563  message_arena, info, submessage_arena);
3564  }
3565  set_has_info();
3566  } else {
3567  clear_has_info();
3568  }
3569  info_ = info;
3570  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_SetLogLevel_In.info)
3571 }
3572 
3573 // -------------------------------------------------------------------
3574 
3575 // StdCmds_Call
3576 
3577 // optional .generated.zpb.hellomalif.StdCmds_Init_In Init = 1;
3578 inline bool StdCmds_Call::has_init() const {
3579  return request_case() == kInit;
3580 }
3581 inline void StdCmds_Call::set_has_init() {
3582  _oneof_case_[0] = kInit;
3583 }
3584 inline void StdCmds_Call::clear_init() {
3585  if (has_init()) {
3586  delete request_.init_;
3587  clear_has_request();
3588  }
3589 }
3590 inline const ::generated::zpb::hellomalif::StdCmds_Init_In& StdCmds_Call::_internal_init() const {
3591  return *request_.init_;
3592 }
3593 inline ::generated::zpb::hellomalif::StdCmds_Init_In* StdCmds_Call::release_init() {
3594  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Init)
3595  if (has_init()) {
3596  clear_has_request();
3597  ::generated::zpb::hellomalif::StdCmds_Init_In* temp = request_.init_;
3598  request_.init_ = NULL;
3599  return temp;
3600  } else {
3601  return NULL;
3602  }
3603 }
3604 inline const ::generated::zpb::hellomalif::StdCmds_Init_In& StdCmds_Call::init() const {
3605  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Init)
3606  return has_init()
3607  ? *request_.init_
3608  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Init_In*>(&::generated::zpb::hellomalif::_StdCmds_Init_In_default_instance_);
3609 }
3610 inline ::generated::zpb::hellomalif::StdCmds_Init_In* StdCmds_Call::mutable_init() {
3611  if (!has_init()) {
3612  clear_request();
3613  set_has_init();
3614  request_.init_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Init_In >(
3615  GetArenaNoVirtual());
3616  }
3617  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Init)
3618  return request_.init_;
3619 }
3620 
3621 // optional .generated.zpb.hellomalif.StdCmds_Reset_In Reset = 2;
3622 inline bool StdCmds_Call::has_reset() const {
3623  return request_case() == kReset;
3624 }
3625 inline void StdCmds_Call::set_has_reset() {
3626  _oneof_case_[0] = kReset;
3627 }
3628 inline void StdCmds_Call::clear_reset() {
3629  if (has_reset()) {
3630  delete request_.reset_;
3631  clear_has_request();
3632  }
3633 }
3634 inline const ::generated::zpb::hellomalif::StdCmds_Reset_In& StdCmds_Call::_internal_reset() const {
3635  return *request_.reset_;
3636 }
3637 inline ::generated::zpb::hellomalif::StdCmds_Reset_In* StdCmds_Call::release_reset() {
3638  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Reset)
3639  if (has_reset()) {
3640  clear_has_request();
3641  ::generated::zpb::hellomalif::StdCmds_Reset_In* temp = request_.reset_;
3642  request_.reset_ = NULL;
3643  return temp;
3644  } else {
3645  return NULL;
3646  }
3647 }
3648 inline const ::generated::zpb::hellomalif::StdCmds_Reset_In& StdCmds_Call::reset() const {
3649  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Reset)
3650  return has_reset()
3651  ? *request_.reset_
3652  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Reset_In*>(&::generated::zpb::hellomalif::_StdCmds_Reset_In_default_instance_);
3653 }
3654 inline ::generated::zpb::hellomalif::StdCmds_Reset_In* StdCmds_Call::mutable_reset() {
3655  if (!has_reset()) {
3656  clear_request();
3657  set_has_reset();
3658  request_.reset_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Reset_In >(
3659  GetArenaNoVirtual());
3660  }
3661  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Reset)
3662  return request_.reset_;
3663 }
3664 
3665 // optional .generated.zpb.hellomalif.StdCmds_Enable_In Enable = 3;
3666 inline bool StdCmds_Call::has_enable() const {
3667  return request_case() == kEnable;
3668 }
3669 inline void StdCmds_Call::set_has_enable() {
3670  _oneof_case_[0] = kEnable;
3671 }
3672 inline void StdCmds_Call::clear_enable() {
3673  if (has_enable()) {
3674  delete request_.enable_;
3675  clear_has_request();
3676  }
3677 }
3678 inline const ::generated::zpb::hellomalif::StdCmds_Enable_In& StdCmds_Call::_internal_enable() const {
3679  return *request_.enable_;
3680 }
3681 inline ::generated::zpb::hellomalif::StdCmds_Enable_In* StdCmds_Call::release_enable() {
3682  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Enable)
3683  if (has_enable()) {
3684  clear_has_request();
3685  ::generated::zpb::hellomalif::StdCmds_Enable_In* temp = request_.enable_;
3686  request_.enable_ = NULL;
3687  return temp;
3688  } else {
3689  return NULL;
3690  }
3691 }
3692 inline const ::generated::zpb::hellomalif::StdCmds_Enable_In& StdCmds_Call::enable() const {
3693  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Enable)
3694  return has_enable()
3695  ? *request_.enable_
3696  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Enable_In*>(&::generated::zpb::hellomalif::_StdCmds_Enable_In_default_instance_);
3697 }
3698 inline ::generated::zpb::hellomalif::StdCmds_Enable_In* StdCmds_Call::mutable_enable() {
3699  if (!has_enable()) {
3700  clear_request();
3701  set_has_enable();
3702  request_.enable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Enable_In >(
3703  GetArenaNoVirtual());
3704  }
3705  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Enable)
3706  return request_.enable_;
3707 }
3708 
3709 // optional .generated.zpb.hellomalif.StdCmds_Disable_In Disable = 4;
3710 inline bool StdCmds_Call::has_disable() const {
3711  return request_case() == kDisable;
3712 }
3713 inline void StdCmds_Call::set_has_disable() {
3714  _oneof_case_[0] = kDisable;
3715 }
3716 inline void StdCmds_Call::clear_disable() {
3717  if (has_disable()) {
3718  delete request_.disable_;
3719  clear_has_request();
3720  }
3721 }
3722 inline const ::generated::zpb::hellomalif::StdCmds_Disable_In& StdCmds_Call::_internal_disable() const {
3723  return *request_.disable_;
3724 }
3725 inline ::generated::zpb::hellomalif::StdCmds_Disable_In* StdCmds_Call::release_disable() {
3726  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Disable)
3727  if (has_disable()) {
3728  clear_has_request();
3729  ::generated::zpb::hellomalif::StdCmds_Disable_In* temp = request_.disable_;
3730  request_.disable_ = NULL;
3731  return temp;
3732  } else {
3733  return NULL;
3734  }
3735 }
3736 inline const ::generated::zpb::hellomalif::StdCmds_Disable_In& StdCmds_Call::disable() const {
3737  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Disable)
3738  return has_disable()
3739  ? *request_.disable_
3740  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Disable_In*>(&::generated::zpb::hellomalif::_StdCmds_Disable_In_default_instance_);
3741 }
3742 inline ::generated::zpb::hellomalif::StdCmds_Disable_In* StdCmds_Call::mutable_disable() {
3743  if (!has_disable()) {
3744  clear_request();
3745  set_has_disable();
3746  request_.disable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Disable_In >(
3747  GetArenaNoVirtual());
3748  }
3749  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Disable)
3750  return request_.disable_;
3751 }
3752 
3753 // optional .generated.zpb.hellomalif.StdCmds_Status_In Status = 5;
3754 inline bool StdCmds_Call::has_status() const {
3755  return request_case() == kStatus;
3756 }
3757 inline void StdCmds_Call::set_has_status() {
3758  _oneof_case_[0] = kStatus;
3759 }
3760 inline void StdCmds_Call::clear_status() {
3761  if (has_status()) {
3762  delete request_.status_;
3763  clear_has_request();
3764  }
3765 }
3766 inline const ::generated::zpb::hellomalif::StdCmds_Status_In& StdCmds_Call::_internal_status() const {
3767  return *request_.status_;
3768 }
3769 inline ::generated::zpb::hellomalif::StdCmds_Status_In* StdCmds_Call::release_status() {
3770  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Status)
3771  if (has_status()) {
3772  clear_has_request();
3773  ::generated::zpb::hellomalif::StdCmds_Status_In* temp = request_.status_;
3774  request_.status_ = NULL;
3775  return temp;
3776  } else {
3777  return NULL;
3778  }
3779 }
3780 inline const ::generated::zpb::hellomalif::StdCmds_Status_In& StdCmds_Call::status() const {
3781  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Status)
3782  return has_status()
3783  ? *request_.status_
3784  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Status_In*>(&::generated::zpb::hellomalif::_StdCmds_Status_In_default_instance_);
3785 }
3786 inline ::generated::zpb::hellomalif::StdCmds_Status_In* StdCmds_Call::mutable_status() {
3787  if (!has_status()) {
3788  clear_request();
3789  set_has_status();
3790  request_.status_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Status_In >(
3791  GetArenaNoVirtual());
3792  }
3793  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Status)
3794  return request_.status_;
3795 }
3796 
3797 // optional .generated.zpb.hellomalif.StdCmds_Config_In Config = 6;
3798 inline bool StdCmds_Call::has_config() const {
3799  return request_case() == kConfig;
3800 }
3801 inline void StdCmds_Call::set_has_config() {
3802  _oneof_case_[0] = kConfig;
3803 }
3804 inline void StdCmds_Call::clear_config() {
3805  if (has_config()) {
3806  delete request_.config_;
3807  clear_has_request();
3808  }
3809 }
3810 inline const ::generated::zpb::hellomalif::StdCmds_Config_In& StdCmds_Call::_internal_config() const {
3811  return *request_.config_;
3812 }
3813 inline ::generated::zpb::hellomalif::StdCmds_Config_In* StdCmds_Call::release_config() {
3814  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Config)
3815  if (has_config()) {
3816  clear_has_request();
3817  ::generated::zpb::hellomalif::StdCmds_Config_In* temp = request_.config_;
3818  request_.config_ = NULL;
3819  return temp;
3820  } else {
3821  return NULL;
3822  }
3823 }
3824 inline const ::generated::zpb::hellomalif::StdCmds_Config_In& StdCmds_Call::config() const {
3825  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Config)
3826  return has_config()
3827  ? *request_.config_
3828  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Config_In*>(&::generated::zpb::hellomalif::_StdCmds_Config_In_default_instance_);
3829 }
3830 inline ::generated::zpb::hellomalif::StdCmds_Config_In* StdCmds_Call::mutable_config() {
3831  if (!has_config()) {
3832  clear_request();
3833  set_has_config();
3834  request_.config_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Config_In >(
3835  GetArenaNoVirtual());
3836  }
3837  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Config)
3838  return request_.config_;
3839 }
3840 
3841 // optional .generated.zpb.hellomalif.StdCmds_Stop_In Stop = 7;
3842 inline bool StdCmds_Call::has_stop() const {
3843  return request_case() == kStop;
3844 }
3845 inline void StdCmds_Call::set_has_stop() {
3846  _oneof_case_[0] = kStop;
3847 }
3848 inline void StdCmds_Call::clear_stop() {
3849  if (has_stop()) {
3850  delete request_.stop_;
3851  clear_has_request();
3852  }
3853 }
3854 inline const ::generated::zpb::hellomalif::StdCmds_Stop_In& StdCmds_Call::_internal_stop() const {
3855  return *request_.stop_;
3856 }
3857 inline ::generated::zpb::hellomalif::StdCmds_Stop_In* StdCmds_Call::release_stop() {
3858  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Stop)
3859  if (has_stop()) {
3860  clear_has_request();
3861  ::generated::zpb::hellomalif::StdCmds_Stop_In* temp = request_.stop_;
3862  request_.stop_ = NULL;
3863  return temp;
3864  } else {
3865  return NULL;
3866  }
3867 }
3868 inline const ::generated::zpb::hellomalif::StdCmds_Stop_In& StdCmds_Call::stop() const {
3869  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Stop)
3870  return has_stop()
3871  ? *request_.stop_
3872  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Stop_In*>(&::generated::zpb::hellomalif::_StdCmds_Stop_In_default_instance_);
3873 }
3874 inline ::generated::zpb::hellomalif::StdCmds_Stop_In* StdCmds_Call::mutable_stop() {
3875  if (!has_stop()) {
3876  clear_request();
3877  set_has_stop();
3878  request_.stop_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Stop_In >(
3879  GetArenaNoVirtual());
3880  }
3881  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Stop)
3882  return request_.stop_;
3883 }
3884 
3885 // optional .generated.zpb.hellomalif.StdCmds_Exit_In Exit = 8;
3886 inline bool StdCmds_Call::has_exit() const {
3887  return request_case() == kExit;
3888 }
3889 inline void StdCmds_Call::set_has_exit() {
3890  _oneof_case_[0] = kExit;
3891 }
3892 inline void StdCmds_Call::clear_exit() {
3893  if (has_exit()) {
3894  delete request_.exit_;
3895  clear_has_request();
3896  }
3897 }
3898 inline const ::generated::zpb::hellomalif::StdCmds_Exit_In& StdCmds_Call::_internal_exit() const {
3899  return *request_.exit_;
3900 }
3901 inline ::generated::zpb::hellomalif::StdCmds_Exit_In* StdCmds_Call::release_exit() {
3902  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.Exit)
3903  if (has_exit()) {
3904  clear_has_request();
3905  ::generated::zpb::hellomalif::StdCmds_Exit_In* temp = request_.exit_;
3906  request_.exit_ = NULL;
3907  return temp;
3908  } else {
3909  return NULL;
3910  }
3911 }
3912 inline const ::generated::zpb::hellomalif::StdCmds_Exit_In& StdCmds_Call::exit() const {
3913  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.Exit)
3914  return has_exit()
3915  ? *request_.exit_
3916  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Exit_In*>(&::generated::zpb::hellomalif::_StdCmds_Exit_In_default_instance_);
3917 }
3918 inline ::generated::zpb::hellomalif::StdCmds_Exit_In* StdCmds_Call::mutable_exit() {
3919  if (!has_exit()) {
3920  clear_request();
3921  set_has_exit();
3922  request_.exit_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Exit_In >(
3923  GetArenaNoVirtual());
3924  }
3925  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.Exit)
3926  return request_.exit_;
3927 }
3928 
3929 // optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_In SetLogLevel = 9;
3930 inline bool StdCmds_Call::has_setloglevel() const {
3931  return request_case() == kSetLogLevel;
3932 }
3933 inline void StdCmds_Call::set_has_setloglevel() {
3934  _oneof_case_[0] = kSetLogLevel;
3935 }
3936 inline void StdCmds_Call::clear_setloglevel() {
3937  if (has_setloglevel()) {
3938  delete request_.setloglevel_;
3939  clear_has_request();
3940  }
3941 }
3942 inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& StdCmds_Call::_internal_setloglevel() const {
3943  return *request_.setloglevel_;
3944 }
3945 inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* StdCmds_Call::release_setloglevel() {
3946  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Call.SetLogLevel)
3947  if (has_setloglevel()) {
3948  clear_has_request();
3949  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* temp = request_.setloglevel_;
3950  request_.setloglevel_ = NULL;
3951  return temp;
3952  } else {
3953  return NULL;
3954  }
3955 }
3956 inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In& StdCmds_Call::setloglevel() const {
3957  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Call.SetLogLevel)
3958  return has_setloglevel()
3959  ? *request_.setloglevel_
3960  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In*>(&::generated::zpb::hellomalif::_StdCmds_SetLogLevel_In_default_instance_);
3961 }
3962 inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In* StdCmds_Call::mutable_setloglevel() {
3963  if (!has_setloglevel()) {
3964  clear_request();
3965  set_has_setloglevel();
3966  request_.setloglevel_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In >(
3967  GetArenaNoVirtual());
3968  }
3969  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Call.SetLogLevel)
3970  return request_.setloglevel_;
3971 }
3972 
3973 inline bool StdCmds_Call::has_request() const {
3974  return request_case() != REQUEST_NOT_SET;
3975 }
3976 inline void StdCmds_Call::clear_has_request() {
3977  _oneof_case_[0] = REQUEST_NOT_SET;
3978 }
3979 inline StdCmds_Call::RequestCase StdCmds_Call::request_case() const {
3980  return StdCmds_Call::RequestCase(_oneof_case_[0]);
3981 }
3982 // -------------------------------------------------------------------
3983 
3984 // StdCmds_Request
3985 
3986 // required .elt.mal.zpb.rr.RequestHeader header = 1;
3987 inline bool StdCmds_Request::has_header() const {
3988  return (_has_bits_[0] & 0x00000001u) != 0;
3989 }
3990 inline void StdCmds_Request::set_has_header() {
3991  _has_bits_[0] |= 0x00000001u;
3992 }
3993 inline void StdCmds_Request::clear_has_header() {
3994  _has_bits_[0] &= ~0x00000001u;
3995 }
3996 inline const ::elt::mal::zpb::rr::RequestHeader& StdCmds_Request::_internal_header() const {
3997  return *header_;
3998 }
3999 inline const ::elt::mal::zpb::rr::RequestHeader& StdCmds_Request::header() const {
4000  const ::elt::mal::zpb::rr::RequestHeader* p = header_;
4001  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Request.header)
4002  return p != NULL ? *p : *reinterpret_cast<const ::elt::mal::zpb::rr::RequestHeader*>(
4003  &::elt::mal::zpb::rr::_RequestHeader_default_instance_);
4004 }
4005 inline ::elt::mal::zpb::rr::RequestHeader* StdCmds_Request::release_header() {
4006  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Request.header)
4007  clear_has_header();
4008  ::elt::mal::zpb::rr::RequestHeader* temp = header_;
4009  header_ = NULL;
4010  return temp;
4011 }
4012 inline ::elt::mal::zpb::rr::RequestHeader* StdCmds_Request::mutable_header() {
4013  set_has_header();
4014  if (header_ == NULL) {
4015  auto* p = CreateMaybeMessage<::elt::mal::zpb::rr::RequestHeader>(GetArenaNoVirtual());
4016  header_ = p;
4017  }
4018  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Request.header)
4019  return header_;
4020 }
4021 inline void StdCmds_Request::set_allocated_header(::elt::mal::zpb::rr::RequestHeader* header) {
4022  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4023  if (message_arena == NULL) {
4024  delete reinterpret_cast< ::google::protobuf::MessageLite*>(header_);
4025  }
4026  if (header) {
4027  ::google::protobuf::Arena* submessage_arena = NULL;
4028  if (message_arena != submessage_arena) {
4029  header = ::google::protobuf::internal::GetOwnedMessage(
4030  message_arena, header, submessage_arena);
4031  }
4032  set_has_header();
4033  } else {
4034  clear_has_header();
4035  }
4036  header_ = header;
4037  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Request.header)
4038 }
4039 
4040 // required .generated.zpb.hellomalif.StdCmds_Call data = 2;
4041 inline bool StdCmds_Request::has_data() const {
4042  return (_has_bits_[0] & 0x00000002u) != 0;
4043 }
4044 inline void StdCmds_Request::set_has_data() {
4045  _has_bits_[0] |= 0x00000002u;
4046 }
4047 inline void StdCmds_Request::clear_has_data() {
4048  _has_bits_[0] &= ~0x00000002u;
4049 }
4050 inline void StdCmds_Request::clear_data() {
4051  if (data_ != NULL) data_->Clear();
4052  clear_has_data();
4053 }
4054 inline const ::generated::zpb::hellomalif::StdCmds_Call& StdCmds_Request::_internal_data() const {
4055  return *data_;
4056 }
4057 inline const ::generated::zpb::hellomalif::StdCmds_Call& StdCmds_Request::data() const {
4058  const ::generated::zpb::hellomalif::StdCmds_Call* p = data_;
4059  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Request.data)
4060  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::StdCmds_Call*>(
4061  &::generated::zpb::hellomalif::_StdCmds_Call_default_instance_);
4062 }
4063 inline ::generated::zpb::hellomalif::StdCmds_Call* StdCmds_Request::release_data() {
4064  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Request.data)
4065  clear_has_data();
4066  ::generated::zpb::hellomalif::StdCmds_Call* temp = data_;
4067  data_ = NULL;
4068  return temp;
4069 }
4070 inline ::generated::zpb::hellomalif::StdCmds_Call* StdCmds_Request::mutable_data() {
4071  set_has_data();
4072  if (data_ == NULL) {
4073  auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Call>(GetArenaNoVirtual());
4074  data_ = p;
4075  }
4076  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Request.data)
4077  return data_;
4078 }
4079 inline void StdCmds_Request::set_allocated_data(::generated::zpb::hellomalif::StdCmds_Call* data) {
4080  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4081  if (message_arena == NULL) {
4082  delete data_;
4083  }
4084  if (data) {
4085  ::google::protobuf::Arena* submessage_arena = NULL;
4086  if (message_arena != submessage_arena) {
4087  data = ::google::protobuf::internal::GetOwnedMessage(
4088  message_arena, data, submessage_arena);
4089  }
4090  set_has_data();
4091  } else {
4092  clear_has_data();
4093  }
4094  data_ = data;
4095  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Request.data)
4096 }
4097 
4098 // -------------------------------------------------------------------
4099 
4100 // StdCmds_Init_Out
4101 
4102 // required string retval = 1;
4103 inline bool StdCmds_Init_Out::has_retval() const {
4104  return (_has_bits_[0] & 0x00000001u) != 0;
4105 }
4106 inline void StdCmds_Init_Out::set_has_retval() {
4107  _has_bits_[0] |= 0x00000001u;
4108 }
4109 inline void StdCmds_Init_Out::clear_has_retval() {
4110  _has_bits_[0] &= ~0x00000001u;
4111 }
4112 inline void StdCmds_Init_Out::clear_retval() {
4113  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4114  clear_has_retval();
4115 }
4116 inline const ::std::string& StdCmds_Init_Out::retval() const {
4117  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4118  return retval_.GetNoArena();
4119 }
4120 inline void StdCmds_Init_Out::set_retval(const ::std::string& value) {
4121  set_has_retval();
4122  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4123  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4124 }
4125 #if LANG_CXX11
4126 inline void StdCmds_Init_Out::set_retval(::std::string&& value) {
4127  set_has_retval();
4128  retval_.SetNoArena(
4129  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4130  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4131 }
4132 #endif
4133 inline void StdCmds_Init_Out::set_retval(const char* value) {
4134  GOOGLE_DCHECK(value != NULL);
4135  set_has_retval();
4136  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4137  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4138 }
4139 inline void StdCmds_Init_Out::set_retval(const char* value, size_t size) {
4140  set_has_retval();
4141  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4142  ::std::string(reinterpret_cast<const char*>(value), size));
4143  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4144 }
4145 inline ::std::string* StdCmds_Init_Out::mutable_retval() {
4146  set_has_retval();
4147  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4148  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4149 }
4150 inline ::std::string* StdCmds_Init_Out::release_retval() {
4151  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4152  if (!has_retval()) {
4153  return NULL;
4154  }
4155  clear_has_retval();
4156  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4157 }
4158 inline void StdCmds_Init_Out::set_allocated_retval(::std::string* retval) {
4159  if (retval != NULL) {
4160  set_has_retval();
4161  } else {
4162  clear_has_retval();
4163  }
4164  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4165  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Init_Out.retval)
4166 }
4167 
4168 // -------------------------------------------------------------------
4169 
4170 // StdCmds_Reset_Out
4171 
4172 // required string retval = 1;
4173 inline bool StdCmds_Reset_Out::has_retval() const {
4174  return (_has_bits_[0] & 0x00000001u) != 0;
4175 }
4176 inline void StdCmds_Reset_Out::set_has_retval() {
4177  _has_bits_[0] |= 0x00000001u;
4178 }
4179 inline void StdCmds_Reset_Out::clear_has_retval() {
4180  _has_bits_[0] &= ~0x00000001u;
4181 }
4182 inline void StdCmds_Reset_Out::clear_retval() {
4183  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4184  clear_has_retval();
4185 }
4186 inline const ::std::string& StdCmds_Reset_Out::retval() const {
4187  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4188  return retval_.GetNoArena();
4189 }
4190 inline void StdCmds_Reset_Out::set_retval(const ::std::string& value) {
4191  set_has_retval();
4192  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4193  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4194 }
4195 #if LANG_CXX11
4196 inline void StdCmds_Reset_Out::set_retval(::std::string&& value) {
4197  set_has_retval();
4198  retval_.SetNoArena(
4199  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4200  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4201 }
4202 #endif
4203 inline void StdCmds_Reset_Out::set_retval(const char* value) {
4204  GOOGLE_DCHECK(value != NULL);
4205  set_has_retval();
4206  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4207  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4208 }
4209 inline void StdCmds_Reset_Out::set_retval(const char* value, size_t size) {
4210  set_has_retval();
4211  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4212  ::std::string(reinterpret_cast<const char*>(value), size));
4213  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4214 }
4215 inline ::std::string* StdCmds_Reset_Out::mutable_retval() {
4216  set_has_retval();
4217  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4218  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4219 }
4220 inline ::std::string* StdCmds_Reset_Out::release_retval() {
4221  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4222  if (!has_retval()) {
4223  return NULL;
4224  }
4225  clear_has_retval();
4226  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4227 }
4228 inline void StdCmds_Reset_Out::set_allocated_retval(::std::string* retval) {
4229  if (retval != NULL) {
4230  set_has_retval();
4231  } else {
4232  clear_has_retval();
4233  }
4234  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4235  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reset_Out.retval)
4236 }
4237 
4238 // -------------------------------------------------------------------
4239 
4240 // StdCmds_Enable_Out
4241 
4242 // required string retval = 1;
4243 inline bool StdCmds_Enable_Out::has_retval() const {
4244  return (_has_bits_[0] & 0x00000001u) != 0;
4245 }
4246 inline void StdCmds_Enable_Out::set_has_retval() {
4247  _has_bits_[0] |= 0x00000001u;
4248 }
4249 inline void StdCmds_Enable_Out::clear_has_retval() {
4250  _has_bits_[0] &= ~0x00000001u;
4251 }
4252 inline void StdCmds_Enable_Out::clear_retval() {
4253  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4254  clear_has_retval();
4255 }
4256 inline const ::std::string& StdCmds_Enable_Out::retval() const {
4257  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4258  return retval_.GetNoArena();
4259 }
4260 inline void StdCmds_Enable_Out::set_retval(const ::std::string& value) {
4261  set_has_retval();
4262  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4263  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4264 }
4265 #if LANG_CXX11
4266 inline void StdCmds_Enable_Out::set_retval(::std::string&& value) {
4267  set_has_retval();
4268  retval_.SetNoArena(
4269  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4270  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4271 }
4272 #endif
4273 inline void StdCmds_Enable_Out::set_retval(const char* value) {
4274  GOOGLE_DCHECK(value != NULL);
4275  set_has_retval();
4276  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4277  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4278 }
4279 inline void StdCmds_Enable_Out::set_retval(const char* value, size_t size) {
4280  set_has_retval();
4281  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4282  ::std::string(reinterpret_cast<const char*>(value), size));
4283  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4284 }
4285 inline ::std::string* StdCmds_Enable_Out::mutable_retval() {
4286  set_has_retval();
4287  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4288  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4289 }
4290 inline ::std::string* StdCmds_Enable_Out::release_retval() {
4291  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4292  if (!has_retval()) {
4293  return NULL;
4294  }
4295  clear_has_retval();
4296  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4297 }
4298 inline void StdCmds_Enable_Out::set_allocated_retval(::std::string* retval) {
4299  if (retval != NULL) {
4300  set_has_retval();
4301  } else {
4302  clear_has_retval();
4303  }
4304  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4305  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Enable_Out.retval)
4306 }
4307 
4308 // -------------------------------------------------------------------
4309 
4310 // StdCmds_Disable_Out
4311 
4312 // required string retval = 1;
4313 inline bool StdCmds_Disable_Out::has_retval() const {
4314  return (_has_bits_[0] & 0x00000001u) != 0;
4315 }
4316 inline void StdCmds_Disable_Out::set_has_retval() {
4317  _has_bits_[0] |= 0x00000001u;
4318 }
4319 inline void StdCmds_Disable_Out::clear_has_retval() {
4320  _has_bits_[0] &= ~0x00000001u;
4321 }
4322 inline void StdCmds_Disable_Out::clear_retval() {
4323  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4324  clear_has_retval();
4325 }
4326 inline const ::std::string& StdCmds_Disable_Out::retval() const {
4327  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4328  return retval_.GetNoArena();
4329 }
4330 inline void StdCmds_Disable_Out::set_retval(const ::std::string& value) {
4331  set_has_retval();
4332  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4333  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4334 }
4335 #if LANG_CXX11
4336 inline void StdCmds_Disable_Out::set_retval(::std::string&& value) {
4337  set_has_retval();
4338  retval_.SetNoArena(
4339  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4340  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4341 }
4342 #endif
4343 inline void StdCmds_Disable_Out::set_retval(const char* value) {
4344  GOOGLE_DCHECK(value != NULL);
4345  set_has_retval();
4346  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4347  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4348 }
4349 inline void StdCmds_Disable_Out::set_retval(const char* value, size_t size) {
4350  set_has_retval();
4351  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4352  ::std::string(reinterpret_cast<const char*>(value), size));
4353  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4354 }
4355 inline ::std::string* StdCmds_Disable_Out::mutable_retval() {
4356  set_has_retval();
4357  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4358  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4359 }
4360 inline ::std::string* StdCmds_Disable_Out::release_retval() {
4361  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4362  if (!has_retval()) {
4363  return NULL;
4364  }
4365  clear_has_retval();
4366  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4367 }
4368 inline void StdCmds_Disable_Out::set_allocated_retval(::std::string* retval) {
4369  if (retval != NULL) {
4370  set_has_retval();
4371  } else {
4372  clear_has_retval();
4373  }
4374  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4375  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Disable_Out.retval)
4376 }
4377 
4378 // -------------------------------------------------------------------
4379 
4380 // StdCmds_Status_Out
4381 
4382 // required string retval = 1;
4383 inline bool StdCmds_Status_Out::has_retval() const {
4384  return (_has_bits_[0] & 0x00000001u) != 0;
4385 }
4386 inline void StdCmds_Status_Out::set_has_retval() {
4387  _has_bits_[0] |= 0x00000001u;
4388 }
4389 inline void StdCmds_Status_Out::clear_has_retval() {
4390  _has_bits_[0] &= ~0x00000001u;
4391 }
4392 inline void StdCmds_Status_Out::clear_retval() {
4393  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4394  clear_has_retval();
4395 }
4396 inline const ::std::string& StdCmds_Status_Out::retval() const {
4397  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4398  return retval_.GetNoArena();
4399 }
4400 inline void StdCmds_Status_Out::set_retval(const ::std::string& value) {
4401  set_has_retval();
4402  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4403  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4404 }
4405 #if LANG_CXX11
4406 inline void StdCmds_Status_Out::set_retval(::std::string&& value) {
4407  set_has_retval();
4408  retval_.SetNoArena(
4409  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4410  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4411 }
4412 #endif
4413 inline void StdCmds_Status_Out::set_retval(const char* value) {
4414  GOOGLE_DCHECK(value != NULL);
4415  set_has_retval();
4416  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4417  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4418 }
4419 inline void StdCmds_Status_Out::set_retval(const char* value, size_t size) {
4420  set_has_retval();
4421  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4422  ::std::string(reinterpret_cast<const char*>(value), size));
4423  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4424 }
4425 inline ::std::string* StdCmds_Status_Out::mutable_retval() {
4426  set_has_retval();
4427  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4428  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4429 }
4430 inline ::std::string* StdCmds_Status_Out::release_retval() {
4431  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4432  if (!has_retval()) {
4433  return NULL;
4434  }
4435  clear_has_retval();
4436  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4437 }
4438 inline void StdCmds_Status_Out::set_allocated_retval(::std::string* retval) {
4439  if (retval != NULL) {
4440  set_has_retval();
4441  } else {
4442  clear_has_retval();
4443  }
4444  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4445  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Status_Out.retval)
4446 }
4447 
4448 // -------------------------------------------------------------------
4449 
4450 // StdCmds_Config_Out
4451 
4452 // required string retval = 1;
4453 inline bool StdCmds_Config_Out::has_retval() const {
4454  return (_has_bits_[0] & 0x00000001u) != 0;
4455 }
4456 inline void StdCmds_Config_Out::set_has_retval() {
4457  _has_bits_[0] |= 0x00000001u;
4458 }
4459 inline void StdCmds_Config_Out::clear_has_retval() {
4460  _has_bits_[0] &= ~0x00000001u;
4461 }
4462 inline void StdCmds_Config_Out::clear_retval() {
4463  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4464  clear_has_retval();
4465 }
4466 inline const ::std::string& StdCmds_Config_Out::retval() const {
4467  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4468  return retval_.GetNoArena();
4469 }
4470 inline void StdCmds_Config_Out::set_retval(const ::std::string& value) {
4471  set_has_retval();
4472  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4473  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4474 }
4475 #if LANG_CXX11
4476 inline void StdCmds_Config_Out::set_retval(::std::string&& value) {
4477  set_has_retval();
4478  retval_.SetNoArena(
4479  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4480  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4481 }
4482 #endif
4483 inline void StdCmds_Config_Out::set_retval(const char* value) {
4484  GOOGLE_DCHECK(value != NULL);
4485  set_has_retval();
4486  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4487  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4488 }
4489 inline void StdCmds_Config_Out::set_retval(const char* value, size_t size) {
4490  set_has_retval();
4491  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4492  ::std::string(reinterpret_cast<const char*>(value), size));
4493  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4494 }
4495 inline ::std::string* StdCmds_Config_Out::mutable_retval() {
4496  set_has_retval();
4497  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4498  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4499 }
4500 inline ::std::string* StdCmds_Config_Out::release_retval() {
4501  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4502  if (!has_retval()) {
4503  return NULL;
4504  }
4505  clear_has_retval();
4506  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4507 }
4508 inline void StdCmds_Config_Out::set_allocated_retval(::std::string* retval) {
4509  if (retval != NULL) {
4510  set_has_retval();
4511  } else {
4512  clear_has_retval();
4513  }
4514  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4515  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Config_Out.retval)
4516 }
4517 
4518 // -------------------------------------------------------------------
4519 
4520 // StdCmds_Stop_Out
4521 
4522 // required string retval = 1;
4523 inline bool StdCmds_Stop_Out::has_retval() const {
4524  return (_has_bits_[0] & 0x00000001u) != 0;
4525 }
4526 inline void StdCmds_Stop_Out::set_has_retval() {
4527  _has_bits_[0] |= 0x00000001u;
4528 }
4529 inline void StdCmds_Stop_Out::clear_has_retval() {
4530  _has_bits_[0] &= ~0x00000001u;
4531 }
4532 inline void StdCmds_Stop_Out::clear_retval() {
4533  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4534  clear_has_retval();
4535 }
4536 inline const ::std::string& StdCmds_Stop_Out::retval() const {
4537  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4538  return retval_.GetNoArena();
4539 }
4540 inline void StdCmds_Stop_Out::set_retval(const ::std::string& value) {
4541  set_has_retval();
4542  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4543  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4544 }
4545 #if LANG_CXX11
4546 inline void StdCmds_Stop_Out::set_retval(::std::string&& value) {
4547  set_has_retval();
4548  retval_.SetNoArena(
4549  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4550  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4551 }
4552 #endif
4553 inline void StdCmds_Stop_Out::set_retval(const char* value) {
4554  GOOGLE_DCHECK(value != NULL);
4555  set_has_retval();
4556  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4557  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4558 }
4559 inline void StdCmds_Stop_Out::set_retval(const char* value, size_t size) {
4560  set_has_retval();
4561  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4562  ::std::string(reinterpret_cast<const char*>(value), size));
4563  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4564 }
4565 inline ::std::string* StdCmds_Stop_Out::mutable_retval() {
4566  set_has_retval();
4567  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4568  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4569 }
4570 inline ::std::string* StdCmds_Stop_Out::release_retval() {
4571  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4572  if (!has_retval()) {
4573  return NULL;
4574  }
4575  clear_has_retval();
4576  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4577 }
4578 inline void StdCmds_Stop_Out::set_allocated_retval(::std::string* retval) {
4579  if (retval != NULL) {
4580  set_has_retval();
4581  } else {
4582  clear_has_retval();
4583  }
4584  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4585  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Stop_Out.retval)
4586 }
4587 
4588 // -------------------------------------------------------------------
4589 
4590 // StdCmds_Exit_Out
4591 
4592 // required string retval = 1;
4593 inline bool StdCmds_Exit_Out::has_retval() const {
4594  return (_has_bits_[0] & 0x00000001u) != 0;
4595 }
4596 inline void StdCmds_Exit_Out::set_has_retval() {
4597  _has_bits_[0] |= 0x00000001u;
4598 }
4599 inline void StdCmds_Exit_Out::clear_has_retval() {
4600  _has_bits_[0] &= ~0x00000001u;
4601 }
4602 inline void StdCmds_Exit_Out::clear_retval() {
4603  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4604  clear_has_retval();
4605 }
4606 inline const ::std::string& StdCmds_Exit_Out::retval() const {
4607  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4608  return retval_.GetNoArena();
4609 }
4610 inline void StdCmds_Exit_Out::set_retval(const ::std::string& value) {
4611  set_has_retval();
4612  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4613  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4614 }
4615 #if LANG_CXX11
4616 inline void StdCmds_Exit_Out::set_retval(::std::string&& value) {
4617  set_has_retval();
4618  retval_.SetNoArena(
4619  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4620  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4621 }
4622 #endif
4623 inline void StdCmds_Exit_Out::set_retval(const char* value) {
4624  GOOGLE_DCHECK(value != NULL);
4625  set_has_retval();
4626  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4627  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4628 }
4629 inline void StdCmds_Exit_Out::set_retval(const char* value, size_t size) {
4630  set_has_retval();
4631  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4632  ::std::string(reinterpret_cast<const char*>(value), size));
4633  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4634 }
4635 inline ::std::string* StdCmds_Exit_Out::mutable_retval() {
4636  set_has_retval();
4637  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4638  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4639 }
4640 inline ::std::string* StdCmds_Exit_Out::release_retval() {
4641  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4642  if (!has_retval()) {
4643  return NULL;
4644  }
4645  clear_has_retval();
4646  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4647 }
4648 inline void StdCmds_Exit_Out::set_allocated_retval(::std::string* retval) {
4649  if (retval != NULL) {
4650  set_has_retval();
4651  } else {
4652  clear_has_retval();
4653  }
4654  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4655  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Exit_Out.retval)
4656 }
4657 
4658 // -------------------------------------------------------------------
4659 
4660 // StdCmds_SetLogLevel_Out
4661 
4662 // optional string retval = 1;
4663 inline bool StdCmds_SetLogLevel_Out::has_retval() const {
4664  return (_has_bits_[0] & 0x00000001u) != 0;
4665 }
4666 inline void StdCmds_SetLogLevel_Out::set_has_retval() {
4667  _has_bits_[0] |= 0x00000001u;
4668 }
4669 inline void StdCmds_SetLogLevel_Out::clear_has_retval() {
4670  _has_bits_[0] &= ~0x00000001u;
4671 }
4672 inline void StdCmds_SetLogLevel_Out::clear_retval() {
4673  retval_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4674  clear_has_retval();
4675 }
4676 inline const ::std::string& StdCmds_SetLogLevel_Out::retval() const {
4677  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4678  return retval_.GetNoArena();
4679 }
4680 inline void StdCmds_SetLogLevel_Out::set_retval(const ::std::string& value) {
4681  set_has_retval();
4682  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4683  // @@protoc_insertion_point(field_set:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4684 }
4685 #if LANG_CXX11
4686 inline void StdCmds_SetLogLevel_Out::set_retval(::std::string&& value) {
4687  set_has_retval();
4688  retval_.SetNoArena(
4689  &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4690  // @@protoc_insertion_point(field_set_rvalue:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4691 }
4692 #endif
4693 inline void StdCmds_SetLogLevel_Out::set_retval(const char* value) {
4694  GOOGLE_DCHECK(value != NULL);
4695  set_has_retval();
4696  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4697  // @@protoc_insertion_point(field_set_char:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4698 }
4699 inline void StdCmds_SetLogLevel_Out::set_retval(const char* value, size_t size) {
4700  set_has_retval();
4701  retval_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4702  ::std::string(reinterpret_cast<const char*>(value), size));
4703  // @@protoc_insertion_point(field_set_pointer:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4704 }
4705 inline ::std::string* StdCmds_SetLogLevel_Out::mutable_retval() {
4706  set_has_retval();
4707  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4708  return retval_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4709 }
4710 inline ::std::string* StdCmds_SetLogLevel_Out::release_retval() {
4711  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4712  if (!has_retval()) {
4713  return NULL;
4714  }
4715  clear_has_retval();
4716  return retval_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4717 }
4718 inline void StdCmds_SetLogLevel_Out::set_allocated_retval(::std::string* retval) {
4719  if (retval != NULL) {
4720  set_has_retval();
4721  } else {
4722  clear_has_retval();
4723  }
4724  retval_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), retval);
4725  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.retval)
4726 }
4727 
4728 // optional .generated.zpb.hellomalif.ExceptionErr exExceptionErr = 2;
4729 inline bool StdCmds_SetLogLevel_Out::has_exexceptionerr() const {
4730  return (_has_bits_[0] & 0x00000002u) != 0;
4731 }
4732 inline void StdCmds_SetLogLevel_Out::set_has_exexceptionerr() {
4733  _has_bits_[0] |= 0x00000002u;
4734 }
4735 inline void StdCmds_SetLogLevel_Out::clear_has_exexceptionerr() {
4736  _has_bits_[0] &= ~0x00000002u;
4737 }
4738 inline void StdCmds_SetLogLevel_Out::clear_exexceptionerr() {
4739  if (exexceptionerr_ != NULL) exexceptionerr_->Clear();
4740  clear_has_exexceptionerr();
4741 }
4742 inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_SetLogLevel_Out::_internal_exexceptionerr() const {
4743  return *exexceptionerr_;
4744 }
4745 inline const ::generated::zpb::hellomalif::ExceptionErr& StdCmds_SetLogLevel_Out::exexceptionerr() const {
4746  const ::generated::zpb::hellomalif::ExceptionErr* p = exexceptionerr_;
4747  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
4748  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::ExceptionErr*>(
4749  &::generated::zpb::hellomalif::_ExceptionErr_default_instance_);
4750 }
4751 inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_SetLogLevel_Out::release_exexceptionerr() {
4752  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
4753  clear_has_exexceptionerr();
4754  ::generated::zpb::hellomalif::ExceptionErr* temp = exexceptionerr_;
4755  exexceptionerr_ = NULL;
4756  return temp;
4757 }
4758 inline ::generated::zpb::hellomalif::ExceptionErr* StdCmds_SetLogLevel_Out::mutable_exexceptionerr() {
4759  set_has_exexceptionerr();
4760  if (exexceptionerr_ == NULL) {
4761  auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::ExceptionErr>(GetArenaNoVirtual());
4762  exexceptionerr_ = p;
4763  }
4764  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
4765  return exexceptionerr_;
4766 }
4767 inline void StdCmds_SetLogLevel_Out::set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr* exexceptionerr) {
4768  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4769  if (message_arena == NULL) {
4770  delete exexceptionerr_;
4771  }
4772  if (exexceptionerr) {
4773  ::google::protobuf::Arena* submessage_arena = NULL;
4774  if (message_arena != submessage_arena) {
4775  exexceptionerr = ::google::protobuf::internal::GetOwnedMessage(
4776  message_arena, exexceptionerr, submessage_arena);
4777  }
4778  set_has_exexceptionerr();
4779  } else {
4780  clear_has_exexceptionerr();
4781  }
4782  exexceptionerr_ = exexceptionerr;
4783  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_SetLogLevel_Out.exExceptionErr)
4784 }
4785 
4786 // -------------------------------------------------------------------
4787 
4788 // StdCmds_Return
4789 
4790 // optional .generated.zpb.hellomalif.StdCmds_Init_Out Init = 1;
4791 inline bool StdCmds_Return::has_init() const {
4792  return reply_case() == kInit;
4793 }
4794 inline void StdCmds_Return::set_has_init() {
4795  _oneof_case_[0] = kInit;
4796 }
4797 inline void StdCmds_Return::clear_init() {
4798  if (has_init()) {
4799  delete reply_.init_;
4800  clear_has_reply();
4801  }
4802 }
4803 inline const ::generated::zpb::hellomalif::StdCmds_Init_Out& StdCmds_Return::_internal_init() const {
4804  return *reply_.init_;
4805 }
4806 inline ::generated::zpb::hellomalif::StdCmds_Init_Out* StdCmds_Return::release_init() {
4807  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Init)
4808  if (has_init()) {
4809  clear_has_reply();
4810  ::generated::zpb::hellomalif::StdCmds_Init_Out* temp = reply_.init_;
4811  reply_.init_ = NULL;
4812  return temp;
4813  } else {
4814  return NULL;
4815  }
4816 }
4817 inline const ::generated::zpb::hellomalif::StdCmds_Init_Out& StdCmds_Return::init() const {
4818  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Init)
4819  return has_init()
4820  ? *reply_.init_
4821  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Init_Out*>(&::generated::zpb::hellomalif::_StdCmds_Init_Out_default_instance_);
4822 }
4823 inline ::generated::zpb::hellomalif::StdCmds_Init_Out* StdCmds_Return::mutable_init() {
4824  if (!has_init()) {
4825  clear_reply();
4826  set_has_init();
4827  reply_.init_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Init_Out >(
4828  GetArenaNoVirtual());
4829  }
4830  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Init)
4831  return reply_.init_;
4832 }
4833 
4834 // optional .generated.zpb.hellomalif.StdCmds_Reset_Out Reset = 2;
4835 inline bool StdCmds_Return::has_reset() const {
4836  return reply_case() == kReset;
4837 }
4838 inline void StdCmds_Return::set_has_reset() {
4839  _oneof_case_[0] = kReset;
4840 }
4841 inline void StdCmds_Return::clear_reset() {
4842  if (has_reset()) {
4843  delete reply_.reset_;
4844  clear_has_reply();
4845  }
4846 }
4847 inline const ::generated::zpb::hellomalif::StdCmds_Reset_Out& StdCmds_Return::_internal_reset() const {
4848  return *reply_.reset_;
4849 }
4850 inline ::generated::zpb::hellomalif::StdCmds_Reset_Out* StdCmds_Return::release_reset() {
4851  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Reset)
4852  if (has_reset()) {
4853  clear_has_reply();
4854  ::generated::zpb::hellomalif::StdCmds_Reset_Out* temp = reply_.reset_;
4855  reply_.reset_ = NULL;
4856  return temp;
4857  } else {
4858  return NULL;
4859  }
4860 }
4861 inline const ::generated::zpb::hellomalif::StdCmds_Reset_Out& StdCmds_Return::reset() const {
4862  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Reset)
4863  return has_reset()
4864  ? *reply_.reset_
4865  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Reset_Out*>(&::generated::zpb::hellomalif::_StdCmds_Reset_Out_default_instance_);
4866 }
4867 inline ::generated::zpb::hellomalif::StdCmds_Reset_Out* StdCmds_Return::mutable_reset() {
4868  if (!has_reset()) {
4869  clear_reply();
4870  set_has_reset();
4871  reply_.reset_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Reset_Out >(
4872  GetArenaNoVirtual());
4873  }
4874  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Reset)
4875  return reply_.reset_;
4876 }
4877 
4878 // optional .generated.zpb.hellomalif.StdCmds_Enable_Out Enable = 3;
4879 inline bool StdCmds_Return::has_enable() const {
4880  return reply_case() == kEnable;
4881 }
4882 inline void StdCmds_Return::set_has_enable() {
4883  _oneof_case_[0] = kEnable;
4884 }
4885 inline void StdCmds_Return::clear_enable() {
4886  if (has_enable()) {
4887  delete reply_.enable_;
4888  clear_has_reply();
4889  }
4890 }
4891 inline const ::generated::zpb::hellomalif::StdCmds_Enable_Out& StdCmds_Return::_internal_enable() const {
4892  return *reply_.enable_;
4893 }
4894 inline ::generated::zpb::hellomalif::StdCmds_Enable_Out* StdCmds_Return::release_enable() {
4895  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Enable)
4896  if (has_enable()) {
4897  clear_has_reply();
4898  ::generated::zpb::hellomalif::StdCmds_Enable_Out* temp = reply_.enable_;
4899  reply_.enable_ = NULL;
4900  return temp;
4901  } else {
4902  return NULL;
4903  }
4904 }
4905 inline const ::generated::zpb::hellomalif::StdCmds_Enable_Out& StdCmds_Return::enable() const {
4906  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Enable)
4907  return has_enable()
4908  ? *reply_.enable_
4909  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Enable_Out*>(&::generated::zpb::hellomalif::_StdCmds_Enable_Out_default_instance_);
4910 }
4911 inline ::generated::zpb::hellomalif::StdCmds_Enable_Out* StdCmds_Return::mutable_enable() {
4912  if (!has_enable()) {
4913  clear_reply();
4914  set_has_enable();
4915  reply_.enable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Enable_Out >(
4916  GetArenaNoVirtual());
4917  }
4918  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Enable)
4919  return reply_.enable_;
4920 }
4921 
4922 // optional .generated.zpb.hellomalif.StdCmds_Disable_Out Disable = 4;
4923 inline bool StdCmds_Return::has_disable() const {
4924  return reply_case() == kDisable;
4925 }
4926 inline void StdCmds_Return::set_has_disable() {
4927  _oneof_case_[0] = kDisable;
4928 }
4929 inline void StdCmds_Return::clear_disable() {
4930  if (has_disable()) {
4931  delete reply_.disable_;
4932  clear_has_reply();
4933  }
4934 }
4935 inline const ::generated::zpb::hellomalif::StdCmds_Disable_Out& StdCmds_Return::_internal_disable() const {
4936  return *reply_.disable_;
4937 }
4938 inline ::generated::zpb::hellomalif::StdCmds_Disable_Out* StdCmds_Return::release_disable() {
4939  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Disable)
4940  if (has_disable()) {
4941  clear_has_reply();
4942  ::generated::zpb::hellomalif::StdCmds_Disable_Out* temp = reply_.disable_;
4943  reply_.disable_ = NULL;
4944  return temp;
4945  } else {
4946  return NULL;
4947  }
4948 }
4949 inline const ::generated::zpb::hellomalif::StdCmds_Disable_Out& StdCmds_Return::disable() const {
4950  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Disable)
4951  return has_disable()
4952  ? *reply_.disable_
4953  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Disable_Out*>(&::generated::zpb::hellomalif::_StdCmds_Disable_Out_default_instance_);
4954 }
4955 inline ::generated::zpb::hellomalif::StdCmds_Disable_Out* StdCmds_Return::mutable_disable() {
4956  if (!has_disable()) {
4957  clear_reply();
4958  set_has_disable();
4959  reply_.disable_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Disable_Out >(
4960  GetArenaNoVirtual());
4961  }
4962  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Disable)
4963  return reply_.disable_;
4964 }
4965 
4966 // optional .generated.zpb.hellomalif.StdCmds_Status_Out Status = 5;
4967 inline bool StdCmds_Return::has_status() const {
4968  return reply_case() == kStatus;
4969 }
4970 inline void StdCmds_Return::set_has_status() {
4971  _oneof_case_[0] = kStatus;
4972 }
4973 inline void StdCmds_Return::clear_status() {
4974  if (has_status()) {
4975  delete reply_.status_;
4976  clear_has_reply();
4977  }
4978 }
4979 inline const ::generated::zpb::hellomalif::StdCmds_Status_Out& StdCmds_Return::_internal_status() const {
4980  return *reply_.status_;
4981 }
4982 inline ::generated::zpb::hellomalif::StdCmds_Status_Out* StdCmds_Return::release_status() {
4983  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Status)
4984  if (has_status()) {
4985  clear_has_reply();
4986  ::generated::zpb::hellomalif::StdCmds_Status_Out* temp = reply_.status_;
4987  reply_.status_ = NULL;
4988  return temp;
4989  } else {
4990  return NULL;
4991  }
4992 }
4993 inline const ::generated::zpb::hellomalif::StdCmds_Status_Out& StdCmds_Return::status() const {
4994  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Status)
4995  return has_status()
4996  ? *reply_.status_
4997  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Status_Out*>(&::generated::zpb::hellomalif::_StdCmds_Status_Out_default_instance_);
4998 }
4999 inline ::generated::zpb::hellomalif::StdCmds_Status_Out* StdCmds_Return::mutable_status() {
5000  if (!has_status()) {
5001  clear_reply();
5002  set_has_status();
5003  reply_.status_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Status_Out >(
5004  GetArenaNoVirtual());
5005  }
5006  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Status)
5007  return reply_.status_;
5008 }
5009 
5010 // optional .generated.zpb.hellomalif.StdCmds_Config_Out Config = 6;
5011 inline bool StdCmds_Return::has_config() const {
5012  return reply_case() == kConfig;
5013 }
5014 inline void StdCmds_Return::set_has_config() {
5015  _oneof_case_[0] = kConfig;
5016 }
5017 inline void StdCmds_Return::clear_config() {
5018  if (has_config()) {
5019  delete reply_.config_;
5020  clear_has_reply();
5021  }
5022 }
5023 inline const ::generated::zpb::hellomalif::StdCmds_Config_Out& StdCmds_Return::_internal_config() const {
5024  return *reply_.config_;
5025 }
5026 inline ::generated::zpb::hellomalif::StdCmds_Config_Out* StdCmds_Return::release_config() {
5027  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Config)
5028  if (has_config()) {
5029  clear_has_reply();
5030  ::generated::zpb::hellomalif::StdCmds_Config_Out* temp = reply_.config_;
5031  reply_.config_ = NULL;
5032  return temp;
5033  } else {
5034  return NULL;
5035  }
5036 }
5037 inline const ::generated::zpb::hellomalif::StdCmds_Config_Out& StdCmds_Return::config() const {
5038  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Config)
5039  return has_config()
5040  ? *reply_.config_
5041  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Config_Out*>(&::generated::zpb::hellomalif::_StdCmds_Config_Out_default_instance_);
5042 }
5043 inline ::generated::zpb::hellomalif::StdCmds_Config_Out* StdCmds_Return::mutable_config() {
5044  if (!has_config()) {
5045  clear_reply();
5046  set_has_config();
5047  reply_.config_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Config_Out >(
5048  GetArenaNoVirtual());
5049  }
5050  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Config)
5051  return reply_.config_;
5052 }
5053 
5054 // optional .generated.zpb.hellomalif.StdCmds_Stop_Out Stop = 7;
5055 inline bool StdCmds_Return::has_stop() const {
5056  return reply_case() == kStop;
5057 }
5058 inline void StdCmds_Return::set_has_stop() {
5059  _oneof_case_[0] = kStop;
5060 }
5061 inline void StdCmds_Return::clear_stop() {
5062  if (has_stop()) {
5063  delete reply_.stop_;
5064  clear_has_reply();
5065  }
5066 }
5067 inline const ::generated::zpb::hellomalif::StdCmds_Stop_Out& StdCmds_Return::_internal_stop() const {
5068  return *reply_.stop_;
5069 }
5070 inline ::generated::zpb::hellomalif::StdCmds_Stop_Out* StdCmds_Return::release_stop() {
5071  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Stop)
5072  if (has_stop()) {
5073  clear_has_reply();
5074  ::generated::zpb::hellomalif::StdCmds_Stop_Out* temp = reply_.stop_;
5075  reply_.stop_ = NULL;
5076  return temp;
5077  } else {
5078  return NULL;
5079  }
5080 }
5081 inline const ::generated::zpb::hellomalif::StdCmds_Stop_Out& StdCmds_Return::stop() const {
5082  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Stop)
5083  return has_stop()
5084  ? *reply_.stop_
5085  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Stop_Out*>(&::generated::zpb::hellomalif::_StdCmds_Stop_Out_default_instance_);
5086 }
5087 inline ::generated::zpb::hellomalif::StdCmds_Stop_Out* StdCmds_Return::mutable_stop() {
5088  if (!has_stop()) {
5089  clear_reply();
5090  set_has_stop();
5091  reply_.stop_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Stop_Out >(
5092  GetArenaNoVirtual());
5093  }
5094  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Stop)
5095  return reply_.stop_;
5096 }
5097 
5098 // optional .generated.zpb.hellomalif.StdCmds_Exit_Out Exit = 8;
5099 inline bool StdCmds_Return::has_exit() const {
5100  return reply_case() == kExit;
5101 }
5102 inline void StdCmds_Return::set_has_exit() {
5103  _oneof_case_[0] = kExit;
5104 }
5105 inline void StdCmds_Return::clear_exit() {
5106  if (has_exit()) {
5107  delete reply_.exit_;
5108  clear_has_reply();
5109  }
5110 }
5111 inline const ::generated::zpb::hellomalif::StdCmds_Exit_Out& StdCmds_Return::_internal_exit() const {
5112  return *reply_.exit_;
5113 }
5114 inline ::generated::zpb::hellomalif::StdCmds_Exit_Out* StdCmds_Return::release_exit() {
5115  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.Exit)
5116  if (has_exit()) {
5117  clear_has_reply();
5118  ::generated::zpb::hellomalif::StdCmds_Exit_Out* temp = reply_.exit_;
5119  reply_.exit_ = NULL;
5120  return temp;
5121  } else {
5122  return NULL;
5123  }
5124 }
5125 inline const ::generated::zpb::hellomalif::StdCmds_Exit_Out& StdCmds_Return::exit() const {
5126  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.Exit)
5127  return has_exit()
5128  ? *reply_.exit_
5129  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_Exit_Out*>(&::generated::zpb::hellomalif::_StdCmds_Exit_Out_default_instance_);
5130 }
5131 inline ::generated::zpb::hellomalif::StdCmds_Exit_Out* StdCmds_Return::mutable_exit() {
5132  if (!has_exit()) {
5133  clear_reply();
5134  set_has_exit();
5135  reply_.exit_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_Exit_Out >(
5136  GetArenaNoVirtual());
5137  }
5138  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.Exit)
5139  return reply_.exit_;
5140 }
5141 
5142 // optional .generated.zpb.hellomalif.StdCmds_SetLogLevel_Out SetLogLevel = 9;
5143 inline bool StdCmds_Return::has_setloglevel() const {
5144  return reply_case() == kSetLogLevel;
5145 }
5146 inline void StdCmds_Return::set_has_setloglevel() {
5147  _oneof_case_[0] = kSetLogLevel;
5148 }
5149 inline void StdCmds_Return::clear_setloglevel() {
5150  if (has_setloglevel()) {
5151  delete reply_.setloglevel_;
5152  clear_has_reply();
5153  }
5154 }
5155 inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& StdCmds_Return::_internal_setloglevel() const {
5156  return *reply_.setloglevel_;
5157 }
5158 inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* StdCmds_Return::release_setloglevel() {
5159  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Return.SetLogLevel)
5160  if (has_setloglevel()) {
5161  clear_has_reply();
5162  ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* temp = reply_.setloglevel_;
5163  reply_.setloglevel_ = NULL;
5164  return temp;
5165  } else {
5166  return NULL;
5167  }
5168 }
5169 inline const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out& StdCmds_Return::setloglevel() const {
5170  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Return.SetLogLevel)
5171  return has_setloglevel()
5172  ? *reply_.setloglevel_
5173  : *reinterpret_cast< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out*>(&::generated::zpb::hellomalif::_StdCmds_SetLogLevel_Out_default_instance_);
5174 }
5175 inline ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out* StdCmds_Return::mutable_setloglevel() {
5176  if (!has_setloglevel()) {
5177  clear_reply();
5178  set_has_setloglevel();
5179  reply_.setloglevel_ = CreateMaybeMessage< ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out >(
5180  GetArenaNoVirtual());
5181  }
5182  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Return.SetLogLevel)
5183  return reply_.setloglevel_;
5184 }
5185 
5186 inline bool StdCmds_Return::has_reply() const {
5187  return reply_case() != REPLY_NOT_SET;
5188 }
5189 inline void StdCmds_Return::clear_has_reply() {
5190  _oneof_case_[0] = REPLY_NOT_SET;
5191 }
5192 inline StdCmds_Return::ReplyCase StdCmds_Return::reply_case() const {
5193  return StdCmds_Return::ReplyCase(_oneof_case_[0]);
5194 }
5195 // -------------------------------------------------------------------
5196 
5197 // StdCmds_Reply
5198 
5199 // required .elt.mal.zpb.rr.ReplyHeader header = 1;
5200 inline bool StdCmds_Reply::has_header() const {
5201  return (_has_bits_[0] & 0x00000001u) != 0;
5202 }
5203 inline void StdCmds_Reply::set_has_header() {
5204  _has_bits_[0] |= 0x00000001u;
5205 }
5206 inline void StdCmds_Reply::clear_has_header() {
5207  _has_bits_[0] &= ~0x00000001u;
5208 }
5209 inline const ::elt::mal::zpb::rr::ReplyHeader& StdCmds_Reply::_internal_header() const {
5210  return *header_;
5211 }
5212 inline const ::elt::mal::zpb::rr::ReplyHeader& StdCmds_Reply::header() const {
5213  const ::elt::mal::zpb::rr::ReplyHeader* p = header_;
5214  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reply.header)
5215  return p != NULL ? *p : *reinterpret_cast<const ::elt::mal::zpb::rr::ReplyHeader*>(
5216  &::elt::mal::zpb::rr::_ReplyHeader_default_instance_);
5217 }
5218 inline ::elt::mal::zpb::rr::ReplyHeader* StdCmds_Reply::release_header() {
5219  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reply.header)
5220  clear_has_header();
5221  ::elt::mal::zpb::rr::ReplyHeader* temp = header_;
5222  header_ = NULL;
5223  return temp;
5224 }
5225 inline ::elt::mal::zpb::rr::ReplyHeader* StdCmds_Reply::mutable_header() {
5226  set_has_header();
5227  if (header_ == NULL) {
5228  auto* p = CreateMaybeMessage<::elt::mal::zpb::rr::ReplyHeader>(GetArenaNoVirtual());
5229  header_ = p;
5230  }
5231  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reply.header)
5232  return header_;
5233 }
5234 inline void StdCmds_Reply::set_allocated_header(::elt::mal::zpb::rr::ReplyHeader* header) {
5235  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5236  if (message_arena == NULL) {
5237  delete reinterpret_cast< ::google::protobuf::MessageLite*>(header_);
5238  }
5239  if (header) {
5240  ::google::protobuf::Arena* submessage_arena = NULL;
5241  if (message_arena != submessage_arena) {
5242  header = ::google::protobuf::internal::GetOwnedMessage(
5243  message_arena, header, submessage_arena);
5244  }
5245  set_has_header();
5246  } else {
5247  clear_has_header();
5248  }
5249  header_ = header;
5250  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reply.header)
5251 }
5252 
5253 // optional .generated.zpb.hellomalif.StdCmds_Return data = 2;
5254 inline bool StdCmds_Reply::has_data() const {
5255  return (_has_bits_[0] & 0x00000002u) != 0;
5256 }
5257 inline void StdCmds_Reply::set_has_data() {
5258  _has_bits_[0] |= 0x00000002u;
5259 }
5260 inline void StdCmds_Reply::clear_has_data() {
5261  _has_bits_[0] &= ~0x00000002u;
5262 }
5263 inline void StdCmds_Reply::clear_data() {
5264  if (data_ != NULL) data_->Clear();
5265  clear_has_data();
5266 }
5267 inline const ::generated::zpb::hellomalif::StdCmds_Return& StdCmds_Reply::_internal_data() const {
5268  return *data_;
5269 }
5270 inline const ::generated::zpb::hellomalif::StdCmds_Return& StdCmds_Reply::data() const {
5271  const ::generated::zpb::hellomalif::StdCmds_Return* p = data_;
5272  // @@protoc_insertion_point(field_get:generated.zpb.hellomalif.StdCmds_Reply.data)
5273  return p != NULL ? *p : *reinterpret_cast<const ::generated::zpb::hellomalif::StdCmds_Return*>(
5274  &::generated::zpb::hellomalif::_StdCmds_Return_default_instance_);
5275 }
5276 inline ::generated::zpb::hellomalif::StdCmds_Return* StdCmds_Reply::release_data() {
5277  // @@protoc_insertion_point(field_release:generated.zpb.hellomalif.StdCmds_Reply.data)
5278  clear_has_data();
5279  ::generated::zpb::hellomalif::StdCmds_Return* temp = data_;
5280  data_ = NULL;
5281  return temp;
5282 }
5283 inline ::generated::zpb::hellomalif::StdCmds_Return* StdCmds_Reply::mutable_data() {
5284  set_has_data();
5285  if (data_ == NULL) {
5286  auto* p = CreateMaybeMessage<::generated::zpb::hellomalif::StdCmds_Return>(GetArenaNoVirtual());
5287  data_ = p;
5288  }
5289  // @@protoc_insertion_point(field_mutable:generated.zpb.hellomalif.StdCmds_Reply.data)
5290  return data_;
5291 }
5292 inline void StdCmds_Reply::set_allocated_data(::generated::zpb::hellomalif::StdCmds_Return* data) {
5293  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5294  if (message_arena == NULL) {
5295  delete data_;
5296  }
5297  if (data) {
5298  ::google::protobuf::Arena* submessage_arena = NULL;
5299  if (message_arena != submessage_arena) {
5300  data = ::google::protobuf::internal::GetOwnedMessage(
5301  message_arena, data, submessage_arena);
5302  }
5303  set_has_data();
5304  } else {
5305  clear_has_data();
5306  }
5307  data_ = data;
5308  // @@protoc_insertion_point(field_set_allocated:generated.zpb.hellomalif.StdCmds_Reply.data)
5309 }
5310 
5311 #ifdef __GNUC__
5312  #pragma GCC diagnostic pop
5313 #endif // __GNUC__
5314 // -------------------------------------------------------------------
5315 
5316 // -------------------------------------------------------------------
5317 
5318 // -------------------------------------------------------------------
5319 
5320 // -------------------------------------------------------------------
5321 
5322 // -------------------------------------------------------------------
5323 
5324 // -------------------------------------------------------------------
5325 
5326 // -------------------------------------------------------------------
5327 
5328 // -------------------------------------------------------------------
5329 
5330 // -------------------------------------------------------------------
5331 
5332 // -------------------------------------------------------------------
5333 
5334 // -------------------------------------------------------------------
5335 
5336 // -------------------------------------------------------------------
5337 
5338 // -------------------------------------------------------------------
5339 
5340 // -------------------------------------------------------------------
5341 
5342 // -------------------------------------------------------------------
5343 
5344 // -------------------------------------------------------------------
5345 
5346 // -------------------------------------------------------------------
5347 
5348 // -------------------------------------------------------------------
5349 
5350 // -------------------------------------------------------------------
5351 
5352 // -------------------------------------------------------------------
5353 
5354 // -------------------------------------------------------------------
5355 
5356 // -------------------------------------------------------------------
5357 
5358 // -------------------------------------------------------------------
5359 
5360 
5361 // @@protoc_insertion_point(namespace_scope)
5362 
5363 } // namespace hellomalif
5364 } // namespace zpb
5365 } // namespace generated
5366 
5367 // @@protoc_insertion_point(global_scope)
5368 
5369 #endif // PROTOBUF_INCLUDED_hellomalif_2eproto
generated::zpb::hellomalif::StdCmds_Call::config
const ::generated::zpb::hellomalif::StdCmds_Config_In & config() const
Definition: hellomalif.pb.h:3824
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::swap
friend void swap(StdCmds_SetLogLevel_Out &a, StdCmds_SetLogLevel_Out &b)
Definition: hellomalif.pb.h:2789
generated::zpb::hellomalif::StdCmds_Return::mutable_stop
::generated::zpb::hellomalif::StdCmds_Stop_Out * mutable_stop()
Definition: hellomalif.pb.h:5087
generated::zpb::hellomalif::LogInfo::CopyFrom
void CopyFrom(const ::google::protobuf::Message &from) final
generated::zpb::hellomalif::ExceptionErr::desc
const ::std::string & desc() const
Definition: hellomalif.pb.h:3291
generated::zpb::hellomalif::StdCmds_Request::operator=
StdCmds_Request & operator=(const StdCmds_Request &from)
Definition: hellomalif.pb.h:1638
generated::zpb::hellomalif::StdCmds_Status_Out::New
StdCmds_Status_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2311
generated::zpb::hellomalif::ExceptionErr::CopyFrom
void CopyFrom(const ::google::protobuf::Message &from) final
generated::zpb::hellomalif::StdCmds_Return::exit
const ::generated::zpb::hellomalif::StdCmds_Exit_Out & exit() const
Definition: hellomalif.pb.h:5125
generated::zpb::hellomalif::StdCmds_Request::clear_data
void clear_data()
Definition: hellomalif.pb.h:4050
generated::zpb::exmalif::_StdCmds_SetLogLevel_In_default_instance_
StdCmds_SetLogLevel_InDefaultTypeInternal _StdCmds_SetLogLevel_In_default_instance_
generated::zpb::hellomalif::StdCmds_Request::release_data
::generated::zpb::hellomalif::StdCmds_Call * release_data()
Definition: hellomalif.pb.h:4063
generated::zpb::hellomalif::LogInfo::New
LogInfo * New() const final
Definition: hellomalif.pb.h:335
generated::zpb::hellomalif::StdCmds_Return::mutable_exit
::generated::zpb::hellomalif::StdCmds_Exit_Out * mutable_exit()
Definition: hellomalif.pb.h:5131
generated::zpb::hellomalif::StdCmds_Config_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4462
generated::zpb::hellomalif::StdCmds_Return::mutable_disable
::generated::zpb::hellomalif::StdCmds_Disable_Out * mutable_disable()
Definition: hellomalif.pb.h:4955
generated::zpb::hellomalif::StdCmds_Exit_Out
Definition: hellomalif.pb.h:2622
generated::zpb::hellomalif::StdCmds_Request::has_data
bool has_data() const
Definition: hellomalif.pb.h:4041
generated::zpb::hellomalif::StdCmds_Call::setloglevel
const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In & setloglevel() const
Definition: hellomalif.pb.h:3956
generated::zpb::hellomalif::StdCmds_Disable_Out::internal_default_instance
static const StdCmds_Disable_Out * internal_default_instance()
Definition: hellomalif.pb.h:2171
generated::zpb::hellomalif::StdCmds_Enable_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:664
generated::zpb::hellomalif::StdCmds_Request::header
const ::elt::mal::zpb::rr::RequestHeader & header() const
Definition: hellomalif.pb.h:3999
generated::zpb::hellomalif::StdCmds_Stop_In::New
StdCmds_Stop_In * New() const final
Definition: hellomalif.pb.h:1102
generated::zpb::hellomalif::StdCmds_Status_In::operator=
StdCmds_Status_In & operator=(const StdCmds_Status_In &from)
Definition: hellomalif.pb.h:850
generated::zpb::hellomalif::StdCmds_Stop_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4536
generated::zpb::hellomalif::StdCmds_Init_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4145
generated::zpb::hellomalif::StdCmds_Exit_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4602
generated::zpb::hellomalif::LogInfo::InternalSerializeWithCachedSizesToArray
::google::protobuf::uint8 * InternalSerializeWithCachedSizesToArray(bool deterministic,::google::protobuf::uint8 *target) const final
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2770
generated::zpb::hellomalif::StdCmds_Config_Out::internal_default_instance
static const StdCmds_Config_Out * internal_default_instance()
Definition: hellomalif.pb.h:2415
generated::zpb::hellomalif::_StdCmds_Call_default_instance_
StdCmds_CallDefaultTypeInternal _StdCmds_Call_default_instance_
Definition: hellomalif.pb.h:60
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::info
const ::generated::zpb::hellomalif::LogInfo & info() const
Definition: hellomalif.pb.h:3532
generated::zpb::hellomalif::StdCmds_Enable_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2038
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::New
StdCmds_SetLogLevel_In * New() const final
Definition: hellomalif.pb.h:1310
generated::zpb::hellomalif::_StdCmds_Status_In_default_instance_
StdCmds_Status_InDefaultTypeInternal _StdCmds_Status_In_default_instance_
Definition: hellomalif.pb.h:114
generated::zpb::hellomalif::StdCmds_Config_Out
Definition: hellomalif.pb.h:2378
generated::zpb::hellomalif::ExceptionErr::kDescFieldNumber
static const int kDescFieldNumber
Definition: hellomalif.pb.h:259
generated::zpb::hellomalif::StdCmds_Reply::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:3163
generated::zpb::hellomalif::LogInfo::set_level
void set_level(const ::std::string &value)
Definition: hellomalif.pb.h:3365
generated::zpb::hellomalif::_StdCmds_Reset_Out_default_instance_
StdCmds_Reset_OutDefaultTypeInternal _StdCmds_Reset_Out_default_instance_
Definition: hellomalif.pb.h:102
generated::zpb::hellomalif::StdCmds_Config_Out::New
StdCmds_Config_Out * New() const final
Definition: hellomalif.pb.h:2429
generated::zpb::hellomalif::StdCmds_Return::has_setloglevel
bool has_setloglevel() const
Definition: hellomalif.pb.h:5143
generated::zpb::exmalif::_StdCmds_Return_default_instance_
StdCmds_ReturnDefaultTypeInternal _StdCmds_Return_default_instance_
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::release_exexceptionerr
::generated::zpb::hellomalif::ExceptionErr * release_exexceptionerr()
Definition: hellomalif.pb.h:4751
generated::zpb::hellomalif::LogInfo::release_level
::std::string * release_level()
Definition: hellomalif.pb.h:3395
generated::zpb::hellomalif::StdCmds_Reset_Out::Swap
void Swap(StdCmds_Reset_Out *other)
generated::zpb::hellomalif::StdCmds_Enable_In::Swap
void Swap(StdCmds_Enable_In *other)
generated::zpb::hellomalif::StdCmds_Call::release_config
::generated::zpb::hellomalif::StdCmds_Config_In * release_config()
Definition: hellomalif.pb.h:3813
generated::zpb::hellomalif::StdCmds_Return::has_config
bool has_config() const
Definition: hellomalif.pb.h:5011
generated::zpb::hellomalif::StdCmds_Call::clear_reset
void clear_reset()
Definition: hellomalif.pb.h:3628
logger
required string logger
Definition: exmalif.proto:25
generated::zpb::hellomalif::StdCmds_Call::clear_stop
void clear_stop()
Definition: hellomalif.pb.h:3848
generated::zpb::hellomalif::StdCmds_Reply::data
const ::generated::zpb::hellomalif::StdCmds_Return & data() const
Definition: hellomalif.pb.h:5270
generated::zpb::hellomalif::StdCmds_Enable_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4285
generated::zpb::hellomalif::ExceptionErr::internal_default_instance
static const ExceptionErr * internal_default_instance()
Definition: hellomalif.pb.h:199
generated::zpb::hellomalif::StdCmds_Init_In::CopyFrom
void CopyFrom(const ::google::protobuf::Message &from) final
generated::zpb::hellomalif::StdCmds_Call::has_config
bool has_config() const
Definition: hellomalif.pb.h:3798
generated::zpb::exmalif::_StdCmds_Status_Out_default_instance_
StdCmds_Status_OutDefaultTypeInternal _StdCmds_Status_Out_default_instance_
generated::zpb::hellomalif::StdCmds_Enable_Out::Swap
void Swap(StdCmds_Enable_Out *other)
generated::zpb::hellomalif::ExceptionErr::GetCachedSize
int GetCachedSize() const final
Definition: hellomalif.pb.h:234
generated::zpb::hellomalif::StdCmds_Return::setloglevel
const ::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out & setloglevel() const
Definition: hellomalif.pb.h:5169
generated::zpb::hellomalif::ExceptionErr::New
ExceptionErr * New() const final
Definition: hellomalif.pb.h:213
generated::zpb::hellomalif::_StdCmds_Reset_In_default_instance_
StdCmds_Reset_InDefaultTypeInternal _StdCmds_Reset_In_default_instance_
Definition: hellomalif.pb.h:99
generated::zpb::hellomalif::StdCmds_Return::has_init
bool has_init() const
Definition: hellomalif.pb.h:4791
generated::zpb::hellomalif::StdCmds_Config_In::Swap
void Swap(StdCmds_Config_In *other)
generated::zpb::hellomalif::LogInfo::kLevelFieldNumber
static const int kLevelFieldNumber
Definition: hellomalif.pb.h:381
generated::zpb::hellomalif::StdCmds_Reply
Definition: hellomalif.pb.h:3134
generated::zpb::hellomalif::_StdCmds_Disable_Out_default_instance_
StdCmds_Disable_OutDefaultTypeInternal _StdCmds_Disable_Out_default_instance_
Definition: hellomalif.pb.h:72
generated::zpb::hellomalif::StdCmds_Return::stop
const ::generated::zpb::hellomalif::StdCmds_Stop_Out & stop() const
Definition: hellomalif.pb.h:5081
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::set_allocated_exexceptionerr
void set_allocated_exexceptionerr(::generated::zpb::hellomalif::ExceptionErr *exexceptionerr)
Definition: hellomalif.pb.h:4767
generated::zpb::hellomalif::StdCmds_Request::release_header
::elt::mal::zpb::rr::RequestHeader * release_header()
Definition: hellomalif.pb.h:4005
generated::zpb::hellomalif::StdCmds_Exit_Out::New
StdCmds_Exit_Out * New() const final
Definition: hellomalif.pb.h:2673
generated::zpb::hellomalif::StdCmds_Init_In::operator=
StdCmds_Init_In & operator=(const StdCmds_Init_In &from)
Definition: hellomalif.pb.h:434
generated::zpb::hellomalif::StdCmds_Init_In::kIndexInFileMessages
static constexpr int kIndexInFileMessages
Definition: hellomalif.pb.h:468
generated::zpb::hellomalif::StdCmds_Exit_Out::swap
friend void swap(StdCmds_Exit_Out &a, StdCmds_Exit_Out &b)
Definition: hellomalif.pb.h:2667
generated::zpb::exmalif::_StdCmds_Reset_In_default_instance_
StdCmds_Reset_InDefaultTypeInternal _StdCmds_Reset_In_default_instance_
generated::zpb::hellomalif::StdCmds_Config_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4470
generated::zpb::hellomalif::StdCmds_Call::mutable_stop
::generated::zpb::hellomalif::StdCmds_Stop_In * mutable_stop()
Definition: hellomalif.pb.h:3874
generated::zpb::hellomalif::StdCmds_Config_In::operator=
StdCmds_Config_In & operator=(const StdCmds_Config_In &from)
Definition: hellomalif.pb.h:954
generated::zpb::hellomalif::StdCmds_Init_Out::New
StdCmds_Init_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1823
generated::zpb::hellomalif::StdCmds_Disable_In::Swap
void Swap(StdCmds_Disable_In *other)
generated::zpb::hellomalif::StdCmds_Status_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:872
generated::zpb::hellomalif::StdCmds_Enable_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4290
generated::zpb::hellomalif::StdCmds_Return::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2910
generated::zpb::hellomalif::StdCmds_Config_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4453
generated::zpb::hellomalif::StdCmds_Stop_Out::operator=
StdCmds_Stop_Out & operator=(const StdCmds_Stop_Out &from)
Definition: hellomalif.pb.h:2507
generated::zpb::hellomalif::StdCmds_Call::mutable_exit
::generated::zpb::hellomalif::StdCmds_Exit_In * mutable_exit()
Definition: hellomalif.pb.h:3918
generated::zpb::hellomalif::_ExceptionErr_default_instance_
ExceptionErrDefaultTypeInternal _ExceptionErr_default_instance_
Definition: hellomalif.pb.h:54
generated::zpb::hellomalif::StdCmds_Enable_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4298
protobuf_hellomalif_2eproto::TableStruct
Definition: hellomalif.pb.h:40
protobuf_hellomalif_2eproto::TableStruct::schema
static const ::google::protobuf::internal::ParseTable schema[24]
Definition: hellomalif.pb.h:43
generated::zpb::hellomalif::StdCmds_Return::has_exit
bool has_exit() const
Definition: hellomalif.pb.h:5099
generated::zpb::hellomalif::StdCmds_Stop_In::swap
friend void swap(StdCmds_Stop_In &a, StdCmds_Stop_In &b)
Definition: hellomalif.pb.h:1096
generated::zpb::hellomalif::ExceptionErr::set_desc
void set_desc(const ::std::string &value)
Definition: hellomalif.pb.h:3295
generated::zpb::hellomalif::StdCmds_Reply::has_header
bool has_header() const
Definition: hellomalif.pb.h:5200
generated::zpb::hellomalif::StdCmds_Init_In::~StdCmds_Init_In
virtual ~StdCmds_Init_In()
generated::zpb::hellomalif::StdCmds_Reply::swap
friend void swap(StdCmds_Reply &a, StdCmds_Reply &b)
Definition: hellomalif.pb.h:3179
generated::zpb::hellomalif::StdCmds_Stop_Out::swap
friend void swap(StdCmds_Stop_Out &a, StdCmds_Stop_Out &b)
Definition: hellomalif.pb.h:2545
generated::zpb::exmalif::_StdCmds_Disable_Out_default_instance_
StdCmds_Disable_OutDefaultTypeInternal _StdCmds_Disable_Out_default_instance_
generated::zpb::hellomalif::LogInfo::descriptor
static const ::google::protobuf::Descriptor * descriptor()
generated::zpb::hellomalif::StdCmds_Exit_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2651
generated::zpb::hellomalif::StdCmds_Stop_In::Swap
void Swap(StdCmds_Stop_In *other)
generated::zpb::hellomalif::StdCmds_Reply::mutable_header
::elt::mal::zpb::rr::ReplyHeader * mutable_header()
Definition: hellomalif.pb.h:5225
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::has_exexceptionerr
bool has_exexceptionerr() const
Definition: hellomalif.pb.h:4729
generated::zpb::hellomalif::StdCmds_Exit_Out::operator=
StdCmds_Exit_Out & operator=(const StdCmds_Exit_Out &from)
Definition: hellomalif.pb.h:2629
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4676
generated::zpb::hellomalif::StdCmds_Reset_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4215
generated::zpb::hellomalif::StdCmds_Call::has_setloglevel
bool has_setloglevel() const
Definition: hellomalif.pb.h:3930
generated::zpb::hellomalif::StdCmds_Config_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2404
generated::zpb::hellomalif::StdCmds_Call::disable
const ::generated::zpb::hellomalif::StdCmds_Disable_In & disable() const
Definition: hellomalif.pb.h:3736
generated::zpb::hellomalif::StdCmds_Exit_In::New
StdCmds_Exit_In * New() const final
Definition: hellomalif.pb.h:1206
generated::zpb::hellomalif::StdCmds_Call::clear_disable
void clear_disable()
Definition: hellomalif.pb.h:3716
generated::zpb::hellomalif::StdCmds_Return::clear_exit
void clear_exit()
Definition: hellomalif.pb.h:5105
generated::zpb::exmalif::_LogInfo_default_instance_
LogInfoDefaultTypeInternal _LogInfo_default_instance_
protobuf_hellomalif_2eproto::TableStruct::field_metadata
static const ::google::protobuf::internal::FieldMetadata field_metadata[]
Definition: hellomalif.pb.h:44
generated::zpb::exmalif::_StdCmds_Config_Out_default_instance_
StdCmds_Config_OutDefaultTypeInternal _StdCmds_Config_Out_default_instance_
generated::zpb::hellomalif::StdCmds_Reply::New
StdCmds_Reply * New() const final
Definition: hellomalif.pb.h:3185
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::internal_default_instance
static const StdCmds_SetLogLevel_Out * internal_default_instance()
Definition: hellomalif.pb.h:2781
generated::zpb::hellomalif::StdCmds_Config_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4495
generated::zpb::hellomalif::StdCmds_Enable_Out::swap
friend void swap(StdCmds_Enable_Out &a, StdCmds_Enable_Out &b)
Definition: hellomalif.pb.h:2057
generated::zpb::hellomalif::LogInfo::logger
const ::std::string & logger() const
Definition: hellomalif.pb.h:3427
generated::zpb::hellomalif::ExceptionErr::has_desc
bool has_desc() const
Definition: hellomalif.pb.h:3278
generated::zpb::hellomalif::_StdCmds_Stop_In_default_instance_
StdCmds_Stop_InDefaultTypeInternal _StdCmds_Stop_In_default_instance_
Definition: hellomalif.pb.h:120
generated::zpb::hellomalif::StdCmds_Return::clear_enable
void clear_enable()
Definition: hellomalif.pb.h:4885
generated::zpb::hellomalif::StdCmds_Disable_In::operator=
StdCmds_Disable_In & operator=(const StdCmds_Disable_In &from)
Definition: hellomalif.pb.h:746
generated::zpb::hellomalif::ExceptionErr::MergePartialFromCodedStream
bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream *input) final
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::has_info
bool has_info() const
Definition: hellomalif.pb.h:3516
generated::zpb::hellomalif::StdCmds_Call::clear_exit
void clear_exit()
Definition: hellomalif.pb.h:3892
generated::zpb::hellomalif::LogInfo::set_allocated_logger
void set_allocated_logger(::std::string *logger)
Definition: hellomalif.pb.h:3469
generated::zpb::hellomalif::StdCmds_Status_In::Swap
void Swap(StdCmds_Status_In *other)
generated::zpb::hellomalif::StdCmds_Return::mutable_enable
::generated::zpb::hellomalif::StdCmds_Enable_Out * mutable_enable()
Definition: hellomalif.pb.h:4911
generated::zpb::hellomalif::StdCmds_Status_In::internal_default_instance
static const StdCmds_Status_In * internal_default_instance()
Definition: hellomalif.pb.h:880
generated::zpb::hellomalif::StdCmds_Init_In::StdCmds_Init_In
StdCmds_Init_In()
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out
Definition: hellomalif.pb.h:2744
generated::zpb::hellomalif::StdCmds_Call
Definition: hellomalif.pb.h:1378
generated::zpb::hellomalif::StdCmds_Init_In::GetMetadata
::google::protobuf::Metadata GetMetadata() const final
generated::zpb::hellomalif::StdCmds_Config_Out::swap
friend void swap(StdCmds_Config_Out &a, StdCmds_Config_Out &b)
Definition: hellomalif.pb.h:2423
generated::zpb::hellomalif::StdCmds_Reset_Out::operator=
StdCmds_Reset_Out & operator=(const StdCmds_Reset_Out &from)
Definition: hellomalif.pb.h:1897
generated::zpb::hellomalif::ExceptionErr::kIndexInFileMessages
static constexpr int kIndexInFileMessages
Definition: hellomalif.pb.h:203
generated::zpb::hellomalif::StdCmds_Disable_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2160
generated::zpb::hellomalif::StdCmds_Reset_Out::New
StdCmds_Reset_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1945
generated::zpb::hellomalif::StdCmds_Reply::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:3160
generated::zpb::hellomalif::LogInfo::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:310
generated::zpb::hellomalif::StdCmds_Exit_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4648
generated::zpb::hellomalif::StdCmds_Return::release_exit
::generated::zpb::hellomalif::StdCmds_Exit_Out * release_exit()
Definition: hellomalif.pb.h:5114
generated::zpb::hellomalif::LogInfo::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:313
generated::zpb::hellomalif::StdCmds_Call::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1407
generated::zpb::hellomalif::StdCmds_Init_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1797
generated::zpb::hellomalif::StdCmds_Enable_Out::operator=
StdCmds_Enable_Out & operator=(const StdCmds_Enable_Out &from)
Definition: hellomalif.pb.h:2019
generated::zpb::hellomalif::StdCmds_Call::mutable_reset
::generated::zpb::hellomalif::StdCmds_Reset_In * mutable_reset()
Definition: hellomalif.pb.h:3654
generated::zpb::hellomalif::StdCmds_Init_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4120
generated::zpb::hellomalif::StdCmds_Enable_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:661
generated::zpb::hellomalif::LogInfo::set_allocated_level
void set_allocated_level(::std::string *level)
Definition: hellomalif.pb.h:3403
generated::zpb::hellomalif::StdCmds_Stop_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4540
generated::zpb::hellomalif::StdCmds_Request::has_header
bool has_header() const
Definition: hellomalif.pb.h:3987
generated::zpb::hellomalif::StdCmds_Stop_In
Definition: hellomalif.pb.h:1051
generated::zpb::hellomalif::StdCmds_Return::has_reset
bool has_reset() const
Definition: hellomalif.pb.h:4835
generated::zpb::hellomalif::StdCmds_Config_Out::New
StdCmds_Config_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2433
generated::zpb::hellomalif::StdCmds_Stop_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4523
generated::zpb::hellomalif::StdCmds_Call::release_exit
::generated::zpb::hellomalif::StdCmds_Exit_In * release_exit()
Definition: hellomalif.pb.h:3901
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::operator=
StdCmds_SetLogLevel_In & operator=(const StdCmds_SetLogLevel_In &from)
Definition: hellomalif.pb.h:1266
generated::zpb::hellomalif::StdCmds_Return::release_stop
::generated::zpb::hellomalif::StdCmds_Stop_Out * release_stop()
Definition: hellomalif.pb.h:5070
generated::zpb::hellomalif::StdCmds_Disable_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2163
generated::zpb::hellomalif::_StdCmds_Return_default_instance_
StdCmds_ReturnDefaultTypeInternal _StdCmds_Return_default_instance_
Definition: hellomalif.pb.h:105
generated::zpb::hellomalif::StdCmds_Call::operator=
StdCmds_Call & operator=(const StdCmds_Call &from)
Definition: hellomalif.pb.h:1385
generated::zpb::hellomalif::StdCmds_Enable_In::internal_default_instance
static const StdCmds_Enable_In * internal_default_instance()
Definition: hellomalif.pb.h:672
generated::zpb::hellomalif::StdCmds_Config_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4508
generated::zpb::hellomalif::ExceptionErr::default_instance
static const ExceptionErr & default_instance()
generated::zpb::hellomalif::StdCmds_Status_Out::internal_default_instance
static const StdCmds_Status_Out * internal_default_instance()
Definition: hellomalif.pb.h:2293
generated::zpb::hellomalif::StdCmds_Request::set_allocated_header
void set_allocated_header(::elt::mal::zpb::rr::RequestHeader *header)
Definition: hellomalif.pb.h:4021
generated::zpb::hellomalif::StdCmds_Request::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1660
generated::zpb::hellomalif::StdCmds_Config_In::New
StdCmds_Config_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1002
generated::zpb::hellomalif::StdCmds_Status_Out::operator=
StdCmds_Status_Out & operator=(const StdCmds_Status_Out &from)
Definition: hellomalif.pb.h:2263
generated::zpb::hellomalif::StdCmds_Stop_Out::internal_default_instance
static const StdCmds_Stop_Out * internal_default_instance()
Definition: hellomalif.pb.h:2537
generated::zpb::hellomalif::StdCmds_Call::has_stop
bool has_stop() const
Definition: hellomalif.pb.h:3842
generated::zpb::hellomalif::StdCmds_Stop_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4532
generated::zpb::hellomalif::StdCmds_Exit_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2648
generated::zpb::hellomalif::_StdCmds_Enable_In_default_instance_
StdCmds_Enable_InDefaultTypeInternal _StdCmds_Enable_In_default_instance_
Definition: hellomalif.pb.h:75
generated::zpb::hellomalif::StdCmds_Call::release_enable
::generated::zpb::hellomalif::StdCmds_Enable_In * release_enable()
Definition: hellomalif.pb.h:3681
generated::zpb::hellomalif::StdCmds_Call::internal_default_instance
static const StdCmds_Call * internal_default_instance()
Definition: hellomalif.pb.h:1428
generated::zpb::hellomalif::StdCmds_Enable_In::New
StdCmds_Enable_In * New() const final
Definition: hellomalif.pb.h:686
generated::zpb::exmalif::_StdCmds_Disable_In_default_instance_
StdCmds_Disable_InDefaultTypeInternal _StdCmds_Disable_In_default_instance_
generated::zpb::hellomalif::StdCmds_Status_Out::New
StdCmds_Status_Out * New() const final
Definition: hellomalif.pb.h:2307
generated::zpb::hellomalif::StdCmds_Return::release_status
::generated::zpb::hellomalif::StdCmds_Status_Out * release_status()
Definition: hellomalif.pb.h:4982
generated::zpb::exmalif::_StdCmds_Stop_In_default_instance_
StdCmds_Stop_InDefaultTypeInternal _StdCmds_Stop_In_default_instance_
generated::zpb::hellomalif::StdCmds_Call::stop
const ::generated::zpb::hellomalif::StdCmds_Stop_In & stop() const
Definition: hellomalif.pb.h:3868
generated::zpb::hellomalif::_StdCmds_Disable_In_default_instance_
StdCmds_Disable_InDefaultTypeInternal _StdCmds_Disable_In_default_instance_
Definition: hellomalif.pb.h:69
generated::zpb::hellomalif::StdCmds_Init_Out::swap
friend void swap(StdCmds_Init_Out &a, StdCmds_Init_Out &b)
Definition: hellomalif.pb.h:1813
generated::zpb::hellomalif::LogInfo::default_instance
static const LogInfo & default_instance()
generated::zpb::hellomalif::StdCmds_Config_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:973
generated::zpb::hellomalif::StdCmds_Reply::Swap
void Swap(StdCmds_Reply *other)
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::New
StdCmds_SetLogLevel_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2799
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::New
StdCmds_SetLogLevel_Out * New() const final
Definition: hellomalif.pb.h:2795
generated::zpb::hellomalif::StdCmds_Call::mutable_enable
::generated::zpb::hellomalif::StdCmds_Enable_In * mutable_enable()
Definition: hellomalif.pb.h:3698
generated::zpb::hellomalif::StdCmds_Stop_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4578
generated::zpb::hellomalif::StdCmds_Return::enable
const ::generated::zpb::hellomalif::StdCmds_Enable_Out & enable() const
Definition: hellomalif.pb.h:4905
generated::zpb::hellomalif::StdCmds_Status_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4425
generated::zpb::hellomalif::StdCmds_Return::mutable_reset
::generated::zpb::hellomalif::StdCmds_Reset_Out * mutable_reset()
Definition: hellomalif.pb.h:4867
generated::zpb::hellomalif::StdCmds_Call::has_disable
bool has_disable() const
Definition: hellomalif.pb.h:3710
generated::zpb::hellomalif::StdCmds_Return::mutable_config
::generated::zpb::hellomalif::StdCmds_Config_Out * mutable_config()
Definition: hellomalif.pb.h:5043
generated::zpb::hellomalif::StdCmds_Return::mutable_status
::generated::zpb::hellomalif::StdCmds_Status_Out * mutable_status()
Definition: hellomalif.pb.h:4999
protobuf_hellomalif_2eproto::TableStruct::aux
static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
Definition: hellomalif.pb.h:42
generated::zpb::hellomalif::StdCmds_Enable_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4256
generated::zpb::hellomalif::ExceptionErr::MergeFrom
void MergeFrom(const ::google::protobuf::Message &from) final
generated::zpb::hellomalif::StdCmds_Call::mutable_init
::generated::zpb::hellomalif::StdCmds_Init_In * mutable_init()
Definition: hellomalif.pb.h:3610
generated::zpb::hellomalif::StdCmds_Init_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4158
generated::zpb::hellomalif::StdCmds_Enable_In::New
StdCmds_Enable_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:690
generated::zpb::hellomalif::StdCmds_Init_Out::operator=
StdCmds_Init_Out & operator=(const StdCmds_Init_Out &from)
Definition: hellomalif.pb.h:1775
generated::zpb::hellomalif::StdCmds_Reset_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1919
generated::zpb::hellomalif::StdCmds_Reply::clear_data
void clear_data()
Definition: hellomalif.pb.h:5263
generated::zpb::hellomalif::StdCmds_Config_In::internal_default_instance
static const StdCmds_Config_In * internal_default_instance()
Definition: hellomalif.pb.h:984
generated::zpb::hellomalif::StdCmds_Request
Definition: hellomalif.pb.h:1631
generated::zpb::exmalif::_StdCmds_Exit_Out_default_instance_
StdCmds_Exit_OutDefaultTypeInternal _StdCmds_Exit_Out_default_instance_
generated::zpb::hellomalif::StdCmds_Stop_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1077
generated::zpb::hellomalif::StdCmds_Exit_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4640
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4710
generated::zpb::hellomalif::StdCmds_Status_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4392
generated::zpb::hellomalif::StdCmds_Stop_Out::New
StdCmds_Stop_Out * New() const final
Definition: hellomalif.pb.h:2551
generated::zpb::hellomalif::StdCmds_Stop_Out
Definition: hellomalif.pb.h:2500
generated::zpb::hellomalif::ExceptionErr::descriptor
static const ::google::protobuf::Descriptor * descriptor()
generated::zpb::hellomalif::StdCmds_Init_In::Clear
void Clear() final
generated::zpb::hellomalif::StdCmds_Return::release_reset
::generated::zpb::hellomalif::StdCmds_Reset_Out * release_reset()
Definition: hellomalif.pb.h:4850
generated::zpb::hellomalif::StdCmds_Init_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4116
generated::zpb::hellomalif::StdCmds_Reply::operator=
StdCmds_Reply & operator=(const StdCmds_Reply &from)
Definition: hellomalif.pb.h:3141
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::operator=
StdCmds_SetLogLevel_Out & operator=(const StdCmds_SetLogLevel_Out &from)
Definition: hellomalif.pb.h:2751
generated::zpb::exmalif::_StdCmds_SetLogLevel_Out_default_instance_
StdCmds_SetLogLevel_OutDefaultTypeInternal _StdCmds_SetLogLevel_Out_default_instance_
generated::zpb::hellomalif::StdCmds_Exit_In::New
StdCmds_Exit_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1210
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::mutable_exexceptionerr
::generated::zpb::hellomalif::ExceptionErr * mutable_exexceptionerr()
Definition: hellomalif.pb.h:4758
generated::zpb::hellomalif::StdCmds_Disable_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4355
generated::zpb::exmalif::_StdCmds_Call_default_instance_
StdCmds_CallDefaultTypeInternal _StdCmds_Call_default_instance_
generated::zpb::hellomalif::StdCmds_Init_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4103
generated::zpb::hellomalif::StdCmds_Init_In::MergeFrom
void MergeFrom(const ::google::protobuf::Message &from) final
generated::zpb::hellomalif::StdCmds_Init_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1794
generated::zpb::hellomalif::StdCmds_Return
Definition: hellomalif.pb.h:2881
generated::zpb::hellomalif::StdCmds_Reply::internal_default_instance
static const StdCmds_Reply * internal_default_instance()
Definition: hellomalif.pb.h:3171
generated::zpb::hellomalif::StdCmds_Disable_Out::operator=
StdCmds_Disable_Out & operator=(const StdCmds_Disable_Out &from)
Definition: hellomalif.pb.h:2141
generated::zpb::hellomalif::StdCmds_Enable_In::operator=
StdCmds_Enable_In & operator=(const StdCmds_Enable_In &from)
Definition: hellomalif.pb.h:642
generated::zpb::hellomalif::StdCmds_Exit_In::Swap
void Swap(StdCmds_Exit_In *other)
generated::zpb::hellomalif::LogInfo::clear_level
void clear_level()
Definition: hellomalif.pb.h:3357
generated::zpb::hellomalif::LogInfo::has_level
bool has_level() const
Definition: hellomalif.pb.h:3348
generated::zpb::hellomalif::_StdCmds_Stop_Out_default_instance_
StdCmds_Stop_OutDefaultTypeInternal _StdCmds_Stop_Out_default_instance_
Definition: hellomalif.pb.h:123
generated::zpb::hellomalif::StdCmds_Return::release_enable
::generated::zpb::hellomalif::StdCmds_Enable_Out * release_enable()
Definition: hellomalif.pb.h:4894
generated::zpb::hellomalif::StdCmds_Init_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:453
generated::zpb::hellomalif::StdCmds_Request::New
StdCmds_Request * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1686
generated::zpb::hellomalif::StdCmds_Return::has_enable
bool has_enable() const
Definition: hellomalif.pb.h:4879
generated::zpb::hellomalif::LogInfo::mutable_level
::std::string * mutable_level()
Definition: hellomalif.pb.h:3390
generated::zpb::hellomalif::LogInfo::release_logger
::std::string * release_logger()
Definition: hellomalif.pb.h:3461
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4663
generated::zpb::hellomalif::StdCmds_Exit_Out::New
StdCmds_Exit_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2677
protobuf_hellomalif_2eproto::TableStruct::offsets
static const ::google::protobuf::uint32 offsets[]
Definition: hellomalif.pb.h:46
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4672
generated::zpb::hellomalif::StdCmds_Stop_In::operator=
StdCmds_Stop_In & operator=(const StdCmds_Stop_In &from)
Definition: hellomalif.pb.h:1058
generated::zpb::hellomalif::LogInfo::internal_default_instance
static const LogInfo * internal_default_instance()
Definition: hellomalif.pb.h:321
generated::zpb::exmalif::_StdCmds_Reset_Out_default_instance_
StdCmds_Reset_OutDefaultTypeInternal _StdCmds_Reset_Out_default_instance_
generated::zpb::hellomalif::StdCmds_Reply::mutable_data
::generated::zpb::hellomalif::StdCmds_Return * mutable_data()
Definition: hellomalif.pb.h:5283
generated::zpb::hellomalif::StdCmds_Disable_In::New
StdCmds_Disable_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:794
generated::zpb::hellomalif::StdCmds_Enable_Out::New
StdCmds_Enable_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2067
generated::zpb::hellomalif::StdCmds_Reset_In::New
StdCmds_Reset_In * New() const final
Definition: hellomalif.pb.h:582
generated::zpb::hellomalif::StdCmds_Config_In::New
StdCmds_Config_In * New() const final
Definition: hellomalif.pb.h:998
generated::zpb::hellomalif::StdCmds_Request::swap
friend void swap(StdCmds_Request &a, StdCmds_Request &b)
Definition: hellomalif.pb.h:1676
generated::zpb::hellomalif::StdCmds_Reset_In::swap
friend void swap(StdCmds_Reset_In &a, StdCmds_Reset_In &b)
Definition: hellomalif.pb.h:576
generated::zpb::hellomalif::ExceptionErr
Definition: hellomalif.pb.h:162
generated::zpb::exmalif::_StdCmds_Status_In_default_instance_
StdCmds_Status_InDefaultTypeInternal _StdCmds_Status_In_default_instance_
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::set_allocated_info
void set_allocated_info(::generated::zpb::hellomalif::LogInfo *info)
Definition: hellomalif.pb.h:3554
generated::zpb::hellomalif::StdCmds_Init_In::ByteSizeLong
size_t ByteSizeLong() const final
generated::zpb::hellomalif::StdCmds_Init_In::swap
friend void swap(StdCmds_Init_In &a, StdCmds_Init_In &b)
Definition: hellomalif.pb.h:472
generated::zpb::hellomalif::StdCmds_Status_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4438
generated::zpb::hellomalif::StdCmds_Status_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2282
generated::zpb::hellomalif::StdCmds_Return::clear_status
void clear_status()
Definition: hellomalif.pb.h:4973
generated::zpb::hellomalif::ExceptionErr::set_allocated_desc
void set_allocated_desc(::std::string *desc)
Definition: hellomalif.pb.h:3333
hellomalif
package generated zpb hellomalif
Definition: hellomalif.proto:11
generated::zpb::hellomalif::LogInfo::MergePartialFromCodedStream
bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream *input) final
generated::zpb::hellomalif::StdCmds_Init_In::internal_default_instance
static const StdCmds_Init_In * internal_default_instance()
Definition: hellomalif.pb.h:464
generated::zpb::hellomalif::StdCmds_Reset_In
Definition: hellomalif.pb.h:531
generated::zpb::hellomalif::LogInfo::SerializeWithCachedSizes
void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream *output) const final
generated::zpb::hellomalif::StdCmds_Return::has_stop
bool has_stop() const
Definition: hellomalif.pb.h:5055
generated::zpb::hellomalif::_StdCmds_Reply_default_instance_
StdCmds_ReplyDefaultTypeInternal _StdCmds_Reply_default_instance_
Definition: hellomalif.pb.h:93
generated::zpb::hellomalif::StdCmds_Init_In::MergePartialFromCodedStream
bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream *input) final
generated::zpb::hellomalif::LogInfo::New
LogInfo * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:339
generated::zpb::hellomalif::StdCmds_Status_In::swap
friend void swap(StdCmds_Status_In &a, StdCmds_Status_In &b)
Definition: hellomalif.pb.h:888
generated::zpb::hellomalif::StdCmds_Disable_In
Definition: hellomalif.pb.h:739
generated::zpb::hellomalif::StdCmds_Status_Out::Swap
void Swap(StdCmds_Status_Out *other)
generated::zpb::hellomalif::StdCmds_Reset_In::internal_default_instance
static const StdCmds_Reset_In * internal_default_instance()
Definition: hellomalif.pb.h:568
generated::zpb::hellomalif::StdCmds_Reset_In::Swap
void Swap(StdCmds_Reset_In *other)
generated::zpb::hellomalif::StdCmds_Init_In::SerializeWithCachedSizes
void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream *output) const final
generated::zpb::hellomalif::StdCmds_Init_In::New
StdCmds_Init_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:482
generated::zpb::hellomalif::StdCmds_Call::release_status
::generated::zpb::hellomalif::StdCmds_Status_In * release_status()
Definition: hellomalif.pb.h:3769
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::mutable_info
::generated::zpb::hellomalif::LogInfo * mutable_info()
Definition: hellomalif.pb.h:3545
generated::zpb::hellomalif::StdCmds_Call::status
const ::generated::zpb::hellomalif::StdCmds_Status_In & status() const
Definition: hellomalif.pb.h:3780
generated::zpb::hellomalif::_StdCmds_Request_default_instance_
StdCmds_RequestDefaultTypeInternal _StdCmds_Request_default_instance_
Definition: hellomalif.pb.h:96
generated::zpb::hellomalif::ExceptionErr::New
ExceptionErr * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:217
generated::zpb::hellomalif::StdCmds_Stop_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2526
generated::zpb::hellomalif::ExceptionErr::mutable_desc
::std::string * mutable_desc()
Definition: hellomalif.pb.h:3320
protobuf_hellomalif_2eproto::TableStruct::serialization_table
static const ::google::protobuf::internal::SerializationTable serialization_table[]
Definition: hellomalif.pb.h:45
generated::zpb::hellomalif::StdCmds_Return::ReplyCase
ReplyCase
Definition: hellomalif.pb.h:2917
generated::zpb::hellomalif::StdCmds_Return::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:2907
generated::zpb::hellomalif::StdCmds_Reply::header
const ::elt::mal::zpb::rr::ReplyHeader & header() const
Definition: hellomalif.pb.h:5212
generated::zpb::hellomalif::LogInfo::GetCachedSize
int GetCachedSize() const final
Definition: hellomalif.pb.h:356
generated::zpb::hellomalif::StdCmds_Call::New
StdCmds_Call * New() const final
Definition: hellomalif.pb.h:1442
generated::zpb::hellomalif::StdCmds_Reset_Out::New
StdCmds_Reset_Out * New() const final
Definition: hellomalif.pb.h:1941
generated::zpb::hellomalif::LogInfo::mutable_logger
::std::string * mutable_logger()
Definition: hellomalif.pb.h:3456
generated::zpb::exmalif::_StdCmds_Init_In_default_instance_
StdCmds_Init_InDefaultTypeInternal _StdCmds_Init_In_default_instance_
generated::zpb::hellomalif::StdCmds_Return::clear_disable
void clear_disable()
Definition: hellomalif.pb.h:4929
generated::zpb::hellomalif::StdCmds_Return::reset
const ::generated::zpb::hellomalif::StdCmds_Reset_Out & reset() const
Definition: hellomalif.pb.h:4861
generated::zpb::hellomalif::StdCmds_Stop_In::internal_default_instance
static const StdCmds_Stop_In * internal_default_instance()
Definition: hellomalif.pb.h:1088
generated::zpb::hellomalif::StdCmds_Init_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:456
generated::zpb::hellomalif::StdCmds_Disable_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4313
generated::zpb::hellomalif::StdCmds_Init_In::InternalSerializeWithCachedSizesToArray
::google::protobuf::uint8 * InternalSerializeWithCachedSizesToArray(bool deterministic,::google::protobuf::uint8 *target) const final
generated::zpb::hellomalif::StdCmds_Disable_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4322
generated::zpb::hellomalif::LogInfo::kLoggerFieldNumber
static const int kLoggerFieldNumber
Definition: hellomalif.pb.h:396
generated::zpb::hellomalif::StdCmds_Return::clear_setloglevel
void clear_setloglevel()
Definition: hellomalif.pb.h:5149
generated::zpb::hellomalif::ExceptionErr::operator=
ExceptionErr & operator=(const ExceptionErr &from)
Definition: hellomalif.pb.h:169
generated::zpb::hellomalif::StdCmds_Request::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1657
generated::zpb::hellomalif::StdCmds_Reply::release_data
::generated::zpb::hellomalif::StdCmds_Return * release_data()
Definition: hellomalif.pb.h:5276
generated::zpb::hellomalif::StdCmds_Call::New
StdCmds_Call * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1446
generated::zpb::hellomalif::StdCmds_Return::release_disable
::generated::zpb::hellomalif::StdCmds_Disable_Out * release_disable()
Definition: hellomalif.pb.h:4938
generated::zpb::hellomalif::StdCmds_Return::config
const ::generated::zpb::hellomalif::StdCmds_Config_Out & config() const
Definition: hellomalif.pb.h:5037
generated::zpb::hellomalif::StdCmds_Return::internal_default_instance
static const StdCmds_Return * internal_default_instance()
Definition: hellomalif.pb.h:2931
generated::zpb::hellomalif::StdCmds_Exit_In::internal_default_instance
static const StdCmds_Exit_In * internal_default_instance()
Definition: hellomalif.pb.h:1192
generated::zpb::hellomalif::StdCmds_Disable_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4368
generated::zpb::hellomalif::StdCmds_Init_In::IsInitialized
bool IsInitialized() const final
generated::zpb::hellomalif::StdCmds_Init_In::descriptor
static const ::google::protobuf::Descriptor * descriptor()
generated::zpb::hellomalif::StdCmds_Call::mutable_config
::generated::zpb::hellomalif::StdCmds_Config_In * mutable_config()
Definition: hellomalif.pb.h:3830
generated::zpb::hellomalif::_StdCmds_Exit_Out_default_instance_
StdCmds_Exit_OutDefaultTypeInternal _StdCmds_Exit_Out_default_instance_
Definition: hellomalif.pb.h:84
generated::zpb::hellomalif::StdCmds_Call::release_setloglevel
::generated::zpb::hellomalif::StdCmds_SetLogLevel_In * release_setloglevel()
Definition: hellomalif.pb.h:3945
generated::zpb::hellomalif::StdCmds_Status_In::New
StdCmds_Status_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:898
generated::zpb::hellomalif::ExceptionErr::swap
friend void swap(ExceptionErr &a, ExceptionErr &b)
Definition: hellomalif.pb.h:207
generated::zpb::hellomalif::StdCmds_Exit_Out::internal_default_instance
static const StdCmds_Exit_Out * internal_default_instance()
Definition: hellomalif.pb.h:2659
generated::zpb::hellomalif::StdCmds_Reset_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4228
generated::zpb::hellomalif::_StdCmds_Status_Out_default_instance_
StdCmds_Status_OutDefaultTypeInternal _StdCmds_Status_Out_default_instance_
Definition: hellomalif.pb.h:117
generated::zpb::hellomalif::LogInfo::clear_logger
void clear_logger()
Definition: hellomalif.pb.h:3423
generated::zpb::hellomalif::LogInfo::swap
friend void swap(LogInfo &a, LogInfo &b)
Definition: hellomalif.pb.h:329
generated::zpb::hellomalif::StdCmds_Request::internal_default_instance
static const StdCmds_Request * internal_default_instance()
Definition: hellomalif.pb.h:1668
generated::zpb::hellomalif::LogInfo::kIndexInFileMessages
static constexpr int kIndexInFileMessages
Definition: hellomalif.pb.h:325
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::release_info
::generated::zpb::hellomalif::LogInfo * release_info()
Definition: hellomalif.pb.h:3538
generated::zpb::hellomalif::_StdCmds_Init_In_default_instance_
StdCmds_Init_InDefaultTypeInternal _StdCmds_Init_In_default_instance_
Definition: hellomalif.pb.h:87
generated::zpb::hellomalif::StdCmds_Return::release_init
::generated::zpb::hellomalif::StdCmds_Init_Out * release_init()
Definition: hellomalif.pb.h:4806
generated::zpb::hellomalif::StdCmds_Init_Out::internal_default_instance
static const StdCmds_Init_Out * internal_default_instance()
Definition: hellomalif.pb.h:1805
generated::zpb::hellomalif::StdCmds_Reset_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4220
generated::zpb::hellomalif::StdCmds_Status_Out::swap
friend void swap(StdCmds_Status_Out &a, StdCmds_Status_Out &b)
Definition: hellomalif.pb.h:2301
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4705
generated::zpb::hellomalif::StdCmds_Call::mutable_setloglevel
::generated::zpb::hellomalif::StdCmds_SetLogLevel_In * mutable_setloglevel()
Definition: hellomalif.pb.h:3962
generated::zpb::exmalif::_StdCmds_Init_Out_default_instance_
StdCmds_Init_OutDefaultTypeInternal _StdCmds_Init_Out_default_instance_
generated::zpb::hellomalif::StdCmds_Stop_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2529
generated::zpb::hellomalif::StdCmds_Call::clear_status
void clear_status()
Definition: hellomalif.pb.h:3760
generated::zpb::hellomalif::StdCmds_Disable_In::swap
friend void swap(StdCmds_Disable_In &a, StdCmds_Disable_In &b)
Definition: hellomalif.pb.h:784
generated::zpb::hellomalif::StdCmds_Call::release_stop
::generated::zpb::hellomalif::StdCmds_Stop_In * release_stop()
Definition: hellomalif.pb.h:3857
generated::zpb::exmalif::_StdCmds_Enable_In_default_instance_
StdCmds_Enable_InDefaultTypeInternal _StdCmds_Enable_In_default_instance_
generated::zpb::hellomalif::StdCmds_Disable_Out::swap
friend void swap(StdCmds_Disable_Out &a, StdCmds_Disable_Out &b)
Definition: hellomalif.pb.h:2179
generated::zpb::hellomalif::StdCmds_Exit_Out::Swap
void Swap(StdCmds_Exit_Out *other)
generated::zpb::exmalif::_StdCmds_Exit_In_default_instance_
StdCmds_Exit_InDefaultTypeInternal _StdCmds_Exit_In_default_instance_
generated::zpb::hellomalif::StdCmds_Request::mutable_data
::generated::zpb::hellomalif::StdCmds_Call * mutable_data()
Definition: hellomalif.pb.h:4070
generated::zpb::hellomalif::StdCmds_Return::release_setloglevel
::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out * release_setloglevel()
Definition: hellomalif.pb.h:5158
generated::zpb::hellomalif::StdCmds_Stop_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1080
generated::zpb::hellomalif::StdCmds_Call::has_enable
bool has_enable() const
Definition: hellomalif.pb.h:3666
LogInfo
message LogInfo
Definition: exmalif.proto:23
generated::zpb::hellomalif::StdCmds_Config_Out::Swap
void Swap(StdCmds_Config_Out *other)
generated::zpb::hellomalif::StdCmds_Enable_In::swap
friend void swap(StdCmds_Enable_In &a, StdCmds_Enable_In &b)
Definition: hellomalif.pb.h:680
generated::zpb::hellomalif::StdCmds_Disable_In::New
StdCmds_Disable_In * New() const final
Definition: hellomalif.pb.h:790
generated::zpb::hellomalif::StdCmds_Call::Swap
void Swap(StdCmds_Call *other)
generated::zpb::hellomalif::ExceptionErr::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:188
generated::zpb::hellomalif::ExceptionErr::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:191
generated::zpb::hellomalif::StdCmds_Status_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4430
generated::zpb::hellomalif::StdCmds_Call::clear_config
void clear_config()
Definition: hellomalif.pb.h:3804
generated::zpb::hellomalif::StdCmds_Disable_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4330
generated::zpb::hellomalif::StdCmds_Disable_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:765
generated::zpb::exmalif::_ExceptionErr_default_instance_
ExceptionErrDefaultTypeInternal _ExceptionErr_default_instance_
generated::zpb::hellomalif::LogInfo::MergeFrom
void MergeFrom(const ::google::protobuf::Message &from) final
generated::zpb::hellomalif::StdCmds_Return::mutable_setloglevel
::generated::zpb::hellomalif::StdCmds_SetLogLevel_Out * mutable_setloglevel()
Definition: hellomalif.pb.h:5175
generated::zpb::hellomalif::StdCmds_Init_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4150
generated::zpb::hellomalif::ExceptionErr::GetMetadata
::google::protobuf::Metadata GetMetadata() const final
generated::zpb::hellomalif::StdCmds_Reply::set_allocated_header
void set_allocated_header(::elt::mal::zpb::rr::ReplyHeader *header)
Definition: hellomalif.pb.h:5234
generated::zpb::hellomalif::StdCmds_Reset_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4190
generated::zpb::hellomalif::StdCmds_Status_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4383
generated::zpb::hellomalif::StdCmds_Call::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1404
generated::zpb::hellomalif::StdCmds_Request::set_allocated_data
void set_allocated_data(::generated::zpb::hellomalif::StdCmds_Call *data)
Definition: hellomalif.pb.h:4079
generated::zpb::hellomalif::StdCmds_Disable_In::internal_default_instance
static const StdCmds_Disable_In * internal_default_instance()
Definition: hellomalif.pb.h:776
generated::zpb::hellomalif::StdCmds_Return::clear_config
void clear_config()
Definition: hellomalif.pb.h:5017
generated::zpb::hellomalif::StdCmds_Reply::has_data
bool has_data() const
Definition: hellomalif.pb.h:5254
generated::zpb::hellomalif::StdCmds_Return::clear_reset
void clear_reset()
Definition: hellomalif.pb.h:4841
generated::zpb::hellomalif::StdCmds_Init_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4112
generated::zpb::hellomalif::StdCmds_Stop_Out::Swap
void Swap(StdCmds_Stop_Out *other)
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::set_allocated_retval
void set_allocated_retval(::std::string *retval)
Definition: hellomalif.pb.h:4718
generated::zpb::hellomalif::StdCmds_Call::has_init
bool has_init() const
Definition: hellomalif.pb.h:3578
generated::zpb::hellomalif::StdCmds_Exit_In::swap
friend void swap(StdCmds_Exit_In &a, StdCmds_Exit_In &b)
Definition: hellomalif.pb.h:1200
generated::zpb::hellomalif::StdCmds_Stop_Out::New
StdCmds_Stop_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2555
generated::zpb::hellomalif::StdCmds_Request::data
const ::generated::zpb::hellomalif::StdCmds_Call & data() const
Definition: hellomalif.pb.h:4057
generated::zpb::hellomalif::LogInfo
Definition: hellomalif.pb.h:284
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::Swap
void Swap(StdCmds_SetLogLevel_In *other)
generated::zpb::hellomalif::LogInfo::set_logger
void set_logger(const ::std::string &value)
Definition: hellomalif.pb.h:3431
generated::zpb::hellomalif::StdCmds_Return::clear_init
void clear_init()
Definition: hellomalif.pb.h:4797
generated::zpb::hellomalif::StdCmds_Return::release_config
::generated::zpb::hellomalif::StdCmds_Config_Out * release_config()
Definition: hellomalif.pb.h:5026
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::clear_exexceptionerr
void clear_exexceptionerr()
Definition: hellomalif.pb.h:4738
generated::zpb::hellomalif::StdCmds_Reset_Out::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1916
generated::zpb::hellomalif::StdCmds_Init_In::Swap
void Swap(StdCmds_Init_In *other)
generated::zpb::exmalif::_StdCmds_Config_In_default_instance_
StdCmds_Config_InDefaultTypeInternal _StdCmds_Config_In_default_instance_
generated::zpb::hellomalif::StdCmds_Reply::set_allocated_data
void set_allocated_data(::generated::zpb::hellomalif::StdCmds_Return *data)
Definition: hellomalif.pb.h:5292
generated::zpb::exmalif::_StdCmds_Enable_Out_default_instance_
StdCmds_Enable_OutDefaultTypeInternal _StdCmds_Enable_Out_default_instance_
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1285
generated::zpb::hellomalif::StdCmds_Return::has_disable
bool has_disable() const
Definition: hellomalif.pb.h:4923
generated::zpb::hellomalif::StdCmds_Return::reply_case
ReplyCase reply_case() const
Definition: hellomalif.pb.h:5192
generated::zpb::hellomalif::StdCmds_Call::release_disable
::generated::zpb::hellomalif::StdCmds_Disable_In * release_disable()
Definition: hellomalif.pb.h:3725
generated::zpb::hellomalif::StdCmds_Disable_Out::New
StdCmds_Disable_Out * New() const final
Definition: hellomalif.pb.h:2185
generated::zpb::hellomalif::StdCmds_Call::enable
const ::generated::zpb::hellomalif::StdCmds_Enable_In & enable() const
Definition: hellomalif.pb.h:3692
generated::zpb::hellomalif::StdCmds_Exit_In
Definition: hellomalif.pb.h:1155
generated::zpb::hellomalif::StdCmds_Reset_In::operator=
StdCmds_Reset_In & operator=(const StdCmds_Reset_In &from)
Definition: hellomalif.pb.h:538
generated::zpb::hellomalif::StdCmds_Enable_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2041
generated::zpb::hellomalif::StdCmds_Status_In::New
StdCmds_Status_In * New() const final
Definition: hellomalif.pb.h:894
generated::zpb::hellomalif::StdCmds_Return::New
StdCmds_Return * New() const final
Definition: hellomalif.pb.h:2945
generated::zpb::hellomalif::StdCmds_Config_In
Definition: hellomalif.pb.h:947
generated::zpb::hellomalif::StdCmds_Call::exit
const ::generated::zpb::hellomalif::StdCmds_Exit_In & exit() const
Definition: hellomalif.pb.h:3912
generated::zpb::hellomalif::StdCmds_Return::mutable_init
::generated::zpb::hellomalif::StdCmds_Init_Out * mutable_init()
Definition: hellomalif.pb.h:4823
generated::zpb::hellomalif::StdCmds_Disable_Out
Definition: hellomalif.pb.h:2134
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::New
StdCmds_SetLogLevel_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1314
generated::zpb::hellomalif::StdCmds_Call::mutable_status
::generated::zpb::hellomalif::StdCmds_Status_In * mutable_status()
Definition: hellomalif.pb.h:3786
generated::zpb::hellomalif::StdCmds_Status_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:869
generated::zpb::hellomalif::ExceptionErr::SerializeWithCachedSizes
void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream *output) const final
generated::zpb::hellomalif::StdCmds_Config_In::swap
friend void swap(StdCmds_Config_In &a, StdCmds_Config_In &b)
Definition: hellomalif.pb.h:992
generated::zpb::hellomalif::StdCmds_Call::has_exit
bool has_exit() const
Definition: hellomalif.pb.h:3886
generated::zpb::hellomalif::_LogInfo_default_instance_
LogInfoDefaultTypeInternal _LogInfo_default_instance_
Definition: hellomalif.pb.h:57
generated::zpb::hellomalif::StdCmds_Init_In::default_instance
static const StdCmds_Init_In & default_instance()
generated::zpb::hellomalif::ExceptionErr::InternalSerializeWithCachedSizesToArray
::google::protobuf::uint8 * InternalSerializeWithCachedSizesToArray(bool deterministic,::google::protobuf::uint8 *target) const final
generated::zpb::hellomalif::StdCmds_Status_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2285
generated::zpb::hellomalif::LogInfo::ByteSizeLong
size_t ByteSizeLong() const final
generated::zpb::hellomalif::_StdCmds_Config_Out_default_instance_
StdCmds_Config_OutDefaultTypeInternal _StdCmds_Config_Out_default_instance_
Definition: hellomalif.pb.h:66
generated::zpb::hellomalif::StdCmds_Enable_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4260
generated::zpb::hellomalif::StdCmds_Reply::New
StdCmds_Reply * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:3189
generated::zpb::hellomalif::StdCmds_Exit_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4610
generated::zpb::hellomalif::LogInfo::level
const ::std::string & level() const
Definition: hellomalif.pb.h:3361
generated::zpb::hellomalif::_StdCmds_Init_Out_default_instance_
StdCmds_Init_OutDefaultTypeInternal _StdCmds_Init_Out_default_instance_
Definition: hellomalif.pb.h:90
generated::zpb::hellomalif::_StdCmds_SetLogLevel_Out_default_instance_
StdCmds_SetLogLevel_OutDefaultTypeInternal _StdCmds_SetLogLevel_Out_default_instance_
Definition: hellomalif.pb.h:111
generated::zpb::hellomalif::StdCmds_Return::New
StdCmds_Return * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2949
generated::zpb::hellomalif::StdCmds_Call::swap
friend void swap(StdCmds_Call &a, StdCmds_Call &b)
Definition: hellomalif.pb.h:1436
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::exexceptionerr
const ::generated::zpb::hellomalif::ExceptionErr & exexceptionerr() const
Definition: hellomalif.pb.h:4745
generated::zpb::hellomalif::StdCmds_Return::disable
const ::generated::zpb::hellomalif::StdCmds_Disable_Out & disable() const
Definition: hellomalif.pb.h:4949
generated::zpb::hellomalif::StdCmds_Return::Swap
void Swap(StdCmds_Return *other)
protobuf_hellomalif_2eproto::AddDescriptors
void AddDescriptors()
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::clear_info
void clear_info()
Definition: hellomalif.pb.h:3525
generated::zpb::hellomalif::StdCmds_Call::RequestCase
RequestCase
Definition: hellomalif.pb.h:1414
generated::zpb::hellomalif::StdCmds_Enable_Out::New
StdCmds_Enable_Out * New() const final
Definition: hellomalif.pb.h:2063
generated::zpb::hellomalif::StdCmds_Stop_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4565
generated::zpb::hellomalif::StdCmds_Enable_Out::internal_default_instance
static const StdCmds_Enable_Out * internal_default_instance()
Definition: hellomalif.pb.h:2049
generated::zpb::hellomalif::StdCmds_Reply::release_header
::elt::mal::zpb::rr::ReplyHeader * release_header()
Definition: hellomalif.pb.h:5218
generated::zpb::hellomalif::StdCmds_Config_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4466
generated::zpb::hellomalif::StdCmds_Config_Out::operator=
StdCmds_Config_Out & operator=(const StdCmds_Config_Out &from)
Definition: hellomalif.pb.h:2385
generated::zpb::hellomalif::_StdCmds_SetLogLevel_In_default_instance_
StdCmds_SetLogLevel_InDefaultTypeInternal _StdCmds_SetLogLevel_In_default_instance_
Definition: hellomalif.pb.h:108
generated::zpb::hellomalif::StdCmds_Exit_In::operator=
StdCmds_Exit_In & operator=(const StdCmds_Exit_In &from)
Definition: hellomalif.pb.h:1162
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::swap
friend void swap(StdCmds_SetLogLevel_In &a, StdCmds_SetLogLevel_In &b)
Definition: hellomalif.pb.h:1304
generated::zpb::hellomalif::StdCmds_Enable_Out
Definition: hellomalif.pb.h:2012
generated::zpb::hellomalif::StdCmds_Request::mutable_header
::elt::mal::zpb::rr::RequestHeader * mutable_header()
Definition: hellomalif.pb.h:4012
generated::zpb::hellomalif::StdCmds_Return::swap
friend void swap(StdCmds_Return &a, StdCmds_Return &b)
Definition: hellomalif.pb.h:2939
generated::zpb::hellomalif::_StdCmds_Enable_Out_default_instance_
StdCmds_Enable_OutDefaultTypeInternal _StdCmds_Enable_Out_default_instance_
Definition: hellomalif.pb.h:78
generated::zpb::hellomalif::StdCmds_Call::init
const ::generated::zpb::hellomalif::StdCmds_Init_In & init() const
Definition: hellomalif.pb.h:3604
generated::zpb::hellomalif::StdCmds_Init_In::InitAsDefaultInstance
static void InitAsDefaultInstance()
generated::zpb::hellomalif::StdCmds_Call::clear_init
void clear_init()
Definition: hellomalif.pb.h:3584
generated::zpb::hellomalif::ExceptionErr::clear_desc
void clear_desc()
Definition: hellomalif.pb.h:3287
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::internal_default_instance
static const StdCmds_SetLogLevel_In * internal_default_instance()
Definition: hellomalif.pb.h:1296
generated::zpb::hellomalif::StdCmds_Reset_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4186
generated::zpb::hellomalif::StdCmds_Reset_Out::internal_default_instance
static const StdCmds_Reset_Out * internal_default_instance()
Definition: hellomalif.pb.h:1927
generated::zpb::hellomalif::StdCmds_Call::clear_setloglevel
void clear_setloglevel()
Definition: hellomalif.pb.h:3936
generated::zpb::hellomalif::LogInfo::has_logger
bool has_logger() const
Definition: hellomalif.pb.h:3414
generated::zpb::hellomalif::StdCmds_Reset_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4182
generated::zpb::hellomalif::StdCmds_Config_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:976
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::Swap
void Swap(StdCmds_SetLogLevel_Out *other)
generated::zpb::hellomalif::StdCmds_Reset_Out
Definition: hellomalif.pb.h:1890
generated::zpb::hellomalif::StdCmds_Exit_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1184
generated::zpb::hellomalif::ExceptionErr::release_desc
::std::string * release_desc()
Definition: hellomalif.pb.h:3325
generated::zpb::hellomalif::StdCmds_Init_In::GetCachedSize
int GetCachedSize() const final
Definition: hellomalif.pb.h:499
generated::zpb::hellomalif::StdCmds_Return::has_status
bool has_status() const
Definition: hellomalif.pb.h:4967
generated::zpb::hellomalif::StdCmds_Stop_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4570
generated::zpb::hellomalif::StdCmds_Init_Out::Swap
void Swap(StdCmds_Init_Out *other)
generated::zpb::hellomalif::StdCmds_Status_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4400
generated::zpb::hellomalif::LogInfo::operator=
LogInfo & operator=(const LogInfo &from)
Definition: hellomalif.pb.h:291
generated::zpb::hellomalif::StdCmds_Status_In
Definition: hellomalif.pb.h:843
generated::zpb::hellomalif::StdCmds_Stop_In::New
StdCmds_Stop_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:1106
generated::zpb::hellomalif::StdCmds_Reset_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4173
generated::zpb::hellomalif::StdCmds_Return::status
const ::generated::zpb::hellomalif::StdCmds_Status_Out & status() const
Definition: hellomalif.pb.h:4993
generated::zpb::hellomalif::LogInfo::GetMetadata
::google::protobuf::Metadata GetMetadata() const final
generated::zpb::hellomalif::StdCmds_Disable_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4326
generated::zpb::hellomalif::StdCmds_Request::New
StdCmds_Request * New() const final
Definition: hellomalif.pb.h:1682
generated::zpb::hellomalif::StdCmds_Call::has_reset
bool has_reset() const
Definition: hellomalif.pb.h:3622
generated::zpb::hellomalif::_StdCmds_Config_In_default_instance_
StdCmds_Config_InDefaultTypeInternal _StdCmds_Config_In_default_instance_
Definition: hellomalif.pb.h:63
generated::zpb::hellomalif::StdCmds_Exit_Out::mutable_retval
::std::string * mutable_retval()
Definition: hellomalif.pb.h:4635
generated::zpb::hellomalif::StdCmds_Call::release_init
::generated::zpb::hellomalif::StdCmds_Init_In * release_init()
Definition: hellomalif.pb.h:3593
ExceptionErr
message ExceptionErr
Definition: exmalif.proto:28
generated::zpb::hellomalif::StdCmds_Return::init
const ::generated::zpb::hellomalif::StdCmds_Init_Out & init() const
Definition: hellomalif.pb.h:4817
generated::zpb::hellomalif::StdCmds_Call::clear_enable
void clear_enable()
Definition: hellomalif.pb.h:3672
generated::zpb::hellomalif::StdCmds_Config_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4500
generated::zpb::hellomalif::StdCmds_Reset_Out::swap
friend void swap(StdCmds_Reset_Out &a, StdCmds_Reset_Out &b)
Definition: hellomalif.pb.h:1935
generated::zpb::hellomalif::StdCmds_Call::has_status
bool has_status() const
Definition: hellomalif.pb.h:3754
generated::zpb::hellomalif::StdCmds_Exit_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4593
generated::zpb::hellomalif::StdCmds_Reset_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:560
generated::zpb::hellomalif::StdCmds_Request::Swap
void Swap(StdCmds_Request *other)
generated::zpb::hellomalif::_StdCmds_Exit_In_default_instance_
StdCmds_Exit_InDefaultTypeInternal _StdCmds_Exit_In_default_instance_
Definition: hellomalif.pb.h:81
generated::zpb::hellomalif::StdCmds_Enable_Out::has_retval
bool has_retval() const
Definition: hellomalif.pb.h:4243
generated::zpb::hellomalif::StdCmds_Call::request_case
RequestCase request_case() const
Definition: hellomalif.pb.h:3979
generated::zpb::hellomalif::StdCmds_Config_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2407
generated::zpb::hellomalif::StdCmds_Disable_Out::Swap
void Swap(StdCmds_Disable_Out *other)
generated::zpb::hellomalif::StdCmds_Init_Out
Definition: hellomalif.pb.h:1768
generated::zpb::hellomalif::StdCmds_SetLogLevel_In
Definition: hellomalif.pb.h:1259
generated::zpb::hellomalif::StdCmds_Return::clear_stop
void clear_stop()
Definition: hellomalif.pb.h:5061
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::set_retval
void set_retval(const ::std::string &value)
Definition: hellomalif.pb.h:4680
generated::zpb::hellomalif::StdCmds_Exit_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:1181
generated::zpb::hellomalif::StdCmds_Reset_In::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const
Definition: hellomalif.pb.h:557
generated::zpb::exmalif::_StdCmds_Stop_Out_default_instance_
StdCmds_Stop_OutDefaultTypeInternal _StdCmds_Stop_Out_default_instance_
generated::zpb::hellomalif::StdCmds_SetLogLevel_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:1288
generated::zpb::hellomalif::StdCmds_Disable_Out::New
StdCmds_Disable_Out * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:2189
generated::zpb::hellomalif::StdCmds_Return::operator=
StdCmds_Return & operator=(const StdCmds_Return &from)
Definition: hellomalif.pb.h:2888
generated::zpb::hellomalif::StdCmds_Init_In::New
StdCmds_Init_In * New() const final
Definition: hellomalif.pb.h:478
generated::zpb::hellomalif::StdCmds_Exit_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4606
generated::zpb::hellomalif::StdCmds_Enable_In
Definition: hellomalif.pb.h:635
generated::zpb::hellomalif::StdCmds_Reset_In::New
StdCmds_Reset_In * New(::google::protobuf::Arena *arena) const final
Definition: hellomalif.pb.h:586
generated::zpb::hellomalif::StdCmds_Disable_In::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:768
generated::zpb::hellomalif::StdCmds_Disable_Out::release_retval
::std::string * release_retval()
Definition: hellomalif.pb.h:4360
generated::zpb::hellomalif::StdCmds_Status_Out
Definition: hellomalif.pb.h:2256
generated::zpb::hellomalif::StdCmds_Init_In
Definition: hellomalif.pb.h:427
generated::zpb::hellomalif::StdCmds_Call::reset
const ::generated::zpb::hellomalif::StdCmds_Reset_In & reset() const
Definition: hellomalif.pb.h:3648
generated::zpb::hellomalif::StdCmds_Enable_Out::clear_retval
void clear_retval()
Definition: hellomalif.pb.h:4252
generated::zpb::hellomalif::StdCmds_Init_Out::New
StdCmds_Init_Out * New() const final
Definition: hellomalif.pb.h:1819
protobuf_hellomalif_2eproto::TableStruct::entries
static const ::google::protobuf::internal::ParseTableField entries[]
Definition: hellomalif.pb.h:41
generated::zpb::hellomalif::StdCmds_Call::mutable_disable
::generated::zpb::hellomalif::StdCmds_Disable_In * mutable_disable()
Definition: hellomalif.pb.h:3742
generated::zpb::hellomalif::StdCmds_Call::release_reset
::generated::zpb::hellomalif::StdCmds_Reset_In * release_reset()
Definition: hellomalif.pb.h:3637
generated::zpb::hellomalif::StdCmds_SetLogLevel_Out::mutable_unknown_fields
inline::google::protobuf::UnknownFieldSet * mutable_unknown_fields()
Definition: hellomalif.pb.h:2773
generated::zpb::hellomalif::StdCmds_Status_Out::retval
const ::std::string & retval() const
Definition: hellomalif.pb.h:4396
Generated by   doxygen 1.8.5