Goby v2
pAcommsHandler_config.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: goby/moos/protobuf/pAcommsHandler_config.proto
3 
4 #ifndef PROTOBUF_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto__INCLUDED
5 #define PROTOBUF_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto__INCLUDED
6 
7 #include <string>
8 
9 #include <google/protobuf/stubs/common.h>
10 
11 #if GOOGLE_PROTOBUF_VERSION < 2006000
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 2006001 < 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/generated_message_util.h>
23 #include <google/protobuf/message.h>
24 #include <google/protobuf/repeated_field.h>
25 #include <google/protobuf/extension_set.h>
26 #include <google/protobuf/generated_enum_reflection.h>
27 #include <google/protobuf/unknown_field_set.h>
28 #include "goby/moos/protobuf/goby_moos_app.pb.h"
29 #include "goby/acomms/protobuf/driver_base.pb.h"
30 #include "goby/acomms/protobuf/queue.pb.h"
31 #include "goby/acomms/protobuf/amac_config.pb.h"
32 #include "goby/acomms/protobuf/dccl.pb.h"
33 #include "goby/acomms/protobuf/route.pb.h"
34 #include "goby/acomms/protobuf/modem_message.pb.h"
35 #include "goby/moos/protobuf/transitional.pb.h"
36 #include "goby/moos/protobuf/translator.pb.h"
37 #include "goby/common/protobuf/option_extensions.pb.h"
38 #include <boost/units/quantity.hpp>
39 #include <boost/units/absolute.hpp>
40 #include <boost/units/dimensionless_type.hpp>
41 #include <boost/units/make_scaled_unit.hpp>
42 // @@protoc_insertion_point(includes)
43 
44 // Internal implementation detail -- do not call these.
45 void protobuf_AddDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
46 void protobuf_AssignDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
47 void protobuf_ShutdownFile_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
48 
49 class pAcommsHandlerConfig;
50 class pAcommsHandlerConfig_DriverFailureApproach;
51 class pAcommsHandlerConfig_MOOSVariables;
52 
53 enum pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique {
54  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_CONTINUALLY_RESTART_DRIVER = 1,
55  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_MOVE_LISTEN_DRIVER_TO_PRIMARY = 2,
56  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY = 3
57 };
58 bool pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_IsValid(int value);
59 const pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MIN = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_CONTINUALLY_RESTART_DRIVER;
60 const pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MAX = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY;
61 const int pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_ARRAYSIZE = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MAX + 1;
62 
63 const ::google::protobuf::EnumDescriptor* pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor();
64 inline const ::std::string& pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Name(pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value) {
65  return ::google::protobuf::internal::NameOfEnum(
66  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor(), value);
67 }
68 inline bool pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Parse(
69  const ::std::string& name, pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique* value) {
70  return ::google::protobuf::internal::ParseNamedEnum<pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique>(
71  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor(), name, value);
72 }
73 // ===================================================================
74 
75 class pAcommsHandlerConfig_DriverFailureApproach : public ::google::protobuf::Message {
76  public:
77  pAcommsHandlerConfig_DriverFailureApproach();
78  virtual ~pAcommsHandlerConfig_DriverFailureApproach();
79 
80  pAcommsHandlerConfig_DriverFailureApproach(const pAcommsHandlerConfig_DriverFailureApproach& from);
81 
82  inline pAcommsHandlerConfig_DriverFailureApproach& operator=(const pAcommsHandlerConfig_DriverFailureApproach& from) {
83  CopyFrom(from);
84  return *this;
85  }
86 
87  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
88  return _unknown_fields_;
89  }
90 
91  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
92  return &_unknown_fields_;
93  }
94 
95  static const ::google::protobuf::Descriptor* descriptor();
96  static const pAcommsHandlerConfig_DriverFailureApproach& default_instance();
97 
98  void Swap(pAcommsHandlerConfig_DriverFailureApproach* other);
99 
100  // implements Message ----------------------------------------------
101 
102  pAcommsHandlerConfig_DriverFailureApproach* New() const;
103  void CopyFrom(const ::google::protobuf::Message& from);
104  void MergeFrom(const ::google::protobuf::Message& from);
105  void CopyFrom(const pAcommsHandlerConfig_DriverFailureApproach& from);
106  void MergeFrom(const pAcommsHandlerConfig_DriverFailureApproach& from);
107  void Clear();
108  bool IsInitialized() const;
109 
110  int ByteSize() const;
111  bool MergePartialFromCodedStream(
112  ::google::protobuf::io::CodedInputStream* input);
113  void SerializeWithCachedSizes(
114  ::google::protobuf::io::CodedOutputStream* output) const;
115  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
116  int GetCachedSize() const { return _cached_size_; }
117  private:
118  void SharedCtor();
119  void SharedDtor();
120  void SetCachedSize(int size) const;
121  public:
122  ::google::protobuf::Metadata GetMetadata() const;
123 
124  // nested types ----------------------------------------------------
125 
126  typedef pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique DriverFailureTechnique;
127  static const DriverFailureTechnique CONTINUALLY_RESTART_DRIVER = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_CONTINUALLY_RESTART_DRIVER;
128  static const DriverFailureTechnique MOVE_LISTEN_DRIVER_TO_PRIMARY = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_MOVE_LISTEN_DRIVER_TO_PRIMARY;
129  static const DriverFailureTechnique DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY;
130  static inline bool DriverFailureTechnique_IsValid(int value) {
131  return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_IsValid(value);
132  }
133  static const DriverFailureTechnique DriverFailureTechnique_MIN =
134  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MIN;
135  static const DriverFailureTechnique DriverFailureTechnique_MAX =
136  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MAX;
137  static const int DriverFailureTechnique_ARRAYSIZE =
138  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_ARRAYSIZE;
139  static inline const ::google::protobuf::EnumDescriptor*
140  DriverFailureTechnique_descriptor() {
141  return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor();
142  }
143  static inline const ::std::string& DriverFailureTechnique_Name(DriverFailureTechnique value) {
144  return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Name(value);
145  }
146  static inline bool DriverFailureTechnique_Parse(const ::std::string& name,
147  DriverFailureTechnique* value) {
148  return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Parse(name, value);
149  }
150 
151  // accessors -------------------------------------------------------
152 
153  // optional .pAcommsHandlerConfig.DriverFailureApproach.DriverFailureTechnique technique = 1 [default = CONTINUALLY_RESTART_DRIVER];
154  inline bool has_technique() const;
155  inline void clear_technique();
156  static const int kTechniqueFieldNumber = 1;
157  inline ::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique technique() const;
158  inline void set_technique(::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value);
159 
160  // optional int32 driver_backoff_sec = 2 [default = 60];
161  inline bool has_driver_backoff_sec() const;
162  inline void clear_driver_backoff_sec();
163  static const int kDriverBackoffSecFieldNumber = 2;
164  inline ::google::protobuf::int32 driver_backoff_sec() const;
165  inline void set_driver_backoff_sec(::google::protobuf::int32 value);
166 
167  // @@protoc_insertion_point(class_scope:pAcommsHandlerConfig.DriverFailureApproach)
168  private:
169  inline void set_has_technique();
170  inline void clear_has_technique();
171  inline void set_has_driver_backoff_sec();
172  inline void clear_has_driver_backoff_sec();
173 
174  ::google::protobuf::UnknownFieldSet _unknown_fields_;
175 
176  ::google::protobuf::uint32 _has_bits_[1];
177  mutable int _cached_size_;
178  int technique_;
179  ::google::protobuf::int32 driver_backoff_sec_;
180  friend void protobuf_AddDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
181  friend void protobuf_AssignDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
182  friend void protobuf_ShutdownFile_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
183 
184  void InitAsDefaultInstance();
185  static pAcommsHandlerConfig_DriverFailureApproach* default_instance_;
186 };
187 // -------------------------------------------------------------------
188 
189 class pAcommsHandlerConfig_MOOSVariables : public ::google::protobuf::Message {
190  public:
191  pAcommsHandlerConfig_MOOSVariables();
192  virtual ~pAcommsHandlerConfig_MOOSVariables();
193 
194  pAcommsHandlerConfig_MOOSVariables(const pAcommsHandlerConfig_MOOSVariables& from);
195 
196  inline pAcommsHandlerConfig_MOOSVariables& operator=(const pAcommsHandlerConfig_MOOSVariables& from) {
197  CopyFrom(from);
198  return *this;
199  }
200 
201  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
202  return _unknown_fields_;
203  }
204 
205  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
206  return &_unknown_fields_;
207  }
208 
209  static const ::google::protobuf::Descriptor* descriptor();
210  static const pAcommsHandlerConfig_MOOSVariables& default_instance();
211 
212  void Swap(pAcommsHandlerConfig_MOOSVariables* other);
213 
214  // implements Message ----------------------------------------------
215 
216  pAcommsHandlerConfig_MOOSVariables* New() const;
217  void CopyFrom(const ::google::protobuf::Message& from);
218  void MergeFrom(const ::google::protobuf::Message& from);
219  void CopyFrom(const pAcommsHandlerConfig_MOOSVariables& from);
220  void MergeFrom(const pAcommsHandlerConfig_MOOSVariables& from);
221  void Clear();
222  bool IsInitialized() const;
223 
224  int ByteSize() const;
225  bool MergePartialFromCodedStream(
226  ::google::protobuf::io::CodedInputStream* input);
227  void SerializeWithCachedSizes(
228  ::google::protobuf::io::CodedOutputStream* output) const;
229  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
230  int GetCachedSize() const { return _cached_size_; }
231  private:
232  void SharedCtor();
233  void SharedDtor();
234  void SetCachedSize(int size) const;
235  public:
236  ::google::protobuf::Metadata GetMetadata() const;
237 
238  // nested types ----------------------------------------------------
239 
240  // accessors -------------------------------------------------------
241 
242  // optional string prefix = 1 [default = "ACOMMS_"];
243  inline bool has_prefix() const;
244  inline void clear_prefix();
245  static const int kPrefixFieldNumber = 1;
246  inline const ::std::string& prefix() const;
247  inline void set_prefix(const ::std::string& value);
248  inline void set_prefix(const char* value);
249  inline void set_prefix(const char* value, size_t size);
250  inline ::std::string* mutable_prefix();
251  inline ::std::string* release_prefix();
252  inline void set_allocated_prefix(::std::string* prefix);
253 
254  // optional string driver_raw_in = 10 [default = "NMEA_IN"];
255  inline bool has_driver_raw_in() const;
256  inline void clear_driver_raw_in();
257  static const int kDriverRawInFieldNumber = 10;
258  inline const ::std::string& driver_raw_in() const;
259  inline void set_driver_raw_in(const ::std::string& value);
260  inline void set_driver_raw_in(const char* value);
261  inline void set_driver_raw_in(const char* value, size_t size);
262  inline ::std::string* mutable_driver_raw_in();
263  inline ::std::string* release_driver_raw_in();
264  inline void set_allocated_driver_raw_in(::std::string* driver_raw_in);
265 
266  // optional string driver_raw_out = 11 [default = "NMEA_OUT"];
267  inline bool has_driver_raw_out() const;
268  inline void clear_driver_raw_out();
269  static const int kDriverRawOutFieldNumber = 11;
270  inline const ::std::string& driver_raw_out() const;
271  inline void set_driver_raw_out(const ::std::string& value);
272  inline void set_driver_raw_out(const char* value);
273  inline void set_driver_raw_out(const char* value, size_t size);
274  inline ::std::string* mutable_driver_raw_out();
275  inline ::std::string* release_driver_raw_out();
276  inline void set_allocated_driver_raw_out(::std::string* driver_raw_out);
277 
278  // optional string driver_raw_msg_in = 12 [default = "RAW_INCOMING"];
279  inline bool has_driver_raw_msg_in() const;
280  inline void clear_driver_raw_msg_in();
281  static const int kDriverRawMsgInFieldNumber = 12;
282  inline const ::std::string& driver_raw_msg_in() const;
283  inline void set_driver_raw_msg_in(const ::std::string& value);
284  inline void set_driver_raw_msg_in(const char* value);
285  inline void set_driver_raw_msg_in(const char* value, size_t size);
286  inline ::std::string* mutable_driver_raw_msg_in();
287  inline ::std::string* release_driver_raw_msg_in();
288  inline void set_allocated_driver_raw_msg_in(::std::string* driver_raw_msg_in);
289 
290  // optional string driver_raw_msg_out = 13 [default = "RAW_OUTGOING"];
291  inline bool has_driver_raw_msg_out() const;
292  inline void clear_driver_raw_msg_out();
293  static const int kDriverRawMsgOutFieldNumber = 13;
294  inline const ::std::string& driver_raw_msg_out() const;
295  inline void set_driver_raw_msg_out(const ::std::string& value);
296  inline void set_driver_raw_msg_out(const char* value);
297  inline void set_driver_raw_msg_out(const char* value, size_t size);
298  inline ::std::string* mutable_driver_raw_msg_out();
299  inline ::std::string* release_driver_raw_msg_out();
300  inline void set_allocated_driver_raw_msg_out(::std::string* driver_raw_msg_out);
301 
302  // optional string driver_receive = 14 [default = "MODEM_RECEIVE"];
303  inline bool has_driver_receive() const;
304  inline void clear_driver_receive();
305  static const int kDriverReceiveFieldNumber = 14;
306  inline const ::std::string& driver_receive() const;
307  inline void set_driver_receive(const ::std::string& value);
308  inline void set_driver_receive(const char* value);
309  inline void set_driver_receive(const char* value, size_t size);
310  inline ::std::string* mutable_driver_receive();
311  inline ::std::string* release_driver_receive();
312  inline void set_allocated_driver_receive(::std::string* driver_receive);
313 
314  // optional string driver_transmit = 15 [default = "MODEM_TRANSMIT"];
315  inline bool has_driver_transmit() const;
316  inline void clear_driver_transmit();
317  static const int kDriverTransmitFieldNumber = 15;
318  inline const ::std::string& driver_transmit() const;
319  inline void set_driver_transmit(const ::std::string& value);
320  inline void set_driver_transmit(const char* value);
321  inline void set_driver_transmit(const char* value, size_t size);
322  inline ::std::string* mutable_driver_transmit();
323  inline ::std::string* release_driver_transmit();
324  inline void set_allocated_driver_transmit(::std::string* driver_transmit);
325 
326  // optional string driver_cfg_update = 16 [default = "DRIVER_CONFIG_UPDATE"];
327  inline bool has_driver_cfg_update() const;
328  inline void clear_driver_cfg_update();
329  static const int kDriverCfgUpdateFieldNumber = 16;
330  inline const ::std::string& driver_cfg_update() const;
331  inline void set_driver_cfg_update(const ::std::string& value);
332  inline void set_driver_cfg_update(const char* value);
333  inline void set_driver_cfg_update(const char* value, size_t size);
334  inline ::std::string* mutable_driver_cfg_update();
335  inline ::std::string* release_driver_cfg_update();
336  inline void set_allocated_driver_cfg_update(::std::string* driver_cfg_update);
337 
338  // optional string queue_receive = 100 [default = "QUEUE_RECEIVE"];
339  inline bool has_queue_receive() const;
340  inline void clear_queue_receive();
341  static const int kQueueReceiveFieldNumber = 100;
342  inline const ::std::string& queue_receive() const;
343  inline void set_queue_receive(const ::std::string& value);
344  inline void set_queue_receive(const char* value);
345  inline void set_queue_receive(const char* value, size_t size);
346  inline ::std::string* mutable_queue_receive();
347  inline ::std::string* release_queue_receive();
348  inline void set_allocated_queue_receive(::std::string* queue_receive);
349 
350  // optional string queue_transmit = 101 [default = "QUEUE_TRANSMIT"];
351  inline bool has_queue_transmit() const;
352  inline void clear_queue_transmit();
353  static const int kQueueTransmitFieldNumber = 101;
354  inline const ::std::string& queue_transmit() const;
355  inline void set_queue_transmit(const ::std::string& value);
356  inline void set_queue_transmit(const char* value);
357  inline void set_queue_transmit(const char* value, size_t size);
358  inline ::std::string* mutable_queue_transmit();
359  inline ::std::string* release_queue_transmit();
360  inline void set_allocated_queue_transmit(::std::string* queue_transmit);
361 
362  // optional string queue_ack_transmission = 102 [default = "ACK"];
363  inline bool has_queue_ack_transmission() const;
364  inline void clear_queue_ack_transmission();
365  static const int kQueueAckTransmissionFieldNumber = 102;
366  inline const ::std::string& queue_ack_transmission() const;
367  inline void set_queue_ack_transmission(const ::std::string& value);
368  inline void set_queue_ack_transmission(const char* value);
369  inline void set_queue_ack_transmission(const char* value, size_t size);
370  inline ::std::string* mutable_queue_ack_transmission();
371  inline ::std::string* release_queue_ack_transmission();
372  inline void set_allocated_queue_ack_transmission(::std::string* queue_ack_transmission);
373 
374  // optional string queue_ack_original_msg = 103 [default = "ACK_ORIGINAL"];
375  inline bool has_queue_ack_original_msg() const;
376  inline void clear_queue_ack_original_msg();
377  static const int kQueueAckOriginalMsgFieldNumber = 103;
378  inline const ::std::string& queue_ack_original_msg() const;
379  inline void set_queue_ack_original_msg(const ::std::string& value);
380  inline void set_queue_ack_original_msg(const char* value);
381  inline void set_queue_ack_original_msg(const char* value, size_t size);
382  inline ::std::string* mutable_queue_ack_original_msg();
383  inline ::std::string* release_queue_ack_original_msg();
384  inline void set_allocated_queue_ack_original_msg(::std::string* queue_ack_original_msg);
385 
386  // optional string queue_expire = 104 [default = "EXPIRE"];
387  inline bool has_queue_expire() const;
388  inline void clear_queue_expire();
389  static const int kQueueExpireFieldNumber = 104;
390  inline const ::std::string& queue_expire() const;
391  inline void set_queue_expire(const ::std::string& value);
392  inline void set_queue_expire(const char* value);
393  inline void set_queue_expire(const char* value, size_t size);
394  inline ::std::string* mutable_queue_expire();
395  inline ::std::string* release_queue_expire();
396  inline void set_allocated_queue_expire(::std::string* queue_expire);
397 
398  // optional string queue_size = 105 [default = "QSIZE"];
399  inline bool has_queue_size() const;
400  inline void clear_queue_size();
401  static const int kQueueSizeFieldNumber = 105;
402  inline const ::std::string& queue_size() const;
403  inline void set_queue_size(const ::std::string& value);
404  inline void set_queue_size(const char* value);
405  inline void set_queue_size(const char* value, size_t size);
406  inline ::std::string* mutable_queue_size();
407  inline ::std::string* release_queue_size();
408  inline void set_allocated_queue_size(::std::string* queue_size);
409 
410  // optional string queue_flush = 106 [default = "FLUSH_QUEUE"];
411  inline bool has_queue_flush() const;
412  inline void clear_queue_flush();
413  static const int kQueueFlushFieldNumber = 106;
414  inline const ::std::string& queue_flush() const;
415  inline void set_queue_flush(const ::std::string& value);
416  inline void set_queue_flush(const char* value);
417  inline void set_queue_flush(const char* value, size_t size);
418  inline ::std::string* mutable_queue_flush();
419  inline ::std::string* release_queue_flush();
420  inline void set_allocated_queue_flush(::std::string* queue_flush);
421 
422  // optional string mac_cycle_update = 200 [default = "MAC_CYCLE_UPDATE"];
423  inline bool has_mac_cycle_update() const;
424  inline void clear_mac_cycle_update();
425  static const int kMacCycleUpdateFieldNumber = 200;
426  inline const ::std::string& mac_cycle_update() const;
427  inline void set_mac_cycle_update(const ::std::string& value);
428  inline void set_mac_cycle_update(const char* value);
429  inline void set_mac_cycle_update(const char* value, size_t size);
430  inline ::std::string* mutable_mac_cycle_update();
431  inline ::std::string* release_mac_cycle_update();
432  inline void set_allocated_mac_cycle_update(::std::string* mac_cycle_update);
433 
434  // optional string mac_initiate_transmission = 201 [default = "MAC_INITIATE_TRANSMISSION"];
435  inline bool has_mac_initiate_transmission() const;
436  inline void clear_mac_initiate_transmission();
437  static const int kMacInitiateTransmissionFieldNumber = 201;
438  inline const ::std::string& mac_initiate_transmission() const;
439  inline void set_mac_initiate_transmission(const ::std::string& value);
440  inline void set_mac_initiate_transmission(const char* value);
441  inline void set_mac_initiate_transmission(const char* value, size_t size);
442  inline ::std::string* mutable_mac_initiate_transmission();
443  inline ::std::string* release_mac_initiate_transmission();
444  inline void set_allocated_mac_initiate_transmission(::std::string* mac_initiate_transmission);
445 
446  // optional string mac_slot_start = 202 [default = "MAC_SLOT_START"];
447  inline bool has_mac_slot_start() const;
448  inline void clear_mac_slot_start();
449  static const int kMacSlotStartFieldNumber = 202;
450  inline const ::std::string& mac_slot_start() const;
451  inline void set_mac_slot_start(const ::std::string& value);
452  inline void set_mac_slot_start(const char* value);
453  inline void set_mac_slot_start(const char* value, size_t size);
454  inline ::std::string* mutable_mac_slot_start();
455  inline ::std::string* release_mac_slot_start();
456  inline void set_allocated_mac_slot_start(::std::string* mac_slot_start);
457 
458  // optional string config_file = 300 [default = "CONFIG"];
459  inline bool has_config_file() const;
460  inline void clear_config_file();
461  static const int kConfigFileFieldNumber = 300;
462  inline const ::std::string& config_file() const;
463  inline void set_config_file(const ::std::string& value);
464  inline void set_config_file(const char* value);
465  inline void set_config_file(const char* value, size_t size);
466  inline ::std::string* mutable_config_file();
467  inline ::std::string* release_config_file();
468  inline void set_allocated_config_file(::std::string* config_file);
469 
470  // optional string config_file_request = 301 [default = "CONFIG_REQUEST"];
471  inline bool has_config_file_request() const;
472  inline void clear_config_file_request();
473  static const int kConfigFileRequestFieldNumber = 301;
474  inline const ::std::string& config_file_request() const;
475  inline void set_config_file_request(const ::std::string& value);
476  inline void set_config_file_request(const char* value);
477  inline void set_config_file_request(const char* value, size_t size);
478  inline ::std::string* mutable_config_file_request();
479  inline ::std::string* release_config_file_request();
480  inline void set_allocated_config_file_request(::std::string* config_file_request);
481 
482  // optional string driver_reset = 400 [default = "DRIVER_RESET"];
483  inline bool has_driver_reset() const;
484  inline void clear_driver_reset();
485  static const int kDriverResetFieldNumber = 400;
486  inline const ::std::string& driver_reset() const;
487  inline void set_driver_reset(const ::std::string& value);
488  inline void set_driver_reset(const char* value);
489  inline void set_driver_reset(const char* value, size_t size);
490  inline ::std::string* mutable_driver_reset();
491  inline ::std::string* release_driver_reset();
492  inline void set_allocated_driver_reset(::std::string* driver_reset);
493 
494  // optional string ifrontseat_data_out = 500 [default = "IFS_DATA_OUT"];
495  inline bool has_ifrontseat_data_out() const;
496  inline void clear_ifrontseat_data_out();
497  static const int kIfrontseatDataOutFieldNumber = 500;
498  inline const ::std::string& ifrontseat_data_out() const;
499  inline void set_ifrontseat_data_out(const ::std::string& value);
500  inline void set_ifrontseat_data_out(const char* value);
501  inline void set_ifrontseat_data_out(const char* value, size_t size);
502  inline ::std::string* mutable_ifrontseat_data_out();
503  inline ::std::string* release_ifrontseat_data_out();
504  inline void set_allocated_ifrontseat_data_out(::std::string* ifrontseat_data_out);
505 
506  // @@protoc_insertion_point(class_scope:pAcommsHandlerConfig.MOOSVariables)
507  private:
508  inline void set_has_prefix();
509  inline void clear_has_prefix();
510  inline void set_has_driver_raw_in();
511  inline void clear_has_driver_raw_in();
512  inline void set_has_driver_raw_out();
513  inline void clear_has_driver_raw_out();
514  inline void set_has_driver_raw_msg_in();
515  inline void clear_has_driver_raw_msg_in();
516  inline void set_has_driver_raw_msg_out();
517  inline void clear_has_driver_raw_msg_out();
518  inline void set_has_driver_receive();
519  inline void clear_has_driver_receive();
520  inline void set_has_driver_transmit();
521  inline void clear_has_driver_transmit();
522  inline void set_has_driver_cfg_update();
523  inline void clear_has_driver_cfg_update();
524  inline void set_has_queue_receive();
525  inline void clear_has_queue_receive();
526  inline void set_has_queue_transmit();
527  inline void clear_has_queue_transmit();
528  inline void set_has_queue_ack_transmission();
529  inline void clear_has_queue_ack_transmission();
530  inline void set_has_queue_ack_original_msg();
531  inline void clear_has_queue_ack_original_msg();
532  inline void set_has_queue_expire();
533  inline void clear_has_queue_expire();
534  inline void set_has_queue_size();
535  inline void clear_has_queue_size();
536  inline void set_has_queue_flush();
537  inline void clear_has_queue_flush();
538  inline void set_has_mac_cycle_update();
539  inline void clear_has_mac_cycle_update();
540  inline void set_has_mac_initiate_transmission();
541  inline void clear_has_mac_initiate_transmission();
542  inline void set_has_mac_slot_start();
543  inline void clear_has_mac_slot_start();
544  inline void set_has_config_file();
545  inline void clear_has_config_file();
546  inline void set_has_config_file_request();
547  inline void clear_has_config_file_request();
548  inline void set_has_driver_reset();
549  inline void clear_has_driver_reset();
550  inline void set_has_ifrontseat_data_out();
551  inline void clear_has_ifrontseat_data_out();
552 
553  ::google::protobuf::UnknownFieldSet _unknown_fields_;
554 
555  ::google::protobuf::uint32 _has_bits_[1];
556  mutable int _cached_size_;
557  static ::std::string* _default_prefix_;
558  ::std::string* prefix_;
559  static ::std::string* _default_driver_raw_in_;
560  ::std::string* driver_raw_in_;
561  static ::std::string* _default_driver_raw_out_;
562  ::std::string* driver_raw_out_;
563  static ::std::string* _default_driver_raw_msg_in_;
564  ::std::string* driver_raw_msg_in_;
565  static ::std::string* _default_driver_raw_msg_out_;
566  ::std::string* driver_raw_msg_out_;
567  static ::std::string* _default_driver_receive_;
568  ::std::string* driver_receive_;
569  static ::std::string* _default_driver_transmit_;
570  ::std::string* driver_transmit_;
571  static ::std::string* _default_driver_cfg_update_;
572  ::std::string* driver_cfg_update_;
573  static ::std::string* _default_queue_receive_;
574  ::std::string* queue_receive_;
575  static ::std::string* _default_queue_transmit_;
576  ::std::string* queue_transmit_;
577  static ::std::string* _default_queue_ack_transmission_;
578  ::std::string* queue_ack_transmission_;
579  static ::std::string* _default_queue_ack_original_msg_;
580  ::std::string* queue_ack_original_msg_;
581  static ::std::string* _default_queue_expire_;
582  ::std::string* queue_expire_;
583  static ::std::string* _default_queue_size_;
584  ::std::string* queue_size_;
585  static ::std::string* _default_queue_flush_;
586  ::std::string* queue_flush_;
587  static ::std::string* _default_mac_cycle_update_;
588  ::std::string* mac_cycle_update_;
589  static ::std::string* _default_mac_initiate_transmission_;
590  ::std::string* mac_initiate_transmission_;
591  static ::std::string* _default_mac_slot_start_;
592  ::std::string* mac_slot_start_;
593  static ::std::string* _default_config_file_;
594  ::std::string* config_file_;
595  static ::std::string* _default_config_file_request_;
596  ::std::string* config_file_request_;
597  static ::std::string* _default_driver_reset_;
598  ::std::string* driver_reset_;
599  static ::std::string* _default_ifrontseat_data_out_;
600  ::std::string* ifrontseat_data_out_;
601  friend void protobuf_AddDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
602  friend void protobuf_AssignDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
603  friend void protobuf_ShutdownFile_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
604 
605  void InitAsDefaultInstance();
606  static pAcommsHandlerConfig_MOOSVariables* default_instance_;
607 };
608 // -------------------------------------------------------------------
609 
610 class pAcommsHandlerConfig : public ::google::protobuf::Message {
611  public:
612  pAcommsHandlerConfig();
613  virtual ~pAcommsHandlerConfig();
614 
615  pAcommsHandlerConfig(const pAcommsHandlerConfig& from);
616 
617  inline pAcommsHandlerConfig& operator=(const pAcommsHandlerConfig& from) {
618  CopyFrom(from);
619  return *this;
620  }
621 
622  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
623  return _unknown_fields_;
624  }
625 
626  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
627  return &_unknown_fields_;
628  }
629 
630  static const ::google::protobuf::Descriptor* descriptor();
631  static const pAcommsHandlerConfig& default_instance();
632 
633  void Swap(pAcommsHandlerConfig* other);
634 
635  // implements Message ----------------------------------------------
636 
637  pAcommsHandlerConfig* New() const;
638  void CopyFrom(const ::google::protobuf::Message& from);
639  void MergeFrom(const ::google::protobuf::Message& from);
640  void CopyFrom(const pAcommsHandlerConfig& from);
641  void MergeFrom(const pAcommsHandlerConfig& from);
642  void Clear();
643  bool IsInitialized() const;
644 
645  int ByteSize() const;
646  bool MergePartialFromCodedStream(
647  ::google::protobuf::io::CodedInputStream* input);
648  void SerializeWithCachedSizes(
649  ::google::protobuf::io::CodedOutputStream* output) const;
650  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
651  int GetCachedSize() const { return _cached_size_; }
652  private:
653  void SharedCtor();
654  void SharedDtor();
655  void SetCachedSize(int size) const;
656  public:
657  ::google::protobuf::Metadata GetMetadata() const;
658 
659  // nested types ----------------------------------------------------
660 
661  typedef pAcommsHandlerConfig_DriverFailureApproach DriverFailureApproach;
662  typedef pAcommsHandlerConfig_MOOSVariables MOOSVariables;
663 
664  // accessors -------------------------------------------------------
665 
666  // optional .GobyMOOSAppConfig common = 1;
667  inline bool has_common() const;
668  inline void clear_common();
669  static const int kCommonFieldNumber = 1;
670  inline const ::GobyMOOSAppConfig& common() const;
671  inline ::GobyMOOSAppConfig* mutable_common();
672  inline ::GobyMOOSAppConfig* release_common();
673  inline void set_allocated_common(::GobyMOOSAppConfig* common);
674 
675  // required int32 modem_id = 2;
676  inline bool has_modem_id() const;
677  inline void clear_modem_id();
678  static const int kModemIdFieldNumber = 2;
679  inline ::google::protobuf::int32 modem_id() const;
680  inline void set_modem_id(::google::protobuf::int32 value);
681 
682  // optional .goby.acomms.protobuf.DriverType driver_type = 3 [default = DRIVER_NONE];
683  inline bool has_driver_type() const;
684  inline void clear_driver_type();
685  static const int kDriverTypeFieldNumber = 3;
686  inline ::goby::acomms::protobuf::DriverType driver_type() const;
687  inline void set_driver_type(::goby::acomms::protobuf::DriverType value);
688 
689  // optional .goby.acomms.protobuf.DriverConfig driver_cfg = 4;
690  inline bool has_driver_cfg() const;
691  inline void clear_driver_cfg();
692  static const int kDriverCfgFieldNumber = 4;
693  inline const ::goby::acomms::protobuf::DriverConfig& driver_cfg() const;
694  inline ::goby::acomms::protobuf::DriverConfig* mutable_driver_cfg();
695  inline ::goby::acomms::protobuf::DriverConfig* release_driver_cfg();
696  inline void set_allocated_driver_cfg(::goby::acomms::protobuf::DriverConfig* driver_cfg);
697 
698  // repeated .goby.acomms.protobuf.DriverType listen_driver_type = 30;
699  inline int listen_driver_type_size() const;
700  inline void clear_listen_driver_type();
701  static const int kListenDriverTypeFieldNumber = 30;
702  inline ::goby::acomms::protobuf::DriverType listen_driver_type(int index) const;
703  inline void set_listen_driver_type(int index, ::goby::acomms::protobuf::DriverType value);
704  inline void add_listen_driver_type(::goby::acomms::protobuf::DriverType value);
705  inline const ::google::protobuf::RepeatedField<int>& listen_driver_type() const;
706  inline ::google::protobuf::RepeatedField<int>* mutable_listen_driver_type();
707 
708  // repeated .goby.acomms.protobuf.DriverConfig listen_driver_cfg = 31;
709  inline int listen_driver_cfg_size() const;
710  inline void clear_listen_driver_cfg();
711  static const int kListenDriverCfgFieldNumber = 31;
712  inline const ::goby::acomms::protobuf::DriverConfig& listen_driver_cfg(int index) const;
713  inline ::goby::acomms::protobuf::DriverConfig* mutable_listen_driver_cfg(int index);
714  inline ::goby::acomms::protobuf::DriverConfig* add_listen_driver_cfg();
715  inline const ::google::protobuf::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >&
716  listen_driver_cfg() const;
717  inline ::google::protobuf::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >*
718  mutable_listen_driver_cfg();
719 
720  // optional .pAcommsHandlerConfig.DriverFailureApproach driver_failure_approach = 32;
721  inline bool has_driver_failure_approach() const;
722  inline void clear_driver_failure_approach();
723  static const int kDriverFailureApproachFieldNumber = 32;
724  inline const ::pAcommsHandlerConfig_DriverFailureApproach& driver_failure_approach() const;
725  inline ::pAcommsHandlerConfig_DriverFailureApproach* mutable_driver_failure_approach();
726  inline ::pAcommsHandlerConfig_DriverFailureApproach* release_driver_failure_approach();
727  inline void set_allocated_driver_failure_approach(::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach);
728 
729  // optional .goby.acomms.protobuf.MACConfig mac_cfg = 5;
730  inline bool has_mac_cfg() const;
731  inline void clear_mac_cfg();
732  static const int kMacCfgFieldNumber = 5;
733  inline const ::goby::acomms::protobuf::MACConfig& mac_cfg() const;
734  inline ::goby::acomms::protobuf::MACConfig* mutable_mac_cfg();
735  inline ::goby::acomms::protobuf::MACConfig* release_mac_cfg();
736  inline void set_allocated_mac_cfg(::goby::acomms::protobuf::MACConfig* mac_cfg);
737 
738  // optional .goby.acomms.protobuf.QueueManagerConfig queue_cfg = 6;
739  inline bool has_queue_cfg() const;
740  inline void clear_queue_cfg();
741  static const int kQueueCfgFieldNumber = 6;
742  inline const ::goby::acomms::protobuf::QueueManagerConfig& queue_cfg() const;
743  inline ::goby::acomms::protobuf::QueueManagerConfig* mutable_queue_cfg();
744  inline ::goby::acomms::protobuf::QueueManagerConfig* release_queue_cfg();
745  inline void set_allocated_queue_cfg(::goby::acomms::protobuf::QueueManagerConfig* queue_cfg);
746 
747  // optional .goby.acomms.protobuf.DCCLConfig dccl_cfg = 7;
748  inline bool has_dccl_cfg() const;
749  inline void clear_dccl_cfg();
750  static const int kDcclCfgFieldNumber = 7;
751  inline const ::goby::acomms::protobuf::DCCLConfig& dccl_cfg() const;
752  inline ::goby::acomms::protobuf::DCCLConfig* mutable_dccl_cfg();
753  inline ::goby::acomms::protobuf::DCCLConfig* release_dccl_cfg();
754  inline void set_allocated_dccl_cfg(::goby::acomms::protobuf::DCCLConfig* dccl_cfg);
755 
756  // optional .goby.acomms.protobuf.RouteManagerConfig route_cfg = 8;
757  inline bool has_route_cfg() const;
758  inline void clear_route_cfg();
759  static const int kRouteCfgFieldNumber = 8;
760  inline const ::goby::acomms::protobuf::RouteManagerConfig& route_cfg() const;
761  inline ::goby::acomms::protobuf::RouteManagerConfig* mutable_route_cfg();
762  inline ::goby::acomms::protobuf::RouteManagerConfig* release_route_cfg();
763  inline void set_allocated_route_cfg(::goby::acomms::protobuf::RouteManagerConfig* route_cfg);
764 
765  // optional .pAcommsHandlerConfig.MOOSVariables moos_var = 10;
766  inline bool has_moos_var() const;
767  inline void clear_moos_var();
768  static const int kMoosVarFieldNumber = 10;
769  inline const ::pAcommsHandlerConfig_MOOSVariables& moos_var() const;
770  inline ::pAcommsHandlerConfig_MOOSVariables* mutable_moos_var();
771  inline ::pAcommsHandlerConfig_MOOSVariables* release_moos_var();
772  inline void set_allocated_moos_var(::pAcommsHandlerConfig_MOOSVariables* moos_var);
773 
774  // repeated string load_shared_library = 20;
775  inline int load_shared_library_size() const;
776  inline void clear_load_shared_library();
777  static const int kLoadSharedLibraryFieldNumber = 20;
778  inline const ::std::string& load_shared_library(int index) const;
779  inline ::std::string* mutable_load_shared_library(int index);
780  inline void set_load_shared_library(int index, const ::std::string& value);
781  inline void set_load_shared_library(int index, const char* value);
782  inline void set_load_shared_library(int index, const char* value, size_t size);
783  inline ::std::string* add_load_shared_library();
784  inline void add_load_shared_library(const ::std::string& value);
785  inline void add_load_shared_library(const char* value);
786  inline void add_load_shared_library(const char* value, size_t size);
787  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& load_shared_library() const;
788  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_load_shared_library();
789 
790  // repeated string load_proto_file = 21;
791  inline int load_proto_file_size() const;
792  inline void clear_load_proto_file();
793  static const int kLoadProtoFileFieldNumber = 21;
794  inline const ::std::string& load_proto_file(int index) const;
795  inline ::std::string* mutable_load_proto_file(int index);
796  inline void set_load_proto_file(int index, const ::std::string& value);
797  inline void set_load_proto_file(int index, const char* value);
798  inline void set_load_proto_file(int index, const char* value, size_t size);
799  inline ::std::string* add_load_proto_file();
800  inline void add_load_proto_file(const ::std::string& value);
801  inline void add_load_proto_file(const char* value);
802  inline void add_load_proto_file(const char* value, size_t size);
803  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& load_proto_file() const;
804  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_load_proto_file();
805 
806  // repeated .goby.moos.protobuf.TranslatorEntry translator_entry = 22;
807  inline int translator_entry_size() const;
808  inline void clear_translator_entry();
809  static const int kTranslatorEntryFieldNumber = 22;
810  inline const ::goby::moos::protobuf::TranslatorEntry& translator_entry(int index) const;
811  inline ::goby::moos::protobuf::TranslatorEntry* mutable_translator_entry(int index);
812  inline ::goby::moos::protobuf::TranslatorEntry* add_translator_entry();
813  inline const ::google::protobuf::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >&
814  translator_entry() const;
815  inline ::google::protobuf::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >*
816  mutable_translator_entry();
817 
818  // repeated string multiplex_create_moos_var = 23;
819  inline int multiplex_create_moos_var_size() const;
820  inline void clear_multiplex_create_moos_var();
821  static const int kMultiplexCreateMoosVarFieldNumber = 23;
822  inline const ::std::string& multiplex_create_moos_var(int index) const;
823  inline ::std::string* mutable_multiplex_create_moos_var(int index);
824  inline void set_multiplex_create_moos_var(int index, const ::std::string& value);
825  inline void set_multiplex_create_moos_var(int index, const char* value);
826  inline void set_multiplex_create_moos_var(int index, const char* value, size_t size);
827  inline ::std::string* add_multiplex_create_moos_var();
828  inline void add_multiplex_create_moos_var(const ::std::string& value);
829  inline void add_multiplex_create_moos_var(const char* value);
830  inline void add_multiplex_create_moos_var(const char* value, size_t size);
831  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& multiplex_create_moos_var() const;
832  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_multiplex_create_moos_var();
833 
834  // repeated string dccl_frontseat_forward_name = 24;
835  inline int dccl_frontseat_forward_name_size() const;
836  inline void clear_dccl_frontseat_forward_name();
837  static const int kDcclFrontseatForwardNameFieldNumber = 24;
838  inline const ::std::string& dccl_frontseat_forward_name(int index) const;
839  inline ::std::string* mutable_dccl_frontseat_forward_name(int index);
840  inline void set_dccl_frontseat_forward_name(int index, const ::std::string& value);
841  inline void set_dccl_frontseat_forward_name(int index, const char* value);
842  inline void set_dccl_frontseat_forward_name(int index, const char* value, size_t size);
843  inline ::std::string* add_dccl_frontseat_forward_name();
844  inline void add_dccl_frontseat_forward_name(const ::std::string& value);
845  inline void add_dccl_frontseat_forward_name(const char* value);
846  inline void add_dccl_frontseat_forward_name(const char* value, size_t size);
847  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& dccl_frontseat_forward_name() const;
848  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_dccl_frontseat_forward_name();
849 
850  // optional string modem_id_lookup_path = 101;
851  inline bool has_modem_id_lookup_path() const;
852  inline void clear_modem_id_lookup_path();
853  static const int kModemIdLookupPathFieldNumber = 101;
854  inline const ::std::string& modem_id_lookup_path() const;
855  inline void set_modem_id_lookup_path(const ::std::string& value);
856  inline void set_modem_id_lookup_path(const char* value);
857  inline void set_modem_id_lookup_path(const char* value, size_t size);
858  inline ::std::string* mutable_modem_id_lookup_path();
859  inline ::std::string* release_modem_id_lookup_path();
860  inline void set_allocated_modem_id_lookup_path(::std::string* modem_id_lookup_path);
861 
862  // optional .goby.transitional.protobuf.DCCLTransitionalConfig transitional_cfg = 200;
863  inline bool has_transitional_cfg() const;
864  inline void clear_transitional_cfg();
865  static const int kTransitionalCfgFieldNumber = 200;
866  inline const ::goby::transitional::protobuf::DCCLTransitionalConfig& transitional_cfg() const;
867  inline ::goby::transitional::protobuf::DCCLTransitionalConfig* mutable_transitional_cfg();
868  inline ::goby::transitional::protobuf::DCCLTransitionalConfig* release_transitional_cfg();
869  inline void set_allocated_transitional_cfg(::goby::transitional::protobuf::DCCLTransitionalConfig* transitional_cfg);
870 
871  // @@protoc_insertion_point(class_scope:pAcommsHandlerConfig)
872  private:
873  inline void set_has_common();
874  inline void clear_has_common();
875  inline void set_has_modem_id();
876  inline void clear_has_modem_id();
877  inline void set_has_driver_type();
878  inline void clear_has_driver_type();
879  inline void set_has_driver_cfg();
880  inline void clear_has_driver_cfg();
881  inline void set_has_driver_failure_approach();
882  inline void clear_has_driver_failure_approach();
883  inline void set_has_mac_cfg();
884  inline void clear_has_mac_cfg();
885  inline void set_has_queue_cfg();
886  inline void clear_has_queue_cfg();
887  inline void set_has_dccl_cfg();
888  inline void clear_has_dccl_cfg();
889  inline void set_has_route_cfg();
890  inline void clear_has_route_cfg();
891  inline void set_has_moos_var();
892  inline void clear_has_moos_var();
893  inline void set_has_modem_id_lookup_path();
894  inline void clear_has_modem_id_lookup_path();
895  inline void set_has_transitional_cfg();
896  inline void clear_has_transitional_cfg();
897 
898  ::google::protobuf::UnknownFieldSet _unknown_fields_;
899 
900  ::google::protobuf::uint32 _has_bits_[1];
901  mutable int _cached_size_;
902  ::GobyMOOSAppConfig* common_;
903  ::google::protobuf::int32 modem_id_;
904  int driver_type_;
905  ::goby::acomms::protobuf::DriverConfig* driver_cfg_;
906  ::google::protobuf::RepeatedField<int> listen_driver_type_;
907  ::google::protobuf::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig > listen_driver_cfg_;
908  ::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach_;
909  ::goby::acomms::protobuf::MACConfig* mac_cfg_;
910  ::goby::acomms::protobuf::QueueManagerConfig* queue_cfg_;
911  ::goby::acomms::protobuf::DCCLConfig* dccl_cfg_;
912  ::goby::acomms::protobuf::RouteManagerConfig* route_cfg_;
913  ::pAcommsHandlerConfig_MOOSVariables* moos_var_;
914  ::google::protobuf::RepeatedPtrField< ::std::string> load_shared_library_;
915  ::google::protobuf::RepeatedPtrField< ::std::string> load_proto_file_;
916  ::google::protobuf::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry > translator_entry_;
917  ::google::protobuf::RepeatedPtrField< ::std::string> multiplex_create_moos_var_;
918  ::google::protobuf::RepeatedPtrField< ::std::string> dccl_frontseat_forward_name_;
919  ::std::string* modem_id_lookup_path_;
920  ::goby::transitional::protobuf::DCCLTransitionalConfig* transitional_cfg_;
921  friend void protobuf_AddDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
922  friend void protobuf_AssignDesc_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
923  friend void protobuf_ShutdownFile_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto();
924 
925  void InitAsDefaultInstance();
926  static pAcommsHandlerConfig* default_instance_;
927 };
928 // ===================================================================
929 
930 
931 // ===================================================================
932 
933 // pAcommsHandlerConfig_DriverFailureApproach
934 
935 // optional .pAcommsHandlerConfig.DriverFailureApproach.DriverFailureTechnique technique = 1 [default = CONTINUALLY_RESTART_DRIVER];
936 inline bool pAcommsHandlerConfig_DriverFailureApproach::has_technique() const {
937  return (_has_bits_[0] & 0x00000001u) != 0;
938 }
939 inline void pAcommsHandlerConfig_DriverFailureApproach::set_has_technique() {
940  _has_bits_[0] |= 0x00000001u;
941 }
942 inline void pAcommsHandlerConfig_DriverFailureApproach::clear_has_technique() {
943  _has_bits_[0] &= ~0x00000001u;
944 }
945 inline void pAcommsHandlerConfig_DriverFailureApproach::clear_technique() {
946  technique_ = 1;
947  clear_has_technique();
948 }
949 inline ::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach::technique() const {
950  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.DriverFailureApproach.technique)
951  return static_cast< ::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique >(technique_);
952 }
953 inline void pAcommsHandlerConfig_DriverFailureApproach::set_technique(::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value) {
954  assert(::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_IsValid(value));
955  set_has_technique();
956  technique_ = value;
957  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.DriverFailureApproach.technique)
958 }
959 
960 // optional int32 driver_backoff_sec = 2 [default = 60];
961 inline bool pAcommsHandlerConfig_DriverFailureApproach::has_driver_backoff_sec() const {
962  return (_has_bits_[0] & 0x00000002u) != 0;
963 }
964 inline void pAcommsHandlerConfig_DriverFailureApproach::set_has_driver_backoff_sec() {
965  _has_bits_[0] |= 0x00000002u;
966 }
967 inline void pAcommsHandlerConfig_DriverFailureApproach::clear_has_driver_backoff_sec() {
968  _has_bits_[0] &= ~0x00000002u;
969 }
970 inline void pAcommsHandlerConfig_DriverFailureApproach::clear_driver_backoff_sec() {
971  driver_backoff_sec_ = 60;
972  clear_has_driver_backoff_sec();
973 }
974 inline ::google::protobuf::int32 pAcommsHandlerConfig_DriverFailureApproach::driver_backoff_sec() const {
975  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.DriverFailureApproach.driver_backoff_sec)
976  return driver_backoff_sec_;
977 }
978 inline void pAcommsHandlerConfig_DriverFailureApproach::set_driver_backoff_sec(::google::protobuf::int32 value) {
979  set_has_driver_backoff_sec();
980  driver_backoff_sec_ = value;
981  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.DriverFailureApproach.driver_backoff_sec)
982 }
983 
984 // -------------------------------------------------------------------
985 
986 // pAcommsHandlerConfig_MOOSVariables
987 
988 // optional string prefix = 1 [default = "ACOMMS_"];
989 inline bool pAcommsHandlerConfig_MOOSVariables::has_prefix() const {
990  return (_has_bits_[0] & 0x00000001u) != 0;
991 }
992 inline void pAcommsHandlerConfig_MOOSVariables::set_has_prefix() {
993  _has_bits_[0] |= 0x00000001u;
994 }
995 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_prefix() {
996  _has_bits_[0] &= ~0x00000001u;
997 }
998 inline void pAcommsHandlerConfig_MOOSVariables::clear_prefix() {
999  if (prefix_ != _default_prefix_) {
1000  prefix_->assign(*_default_prefix_);
1001  }
1002  clear_has_prefix();
1003 }
1004 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::prefix() const {
1005  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.prefix)
1006  return *prefix_;
1007 }
1008 inline void pAcommsHandlerConfig_MOOSVariables::set_prefix(const ::std::string& value) {
1009  set_has_prefix();
1010  if (prefix_ == _default_prefix_) {
1011  prefix_ = new ::std::string;
1012  }
1013  prefix_->assign(value);
1014  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.prefix)
1015 }
1016 inline void pAcommsHandlerConfig_MOOSVariables::set_prefix(const char* value) {
1017  set_has_prefix();
1018  if (prefix_ == _default_prefix_) {
1019  prefix_ = new ::std::string;
1020  }
1021  prefix_->assign(value);
1022  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.prefix)
1023 }
1024 inline void pAcommsHandlerConfig_MOOSVariables::set_prefix(const char* value, size_t size) {
1025  set_has_prefix();
1026  if (prefix_ == _default_prefix_) {
1027  prefix_ = new ::std::string;
1028  }
1029  prefix_->assign(reinterpret_cast<const char*>(value), size);
1030  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.prefix)
1031 }
1032 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_prefix() {
1033  set_has_prefix();
1034  if (prefix_ == _default_prefix_) {
1035  prefix_ = new ::std::string(*_default_prefix_);
1036  }
1037  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.prefix)
1038  return prefix_;
1039 }
1040 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_prefix() {
1041  clear_has_prefix();
1042  if (prefix_ == _default_prefix_) {
1043  return NULL;
1044  } else {
1045  ::std::string* temp = prefix_;
1046  prefix_ = const_cast< ::std::string*>(_default_prefix_);
1047  return temp;
1048  }
1049 }
1050 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_prefix(::std::string* prefix) {
1051  if (prefix_ != _default_prefix_) {
1052  delete prefix_;
1053  }
1054  if (prefix) {
1055  set_has_prefix();
1056  prefix_ = prefix;
1057  } else {
1058  clear_has_prefix();
1059  prefix_ = const_cast< ::std::string*>(_default_prefix_);
1060  }
1061  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.prefix)
1062 }
1063 
1064 // optional string driver_raw_in = 10 [default = "NMEA_IN"];
1065 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_in() const {
1066  return (_has_bits_[0] & 0x00000002u) != 0;
1067 }
1068 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_raw_in() {
1069  _has_bits_[0] |= 0x00000002u;
1070 }
1071 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_raw_in() {
1072  _has_bits_[0] &= ~0x00000002u;
1073 }
1074 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_in() {
1075  if (driver_raw_in_ != _default_driver_raw_in_) {
1076  driver_raw_in_->assign(*_default_driver_raw_in_);
1077  }
1078  clear_has_driver_raw_in();
1079 }
1080 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_in() const {
1081  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
1082  return *driver_raw_in_;
1083 }
1084 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_in(const ::std::string& value) {
1085  set_has_driver_raw_in();
1086  if (driver_raw_in_ == _default_driver_raw_in_) {
1087  driver_raw_in_ = new ::std::string;
1088  }
1089  driver_raw_in_->assign(value);
1090  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
1091 }
1092 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_in(const char* value) {
1093  set_has_driver_raw_in();
1094  if (driver_raw_in_ == _default_driver_raw_in_) {
1095  driver_raw_in_ = new ::std::string;
1096  }
1097  driver_raw_in_->assign(value);
1098  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
1099 }
1100 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_in(const char* value, size_t size) {
1101  set_has_driver_raw_in();
1102  if (driver_raw_in_ == _default_driver_raw_in_) {
1103  driver_raw_in_ = new ::std::string;
1104  }
1105  driver_raw_in_->assign(reinterpret_cast<const char*>(value), size);
1106  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
1107 }
1108 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_in() {
1109  set_has_driver_raw_in();
1110  if (driver_raw_in_ == _default_driver_raw_in_) {
1111  driver_raw_in_ = new ::std::string(*_default_driver_raw_in_);
1112  }
1113  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
1114  return driver_raw_in_;
1115 }
1116 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_in() {
1117  clear_has_driver_raw_in();
1118  if (driver_raw_in_ == _default_driver_raw_in_) {
1119  return NULL;
1120  } else {
1121  ::std::string* temp = driver_raw_in_;
1122  driver_raw_in_ = const_cast< ::std::string*>(_default_driver_raw_in_);
1123  return temp;
1124  }
1125 }
1126 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_in(::std::string* driver_raw_in) {
1127  if (driver_raw_in_ != _default_driver_raw_in_) {
1128  delete driver_raw_in_;
1129  }
1130  if (driver_raw_in) {
1131  set_has_driver_raw_in();
1132  driver_raw_in_ = driver_raw_in;
1133  } else {
1134  clear_has_driver_raw_in();
1135  driver_raw_in_ = const_cast< ::std::string*>(_default_driver_raw_in_);
1136  }
1137  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
1138 }
1139 
1140 // optional string driver_raw_out = 11 [default = "NMEA_OUT"];
1141 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_out() const {
1142  return (_has_bits_[0] & 0x00000004u) != 0;
1143 }
1144 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_raw_out() {
1145  _has_bits_[0] |= 0x00000004u;
1146 }
1147 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_raw_out() {
1148  _has_bits_[0] &= ~0x00000004u;
1149 }
1150 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_out() {
1151  if (driver_raw_out_ != _default_driver_raw_out_) {
1152  driver_raw_out_->assign(*_default_driver_raw_out_);
1153  }
1154  clear_has_driver_raw_out();
1155 }
1156 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_out() const {
1157  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
1158  return *driver_raw_out_;
1159 }
1160 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_out(const ::std::string& value) {
1161  set_has_driver_raw_out();
1162  if (driver_raw_out_ == _default_driver_raw_out_) {
1163  driver_raw_out_ = new ::std::string;
1164  }
1165  driver_raw_out_->assign(value);
1166  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
1167 }
1168 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_out(const char* value) {
1169  set_has_driver_raw_out();
1170  if (driver_raw_out_ == _default_driver_raw_out_) {
1171  driver_raw_out_ = new ::std::string;
1172  }
1173  driver_raw_out_->assign(value);
1174  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
1175 }
1176 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_out(const char* value, size_t size) {
1177  set_has_driver_raw_out();
1178  if (driver_raw_out_ == _default_driver_raw_out_) {
1179  driver_raw_out_ = new ::std::string;
1180  }
1181  driver_raw_out_->assign(reinterpret_cast<const char*>(value), size);
1182  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
1183 }
1184 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_out() {
1185  set_has_driver_raw_out();
1186  if (driver_raw_out_ == _default_driver_raw_out_) {
1187  driver_raw_out_ = new ::std::string(*_default_driver_raw_out_);
1188  }
1189  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
1190  return driver_raw_out_;
1191 }
1192 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_out() {
1193  clear_has_driver_raw_out();
1194  if (driver_raw_out_ == _default_driver_raw_out_) {
1195  return NULL;
1196  } else {
1197  ::std::string* temp = driver_raw_out_;
1198  driver_raw_out_ = const_cast< ::std::string*>(_default_driver_raw_out_);
1199  return temp;
1200  }
1201 }
1202 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_out(::std::string* driver_raw_out) {
1203  if (driver_raw_out_ != _default_driver_raw_out_) {
1204  delete driver_raw_out_;
1205  }
1206  if (driver_raw_out) {
1207  set_has_driver_raw_out();
1208  driver_raw_out_ = driver_raw_out;
1209  } else {
1210  clear_has_driver_raw_out();
1211  driver_raw_out_ = const_cast< ::std::string*>(_default_driver_raw_out_);
1212  }
1213  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
1214 }
1215 
1216 // optional string driver_raw_msg_in = 12 [default = "RAW_INCOMING"];
1217 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_msg_in() const {
1218  return (_has_bits_[0] & 0x00000008u) != 0;
1219 }
1220 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_raw_msg_in() {
1221  _has_bits_[0] |= 0x00000008u;
1222 }
1223 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_raw_msg_in() {
1224  _has_bits_[0] &= ~0x00000008u;
1225 }
1226 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_msg_in() {
1227  if (driver_raw_msg_in_ != _default_driver_raw_msg_in_) {
1228  driver_raw_msg_in_->assign(*_default_driver_raw_msg_in_);
1229  }
1230  clear_has_driver_raw_msg_in();
1231 }
1232 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_msg_in() const {
1233  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
1234  return *driver_raw_msg_in_;
1235 }
1236 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_in(const ::std::string& value) {
1237  set_has_driver_raw_msg_in();
1238  if (driver_raw_msg_in_ == _default_driver_raw_msg_in_) {
1239  driver_raw_msg_in_ = new ::std::string;
1240  }
1241  driver_raw_msg_in_->assign(value);
1242  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
1243 }
1244 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_in(const char* value) {
1245  set_has_driver_raw_msg_in();
1246  if (driver_raw_msg_in_ == _default_driver_raw_msg_in_) {
1247  driver_raw_msg_in_ = new ::std::string;
1248  }
1249  driver_raw_msg_in_->assign(value);
1250  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
1251 }
1252 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_in(const char* value, size_t size) {
1253  set_has_driver_raw_msg_in();
1254  if (driver_raw_msg_in_ == _default_driver_raw_msg_in_) {
1255  driver_raw_msg_in_ = new ::std::string;
1256  }
1257  driver_raw_msg_in_->assign(reinterpret_cast<const char*>(value), size);
1258  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
1259 }
1260 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_msg_in() {
1261  set_has_driver_raw_msg_in();
1262  if (driver_raw_msg_in_ == _default_driver_raw_msg_in_) {
1263  driver_raw_msg_in_ = new ::std::string(*_default_driver_raw_msg_in_);
1264  }
1265  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
1266  return driver_raw_msg_in_;
1267 }
1268 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_msg_in() {
1269  clear_has_driver_raw_msg_in();
1270  if (driver_raw_msg_in_ == _default_driver_raw_msg_in_) {
1271  return NULL;
1272  } else {
1273  ::std::string* temp = driver_raw_msg_in_;
1274  driver_raw_msg_in_ = const_cast< ::std::string*>(_default_driver_raw_msg_in_);
1275  return temp;
1276  }
1277 }
1278 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_msg_in(::std::string* driver_raw_msg_in) {
1279  if (driver_raw_msg_in_ != _default_driver_raw_msg_in_) {
1280  delete driver_raw_msg_in_;
1281  }
1282  if (driver_raw_msg_in) {
1283  set_has_driver_raw_msg_in();
1284  driver_raw_msg_in_ = driver_raw_msg_in;
1285  } else {
1286  clear_has_driver_raw_msg_in();
1287  driver_raw_msg_in_ = const_cast< ::std::string*>(_default_driver_raw_msg_in_);
1288  }
1289  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
1290 }
1291 
1292 // optional string driver_raw_msg_out = 13 [default = "RAW_OUTGOING"];
1293 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_msg_out() const {
1294  return (_has_bits_[0] & 0x00000010u) != 0;
1295 }
1296 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_raw_msg_out() {
1297  _has_bits_[0] |= 0x00000010u;
1298 }
1299 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_raw_msg_out() {
1300  _has_bits_[0] &= ~0x00000010u;
1301 }
1302 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_msg_out() {
1303  if (driver_raw_msg_out_ != _default_driver_raw_msg_out_) {
1304  driver_raw_msg_out_->assign(*_default_driver_raw_msg_out_);
1305  }
1306  clear_has_driver_raw_msg_out();
1307 }
1308 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_msg_out() const {
1309  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
1310  return *driver_raw_msg_out_;
1311 }
1312 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_out(const ::std::string& value) {
1313  set_has_driver_raw_msg_out();
1314  if (driver_raw_msg_out_ == _default_driver_raw_msg_out_) {
1315  driver_raw_msg_out_ = new ::std::string;
1316  }
1317  driver_raw_msg_out_->assign(value);
1318  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
1319 }
1320 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_out(const char* value) {
1321  set_has_driver_raw_msg_out();
1322  if (driver_raw_msg_out_ == _default_driver_raw_msg_out_) {
1323  driver_raw_msg_out_ = new ::std::string;
1324  }
1325  driver_raw_msg_out_->assign(value);
1326  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
1327 }
1328 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_out(const char* value, size_t size) {
1329  set_has_driver_raw_msg_out();
1330  if (driver_raw_msg_out_ == _default_driver_raw_msg_out_) {
1331  driver_raw_msg_out_ = new ::std::string;
1332  }
1333  driver_raw_msg_out_->assign(reinterpret_cast<const char*>(value), size);
1334  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
1335 }
1336 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_msg_out() {
1337  set_has_driver_raw_msg_out();
1338  if (driver_raw_msg_out_ == _default_driver_raw_msg_out_) {
1339  driver_raw_msg_out_ = new ::std::string(*_default_driver_raw_msg_out_);
1340  }
1341  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
1342  return driver_raw_msg_out_;
1343 }
1344 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_msg_out() {
1345  clear_has_driver_raw_msg_out();
1346  if (driver_raw_msg_out_ == _default_driver_raw_msg_out_) {
1347  return NULL;
1348  } else {
1349  ::std::string* temp = driver_raw_msg_out_;
1350  driver_raw_msg_out_ = const_cast< ::std::string*>(_default_driver_raw_msg_out_);
1351  return temp;
1352  }
1353 }
1354 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_msg_out(::std::string* driver_raw_msg_out) {
1355  if (driver_raw_msg_out_ != _default_driver_raw_msg_out_) {
1356  delete driver_raw_msg_out_;
1357  }
1358  if (driver_raw_msg_out) {
1359  set_has_driver_raw_msg_out();
1360  driver_raw_msg_out_ = driver_raw_msg_out;
1361  } else {
1362  clear_has_driver_raw_msg_out();
1363  driver_raw_msg_out_ = const_cast< ::std::string*>(_default_driver_raw_msg_out_);
1364  }
1365  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
1366 }
1367 
1368 // optional string driver_receive = 14 [default = "MODEM_RECEIVE"];
1369 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_receive() const {
1370  return (_has_bits_[0] & 0x00000020u) != 0;
1371 }
1372 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_receive() {
1373  _has_bits_[0] |= 0x00000020u;
1374 }
1375 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_receive() {
1376  _has_bits_[0] &= ~0x00000020u;
1377 }
1378 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_receive() {
1379  if (driver_receive_ != _default_driver_receive_) {
1380  driver_receive_->assign(*_default_driver_receive_);
1381  }
1382  clear_has_driver_receive();
1383 }
1384 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_receive() const {
1385  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_receive)
1386  return *driver_receive_;
1387 }
1388 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_receive(const ::std::string& value) {
1389  set_has_driver_receive();
1390  if (driver_receive_ == _default_driver_receive_) {
1391  driver_receive_ = new ::std::string;
1392  }
1393  driver_receive_->assign(value);
1394  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_receive)
1395 }
1396 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_receive(const char* value) {
1397  set_has_driver_receive();
1398  if (driver_receive_ == _default_driver_receive_) {
1399  driver_receive_ = new ::std::string;
1400  }
1401  driver_receive_->assign(value);
1402  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_receive)
1403 }
1404 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_receive(const char* value, size_t size) {
1405  set_has_driver_receive();
1406  if (driver_receive_ == _default_driver_receive_) {
1407  driver_receive_ = new ::std::string;
1408  }
1409  driver_receive_->assign(reinterpret_cast<const char*>(value), size);
1410  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_receive)
1411 }
1412 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_receive() {
1413  set_has_driver_receive();
1414  if (driver_receive_ == _default_driver_receive_) {
1415  driver_receive_ = new ::std::string(*_default_driver_receive_);
1416  }
1417  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_receive)
1418  return driver_receive_;
1419 }
1420 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_receive() {
1421  clear_has_driver_receive();
1422  if (driver_receive_ == _default_driver_receive_) {
1423  return NULL;
1424  } else {
1425  ::std::string* temp = driver_receive_;
1426  driver_receive_ = const_cast< ::std::string*>(_default_driver_receive_);
1427  return temp;
1428  }
1429 }
1430 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_receive(::std::string* driver_receive) {
1431  if (driver_receive_ != _default_driver_receive_) {
1432  delete driver_receive_;
1433  }
1434  if (driver_receive) {
1435  set_has_driver_receive();
1436  driver_receive_ = driver_receive;
1437  } else {
1438  clear_has_driver_receive();
1439  driver_receive_ = const_cast< ::std::string*>(_default_driver_receive_);
1440  }
1441  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_receive)
1442 }
1443 
1444 // optional string driver_transmit = 15 [default = "MODEM_TRANSMIT"];
1445 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_transmit() const {
1446  return (_has_bits_[0] & 0x00000040u) != 0;
1447 }
1448 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_transmit() {
1449  _has_bits_[0] |= 0x00000040u;
1450 }
1451 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_transmit() {
1452  _has_bits_[0] &= ~0x00000040u;
1453 }
1454 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_transmit() {
1455  if (driver_transmit_ != _default_driver_transmit_) {
1456  driver_transmit_->assign(*_default_driver_transmit_);
1457  }
1458  clear_has_driver_transmit();
1459 }
1460 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_transmit() const {
1461  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_transmit)
1462  return *driver_transmit_;
1463 }
1464 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_transmit(const ::std::string& value) {
1465  set_has_driver_transmit();
1466  if (driver_transmit_ == _default_driver_transmit_) {
1467  driver_transmit_ = new ::std::string;
1468  }
1469  driver_transmit_->assign(value);
1470  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_transmit)
1471 }
1472 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_transmit(const char* value) {
1473  set_has_driver_transmit();
1474  if (driver_transmit_ == _default_driver_transmit_) {
1475  driver_transmit_ = new ::std::string;
1476  }
1477  driver_transmit_->assign(value);
1478  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_transmit)
1479 }
1480 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_transmit(const char* value, size_t size) {
1481  set_has_driver_transmit();
1482  if (driver_transmit_ == _default_driver_transmit_) {
1483  driver_transmit_ = new ::std::string;
1484  }
1485  driver_transmit_->assign(reinterpret_cast<const char*>(value), size);
1486  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_transmit)
1487 }
1488 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_transmit() {
1489  set_has_driver_transmit();
1490  if (driver_transmit_ == _default_driver_transmit_) {
1491  driver_transmit_ = new ::std::string(*_default_driver_transmit_);
1492  }
1493  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_transmit)
1494  return driver_transmit_;
1495 }
1496 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_transmit() {
1497  clear_has_driver_transmit();
1498  if (driver_transmit_ == _default_driver_transmit_) {
1499  return NULL;
1500  } else {
1501  ::std::string* temp = driver_transmit_;
1502  driver_transmit_ = const_cast< ::std::string*>(_default_driver_transmit_);
1503  return temp;
1504  }
1505 }
1506 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_transmit(::std::string* driver_transmit) {
1507  if (driver_transmit_ != _default_driver_transmit_) {
1508  delete driver_transmit_;
1509  }
1510  if (driver_transmit) {
1511  set_has_driver_transmit();
1512  driver_transmit_ = driver_transmit;
1513  } else {
1514  clear_has_driver_transmit();
1515  driver_transmit_ = const_cast< ::std::string*>(_default_driver_transmit_);
1516  }
1517  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_transmit)
1518 }
1519 
1520 // optional string driver_cfg_update = 16 [default = "DRIVER_CONFIG_UPDATE"];
1521 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_cfg_update() const {
1522  return (_has_bits_[0] & 0x00000080u) != 0;
1523 }
1524 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_cfg_update() {
1525  _has_bits_[0] |= 0x00000080u;
1526 }
1527 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_cfg_update() {
1528  _has_bits_[0] &= ~0x00000080u;
1529 }
1530 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_cfg_update() {
1531  if (driver_cfg_update_ != _default_driver_cfg_update_) {
1532  driver_cfg_update_->assign(*_default_driver_cfg_update_);
1533  }
1534  clear_has_driver_cfg_update();
1535 }
1536 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_cfg_update() const {
1537  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
1538  return *driver_cfg_update_;
1539 }
1540 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_cfg_update(const ::std::string& value) {
1541  set_has_driver_cfg_update();
1542  if (driver_cfg_update_ == _default_driver_cfg_update_) {
1543  driver_cfg_update_ = new ::std::string;
1544  }
1545  driver_cfg_update_->assign(value);
1546  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
1547 }
1548 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_cfg_update(const char* value) {
1549  set_has_driver_cfg_update();
1550  if (driver_cfg_update_ == _default_driver_cfg_update_) {
1551  driver_cfg_update_ = new ::std::string;
1552  }
1553  driver_cfg_update_->assign(value);
1554  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
1555 }
1556 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_cfg_update(const char* value, size_t size) {
1557  set_has_driver_cfg_update();
1558  if (driver_cfg_update_ == _default_driver_cfg_update_) {
1559  driver_cfg_update_ = new ::std::string;
1560  }
1561  driver_cfg_update_->assign(reinterpret_cast<const char*>(value), size);
1562  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
1563 }
1564 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_cfg_update() {
1565  set_has_driver_cfg_update();
1566  if (driver_cfg_update_ == _default_driver_cfg_update_) {
1567  driver_cfg_update_ = new ::std::string(*_default_driver_cfg_update_);
1568  }
1569  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
1570  return driver_cfg_update_;
1571 }
1572 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_cfg_update() {
1573  clear_has_driver_cfg_update();
1574  if (driver_cfg_update_ == _default_driver_cfg_update_) {
1575  return NULL;
1576  } else {
1577  ::std::string* temp = driver_cfg_update_;
1578  driver_cfg_update_ = const_cast< ::std::string*>(_default_driver_cfg_update_);
1579  return temp;
1580  }
1581 }
1582 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_cfg_update(::std::string* driver_cfg_update) {
1583  if (driver_cfg_update_ != _default_driver_cfg_update_) {
1584  delete driver_cfg_update_;
1585  }
1586  if (driver_cfg_update) {
1587  set_has_driver_cfg_update();
1588  driver_cfg_update_ = driver_cfg_update;
1589  } else {
1590  clear_has_driver_cfg_update();
1591  driver_cfg_update_ = const_cast< ::std::string*>(_default_driver_cfg_update_);
1592  }
1593  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
1594 }
1595 
1596 // optional string queue_receive = 100 [default = "QUEUE_RECEIVE"];
1597 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_receive() const {
1598  return (_has_bits_[0] & 0x00000100u) != 0;
1599 }
1600 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_receive() {
1601  _has_bits_[0] |= 0x00000100u;
1602 }
1603 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_receive() {
1604  _has_bits_[0] &= ~0x00000100u;
1605 }
1606 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_receive() {
1607  if (queue_receive_ != _default_queue_receive_) {
1608  queue_receive_->assign(*_default_queue_receive_);
1609  }
1610  clear_has_queue_receive();
1611 }
1612 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_receive() const {
1613  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_receive)
1614  return *queue_receive_;
1615 }
1616 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_receive(const ::std::string& value) {
1617  set_has_queue_receive();
1618  if (queue_receive_ == _default_queue_receive_) {
1619  queue_receive_ = new ::std::string;
1620  }
1621  queue_receive_->assign(value);
1622  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_receive)
1623 }
1624 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_receive(const char* value) {
1625  set_has_queue_receive();
1626  if (queue_receive_ == _default_queue_receive_) {
1627  queue_receive_ = new ::std::string;
1628  }
1629  queue_receive_->assign(value);
1630  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_receive)
1631 }
1632 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_receive(const char* value, size_t size) {
1633  set_has_queue_receive();
1634  if (queue_receive_ == _default_queue_receive_) {
1635  queue_receive_ = new ::std::string;
1636  }
1637  queue_receive_->assign(reinterpret_cast<const char*>(value), size);
1638  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_receive)
1639 }
1640 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_receive() {
1641  set_has_queue_receive();
1642  if (queue_receive_ == _default_queue_receive_) {
1643  queue_receive_ = new ::std::string(*_default_queue_receive_);
1644  }
1645  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_receive)
1646  return queue_receive_;
1647 }
1648 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_receive() {
1649  clear_has_queue_receive();
1650  if (queue_receive_ == _default_queue_receive_) {
1651  return NULL;
1652  } else {
1653  ::std::string* temp = queue_receive_;
1654  queue_receive_ = const_cast< ::std::string*>(_default_queue_receive_);
1655  return temp;
1656  }
1657 }
1658 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_receive(::std::string* queue_receive) {
1659  if (queue_receive_ != _default_queue_receive_) {
1660  delete queue_receive_;
1661  }
1662  if (queue_receive) {
1663  set_has_queue_receive();
1664  queue_receive_ = queue_receive;
1665  } else {
1666  clear_has_queue_receive();
1667  queue_receive_ = const_cast< ::std::string*>(_default_queue_receive_);
1668  }
1669  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_receive)
1670 }
1671 
1672 // optional string queue_transmit = 101 [default = "QUEUE_TRANSMIT"];
1673 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_transmit() const {
1674  return (_has_bits_[0] & 0x00000200u) != 0;
1675 }
1676 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_transmit() {
1677  _has_bits_[0] |= 0x00000200u;
1678 }
1679 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_transmit() {
1680  _has_bits_[0] &= ~0x00000200u;
1681 }
1682 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_transmit() {
1683  if (queue_transmit_ != _default_queue_transmit_) {
1684  queue_transmit_->assign(*_default_queue_transmit_);
1685  }
1686  clear_has_queue_transmit();
1687 }
1688 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_transmit() const {
1689  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_transmit)
1690  return *queue_transmit_;
1691 }
1692 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_transmit(const ::std::string& value) {
1693  set_has_queue_transmit();
1694  if (queue_transmit_ == _default_queue_transmit_) {
1695  queue_transmit_ = new ::std::string;
1696  }
1697  queue_transmit_->assign(value);
1698  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_transmit)
1699 }
1700 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_transmit(const char* value) {
1701  set_has_queue_transmit();
1702  if (queue_transmit_ == _default_queue_transmit_) {
1703  queue_transmit_ = new ::std::string;
1704  }
1705  queue_transmit_->assign(value);
1706  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_transmit)
1707 }
1708 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_transmit(const char* value, size_t size) {
1709  set_has_queue_transmit();
1710  if (queue_transmit_ == _default_queue_transmit_) {
1711  queue_transmit_ = new ::std::string;
1712  }
1713  queue_transmit_->assign(reinterpret_cast<const char*>(value), size);
1714  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_transmit)
1715 }
1716 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_transmit() {
1717  set_has_queue_transmit();
1718  if (queue_transmit_ == _default_queue_transmit_) {
1719  queue_transmit_ = new ::std::string(*_default_queue_transmit_);
1720  }
1721  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_transmit)
1722  return queue_transmit_;
1723 }
1724 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_transmit() {
1725  clear_has_queue_transmit();
1726  if (queue_transmit_ == _default_queue_transmit_) {
1727  return NULL;
1728  } else {
1729  ::std::string* temp = queue_transmit_;
1730  queue_transmit_ = const_cast< ::std::string*>(_default_queue_transmit_);
1731  return temp;
1732  }
1733 }
1734 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_transmit(::std::string* queue_transmit) {
1735  if (queue_transmit_ != _default_queue_transmit_) {
1736  delete queue_transmit_;
1737  }
1738  if (queue_transmit) {
1739  set_has_queue_transmit();
1740  queue_transmit_ = queue_transmit;
1741  } else {
1742  clear_has_queue_transmit();
1743  queue_transmit_ = const_cast< ::std::string*>(_default_queue_transmit_);
1744  }
1745  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_transmit)
1746 }
1747 
1748 // optional string queue_ack_transmission = 102 [default = "ACK"];
1749 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_ack_transmission() const {
1750  return (_has_bits_[0] & 0x00000400u) != 0;
1751 }
1752 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_ack_transmission() {
1753  _has_bits_[0] |= 0x00000400u;
1754 }
1755 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_ack_transmission() {
1756  _has_bits_[0] &= ~0x00000400u;
1757 }
1758 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_ack_transmission() {
1759  if (queue_ack_transmission_ != _default_queue_ack_transmission_) {
1760  queue_ack_transmission_->assign(*_default_queue_ack_transmission_);
1761  }
1762  clear_has_queue_ack_transmission();
1763 }
1764 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_ack_transmission() const {
1765  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
1766  return *queue_ack_transmission_;
1767 }
1768 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_transmission(const ::std::string& value) {
1769  set_has_queue_ack_transmission();
1770  if (queue_ack_transmission_ == _default_queue_ack_transmission_) {
1771  queue_ack_transmission_ = new ::std::string;
1772  }
1773  queue_ack_transmission_->assign(value);
1774  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
1775 }
1776 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_transmission(const char* value) {
1777  set_has_queue_ack_transmission();
1778  if (queue_ack_transmission_ == _default_queue_ack_transmission_) {
1779  queue_ack_transmission_ = new ::std::string;
1780  }
1781  queue_ack_transmission_->assign(value);
1782  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
1783 }
1784 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_transmission(const char* value, size_t size) {
1785  set_has_queue_ack_transmission();
1786  if (queue_ack_transmission_ == _default_queue_ack_transmission_) {
1787  queue_ack_transmission_ = new ::std::string;
1788  }
1789  queue_ack_transmission_->assign(reinterpret_cast<const char*>(value), size);
1790  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
1791 }
1792 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_ack_transmission() {
1793  set_has_queue_ack_transmission();
1794  if (queue_ack_transmission_ == _default_queue_ack_transmission_) {
1795  queue_ack_transmission_ = new ::std::string(*_default_queue_ack_transmission_);
1796  }
1797  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
1798  return queue_ack_transmission_;
1799 }
1800 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_ack_transmission() {
1801  clear_has_queue_ack_transmission();
1802  if (queue_ack_transmission_ == _default_queue_ack_transmission_) {
1803  return NULL;
1804  } else {
1805  ::std::string* temp = queue_ack_transmission_;
1806  queue_ack_transmission_ = const_cast< ::std::string*>(_default_queue_ack_transmission_);
1807  return temp;
1808  }
1809 }
1810 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_ack_transmission(::std::string* queue_ack_transmission) {
1811  if (queue_ack_transmission_ != _default_queue_ack_transmission_) {
1812  delete queue_ack_transmission_;
1813  }
1814  if (queue_ack_transmission) {
1815  set_has_queue_ack_transmission();
1816  queue_ack_transmission_ = queue_ack_transmission;
1817  } else {
1818  clear_has_queue_ack_transmission();
1819  queue_ack_transmission_ = const_cast< ::std::string*>(_default_queue_ack_transmission_);
1820  }
1821  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
1822 }
1823 
1824 // optional string queue_ack_original_msg = 103 [default = "ACK_ORIGINAL"];
1825 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_ack_original_msg() const {
1826  return (_has_bits_[0] & 0x00000800u) != 0;
1827 }
1828 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_ack_original_msg() {
1829  _has_bits_[0] |= 0x00000800u;
1830 }
1831 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_ack_original_msg() {
1832  _has_bits_[0] &= ~0x00000800u;
1833 }
1834 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_ack_original_msg() {
1835  if (queue_ack_original_msg_ != _default_queue_ack_original_msg_) {
1836  queue_ack_original_msg_->assign(*_default_queue_ack_original_msg_);
1837  }
1838  clear_has_queue_ack_original_msg();
1839 }
1840 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_ack_original_msg() const {
1841  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
1842  return *queue_ack_original_msg_;
1843 }
1844 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_original_msg(const ::std::string& value) {
1845  set_has_queue_ack_original_msg();
1846  if (queue_ack_original_msg_ == _default_queue_ack_original_msg_) {
1847  queue_ack_original_msg_ = new ::std::string;
1848  }
1849  queue_ack_original_msg_->assign(value);
1850  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
1851 }
1852 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_original_msg(const char* value) {
1853  set_has_queue_ack_original_msg();
1854  if (queue_ack_original_msg_ == _default_queue_ack_original_msg_) {
1855  queue_ack_original_msg_ = new ::std::string;
1856  }
1857  queue_ack_original_msg_->assign(value);
1858  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
1859 }
1860 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_original_msg(const char* value, size_t size) {
1861  set_has_queue_ack_original_msg();
1862  if (queue_ack_original_msg_ == _default_queue_ack_original_msg_) {
1863  queue_ack_original_msg_ = new ::std::string;
1864  }
1865  queue_ack_original_msg_->assign(reinterpret_cast<const char*>(value), size);
1866  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
1867 }
1868 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_ack_original_msg() {
1869  set_has_queue_ack_original_msg();
1870  if (queue_ack_original_msg_ == _default_queue_ack_original_msg_) {
1871  queue_ack_original_msg_ = new ::std::string(*_default_queue_ack_original_msg_);
1872  }
1873  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
1874  return queue_ack_original_msg_;
1875 }
1876 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_ack_original_msg() {
1877  clear_has_queue_ack_original_msg();
1878  if (queue_ack_original_msg_ == _default_queue_ack_original_msg_) {
1879  return NULL;
1880  } else {
1881  ::std::string* temp = queue_ack_original_msg_;
1882  queue_ack_original_msg_ = const_cast< ::std::string*>(_default_queue_ack_original_msg_);
1883  return temp;
1884  }
1885 }
1886 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_ack_original_msg(::std::string* queue_ack_original_msg) {
1887  if (queue_ack_original_msg_ != _default_queue_ack_original_msg_) {
1888  delete queue_ack_original_msg_;
1889  }
1890  if (queue_ack_original_msg) {
1891  set_has_queue_ack_original_msg();
1892  queue_ack_original_msg_ = queue_ack_original_msg;
1893  } else {
1894  clear_has_queue_ack_original_msg();
1895  queue_ack_original_msg_ = const_cast< ::std::string*>(_default_queue_ack_original_msg_);
1896  }
1897  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
1898 }
1899 
1900 // optional string queue_expire = 104 [default = "EXPIRE"];
1901 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_expire() const {
1902  return (_has_bits_[0] & 0x00001000u) != 0;
1903 }
1904 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_expire() {
1905  _has_bits_[0] |= 0x00001000u;
1906 }
1907 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_expire() {
1908  _has_bits_[0] &= ~0x00001000u;
1909 }
1910 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_expire() {
1911  if (queue_expire_ != _default_queue_expire_) {
1912  queue_expire_->assign(*_default_queue_expire_);
1913  }
1914  clear_has_queue_expire();
1915 }
1916 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_expire() const {
1917  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_expire)
1918  return *queue_expire_;
1919 }
1920 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_expire(const ::std::string& value) {
1921  set_has_queue_expire();
1922  if (queue_expire_ == _default_queue_expire_) {
1923  queue_expire_ = new ::std::string;
1924  }
1925  queue_expire_->assign(value);
1926  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_expire)
1927 }
1928 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_expire(const char* value) {
1929  set_has_queue_expire();
1930  if (queue_expire_ == _default_queue_expire_) {
1931  queue_expire_ = new ::std::string;
1932  }
1933  queue_expire_->assign(value);
1934  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_expire)
1935 }
1936 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_expire(const char* value, size_t size) {
1937  set_has_queue_expire();
1938  if (queue_expire_ == _default_queue_expire_) {
1939  queue_expire_ = new ::std::string;
1940  }
1941  queue_expire_->assign(reinterpret_cast<const char*>(value), size);
1942  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_expire)
1943 }
1944 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_expire() {
1945  set_has_queue_expire();
1946  if (queue_expire_ == _default_queue_expire_) {
1947  queue_expire_ = new ::std::string(*_default_queue_expire_);
1948  }
1949  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_expire)
1950  return queue_expire_;
1951 }
1952 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_expire() {
1953  clear_has_queue_expire();
1954  if (queue_expire_ == _default_queue_expire_) {
1955  return NULL;
1956  } else {
1957  ::std::string* temp = queue_expire_;
1958  queue_expire_ = const_cast< ::std::string*>(_default_queue_expire_);
1959  return temp;
1960  }
1961 }
1962 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_expire(::std::string* queue_expire) {
1963  if (queue_expire_ != _default_queue_expire_) {
1964  delete queue_expire_;
1965  }
1966  if (queue_expire) {
1967  set_has_queue_expire();
1968  queue_expire_ = queue_expire;
1969  } else {
1970  clear_has_queue_expire();
1971  queue_expire_ = const_cast< ::std::string*>(_default_queue_expire_);
1972  }
1973  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_expire)
1974 }
1975 
1976 // optional string queue_size = 105 [default = "QSIZE"];
1977 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_size() const {
1978  return (_has_bits_[0] & 0x00002000u) != 0;
1979 }
1980 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_size() {
1981  _has_bits_[0] |= 0x00002000u;
1982 }
1983 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_size() {
1984  _has_bits_[0] &= ~0x00002000u;
1985 }
1986 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_size() {
1987  if (queue_size_ != _default_queue_size_) {
1988  queue_size_->assign(*_default_queue_size_);
1989  }
1990  clear_has_queue_size();
1991 }
1992 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_size() const {
1993  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_size)
1994  return *queue_size_;
1995 }
1996 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_size(const ::std::string& value) {
1997  set_has_queue_size();
1998  if (queue_size_ == _default_queue_size_) {
1999  queue_size_ = new ::std::string;
2000  }
2001  queue_size_->assign(value);
2002  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_size)
2003 }
2004 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_size(const char* value) {
2005  set_has_queue_size();
2006  if (queue_size_ == _default_queue_size_) {
2007  queue_size_ = new ::std::string;
2008  }
2009  queue_size_->assign(value);
2010  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_size)
2011 }
2012 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_size(const char* value, size_t size) {
2013  set_has_queue_size();
2014  if (queue_size_ == _default_queue_size_) {
2015  queue_size_ = new ::std::string;
2016  }
2017  queue_size_->assign(reinterpret_cast<const char*>(value), size);
2018  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_size)
2019 }
2020 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_size() {
2021  set_has_queue_size();
2022  if (queue_size_ == _default_queue_size_) {
2023  queue_size_ = new ::std::string(*_default_queue_size_);
2024  }
2025  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_size)
2026  return queue_size_;
2027 }
2028 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_size() {
2029  clear_has_queue_size();
2030  if (queue_size_ == _default_queue_size_) {
2031  return NULL;
2032  } else {
2033  ::std::string* temp = queue_size_;
2034  queue_size_ = const_cast< ::std::string*>(_default_queue_size_);
2035  return temp;
2036  }
2037 }
2038 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_size(::std::string* queue_size) {
2039  if (queue_size_ != _default_queue_size_) {
2040  delete queue_size_;
2041  }
2042  if (queue_size) {
2043  set_has_queue_size();
2044  queue_size_ = queue_size;
2045  } else {
2046  clear_has_queue_size();
2047  queue_size_ = const_cast< ::std::string*>(_default_queue_size_);
2048  }
2049  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_size)
2050 }
2051 
2052 // optional string queue_flush = 106 [default = "FLUSH_QUEUE"];
2053 inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_flush() const {
2054  return (_has_bits_[0] & 0x00004000u) != 0;
2055 }
2056 inline void pAcommsHandlerConfig_MOOSVariables::set_has_queue_flush() {
2057  _has_bits_[0] |= 0x00004000u;
2058 }
2059 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_queue_flush() {
2060  _has_bits_[0] &= ~0x00004000u;
2061 }
2062 inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_flush() {
2063  if (queue_flush_ != _default_queue_flush_) {
2064  queue_flush_->assign(*_default_queue_flush_);
2065  }
2066  clear_has_queue_flush();
2067 }
2068 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::queue_flush() const {
2069  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.queue_flush)
2070  return *queue_flush_;
2071 }
2072 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_flush(const ::std::string& value) {
2073  set_has_queue_flush();
2074  if (queue_flush_ == _default_queue_flush_) {
2075  queue_flush_ = new ::std::string;
2076  }
2077  queue_flush_->assign(value);
2078  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.queue_flush)
2079 }
2080 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_flush(const char* value) {
2081  set_has_queue_flush();
2082  if (queue_flush_ == _default_queue_flush_) {
2083  queue_flush_ = new ::std::string;
2084  }
2085  queue_flush_->assign(value);
2086  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.queue_flush)
2087 }
2088 inline void pAcommsHandlerConfig_MOOSVariables::set_queue_flush(const char* value, size_t size) {
2089  set_has_queue_flush();
2090  if (queue_flush_ == _default_queue_flush_) {
2091  queue_flush_ = new ::std::string;
2092  }
2093  queue_flush_->assign(reinterpret_cast<const char*>(value), size);
2094  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.queue_flush)
2095 }
2096 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_flush() {
2097  set_has_queue_flush();
2098  if (queue_flush_ == _default_queue_flush_) {
2099  queue_flush_ = new ::std::string(*_default_queue_flush_);
2100  }
2101  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.queue_flush)
2102  return queue_flush_;
2103 }
2104 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_flush() {
2105  clear_has_queue_flush();
2106  if (queue_flush_ == _default_queue_flush_) {
2107  return NULL;
2108  } else {
2109  ::std::string* temp = queue_flush_;
2110  queue_flush_ = const_cast< ::std::string*>(_default_queue_flush_);
2111  return temp;
2112  }
2113 }
2114 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_flush(::std::string* queue_flush) {
2115  if (queue_flush_ != _default_queue_flush_) {
2116  delete queue_flush_;
2117  }
2118  if (queue_flush) {
2119  set_has_queue_flush();
2120  queue_flush_ = queue_flush;
2121  } else {
2122  clear_has_queue_flush();
2123  queue_flush_ = const_cast< ::std::string*>(_default_queue_flush_);
2124  }
2125  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.queue_flush)
2126 }
2127 
2128 // optional string mac_cycle_update = 200 [default = "MAC_CYCLE_UPDATE"];
2129 inline bool pAcommsHandlerConfig_MOOSVariables::has_mac_cycle_update() const {
2130  return (_has_bits_[0] & 0x00008000u) != 0;
2131 }
2132 inline void pAcommsHandlerConfig_MOOSVariables::set_has_mac_cycle_update() {
2133  _has_bits_[0] |= 0x00008000u;
2134 }
2135 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_mac_cycle_update() {
2136  _has_bits_[0] &= ~0x00008000u;
2137 }
2138 inline void pAcommsHandlerConfig_MOOSVariables::clear_mac_cycle_update() {
2139  if (mac_cycle_update_ != _default_mac_cycle_update_) {
2140  mac_cycle_update_->assign(*_default_mac_cycle_update_);
2141  }
2142  clear_has_mac_cycle_update();
2143 }
2144 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::mac_cycle_update() const {
2145  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
2146  return *mac_cycle_update_;
2147 }
2148 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_cycle_update(const ::std::string& value) {
2149  set_has_mac_cycle_update();
2150  if (mac_cycle_update_ == _default_mac_cycle_update_) {
2151  mac_cycle_update_ = new ::std::string;
2152  }
2153  mac_cycle_update_->assign(value);
2154  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
2155 }
2156 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_cycle_update(const char* value) {
2157  set_has_mac_cycle_update();
2158  if (mac_cycle_update_ == _default_mac_cycle_update_) {
2159  mac_cycle_update_ = new ::std::string;
2160  }
2161  mac_cycle_update_->assign(value);
2162  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
2163 }
2164 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_cycle_update(const char* value, size_t size) {
2165  set_has_mac_cycle_update();
2166  if (mac_cycle_update_ == _default_mac_cycle_update_) {
2167  mac_cycle_update_ = new ::std::string;
2168  }
2169  mac_cycle_update_->assign(reinterpret_cast<const char*>(value), size);
2170  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
2171 }
2172 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_mac_cycle_update() {
2173  set_has_mac_cycle_update();
2174  if (mac_cycle_update_ == _default_mac_cycle_update_) {
2175  mac_cycle_update_ = new ::std::string(*_default_mac_cycle_update_);
2176  }
2177  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
2178  return mac_cycle_update_;
2179 }
2180 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_mac_cycle_update() {
2181  clear_has_mac_cycle_update();
2182  if (mac_cycle_update_ == _default_mac_cycle_update_) {
2183  return NULL;
2184  } else {
2185  ::std::string* temp = mac_cycle_update_;
2186  mac_cycle_update_ = const_cast< ::std::string*>(_default_mac_cycle_update_);
2187  return temp;
2188  }
2189 }
2190 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_mac_cycle_update(::std::string* mac_cycle_update) {
2191  if (mac_cycle_update_ != _default_mac_cycle_update_) {
2192  delete mac_cycle_update_;
2193  }
2194  if (mac_cycle_update) {
2195  set_has_mac_cycle_update();
2196  mac_cycle_update_ = mac_cycle_update;
2197  } else {
2198  clear_has_mac_cycle_update();
2199  mac_cycle_update_ = const_cast< ::std::string*>(_default_mac_cycle_update_);
2200  }
2201  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
2202 }
2203 
2204 // optional string mac_initiate_transmission = 201 [default = "MAC_INITIATE_TRANSMISSION"];
2205 inline bool pAcommsHandlerConfig_MOOSVariables::has_mac_initiate_transmission() const {
2206  return (_has_bits_[0] & 0x00010000u) != 0;
2207 }
2208 inline void pAcommsHandlerConfig_MOOSVariables::set_has_mac_initiate_transmission() {
2209  _has_bits_[0] |= 0x00010000u;
2210 }
2211 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_mac_initiate_transmission() {
2212  _has_bits_[0] &= ~0x00010000u;
2213 }
2214 inline void pAcommsHandlerConfig_MOOSVariables::clear_mac_initiate_transmission() {
2215  if (mac_initiate_transmission_ != _default_mac_initiate_transmission_) {
2216  mac_initiate_transmission_->assign(*_default_mac_initiate_transmission_);
2217  }
2218  clear_has_mac_initiate_transmission();
2219 }
2220 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::mac_initiate_transmission() const {
2221  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
2222  return *mac_initiate_transmission_;
2223 }
2224 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_initiate_transmission(const ::std::string& value) {
2225  set_has_mac_initiate_transmission();
2226  if (mac_initiate_transmission_ == _default_mac_initiate_transmission_) {
2227  mac_initiate_transmission_ = new ::std::string;
2228  }
2229  mac_initiate_transmission_->assign(value);
2230  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
2231 }
2232 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_initiate_transmission(const char* value) {
2233  set_has_mac_initiate_transmission();
2234  if (mac_initiate_transmission_ == _default_mac_initiate_transmission_) {
2235  mac_initiate_transmission_ = new ::std::string;
2236  }
2237  mac_initiate_transmission_->assign(value);
2238  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
2239 }
2240 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_initiate_transmission(const char* value, size_t size) {
2241  set_has_mac_initiate_transmission();
2242  if (mac_initiate_transmission_ == _default_mac_initiate_transmission_) {
2243  mac_initiate_transmission_ = new ::std::string;
2244  }
2245  mac_initiate_transmission_->assign(reinterpret_cast<const char*>(value), size);
2246  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
2247 }
2248 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_mac_initiate_transmission() {
2249  set_has_mac_initiate_transmission();
2250  if (mac_initiate_transmission_ == _default_mac_initiate_transmission_) {
2251  mac_initiate_transmission_ = new ::std::string(*_default_mac_initiate_transmission_);
2252  }
2253  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
2254  return mac_initiate_transmission_;
2255 }
2256 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_mac_initiate_transmission() {
2257  clear_has_mac_initiate_transmission();
2258  if (mac_initiate_transmission_ == _default_mac_initiate_transmission_) {
2259  return NULL;
2260  } else {
2261  ::std::string* temp = mac_initiate_transmission_;
2262  mac_initiate_transmission_ = const_cast< ::std::string*>(_default_mac_initiate_transmission_);
2263  return temp;
2264  }
2265 }
2266 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_mac_initiate_transmission(::std::string* mac_initiate_transmission) {
2267  if (mac_initiate_transmission_ != _default_mac_initiate_transmission_) {
2268  delete mac_initiate_transmission_;
2269  }
2270  if (mac_initiate_transmission) {
2271  set_has_mac_initiate_transmission();
2272  mac_initiate_transmission_ = mac_initiate_transmission;
2273  } else {
2274  clear_has_mac_initiate_transmission();
2275  mac_initiate_transmission_ = const_cast< ::std::string*>(_default_mac_initiate_transmission_);
2276  }
2277  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
2278 }
2279 
2280 // optional string mac_slot_start = 202 [default = "MAC_SLOT_START"];
2281 inline bool pAcommsHandlerConfig_MOOSVariables::has_mac_slot_start() const {
2282  return (_has_bits_[0] & 0x00020000u) != 0;
2283 }
2284 inline void pAcommsHandlerConfig_MOOSVariables::set_has_mac_slot_start() {
2285  _has_bits_[0] |= 0x00020000u;
2286 }
2287 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_mac_slot_start() {
2288  _has_bits_[0] &= ~0x00020000u;
2289 }
2290 inline void pAcommsHandlerConfig_MOOSVariables::clear_mac_slot_start() {
2291  if (mac_slot_start_ != _default_mac_slot_start_) {
2292  mac_slot_start_->assign(*_default_mac_slot_start_);
2293  }
2294  clear_has_mac_slot_start();
2295 }
2296 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::mac_slot_start() const {
2297  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
2298  return *mac_slot_start_;
2299 }
2300 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_slot_start(const ::std::string& value) {
2301  set_has_mac_slot_start();
2302  if (mac_slot_start_ == _default_mac_slot_start_) {
2303  mac_slot_start_ = new ::std::string;
2304  }
2305  mac_slot_start_->assign(value);
2306  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
2307 }
2308 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_slot_start(const char* value) {
2309  set_has_mac_slot_start();
2310  if (mac_slot_start_ == _default_mac_slot_start_) {
2311  mac_slot_start_ = new ::std::string;
2312  }
2313  mac_slot_start_->assign(value);
2314  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
2315 }
2316 inline void pAcommsHandlerConfig_MOOSVariables::set_mac_slot_start(const char* value, size_t size) {
2317  set_has_mac_slot_start();
2318  if (mac_slot_start_ == _default_mac_slot_start_) {
2319  mac_slot_start_ = new ::std::string;
2320  }
2321  mac_slot_start_->assign(reinterpret_cast<const char*>(value), size);
2322  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
2323 }
2324 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_mac_slot_start() {
2325  set_has_mac_slot_start();
2326  if (mac_slot_start_ == _default_mac_slot_start_) {
2327  mac_slot_start_ = new ::std::string(*_default_mac_slot_start_);
2328  }
2329  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
2330  return mac_slot_start_;
2331 }
2332 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_mac_slot_start() {
2333  clear_has_mac_slot_start();
2334  if (mac_slot_start_ == _default_mac_slot_start_) {
2335  return NULL;
2336  } else {
2337  ::std::string* temp = mac_slot_start_;
2338  mac_slot_start_ = const_cast< ::std::string*>(_default_mac_slot_start_);
2339  return temp;
2340  }
2341 }
2342 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_mac_slot_start(::std::string* mac_slot_start) {
2343  if (mac_slot_start_ != _default_mac_slot_start_) {
2344  delete mac_slot_start_;
2345  }
2346  if (mac_slot_start) {
2347  set_has_mac_slot_start();
2348  mac_slot_start_ = mac_slot_start;
2349  } else {
2350  clear_has_mac_slot_start();
2351  mac_slot_start_ = const_cast< ::std::string*>(_default_mac_slot_start_);
2352  }
2353  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
2354 }
2355 
2356 // optional string config_file = 300 [default = "CONFIG"];
2357 inline bool pAcommsHandlerConfig_MOOSVariables::has_config_file() const {
2358  return (_has_bits_[0] & 0x00040000u) != 0;
2359 }
2360 inline void pAcommsHandlerConfig_MOOSVariables::set_has_config_file() {
2361  _has_bits_[0] |= 0x00040000u;
2362 }
2363 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_config_file() {
2364  _has_bits_[0] &= ~0x00040000u;
2365 }
2366 inline void pAcommsHandlerConfig_MOOSVariables::clear_config_file() {
2367  if (config_file_ != _default_config_file_) {
2368  config_file_->assign(*_default_config_file_);
2369  }
2370  clear_has_config_file();
2371 }
2372 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::config_file() const {
2373  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.config_file)
2374  return *config_file_;
2375 }
2376 inline void pAcommsHandlerConfig_MOOSVariables::set_config_file(const ::std::string& value) {
2377  set_has_config_file();
2378  if (config_file_ == _default_config_file_) {
2379  config_file_ = new ::std::string;
2380  }
2381  config_file_->assign(value);
2382  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.config_file)
2383 }
2384 inline void pAcommsHandlerConfig_MOOSVariables::set_config_file(const char* value) {
2385  set_has_config_file();
2386  if (config_file_ == _default_config_file_) {
2387  config_file_ = new ::std::string;
2388  }
2389  config_file_->assign(value);
2390  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.config_file)
2391 }
2392 inline void pAcommsHandlerConfig_MOOSVariables::set_config_file(const char* value, size_t size) {
2393  set_has_config_file();
2394  if (config_file_ == _default_config_file_) {
2395  config_file_ = new ::std::string;
2396  }
2397  config_file_->assign(reinterpret_cast<const char*>(value), size);
2398  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.config_file)
2399 }
2400 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_config_file() {
2401  set_has_config_file();
2402  if (config_file_ == _default_config_file_) {
2403  config_file_ = new ::std::string(*_default_config_file_);
2404  }
2405  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.config_file)
2406  return config_file_;
2407 }
2408 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_config_file() {
2409  clear_has_config_file();
2410  if (config_file_ == _default_config_file_) {
2411  return NULL;
2412  } else {
2413  ::std::string* temp = config_file_;
2414  config_file_ = const_cast< ::std::string*>(_default_config_file_);
2415  return temp;
2416  }
2417 }
2418 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_config_file(::std::string* config_file) {
2419  if (config_file_ != _default_config_file_) {
2420  delete config_file_;
2421  }
2422  if (config_file) {
2423  set_has_config_file();
2424  config_file_ = config_file;
2425  } else {
2426  clear_has_config_file();
2427  config_file_ = const_cast< ::std::string*>(_default_config_file_);
2428  }
2429  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.config_file)
2430 }
2431 
2432 // optional string config_file_request = 301 [default = "CONFIG_REQUEST"];
2433 inline bool pAcommsHandlerConfig_MOOSVariables::has_config_file_request() const {
2434  return (_has_bits_[0] & 0x00080000u) != 0;
2435 }
2436 inline void pAcommsHandlerConfig_MOOSVariables::set_has_config_file_request() {
2437  _has_bits_[0] |= 0x00080000u;
2438 }
2439 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_config_file_request() {
2440  _has_bits_[0] &= ~0x00080000u;
2441 }
2442 inline void pAcommsHandlerConfig_MOOSVariables::clear_config_file_request() {
2443  if (config_file_request_ != _default_config_file_request_) {
2444  config_file_request_->assign(*_default_config_file_request_);
2445  }
2446  clear_has_config_file_request();
2447 }
2448 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::config_file_request() const {
2449  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.config_file_request)
2450  return *config_file_request_;
2451 }
2452 inline void pAcommsHandlerConfig_MOOSVariables::set_config_file_request(const ::std::string& value) {
2453  set_has_config_file_request();
2454  if (config_file_request_ == _default_config_file_request_) {
2455  config_file_request_ = new ::std::string;
2456  }
2457  config_file_request_->assign(value);
2458  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.config_file_request)
2459 }
2460 inline void pAcommsHandlerConfig_MOOSVariables::set_config_file_request(const char* value) {
2461  set_has_config_file_request();
2462  if (config_file_request_ == _default_config_file_request_) {
2463  config_file_request_ = new ::std::string;
2464  }
2465  config_file_request_->assign(value);
2466  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.config_file_request)
2467 }
2468 inline void pAcommsHandlerConfig_MOOSVariables::set_config_file_request(const char* value, size_t size) {
2469  set_has_config_file_request();
2470  if (config_file_request_ == _default_config_file_request_) {
2471  config_file_request_ = new ::std::string;
2472  }
2473  config_file_request_->assign(reinterpret_cast<const char*>(value), size);
2474  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.config_file_request)
2475 }
2476 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_config_file_request() {
2477  set_has_config_file_request();
2478  if (config_file_request_ == _default_config_file_request_) {
2479  config_file_request_ = new ::std::string(*_default_config_file_request_);
2480  }
2481  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.config_file_request)
2482  return config_file_request_;
2483 }
2484 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_config_file_request() {
2485  clear_has_config_file_request();
2486  if (config_file_request_ == _default_config_file_request_) {
2487  return NULL;
2488  } else {
2489  ::std::string* temp = config_file_request_;
2490  config_file_request_ = const_cast< ::std::string*>(_default_config_file_request_);
2491  return temp;
2492  }
2493 }
2494 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_config_file_request(::std::string* config_file_request) {
2495  if (config_file_request_ != _default_config_file_request_) {
2496  delete config_file_request_;
2497  }
2498  if (config_file_request) {
2499  set_has_config_file_request();
2500  config_file_request_ = config_file_request;
2501  } else {
2502  clear_has_config_file_request();
2503  config_file_request_ = const_cast< ::std::string*>(_default_config_file_request_);
2504  }
2505  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.config_file_request)
2506 }
2507 
2508 // optional string driver_reset = 400 [default = "DRIVER_RESET"];
2509 inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_reset() const {
2510  return (_has_bits_[0] & 0x00100000u) != 0;
2511 }
2512 inline void pAcommsHandlerConfig_MOOSVariables::set_has_driver_reset() {
2513  _has_bits_[0] |= 0x00100000u;
2514 }
2515 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_driver_reset() {
2516  _has_bits_[0] &= ~0x00100000u;
2517 }
2518 inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_reset() {
2519  if (driver_reset_ != _default_driver_reset_) {
2520  driver_reset_->assign(*_default_driver_reset_);
2521  }
2522  clear_has_driver_reset();
2523 }
2524 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::driver_reset() const {
2525  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.driver_reset)
2526  return *driver_reset_;
2527 }
2528 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_reset(const ::std::string& value) {
2529  set_has_driver_reset();
2530  if (driver_reset_ == _default_driver_reset_) {
2531  driver_reset_ = new ::std::string;
2532  }
2533  driver_reset_->assign(value);
2534  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.driver_reset)
2535 }
2536 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_reset(const char* value) {
2537  set_has_driver_reset();
2538  if (driver_reset_ == _default_driver_reset_) {
2539  driver_reset_ = new ::std::string;
2540  }
2541  driver_reset_->assign(value);
2542  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.driver_reset)
2543 }
2544 inline void pAcommsHandlerConfig_MOOSVariables::set_driver_reset(const char* value, size_t size) {
2545  set_has_driver_reset();
2546  if (driver_reset_ == _default_driver_reset_) {
2547  driver_reset_ = new ::std::string;
2548  }
2549  driver_reset_->assign(reinterpret_cast<const char*>(value), size);
2550  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.driver_reset)
2551 }
2552 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_reset() {
2553  set_has_driver_reset();
2554  if (driver_reset_ == _default_driver_reset_) {
2555  driver_reset_ = new ::std::string(*_default_driver_reset_);
2556  }
2557  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.driver_reset)
2558  return driver_reset_;
2559 }
2560 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_reset() {
2561  clear_has_driver_reset();
2562  if (driver_reset_ == _default_driver_reset_) {
2563  return NULL;
2564  } else {
2565  ::std::string* temp = driver_reset_;
2566  driver_reset_ = const_cast< ::std::string*>(_default_driver_reset_);
2567  return temp;
2568  }
2569 }
2570 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_reset(::std::string* driver_reset) {
2571  if (driver_reset_ != _default_driver_reset_) {
2572  delete driver_reset_;
2573  }
2574  if (driver_reset) {
2575  set_has_driver_reset();
2576  driver_reset_ = driver_reset;
2577  } else {
2578  clear_has_driver_reset();
2579  driver_reset_ = const_cast< ::std::string*>(_default_driver_reset_);
2580  }
2581  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.driver_reset)
2582 }
2583 
2584 // optional string ifrontseat_data_out = 500 [default = "IFS_DATA_OUT"];
2585 inline bool pAcommsHandlerConfig_MOOSVariables::has_ifrontseat_data_out() const {
2586  return (_has_bits_[0] & 0x00200000u) != 0;
2587 }
2588 inline void pAcommsHandlerConfig_MOOSVariables::set_has_ifrontseat_data_out() {
2589  _has_bits_[0] |= 0x00200000u;
2590 }
2591 inline void pAcommsHandlerConfig_MOOSVariables::clear_has_ifrontseat_data_out() {
2592  _has_bits_[0] &= ~0x00200000u;
2593 }
2594 inline void pAcommsHandlerConfig_MOOSVariables::clear_ifrontseat_data_out() {
2595  if (ifrontseat_data_out_ != _default_ifrontseat_data_out_) {
2596  ifrontseat_data_out_->assign(*_default_ifrontseat_data_out_);
2597  }
2598  clear_has_ifrontseat_data_out();
2599 }
2600 inline const ::std::string& pAcommsHandlerConfig_MOOSVariables::ifrontseat_data_out() const {
2601  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
2602  return *ifrontseat_data_out_;
2603 }
2604 inline void pAcommsHandlerConfig_MOOSVariables::set_ifrontseat_data_out(const ::std::string& value) {
2605  set_has_ifrontseat_data_out();
2606  if (ifrontseat_data_out_ == _default_ifrontseat_data_out_) {
2607  ifrontseat_data_out_ = new ::std::string;
2608  }
2609  ifrontseat_data_out_->assign(value);
2610  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
2611 }
2612 inline void pAcommsHandlerConfig_MOOSVariables::set_ifrontseat_data_out(const char* value) {
2613  set_has_ifrontseat_data_out();
2614  if (ifrontseat_data_out_ == _default_ifrontseat_data_out_) {
2615  ifrontseat_data_out_ = new ::std::string;
2616  }
2617  ifrontseat_data_out_->assign(value);
2618  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
2619 }
2620 inline void pAcommsHandlerConfig_MOOSVariables::set_ifrontseat_data_out(const char* value, size_t size) {
2621  set_has_ifrontseat_data_out();
2622  if (ifrontseat_data_out_ == _default_ifrontseat_data_out_) {
2623  ifrontseat_data_out_ = new ::std::string;
2624  }
2625  ifrontseat_data_out_->assign(reinterpret_cast<const char*>(value), size);
2626  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
2627 }
2628 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::mutable_ifrontseat_data_out() {
2629  set_has_ifrontseat_data_out();
2630  if (ifrontseat_data_out_ == _default_ifrontseat_data_out_) {
2631  ifrontseat_data_out_ = new ::std::string(*_default_ifrontseat_data_out_);
2632  }
2633  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
2634  return ifrontseat_data_out_;
2635 }
2636 inline ::std::string* pAcommsHandlerConfig_MOOSVariables::release_ifrontseat_data_out() {
2637  clear_has_ifrontseat_data_out();
2638  if (ifrontseat_data_out_ == _default_ifrontseat_data_out_) {
2639  return NULL;
2640  } else {
2641  ::std::string* temp = ifrontseat_data_out_;
2642  ifrontseat_data_out_ = const_cast< ::std::string*>(_default_ifrontseat_data_out_);
2643  return temp;
2644  }
2645 }
2646 inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_ifrontseat_data_out(::std::string* ifrontseat_data_out) {
2647  if (ifrontseat_data_out_ != _default_ifrontseat_data_out_) {
2648  delete ifrontseat_data_out_;
2649  }
2650  if (ifrontseat_data_out) {
2651  set_has_ifrontseat_data_out();
2652  ifrontseat_data_out_ = ifrontseat_data_out;
2653  } else {
2654  clear_has_ifrontseat_data_out();
2655  ifrontseat_data_out_ = const_cast< ::std::string*>(_default_ifrontseat_data_out_);
2656  }
2657  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
2658 }
2659 
2660 // -------------------------------------------------------------------
2661 
2662 // pAcommsHandlerConfig
2663 
2664 // optional .GobyMOOSAppConfig common = 1;
2665 inline bool pAcommsHandlerConfig::has_common() const {
2666  return (_has_bits_[0] & 0x00000001u) != 0;
2667 }
2668 inline void pAcommsHandlerConfig::set_has_common() {
2669  _has_bits_[0] |= 0x00000001u;
2670 }
2671 inline void pAcommsHandlerConfig::clear_has_common() {
2672  _has_bits_[0] &= ~0x00000001u;
2673 }
2674 inline void pAcommsHandlerConfig::clear_common() {
2675  if (common_ != NULL) common_->::GobyMOOSAppConfig::Clear();
2676  clear_has_common();
2677 }
2678 inline const ::GobyMOOSAppConfig& pAcommsHandlerConfig::common() const {
2679  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.common)
2680  return common_ != NULL ? *common_ : *default_instance_->common_;
2681 }
2682 inline ::GobyMOOSAppConfig* pAcommsHandlerConfig::mutable_common() {
2683  set_has_common();
2684  if (common_ == NULL) common_ = new ::GobyMOOSAppConfig;
2685  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.common)
2686  return common_;
2687 }
2688 inline ::GobyMOOSAppConfig* pAcommsHandlerConfig::release_common() {
2689  clear_has_common();
2690  ::GobyMOOSAppConfig* temp = common_;
2691  common_ = NULL;
2692  return temp;
2693 }
2694 inline void pAcommsHandlerConfig::set_allocated_common(::GobyMOOSAppConfig* common) {
2695  delete common_;
2696  common_ = common;
2697  if (common) {
2698  set_has_common();
2699  } else {
2700  clear_has_common();
2701  }
2702  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.common)
2703 }
2704 
2705 // required int32 modem_id = 2;
2706 inline bool pAcommsHandlerConfig::has_modem_id() const {
2707  return (_has_bits_[0] & 0x00000002u) != 0;
2708 }
2709 inline void pAcommsHandlerConfig::set_has_modem_id() {
2710  _has_bits_[0] |= 0x00000002u;
2711 }
2712 inline void pAcommsHandlerConfig::clear_has_modem_id() {
2713  _has_bits_[0] &= ~0x00000002u;
2714 }
2715 inline void pAcommsHandlerConfig::clear_modem_id() {
2716  modem_id_ = 0;
2717  clear_has_modem_id();
2718 }
2719 inline ::google::protobuf::int32 pAcommsHandlerConfig::modem_id() const {
2720  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.modem_id)
2721  return modem_id_;
2722 }
2723 inline void pAcommsHandlerConfig::set_modem_id(::google::protobuf::int32 value) {
2724  set_has_modem_id();
2725  modem_id_ = value;
2726  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.modem_id)
2727 }
2728 
2729 // optional .goby.acomms.protobuf.DriverType driver_type = 3 [default = DRIVER_NONE];
2730 inline bool pAcommsHandlerConfig::has_driver_type() const {
2731  return (_has_bits_[0] & 0x00000004u) != 0;
2732 }
2733 inline void pAcommsHandlerConfig::set_has_driver_type() {
2734  _has_bits_[0] |= 0x00000004u;
2735 }
2736 inline void pAcommsHandlerConfig::clear_has_driver_type() {
2737  _has_bits_[0] &= ~0x00000004u;
2738 }
2739 inline void pAcommsHandlerConfig::clear_driver_type() {
2740  driver_type_ = 1;
2741  clear_has_driver_type();
2742 }
2743 inline ::goby::acomms::protobuf::DriverType pAcommsHandlerConfig::driver_type() const {
2744  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.driver_type)
2745  return static_cast< ::goby::acomms::protobuf::DriverType >(driver_type_);
2746 }
2747 inline void pAcommsHandlerConfig::set_driver_type(::goby::acomms::protobuf::DriverType value) {
2748  assert(::goby::acomms::protobuf::DriverType_IsValid(value));
2749  set_has_driver_type();
2750  driver_type_ = value;
2751  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.driver_type)
2752 }
2753 
2754 // optional .goby.acomms.protobuf.DriverConfig driver_cfg = 4;
2755 inline bool pAcommsHandlerConfig::has_driver_cfg() const {
2756  return (_has_bits_[0] & 0x00000008u) != 0;
2757 }
2758 inline void pAcommsHandlerConfig::set_has_driver_cfg() {
2759  _has_bits_[0] |= 0x00000008u;
2760 }
2761 inline void pAcommsHandlerConfig::clear_has_driver_cfg() {
2762  _has_bits_[0] &= ~0x00000008u;
2763 }
2764 inline void pAcommsHandlerConfig::clear_driver_cfg() {
2765  if (driver_cfg_ != NULL) driver_cfg_->::goby::acomms::protobuf::DriverConfig::Clear();
2766  clear_has_driver_cfg();
2767 }
2768 inline const ::goby::acomms::protobuf::DriverConfig& pAcommsHandlerConfig::driver_cfg() const {
2769  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.driver_cfg)
2770  return driver_cfg_ != NULL ? *driver_cfg_ : *default_instance_->driver_cfg_;
2771 }
2772 inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::mutable_driver_cfg() {
2773  set_has_driver_cfg();
2774  if (driver_cfg_ == NULL) driver_cfg_ = new ::goby::acomms::protobuf::DriverConfig;
2775  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.driver_cfg)
2776  return driver_cfg_;
2777 }
2778 inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::release_driver_cfg() {
2779  clear_has_driver_cfg();
2780  ::goby::acomms::protobuf::DriverConfig* temp = driver_cfg_;
2781  driver_cfg_ = NULL;
2782  return temp;
2783 }
2784 inline void pAcommsHandlerConfig::set_allocated_driver_cfg(::goby::acomms::protobuf::DriverConfig* driver_cfg) {
2785  delete driver_cfg_;
2786  driver_cfg_ = driver_cfg;
2787  if (driver_cfg) {
2788  set_has_driver_cfg();
2789  } else {
2790  clear_has_driver_cfg();
2791  }
2792  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.driver_cfg)
2793 }
2794 
2795 // repeated .goby.acomms.protobuf.DriverType listen_driver_type = 30;
2796 inline int pAcommsHandlerConfig::listen_driver_type_size() const {
2797  return listen_driver_type_.size();
2798 }
2799 inline void pAcommsHandlerConfig::clear_listen_driver_type() {
2800  listen_driver_type_.Clear();
2801 }
2802 inline ::goby::acomms::protobuf::DriverType pAcommsHandlerConfig::listen_driver_type(int index) const {
2803  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.listen_driver_type)
2804  return static_cast< ::goby::acomms::protobuf::DriverType >(listen_driver_type_.Get(index));
2805 }
2806 inline void pAcommsHandlerConfig::set_listen_driver_type(int index, ::goby::acomms::protobuf::DriverType value) {
2807  assert(::goby::acomms::protobuf::DriverType_IsValid(value));
2808  listen_driver_type_.Set(index, value);
2809  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.listen_driver_type)
2810 }
2811 inline void pAcommsHandlerConfig::add_listen_driver_type(::goby::acomms::protobuf::DriverType value) {
2812  assert(::goby::acomms::protobuf::DriverType_IsValid(value));
2813  listen_driver_type_.Add(value);
2814  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.listen_driver_type)
2815 }
2816 inline const ::google::protobuf::RepeatedField<int>&
2817 pAcommsHandlerConfig::listen_driver_type() const {
2818  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.listen_driver_type)
2819  return listen_driver_type_;
2820 }
2821 inline ::google::protobuf::RepeatedField<int>*
2822 pAcommsHandlerConfig::mutable_listen_driver_type() {
2823  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.listen_driver_type)
2824  return &listen_driver_type_;
2825 }
2826 
2827 // repeated .goby.acomms.protobuf.DriverConfig listen_driver_cfg = 31;
2828 inline int pAcommsHandlerConfig::listen_driver_cfg_size() const {
2829  return listen_driver_cfg_.size();
2830 }
2831 inline void pAcommsHandlerConfig::clear_listen_driver_cfg() {
2832  listen_driver_cfg_.Clear();
2833 }
2834 inline const ::goby::acomms::protobuf::DriverConfig& pAcommsHandlerConfig::listen_driver_cfg(int index) const {
2835  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.listen_driver_cfg)
2836  return listen_driver_cfg_.Get(index);
2837 }
2838 inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::mutable_listen_driver_cfg(int index) {
2839  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.listen_driver_cfg)
2840  return listen_driver_cfg_.Mutable(index);
2841 }
2842 inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::add_listen_driver_cfg() {
2843  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.listen_driver_cfg)
2844  return listen_driver_cfg_.Add();
2845 }
2846 inline const ::google::protobuf::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >&
2847 pAcommsHandlerConfig::listen_driver_cfg() const {
2848  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.listen_driver_cfg)
2849  return listen_driver_cfg_;
2850 }
2851 inline ::google::protobuf::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >*
2852 pAcommsHandlerConfig::mutable_listen_driver_cfg() {
2853  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.listen_driver_cfg)
2854  return &listen_driver_cfg_;
2855 }
2856 
2857 // optional .pAcommsHandlerConfig.DriverFailureApproach driver_failure_approach = 32;
2858 inline bool pAcommsHandlerConfig::has_driver_failure_approach() const {
2859  return (_has_bits_[0] & 0x00000040u) != 0;
2860 }
2861 inline void pAcommsHandlerConfig::set_has_driver_failure_approach() {
2862  _has_bits_[0] |= 0x00000040u;
2863 }
2864 inline void pAcommsHandlerConfig::clear_has_driver_failure_approach() {
2865  _has_bits_[0] &= ~0x00000040u;
2866 }
2867 inline void pAcommsHandlerConfig::clear_driver_failure_approach() {
2868  if (driver_failure_approach_ != NULL) driver_failure_approach_->::pAcommsHandlerConfig_DriverFailureApproach::Clear();
2869  clear_has_driver_failure_approach();
2870 }
2871 inline const ::pAcommsHandlerConfig_DriverFailureApproach& pAcommsHandlerConfig::driver_failure_approach() const {
2872  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.driver_failure_approach)
2873  return driver_failure_approach_ != NULL ? *driver_failure_approach_ : *default_instance_->driver_failure_approach_;
2874 }
2875 inline ::pAcommsHandlerConfig_DriverFailureApproach* pAcommsHandlerConfig::mutable_driver_failure_approach() {
2876  set_has_driver_failure_approach();
2877  if (driver_failure_approach_ == NULL) driver_failure_approach_ = new ::pAcommsHandlerConfig_DriverFailureApproach;
2878  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.driver_failure_approach)
2879  return driver_failure_approach_;
2880 }
2881 inline ::pAcommsHandlerConfig_DriverFailureApproach* pAcommsHandlerConfig::release_driver_failure_approach() {
2882  clear_has_driver_failure_approach();
2883  ::pAcommsHandlerConfig_DriverFailureApproach* temp = driver_failure_approach_;
2884  driver_failure_approach_ = NULL;
2885  return temp;
2886 }
2887 inline void pAcommsHandlerConfig::set_allocated_driver_failure_approach(::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach) {
2888  delete driver_failure_approach_;
2889  driver_failure_approach_ = driver_failure_approach;
2890  if (driver_failure_approach) {
2891  set_has_driver_failure_approach();
2892  } else {
2893  clear_has_driver_failure_approach();
2894  }
2895  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.driver_failure_approach)
2896 }
2897 
2898 // optional .goby.acomms.protobuf.MACConfig mac_cfg = 5;
2899 inline bool pAcommsHandlerConfig::has_mac_cfg() const {
2900  return (_has_bits_[0] & 0x00000080u) != 0;
2901 }
2902 inline void pAcommsHandlerConfig::set_has_mac_cfg() {
2903  _has_bits_[0] |= 0x00000080u;
2904 }
2905 inline void pAcommsHandlerConfig::clear_has_mac_cfg() {
2906  _has_bits_[0] &= ~0x00000080u;
2907 }
2908 inline void pAcommsHandlerConfig::clear_mac_cfg() {
2909  if (mac_cfg_ != NULL) mac_cfg_->::goby::acomms::protobuf::MACConfig::Clear();
2910  clear_has_mac_cfg();
2911 }
2912 inline const ::goby::acomms::protobuf::MACConfig& pAcommsHandlerConfig::mac_cfg() const {
2913  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.mac_cfg)
2914  return mac_cfg_ != NULL ? *mac_cfg_ : *default_instance_->mac_cfg_;
2915 }
2916 inline ::goby::acomms::protobuf::MACConfig* pAcommsHandlerConfig::mutable_mac_cfg() {
2917  set_has_mac_cfg();
2918  if (mac_cfg_ == NULL) mac_cfg_ = new ::goby::acomms::protobuf::MACConfig;
2919  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.mac_cfg)
2920  return mac_cfg_;
2921 }
2922 inline ::goby::acomms::protobuf::MACConfig* pAcommsHandlerConfig::release_mac_cfg() {
2923  clear_has_mac_cfg();
2924  ::goby::acomms::protobuf::MACConfig* temp = mac_cfg_;
2925  mac_cfg_ = NULL;
2926  return temp;
2927 }
2928 inline void pAcommsHandlerConfig::set_allocated_mac_cfg(::goby::acomms::protobuf::MACConfig* mac_cfg) {
2929  delete mac_cfg_;
2930  mac_cfg_ = mac_cfg;
2931  if (mac_cfg) {
2932  set_has_mac_cfg();
2933  } else {
2934  clear_has_mac_cfg();
2935  }
2936  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.mac_cfg)
2937 }
2938 
2939 // optional .goby.acomms.protobuf.QueueManagerConfig queue_cfg = 6;
2940 inline bool pAcommsHandlerConfig::has_queue_cfg() const {
2941  return (_has_bits_[0] & 0x00000100u) != 0;
2942 }
2943 inline void pAcommsHandlerConfig::set_has_queue_cfg() {
2944  _has_bits_[0] |= 0x00000100u;
2945 }
2946 inline void pAcommsHandlerConfig::clear_has_queue_cfg() {
2947  _has_bits_[0] &= ~0x00000100u;
2948 }
2949 inline void pAcommsHandlerConfig::clear_queue_cfg() {
2950  if (queue_cfg_ != NULL) queue_cfg_->::goby::acomms::protobuf::QueueManagerConfig::Clear();
2951  clear_has_queue_cfg();
2952 }
2953 inline const ::goby::acomms::protobuf::QueueManagerConfig& pAcommsHandlerConfig::queue_cfg() const {
2954  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.queue_cfg)
2955  return queue_cfg_ != NULL ? *queue_cfg_ : *default_instance_->queue_cfg_;
2956 }
2957 inline ::goby::acomms::protobuf::QueueManagerConfig* pAcommsHandlerConfig::mutable_queue_cfg() {
2958  set_has_queue_cfg();
2959  if (queue_cfg_ == NULL) queue_cfg_ = new ::goby::acomms::protobuf::QueueManagerConfig;
2960  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.queue_cfg)
2961  return queue_cfg_;
2962 }
2963 inline ::goby::acomms::protobuf::QueueManagerConfig* pAcommsHandlerConfig::release_queue_cfg() {
2964  clear_has_queue_cfg();
2965  ::goby::acomms::protobuf::QueueManagerConfig* temp = queue_cfg_;
2966  queue_cfg_ = NULL;
2967  return temp;
2968 }
2969 inline void pAcommsHandlerConfig::set_allocated_queue_cfg(::goby::acomms::protobuf::QueueManagerConfig* queue_cfg) {
2970  delete queue_cfg_;
2971  queue_cfg_ = queue_cfg;
2972  if (queue_cfg) {
2973  set_has_queue_cfg();
2974  } else {
2975  clear_has_queue_cfg();
2976  }
2977  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.queue_cfg)
2978 }
2979 
2980 // optional .goby.acomms.protobuf.DCCLConfig dccl_cfg = 7;
2981 inline bool pAcommsHandlerConfig::has_dccl_cfg() const {
2982  return (_has_bits_[0] & 0x00000200u) != 0;
2983 }
2984 inline void pAcommsHandlerConfig::set_has_dccl_cfg() {
2985  _has_bits_[0] |= 0x00000200u;
2986 }
2987 inline void pAcommsHandlerConfig::clear_has_dccl_cfg() {
2988  _has_bits_[0] &= ~0x00000200u;
2989 }
2990 inline void pAcommsHandlerConfig::clear_dccl_cfg() {
2991  if (dccl_cfg_ != NULL) dccl_cfg_->::goby::acomms::protobuf::DCCLConfig::Clear();
2992  clear_has_dccl_cfg();
2993 }
2994 inline const ::goby::acomms::protobuf::DCCLConfig& pAcommsHandlerConfig::dccl_cfg() const {
2995  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.dccl_cfg)
2996  return dccl_cfg_ != NULL ? *dccl_cfg_ : *default_instance_->dccl_cfg_;
2997 }
2998 inline ::goby::acomms::protobuf::DCCLConfig* pAcommsHandlerConfig::mutable_dccl_cfg() {
2999  set_has_dccl_cfg();
3000  if (dccl_cfg_ == NULL) dccl_cfg_ = new ::goby::acomms::protobuf::DCCLConfig;
3001  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.dccl_cfg)
3002  return dccl_cfg_;
3003 }
3004 inline ::goby::acomms::protobuf::DCCLConfig* pAcommsHandlerConfig::release_dccl_cfg() {
3005  clear_has_dccl_cfg();
3006  ::goby::acomms::protobuf::DCCLConfig* temp = dccl_cfg_;
3007  dccl_cfg_ = NULL;
3008  return temp;
3009 }
3010 inline void pAcommsHandlerConfig::set_allocated_dccl_cfg(::goby::acomms::protobuf::DCCLConfig* dccl_cfg) {
3011  delete dccl_cfg_;
3012  dccl_cfg_ = dccl_cfg;
3013  if (dccl_cfg) {
3014  set_has_dccl_cfg();
3015  } else {
3016  clear_has_dccl_cfg();
3017  }
3018  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.dccl_cfg)
3019 }
3020 
3021 // optional .goby.acomms.protobuf.RouteManagerConfig route_cfg = 8;
3022 inline bool pAcommsHandlerConfig::has_route_cfg() const {
3023  return (_has_bits_[0] & 0x00000400u) != 0;
3024 }
3025 inline void pAcommsHandlerConfig::set_has_route_cfg() {
3026  _has_bits_[0] |= 0x00000400u;
3027 }
3028 inline void pAcommsHandlerConfig::clear_has_route_cfg() {
3029  _has_bits_[0] &= ~0x00000400u;
3030 }
3031 inline void pAcommsHandlerConfig::clear_route_cfg() {
3032  if (route_cfg_ != NULL) route_cfg_->::goby::acomms::protobuf::RouteManagerConfig::Clear();
3033  clear_has_route_cfg();
3034 }
3035 inline const ::goby::acomms::protobuf::RouteManagerConfig& pAcommsHandlerConfig::route_cfg() const {
3036  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.route_cfg)
3037  return route_cfg_ != NULL ? *route_cfg_ : *default_instance_->route_cfg_;
3038 }
3039 inline ::goby::acomms::protobuf::RouteManagerConfig* pAcommsHandlerConfig::mutable_route_cfg() {
3040  set_has_route_cfg();
3041  if (route_cfg_ == NULL) route_cfg_ = new ::goby::acomms::protobuf::RouteManagerConfig;
3042  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.route_cfg)
3043  return route_cfg_;
3044 }
3045 inline ::goby::acomms::protobuf::RouteManagerConfig* pAcommsHandlerConfig::release_route_cfg() {
3046  clear_has_route_cfg();
3047  ::goby::acomms::protobuf::RouteManagerConfig* temp = route_cfg_;
3048  route_cfg_ = NULL;
3049  return temp;
3050 }
3051 inline void pAcommsHandlerConfig::set_allocated_route_cfg(::goby::acomms::protobuf::RouteManagerConfig* route_cfg) {
3052  delete route_cfg_;
3053  route_cfg_ = route_cfg;
3054  if (route_cfg) {
3055  set_has_route_cfg();
3056  } else {
3057  clear_has_route_cfg();
3058  }
3059  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.route_cfg)
3060 }
3061 
3062 // optional .pAcommsHandlerConfig.MOOSVariables moos_var = 10;
3063 inline bool pAcommsHandlerConfig::has_moos_var() const {
3064  return (_has_bits_[0] & 0x00000800u) != 0;
3065 }
3066 inline void pAcommsHandlerConfig::set_has_moos_var() {
3067  _has_bits_[0] |= 0x00000800u;
3068 }
3069 inline void pAcommsHandlerConfig::clear_has_moos_var() {
3070  _has_bits_[0] &= ~0x00000800u;
3071 }
3072 inline void pAcommsHandlerConfig::clear_moos_var() {
3073  if (moos_var_ != NULL) moos_var_->::pAcommsHandlerConfig_MOOSVariables::Clear();
3074  clear_has_moos_var();
3075 }
3076 inline const ::pAcommsHandlerConfig_MOOSVariables& pAcommsHandlerConfig::moos_var() const {
3077  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.moos_var)
3078  return moos_var_ != NULL ? *moos_var_ : *default_instance_->moos_var_;
3079 }
3080 inline ::pAcommsHandlerConfig_MOOSVariables* pAcommsHandlerConfig::mutable_moos_var() {
3081  set_has_moos_var();
3082  if (moos_var_ == NULL) moos_var_ = new ::pAcommsHandlerConfig_MOOSVariables;
3083  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.moos_var)
3084  return moos_var_;
3085 }
3086 inline ::pAcommsHandlerConfig_MOOSVariables* pAcommsHandlerConfig::release_moos_var() {
3087  clear_has_moos_var();
3088  ::pAcommsHandlerConfig_MOOSVariables* temp = moos_var_;
3089  moos_var_ = NULL;
3090  return temp;
3091 }
3092 inline void pAcommsHandlerConfig::set_allocated_moos_var(::pAcommsHandlerConfig_MOOSVariables* moos_var) {
3093  delete moos_var_;
3094  moos_var_ = moos_var;
3095  if (moos_var) {
3096  set_has_moos_var();
3097  } else {
3098  clear_has_moos_var();
3099  }
3100  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.moos_var)
3101 }
3102 
3103 // repeated string load_shared_library = 20;
3104 inline int pAcommsHandlerConfig::load_shared_library_size() const {
3105  return load_shared_library_.size();
3106 }
3107 inline void pAcommsHandlerConfig::clear_load_shared_library() {
3108  load_shared_library_.Clear();
3109 }
3110 inline const ::std::string& pAcommsHandlerConfig::load_shared_library(int index) const {
3111  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.load_shared_library)
3112  return load_shared_library_.Get(index);
3113 }
3114 inline ::std::string* pAcommsHandlerConfig::mutable_load_shared_library(int index) {
3115  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.load_shared_library)
3116  return load_shared_library_.Mutable(index);
3117 }
3118 inline void pAcommsHandlerConfig::set_load_shared_library(int index, const ::std::string& value) {
3119  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.load_shared_library)
3120  load_shared_library_.Mutable(index)->assign(value);
3121 }
3122 inline void pAcommsHandlerConfig::set_load_shared_library(int index, const char* value) {
3123  load_shared_library_.Mutable(index)->assign(value);
3124  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.load_shared_library)
3125 }
3126 inline void pAcommsHandlerConfig::set_load_shared_library(int index, const char* value, size_t size) {
3127  load_shared_library_.Mutable(index)->assign(
3128  reinterpret_cast<const char*>(value), size);
3129  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.load_shared_library)
3130 }
3131 inline ::std::string* pAcommsHandlerConfig::add_load_shared_library() {
3132  return load_shared_library_.Add();
3133 }
3134 inline void pAcommsHandlerConfig::add_load_shared_library(const ::std::string& value) {
3135  load_shared_library_.Add()->assign(value);
3136  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.load_shared_library)
3137 }
3138 inline void pAcommsHandlerConfig::add_load_shared_library(const char* value) {
3139  load_shared_library_.Add()->assign(value);
3140  // @@protoc_insertion_point(field_add_char:pAcommsHandlerConfig.load_shared_library)
3141 }
3142 inline void pAcommsHandlerConfig::add_load_shared_library(const char* value, size_t size) {
3143  load_shared_library_.Add()->assign(reinterpret_cast<const char*>(value), size);
3144  // @@protoc_insertion_point(field_add_pointer:pAcommsHandlerConfig.load_shared_library)
3145 }
3146 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3147 pAcommsHandlerConfig::load_shared_library() const {
3148  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.load_shared_library)
3149  return load_shared_library_;
3150 }
3151 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3152 pAcommsHandlerConfig::mutable_load_shared_library() {
3153  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.load_shared_library)
3154  return &load_shared_library_;
3155 }
3156 
3157 // repeated string load_proto_file = 21;
3158 inline int pAcommsHandlerConfig::load_proto_file_size() const {
3159  return load_proto_file_.size();
3160 }
3161 inline void pAcommsHandlerConfig::clear_load_proto_file() {
3162  load_proto_file_.Clear();
3163 }
3164 inline const ::std::string& pAcommsHandlerConfig::load_proto_file(int index) const {
3165  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.load_proto_file)
3166  return load_proto_file_.Get(index);
3167 }
3168 inline ::std::string* pAcommsHandlerConfig::mutable_load_proto_file(int index) {
3169  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.load_proto_file)
3170  return load_proto_file_.Mutable(index);
3171 }
3172 inline void pAcommsHandlerConfig::set_load_proto_file(int index, const ::std::string& value) {
3173  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.load_proto_file)
3174  load_proto_file_.Mutable(index)->assign(value);
3175 }
3176 inline void pAcommsHandlerConfig::set_load_proto_file(int index, const char* value) {
3177  load_proto_file_.Mutable(index)->assign(value);
3178  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.load_proto_file)
3179 }
3180 inline void pAcommsHandlerConfig::set_load_proto_file(int index, const char* value, size_t size) {
3181  load_proto_file_.Mutable(index)->assign(
3182  reinterpret_cast<const char*>(value), size);
3183  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.load_proto_file)
3184 }
3185 inline ::std::string* pAcommsHandlerConfig::add_load_proto_file() {
3186  return load_proto_file_.Add();
3187 }
3188 inline void pAcommsHandlerConfig::add_load_proto_file(const ::std::string& value) {
3189  load_proto_file_.Add()->assign(value);
3190  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.load_proto_file)
3191 }
3192 inline void pAcommsHandlerConfig::add_load_proto_file(const char* value) {
3193  load_proto_file_.Add()->assign(value);
3194  // @@protoc_insertion_point(field_add_char:pAcommsHandlerConfig.load_proto_file)
3195 }
3196 inline void pAcommsHandlerConfig::add_load_proto_file(const char* value, size_t size) {
3197  load_proto_file_.Add()->assign(reinterpret_cast<const char*>(value), size);
3198  // @@protoc_insertion_point(field_add_pointer:pAcommsHandlerConfig.load_proto_file)
3199 }
3200 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3201 pAcommsHandlerConfig::load_proto_file() const {
3202  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.load_proto_file)
3203  return load_proto_file_;
3204 }
3205 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3206 pAcommsHandlerConfig::mutable_load_proto_file() {
3207  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.load_proto_file)
3208  return &load_proto_file_;
3209 }
3210 
3211 // repeated .goby.moos.protobuf.TranslatorEntry translator_entry = 22;
3212 inline int pAcommsHandlerConfig::translator_entry_size() const {
3213  return translator_entry_.size();
3214 }
3215 inline void pAcommsHandlerConfig::clear_translator_entry() {
3216  translator_entry_.Clear();
3217 }
3218 inline const ::goby::moos::protobuf::TranslatorEntry& pAcommsHandlerConfig::translator_entry(int index) const {
3219  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.translator_entry)
3220  return translator_entry_.Get(index);
3221 }
3222 inline ::goby::moos::protobuf::TranslatorEntry* pAcommsHandlerConfig::mutable_translator_entry(int index) {
3223  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.translator_entry)
3224  return translator_entry_.Mutable(index);
3225 }
3226 inline ::goby::moos::protobuf::TranslatorEntry* pAcommsHandlerConfig::add_translator_entry() {
3227  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.translator_entry)
3228  return translator_entry_.Add();
3229 }
3230 inline const ::google::protobuf::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >&
3231 pAcommsHandlerConfig::translator_entry() const {
3232  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.translator_entry)
3233  return translator_entry_;
3234 }
3235 inline ::google::protobuf::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >*
3236 pAcommsHandlerConfig::mutable_translator_entry() {
3237  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.translator_entry)
3238  return &translator_entry_;
3239 }
3240 
3241 // repeated string multiplex_create_moos_var = 23;
3242 inline int pAcommsHandlerConfig::multiplex_create_moos_var_size() const {
3243  return multiplex_create_moos_var_.size();
3244 }
3245 inline void pAcommsHandlerConfig::clear_multiplex_create_moos_var() {
3246  multiplex_create_moos_var_.Clear();
3247 }
3248 inline const ::std::string& pAcommsHandlerConfig::multiplex_create_moos_var(int index) const {
3249  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.multiplex_create_moos_var)
3250  return multiplex_create_moos_var_.Get(index);
3251 }
3252 inline ::std::string* pAcommsHandlerConfig::mutable_multiplex_create_moos_var(int index) {
3253  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.multiplex_create_moos_var)
3254  return multiplex_create_moos_var_.Mutable(index);
3255 }
3256 inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, const ::std::string& value) {
3257  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.multiplex_create_moos_var)
3258  multiplex_create_moos_var_.Mutable(index)->assign(value);
3259 }
3260 inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, const char* value) {
3261  multiplex_create_moos_var_.Mutable(index)->assign(value);
3262  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.multiplex_create_moos_var)
3263 }
3264 inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, const char* value, size_t size) {
3265  multiplex_create_moos_var_.Mutable(index)->assign(
3266  reinterpret_cast<const char*>(value), size);
3267  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.multiplex_create_moos_var)
3268 }
3269 inline ::std::string* pAcommsHandlerConfig::add_multiplex_create_moos_var() {
3270  return multiplex_create_moos_var_.Add();
3271 }
3272 inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(const ::std::string& value) {
3273  multiplex_create_moos_var_.Add()->assign(value);
3274  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.multiplex_create_moos_var)
3275 }
3276 inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(const char* value) {
3277  multiplex_create_moos_var_.Add()->assign(value);
3278  // @@protoc_insertion_point(field_add_char:pAcommsHandlerConfig.multiplex_create_moos_var)
3279 }
3280 inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(const char* value, size_t size) {
3281  multiplex_create_moos_var_.Add()->assign(reinterpret_cast<const char*>(value), size);
3282  // @@protoc_insertion_point(field_add_pointer:pAcommsHandlerConfig.multiplex_create_moos_var)
3283 }
3284 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3285 pAcommsHandlerConfig::multiplex_create_moos_var() const {
3286  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.multiplex_create_moos_var)
3287  return multiplex_create_moos_var_;
3288 }
3289 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3290 pAcommsHandlerConfig::mutable_multiplex_create_moos_var() {
3291  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.multiplex_create_moos_var)
3292  return &multiplex_create_moos_var_;
3293 }
3294 
3295 // repeated string dccl_frontseat_forward_name = 24;
3296 inline int pAcommsHandlerConfig::dccl_frontseat_forward_name_size() const {
3297  return dccl_frontseat_forward_name_.size();
3298 }
3299 inline void pAcommsHandlerConfig::clear_dccl_frontseat_forward_name() {
3300  dccl_frontseat_forward_name_.Clear();
3301 }
3302 inline const ::std::string& pAcommsHandlerConfig::dccl_frontseat_forward_name(int index) const {
3303  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3304  return dccl_frontseat_forward_name_.Get(index);
3305 }
3306 inline ::std::string* pAcommsHandlerConfig::mutable_dccl_frontseat_forward_name(int index) {
3307  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3308  return dccl_frontseat_forward_name_.Mutable(index);
3309 }
3310 inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, const ::std::string& value) {
3311  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3312  dccl_frontseat_forward_name_.Mutable(index)->assign(value);
3313 }
3314 inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, const char* value) {
3315  dccl_frontseat_forward_name_.Mutable(index)->assign(value);
3316  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3317 }
3318 inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, const char* value, size_t size) {
3319  dccl_frontseat_forward_name_.Mutable(index)->assign(
3320  reinterpret_cast<const char*>(value), size);
3321  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3322 }
3323 inline ::std::string* pAcommsHandlerConfig::add_dccl_frontseat_forward_name() {
3324  return dccl_frontseat_forward_name_.Add();
3325 }
3326 inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(const ::std::string& value) {
3327  dccl_frontseat_forward_name_.Add()->assign(value);
3328  // @@protoc_insertion_point(field_add:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3329 }
3330 inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(const char* value) {
3331  dccl_frontseat_forward_name_.Add()->assign(value);
3332  // @@protoc_insertion_point(field_add_char:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3333 }
3334 inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(const char* value, size_t size) {
3335  dccl_frontseat_forward_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
3336  // @@protoc_insertion_point(field_add_pointer:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3337 }
3338 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3339 pAcommsHandlerConfig::dccl_frontseat_forward_name() const {
3340  // @@protoc_insertion_point(field_list:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3341  return dccl_frontseat_forward_name_;
3342 }
3343 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3344 pAcommsHandlerConfig::mutable_dccl_frontseat_forward_name() {
3345  // @@protoc_insertion_point(field_mutable_list:pAcommsHandlerConfig.dccl_frontseat_forward_name)
3346  return &dccl_frontseat_forward_name_;
3347 }
3348 
3349 // optional string modem_id_lookup_path = 101;
3350 inline bool pAcommsHandlerConfig::has_modem_id_lookup_path() const {
3351  return (_has_bits_[0] & 0x00020000u) != 0;
3352 }
3353 inline void pAcommsHandlerConfig::set_has_modem_id_lookup_path() {
3354  _has_bits_[0] |= 0x00020000u;
3355 }
3356 inline void pAcommsHandlerConfig::clear_has_modem_id_lookup_path() {
3357  _has_bits_[0] &= ~0x00020000u;
3358 }
3359 inline void pAcommsHandlerConfig::clear_modem_id_lookup_path() {
3360  if (modem_id_lookup_path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3361  modem_id_lookup_path_->clear();
3362  }
3363  clear_has_modem_id_lookup_path();
3364 }
3365 inline const ::std::string& pAcommsHandlerConfig::modem_id_lookup_path() const {
3366  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.modem_id_lookup_path)
3367  return *modem_id_lookup_path_;
3368 }
3369 inline void pAcommsHandlerConfig::set_modem_id_lookup_path(const ::std::string& value) {
3370  set_has_modem_id_lookup_path();
3371  if (modem_id_lookup_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3372  modem_id_lookup_path_ = new ::std::string;
3373  }
3374  modem_id_lookup_path_->assign(value);
3375  // @@protoc_insertion_point(field_set:pAcommsHandlerConfig.modem_id_lookup_path)
3376 }
3377 inline void pAcommsHandlerConfig::set_modem_id_lookup_path(const char* value) {
3378  set_has_modem_id_lookup_path();
3379  if (modem_id_lookup_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3380  modem_id_lookup_path_ = new ::std::string;
3381  }
3382  modem_id_lookup_path_->assign(value);
3383  // @@protoc_insertion_point(field_set_char:pAcommsHandlerConfig.modem_id_lookup_path)
3384 }
3385 inline void pAcommsHandlerConfig::set_modem_id_lookup_path(const char* value, size_t size) {
3386  set_has_modem_id_lookup_path();
3387  if (modem_id_lookup_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3388  modem_id_lookup_path_ = new ::std::string;
3389  }
3390  modem_id_lookup_path_->assign(reinterpret_cast<const char*>(value), size);
3391  // @@protoc_insertion_point(field_set_pointer:pAcommsHandlerConfig.modem_id_lookup_path)
3392 }
3393 inline ::std::string* pAcommsHandlerConfig::mutable_modem_id_lookup_path() {
3394  set_has_modem_id_lookup_path();
3395  if (modem_id_lookup_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3396  modem_id_lookup_path_ = new ::std::string;
3397  }
3398  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.modem_id_lookup_path)
3399  return modem_id_lookup_path_;
3400 }
3401 inline ::std::string* pAcommsHandlerConfig::release_modem_id_lookup_path() {
3402  clear_has_modem_id_lookup_path();
3403  if (modem_id_lookup_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3404  return NULL;
3405  } else {
3406  ::std::string* temp = modem_id_lookup_path_;
3407  modem_id_lookup_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3408  return temp;
3409  }
3410 }
3411 inline void pAcommsHandlerConfig::set_allocated_modem_id_lookup_path(::std::string* modem_id_lookup_path) {
3412  if (modem_id_lookup_path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3413  delete modem_id_lookup_path_;
3414  }
3415  if (modem_id_lookup_path) {
3416  set_has_modem_id_lookup_path();
3417  modem_id_lookup_path_ = modem_id_lookup_path;
3418  } else {
3419  clear_has_modem_id_lookup_path();
3420  modem_id_lookup_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3421  }
3422  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.modem_id_lookup_path)
3423 }
3424 
3425 // optional .goby.transitional.protobuf.DCCLTransitionalConfig transitional_cfg = 200;
3426 inline bool pAcommsHandlerConfig::has_transitional_cfg() const {
3427  return (_has_bits_[0] & 0x00040000u) != 0;
3428 }
3429 inline void pAcommsHandlerConfig::set_has_transitional_cfg() {
3430  _has_bits_[0] |= 0x00040000u;
3431 }
3432 inline void pAcommsHandlerConfig::clear_has_transitional_cfg() {
3433  _has_bits_[0] &= ~0x00040000u;
3434 }
3435 inline void pAcommsHandlerConfig::clear_transitional_cfg() {
3436  if (transitional_cfg_ != NULL) transitional_cfg_->::goby::transitional::protobuf::DCCLTransitionalConfig::Clear();
3437  clear_has_transitional_cfg();
3438 }
3439 inline const ::goby::transitional::protobuf::DCCLTransitionalConfig& pAcommsHandlerConfig::transitional_cfg() const {
3440  // @@protoc_insertion_point(field_get:pAcommsHandlerConfig.transitional_cfg)
3441  return transitional_cfg_ != NULL ? *transitional_cfg_ : *default_instance_->transitional_cfg_;
3442 }
3443 inline ::goby::transitional::protobuf::DCCLTransitionalConfig* pAcommsHandlerConfig::mutable_transitional_cfg() {
3444  set_has_transitional_cfg();
3445  if (transitional_cfg_ == NULL) transitional_cfg_ = new ::goby::transitional::protobuf::DCCLTransitionalConfig;
3446  // @@protoc_insertion_point(field_mutable:pAcommsHandlerConfig.transitional_cfg)
3447  return transitional_cfg_;
3448 }
3449 inline ::goby::transitional::protobuf::DCCLTransitionalConfig* pAcommsHandlerConfig::release_transitional_cfg() {
3450  clear_has_transitional_cfg();
3451  ::goby::transitional::protobuf::DCCLTransitionalConfig* temp = transitional_cfg_;
3452  transitional_cfg_ = NULL;
3453  return temp;
3454 }
3455 inline void pAcommsHandlerConfig::set_allocated_transitional_cfg(::goby::transitional::protobuf::DCCLTransitionalConfig* transitional_cfg) {
3456  delete transitional_cfg_;
3457  transitional_cfg_ = transitional_cfg;
3458  if (transitional_cfg) {
3459  set_has_transitional_cfg();
3460  } else {
3461  clear_has_transitional_cfg();
3462  }
3463  // @@protoc_insertion_point(field_set_allocated:pAcommsHandlerConfig.transitional_cfg)
3464 }
3465 
3466 
3467 // @@protoc_insertion_point(namespace_scope)
3468 
3469 #ifndef SWIG
3470 namespace google {
3471 namespace protobuf {
3472 
3473 template <> struct is_proto_enum< ::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique> : ::google::protobuf::internal::true_type {};
3474 template <>
3475 inline const EnumDescriptor* GetEnumDescriptor< ::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique>() {
3476  return ::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor();
3477 }
3478 
3479 } // namespace google
3480 } // namespace protobuf
3481 #endif // SWIG
3482 
3483 // @@protoc_insertion_point(global_scope)
3484 
3485 #endif // PROTOBUF_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto__INCLUDED
pAcommsHandlerConfig_MOOSVariables
Definition: pAcommsHandler_config.pb.h:189
pAcommsHandlerConfig_DriverFailureApproach
Definition: pAcommsHandler_config.pb.h:75
Generated by   doxygen 1.8.11