DCCL v4
Loading...
Searching...
No Matches
option_extensions.pb.h
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: dccl/apps/pb_plugin/option_extensions.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3021000
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 3021012 < 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/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_util.h>
27#include <google/protobuf/metadata_lite.h>
28#include <google/protobuf/generated_message_reflection.h>
29#include <google/protobuf/message.h>
30#include <google/protobuf/repeated_field.h> // IWYU pragma: export
31#include <google/protobuf/extension_set.h> // IWYU pragma: export
32#include <google/protobuf/unknown_field_set.h>
33#include <google/protobuf/descriptor.pb.h>
34// @@protoc_insertion_point(includes)
35#include <google/protobuf/port_def.inc>
36#define PROTOBUF_INTERNAL_EXPORT_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto
37PROTOBUF_NAMESPACE_OPEN
38namespace internal {
39class AnyMetadata;
40} // namespace internal
41PROTOBUF_NAMESPACE_CLOSE
42
43// Internal implementation detail -- do not use these members.
44struct TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto {
45 static const uint32_t offsets[];
46};
47extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto;
48namespace dccl {
49class DCCLFieldOptions;
50struct DCCLFieldOptionsDefaultTypeInternal;
51extern DCCLFieldOptionsDefaultTypeInternal _DCCLFieldOptions_default_instance_;
52class DCCLFieldOptions_Conditions;
53struct DCCLFieldOptions_ConditionsDefaultTypeInternal;
54extern DCCLFieldOptions_ConditionsDefaultTypeInternal _DCCLFieldOptions_Conditions_default_instance_;
55class DCCLFieldOptions_Units;
56struct DCCLFieldOptions_UnitsDefaultTypeInternal;
57extern DCCLFieldOptions_UnitsDefaultTypeInternal _DCCLFieldOptions_Units_default_instance_;
58class DCCLFieldOptions_Units_CustomUnit;
59struct DCCLFieldOptions_Units_CustomUnitDefaultTypeInternal;
60extern DCCLFieldOptions_Units_CustomUnitDefaultTypeInternal _DCCLFieldOptions_Units_CustomUnit_default_instance_;
61class DCCLMessageOptions;
62struct DCCLMessageOptionsDefaultTypeInternal;
63extern DCCLMessageOptionsDefaultTypeInternal _DCCLMessageOptions_default_instance_;
64} // namespace dccl
65PROTOBUF_NAMESPACE_OPEN
66template<> ::dccl::DCCLFieldOptions* Arena::CreateMaybeMessage<::dccl::DCCLFieldOptions>(Arena*);
67template<> ::dccl::DCCLFieldOptions_Conditions* Arena::CreateMaybeMessage<::dccl::DCCLFieldOptions_Conditions>(Arena*);
68template<> ::dccl::DCCLFieldOptions_Units* Arena::CreateMaybeMessage<::dccl::DCCLFieldOptions_Units>(Arena*);
69template<> ::dccl::DCCLFieldOptions_Units_CustomUnit* Arena::CreateMaybeMessage<::dccl::DCCLFieldOptions_Units_CustomUnit>(Arena*);
70template<> ::dccl::DCCLMessageOptions* Arena::CreateMaybeMessage<::dccl::DCCLMessageOptions>(Arena*);
71PROTOBUF_NAMESPACE_CLOSE
72namespace dccl {
73
74// ===================================================================
75
76class DCCLFieldOptions_Units_CustomUnit final :
77 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dccl.DCCLFieldOptions.Units.CustomUnit) */ {
78 public:
79 inline DCCLFieldOptions_Units_CustomUnit() : DCCLFieldOptions_Units_CustomUnit(nullptr) {}
80 ~DCCLFieldOptions_Units_CustomUnit() override;
81 explicit PROTOBUF_CONSTEXPR DCCLFieldOptions_Units_CustomUnit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
82
83 DCCLFieldOptions_Units_CustomUnit(const DCCLFieldOptions_Units_CustomUnit& from);
84 DCCLFieldOptions_Units_CustomUnit(DCCLFieldOptions_Units_CustomUnit&& from) noexcept
85 : DCCLFieldOptions_Units_CustomUnit() {
86 *this = ::std::move(from);
87 }
88
89 inline DCCLFieldOptions_Units_CustomUnit& operator=(const DCCLFieldOptions_Units_CustomUnit& from) {
90 CopyFrom(from);
91 return *this;
92 }
93 inline DCCLFieldOptions_Units_CustomUnit& operator=(DCCLFieldOptions_Units_CustomUnit&& from) noexcept {
94 if (this == &from) return *this;
95 if (GetOwningArena() == from.GetOwningArena()
96 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
97 && GetOwningArena() != nullptr
98 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
99 ) {
100 InternalSwap(&from);
101 } else {
102 CopyFrom(from);
103 }
104 return *this;
105 }
106
107 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
108 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
109 }
110 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
111 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
112 }
113
114 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
115 return GetDescriptor();
116 }
117 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
118 return default_instance().GetMetadata().descriptor;
119 }
120 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
121 return default_instance().GetMetadata().reflection;
122 }
123 static const DCCLFieldOptions_Units_CustomUnit& default_instance() {
124 return *internal_default_instance();
125 }
126 static inline const DCCLFieldOptions_Units_CustomUnit* internal_default_instance() {
127 return reinterpret_cast<const DCCLFieldOptions_Units_CustomUnit*>(
128 &_DCCLFieldOptions_Units_CustomUnit_default_instance_);
129 }
130 static constexpr int kIndexInFileMessages =
131 0;
132
133 friend void swap(DCCLFieldOptions_Units_CustomUnit& a, DCCLFieldOptions_Units_CustomUnit& b) {
134 a.Swap(&b);
135 }
136 inline void Swap(DCCLFieldOptions_Units_CustomUnit* other) {
137 if (other == this) return;
138 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
139 if (GetOwningArena() != nullptr &&
140 GetOwningArena() == other->GetOwningArena()) {
141 #else // PROTOBUF_FORCE_COPY_IN_SWAP
142 if (GetOwningArena() == other->GetOwningArena()) {
143 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
144 InternalSwap(other);
145 } else {
146 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
147 }
148 }
149 void UnsafeArenaSwap(DCCLFieldOptions_Units_CustomUnit* other) {
150 if (other == this) return;
151 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
152 InternalSwap(other);
153 }
154
155 // implements Message ----------------------------------------------
156
157 DCCLFieldOptions_Units_CustomUnit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
158 return CreateMaybeMessage<DCCLFieldOptions_Units_CustomUnit>(arena);
159 }
160 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
161 void CopyFrom(const DCCLFieldOptions_Units_CustomUnit& from);
162 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
163 void MergeFrom( const DCCLFieldOptions_Units_CustomUnit& from) {
164 DCCLFieldOptions_Units_CustomUnit::MergeImpl(*this, from);
165 }
166 private:
167 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
168 public:
169 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
170 bool IsInitialized() const final;
171
172 size_t ByteSizeLong() const final;
173 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
174 uint8_t* _InternalSerialize(
175 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
176 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
177
178 private:
179 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
180 void SharedDtor();
181 void SetCachedSize(int size) const final;
182 void InternalSwap(DCCLFieldOptions_Units_CustomUnit* other);
183
184 private:
185 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
186 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
187 return "dccl.DCCLFieldOptions.Units.CustomUnit";
188 }
189 protected:
190 explicit DCCLFieldOptions_Units_CustomUnit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
191 bool is_message_owned = false);
192 public:
193
194 static const ClassData _class_data_;
195 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
196
197 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
198
199 // nested types ----------------------------------------------------
200
201 // accessors -------------------------------------------------------
202
203 enum : int {
204 kUnitFieldNumber = 1,
205 kHeaderFieldNumber = 2,
206 };
207 // required string unit = 1;
208 bool has_unit() const;
209 private:
210 bool _internal_has_unit() const;
211 public:
212 void clear_unit();
213 const std::string& unit() const;
214 template <typename ArgT0 = const std::string&, typename... ArgT>
215 void set_unit(ArgT0&& arg0, ArgT... args);
216 std::string* mutable_unit();
217 PROTOBUF_NODISCARD std::string* release_unit();
218 void set_allocated_unit(std::string* unit);
219 private:
220 const std::string& _internal_unit() const;
221 inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit(const std::string& value);
222 std::string* _internal_mutable_unit();
223 public:
224
225 // optional string header = 2;
226 bool has_header() const;
227 private:
228 bool _internal_has_header() const;
229 public:
230 void clear_header();
231 const std::string& header() const;
232 template <typename ArgT0 = const std::string&, typename... ArgT>
233 void set_header(ArgT0&& arg0, ArgT... args);
234 std::string* mutable_header();
235 PROTOBUF_NODISCARD std::string* release_header();
236 void set_allocated_header(std::string* header);
237 private:
238 const std::string& _internal_header() const;
239 inline PROTOBUF_ALWAYS_INLINE void _internal_set_header(const std::string& value);
240 std::string* _internal_mutable_header();
241 public:
242
243 // @@protoc_insertion_point(class_scope:dccl.DCCLFieldOptions.Units.CustomUnit)
244 private:
245 class _Internal;
246
247 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
248 typedef void InternalArenaConstructable_;
249 typedef void DestructorSkippable_;
250 struct Impl_ {
251 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
252 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
253 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unit_;
254 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr header_;
255 };
256 union { Impl_ _impl_; };
257 friend struct ::TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto;
258};
259// -------------------------------------------------------------------
260
261class DCCLFieldOptions_Units final :
262 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dccl.DCCLFieldOptions.Units) */ {
263 public:
264 inline DCCLFieldOptions_Units() : DCCLFieldOptions_Units(nullptr) {}
265 ~DCCLFieldOptions_Units() override;
266 explicit PROTOBUF_CONSTEXPR DCCLFieldOptions_Units(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
267
268 DCCLFieldOptions_Units(const DCCLFieldOptions_Units& from);
269 DCCLFieldOptions_Units(DCCLFieldOptions_Units&& from) noexcept
270 : DCCLFieldOptions_Units() {
271 *this = ::std::move(from);
272 }
273
274 inline DCCLFieldOptions_Units& operator=(const DCCLFieldOptions_Units& from) {
275 CopyFrom(from);
276 return *this;
277 }
278 inline DCCLFieldOptions_Units& operator=(DCCLFieldOptions_Units&& from) noexcept {
279 if (this == &from) return *this;
280 if (GetOwningArena() == from.GetOwningArena()
281 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
282 && GetOwningArena() != nullptr
283 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
284 ) {
285 InternalSwap(&from);
286 } else {
287 CopyFrom(from);
288 }
289 return *this;
290 }
291
292 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
293 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
294 }
295 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
296 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
297 }
298
299 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
300 return GetDescriptor();
301 }
302 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
303 return default_instance().GetMetadata().descriptor;
304 }
305 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
306 return default_instance().GetMetadata().reflection;
307 }
308 static const DCCLFieldOptions_Units& default_instance() {
309 return *internal_default_instance();
310 }
311 static inline const DCCLFieldOptions_Units* internal_default_instance() {
312 return reinterpret_cast<const DCCLFieldOptions_Units*>(
313 &_DCCLFieldOptions_Units_default_instance_);
314 }
315 static constexpr int kIndexInFileMessages =
316 1;
317
318 friend void swap(DCCLFieldOptions_Units& a, DCCLFieldOptions_Units& b) {
319 a.Swap(&b);
320 }
321 inline void Swap(DCCLFieldOptions_Units* other) {
322 if (other == this) return;
323 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
324 if (GetOwningArena() != nullptr &&
325 GetOwningArena() == other->GetOwningArena()) {
326 #else // PROTOBUF_FORCE_COPY_IN_SWAP
327 if (GetOwningArena() == other->GetOwningArena()) {
328 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
329 InternalSwap(other);
330 } else {
331 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
332 }
333 }
334 void UnsafeArenaSwap(DCCLFieldOptions_Units* other) {
335 if (other == this) return;
336 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
337 InternalSwap(other);
338 }
339
340 // implements Message ----------------------------------------------
341
342 DCCLFieldOptions_Units* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
343 return CreateMaybeMessage<DCCLFieldOptions_Units>(arena);
344 }
345 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
346 void CopyFrom(const DCCLFieldOptions_Units& from);
347 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
348 void MergeFrom( const DCCLFieldOptions_Units& from) {
349 DCCLFieldOptions_Units::MergeImpl(*this, from);
350 }
351 private:
352 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
353 public:
354 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
355 bool IsInitialized() const final;
356
357 size_t ByteSizeLong() const final;
358 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
359 uint8_t* _InternalSerialize(
360 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
361 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
362
363 private:
364 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
365 void SharedDtor();
366 void SetCachedSize(int size) const final;
367 void InternalSwap(DCCLFieldOptions_Units* other);
368
369 private:
370 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
371 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
372 return "dccl.DCCLFieldOptions.Units";
373 }
374 protected:
375 explicit DCCLFieldOptions_Units(::PROTOBUF_NAMESPACE_ID::Arena* arena,
376 bool is_message_owned = false);
377 public:
378
379 static const ClassData _class_data_;
380 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
381
382 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
383
384 // nested types ----------------------------------------------------
385
386 typedef DCCLFieldOptions_Units_CustomUnit CustomUnit;
387
388 // accessors -------------------------------------------------------
389
390 enum : int {
391 kBaseDimensionsFieldNumber = 1,
392 kDerivedDimensionsFieldNumber = 2,
393 kSystemFieldNumber = 3,
394 kUnitFieldNumber = 5,
395 kPrefixFieldNumber = 6,
396 kCustomFieldNumber = 7,
397 kRelativeTemperatureFieldNumber = 4,
398 };
399 // optional string base_dimensions = 1;
400 bool has_base_dimensions() const;
401 private:
402 bool _internal_has_base_dimensions() const;
403 public:
404 void clear_base_dimensions();
405 const std::string& base_dimensions() const;
406 template <typename ArgT0 = const std::string&, typename... ArgT>
407 void set_base_dimensions(ArgT0&& arg0, ArgT... args);
408 std::string* mutable_base_dimensions();
409 PROTOBUF_NODISCARD std::string* release_base_dimensions();
410 void set_allocated_base_dimensions(std::string* base_dimensions);
411 private:
412 const std::string& _internal_base_dimensions() const;
413 inline PROTOBUF_ALWAYS_INLINE void _internal_set_base_dimensions(const std::string& value);
414 std::string* _internal_mutable_base_dimensions();
415 public:
416
417 // optional string derived_dimensions = 2;
418 bool has_derived_dimensions() const;
419 private:
420 bool _internal_has_derived_dimensions() const;
421 public:
422 void clear_derived_dimensions();
423 const std::string& derived_dimensions() const;
424 template <typename ArgT0 = const std::string&, typename... ArgT>
425 void set_derived_dimensions(ArgT0&& arg0, ArgT... args);
426 std::string* mutable_derived_dimensions();
427 PROTOBUF_NODISCARD std::string* release_derived_dimensions();
428 void set_allocated_derived_dimensions(std::string* derived_dimensions);
429 private:
430 const std::string& _internal_derived_dimensions() const;
431 inline PROTOBUF_ALWAYS_INLINE void _internal_set_derived_dimensions(const std::string& value);
432 std::string* _internal_mutable_derived_dimensions();
433 public:
434
435 // optional string system = 3 [default = "si"];
436 bool has_system() const;
437 private:
438 bool _internal_has_system() const;
439 public:
440 void clear_system();
441 const std::string& system() const;
442 template <typename ArgT0 = const std::string&, typename... ArgT>
443 void set_system(ArgT0&& arg0, ArgT... args);
444 std::string* mutable_system();
445 PROTOBUF_NODISCARD std::string* release_system();
446 void set_allocated_system(std::string* system);
447 private:
448 const std::string& _internal_system() const;
449 inline PROTOBUF_ALWAYS_INLINE void _internal_set_system(const std::string& value);
450 std::string* _internal_mutable_system();
451 public:
452
453 // optional string unit = 5;
454 bool has_unit() const;
455 private:
456 bool _internal_has_unit() const;
457 public:
458 void clear_unit();
459 const std::string& unit() const;
460 template <typename ArgT0 = const std::string&, typename... ArgT>
461 void set_unit(ArgT0&& arg0, ArgT... args);
462 std::string* mutable_unit();
463 PROTOBUF_NODISCARD std::string* release_unit();
464 void set_allocated_unit(std::string* unit);
465 private:
466 const std::string& _internal_unit() const;
467 inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit(const std::string& value);
468 std::string* _internal_mutable_unit();
469 public:
470
471 // optional string prefix = 6;
472 bool has_prefix() const;
473 private:
474 bool _internal_has_prefix() const;
475 public:
476 void clear_prefix();
477 const std::string& prefix() const;
478 template <typename ArgT0 = const std::string&, typename... ArgT>
479 void set_prefix(ArgT0&& arg0, ArgT... args);
480 std::string* mutable_prefix();
481 PROTOBUF_NODISCARD std::string* release_prefix();
482 void set_allocated_prefix(std::string* prefix);
483 private:
484 const std::string& _internal_prefix() const;
485 inline PROTOBUF_ALWAYS_INLINE void _internal_set_prefix(const std::string& value);
486 std::string* _internal_mutable_prefix();
487 public:
488
489 // optional .dccl.DCCLFieldOptions.Units.CustomUnit custom = 7;
490 bool has_custom() const;
491 private:
492 bool _internal_has_custom() const;
493 public:
494 void clear_custom();
495 const ::dccl::DCCLFieldOptions_Units_CustomUnit& custom() const;
496 PROTOBUF_NODISCARD ::dccl::DCCLFieldOptions_Units_CustomUnit* release_custom();
497 ::dccl::DCCLFieldOptions_Units_CustomUnit* mutable_custom();
498 void set_allocated_custom(::dccl::DCCLFieldOptions_Units_CustomUnit* custom);
499 private:
500 const ::dccl::DCCLFieldOptions_Units_CustomUnit& _internal_custom() const;
501 ::dccl::DCCLFieldOptions_Units_CustomUnit* _internal_mutable_custom();
502 public:
503 void unsafe_arena_set_allocated_custom(
504 ::dccl::DCCLFieldOptions_Units_CustomUnit* custom);
505 ::dccl::DCCLFieldOptions_Units_CustomUnit* unsafe_arena_release_custom();
506
507 // optional bool relative_temperature = 4 [default = false];
508 bool has_relative_temperature() const;
509 private:
510 bool _internal_has_relative_temperature() const;
511 public:
512 void clear_relative_temperature();
513 bool relative_temperature() const;
514 void set_relative_temperature(bool value);
515 private:
516 bool _internal_relative_temperature() const;
517 void _internal_set_relative_temperature(bool value);
518 public:
519
520 // @@protoc_insertion_point(class_scope:dccl.DCCLFieldOptions.Units)
521 private:
522 class _Internal;
523
524 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
525 typedef void InternalArenaConstructable_;
526 typedef void DestructorSkippable_;
527 struct Impl_ {
528 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
529 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
530 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr base_dimensions_;
531 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr derived_dimensions_;
532 static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_system_;
533 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_;
534 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unit_;
535 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_;
536 ::dccl::DCCLFieldOptions_Units_CustomUnit* custom_;
537 bool relative_temperature_;
538 };
539 union { Impl_ _impl_; };
540 friend struct ::TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto;
541};
542// -------------------------------------------------------------------
543
544class DCCLFieldOptions_Conditions final :
545 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dccl.DCCLFieldOptions.Conditions) */ {
546 public:
547 inline DCCLFieldOptions_Conditions() : DCCLFieldOptions_Conditions(nullptr) {}
548 ~DCCLFieldOptions_Conditions() override;
549 explicit PROTOBUF_CONSTEXPR DCCLFieldOptions_Conditions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
550
551 DCCLFieldOptions_Conditions(const DCCLFieldOptions_Conditions& from);
552 DCCLFieldOptions_Conditions(DCCLFieldOptions_Conditions&& from) noexcept
553 : DCCLFieldOptions_Conditions() {
554 *this = ::std::move(from);
555 }
556
557 inline DCCLFieldOptions_Conditions& operator=(const DCCLFieldOptions_Conditions& from) {
558 CopyFrom(from);
559 return *this;
560 }
561 inline DCCLFieldOptions_Conditions& operator=(DCCLFieldOptions_Conditions&& from) noexcept {
562 if (this == &from) return *this;
563 if (GetOwningArena() == from.GetOwningArena()
564 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
565 && GetOwningArena() != nullptr
566 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
567 ) {
568 InternalSwap(&from);
569 } else {
570 CopyFrom(from);
571 }
572 return *this;
573 }
574
575 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
576 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
577 }
578 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
579 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
580 }
581
582 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
583 return GetDescriptor();
584 }
585 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
586 return default_instance().GetMetadata().descriptor;
587 }
588 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
589 return default_instance().GetMetadata().reflection;
590 }
591 static const DCCLFieldOptions_Conditions& default_instance() {
592 return *internal_default_instance();
593 }
594 static inline const DCCLFieldOptions_Conditions* internal_default_instance() {
595 return reinterpret_cast<const DCCLFieldOptions_Conditions*>(
596 &_DCCLFieldOptions_Conditions_default_instance_);
597 }
598 static constexpr int kIndexInFileMessages =
599 2;
600
601 friend void swap(DCCLFieldOptions_Conditions& a, DCCLFieldOptions_Conditions& b) {
602 a.Swap(&b);
603 }
604 inline void Swap(DCCLFieldOptions_Conditions* other) {
605 if (other == this) return;
606 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
607 if (GetOwningArena() != nullptr &&
608 GetOwningArena() == other->GetOwningArena()) {
609 #else // PROTOBUF_FORCE_COPY_IN_SWAP
610 if (GetOwningArena() == other->GetOwningArena()) {
611 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
612 InternalSwap(other);
613 } else {
614 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
615 }
616 }
617 void UnsafeArenaSwap(DCCLFieldOptions_Conditions* other) {
618 if (other == this) return;
619 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
620 InternalSwap(other);
621 }
622
623 // implements Message ----------------------------------------------
624
625 DCCLFieldOptions_Conditions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
626 return CreateMaybeMessage<DCCLFieldOptions_Conditions>(arena);
627 }
628 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
629 void CopyFrom(const DCCLFieldOptions_Conditions& from);
630 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
631 void MergeFrom( const DCCLFieldOptions_Conditions& from) {
632 DCCLFieldOptions_Conditions::MergeImpl(*this, from);
633 }
634 private:
635 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
636 public:
637 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
638 bool IsInitialized() const final;
639
640 size_t ByteSizeLong() const final;
641 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
642 uint8_t* _InternalSerialize(
643 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
644 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
645
646 private:
647 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
648 void SharedDtor();
649 void SetCachedSize(int size) const final;
650 void InternalSwap(DCCLFieldOptions_Conditions* other);
651
652 private:
653 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
654 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
655 return "dccl.DCCLFieldOptions.Conditions";
656 }
657 protected:
658 explicit DCCLFieldOptions_Conditions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
659 bool is_message_owned = false);
660 public:
661
662 static const ClassData _class_data_;
663 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
664
665 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
666
667 // nested types ----------------------------------------------------
668
669 // accessors -------------------------------------------------------
670
671 enum : int {
672 kRequiredIfFieldNumber = 1,
673 kOmitIfFieldNumber = 2,
674 kOnlyIfFieldNumber = 3,
675 kMinFieldNumber = 10,
676 kMaxFieldNumber = 11,
677 };
678 // optional string required_if = 1;
679 bool has_required_if() const;
680 private:
681 bool _internal_has_required_if() const;
682 public:
683 void clear_required_if();
684 const std::string& required_if() const;
685 template <typename ArgT0 = const std::string&, typename... ArgT>
686 void set_required_if(ArgT0&& arg0, ArgT... args);
687 std::string* mutable_required_if();
688 PROTOBUF_NODISCARD std::string* release_required_if();
689 void set_allocated_required_if(std::string* required_if);
690 private:
691 const std::string& _internal_required_if() const;
692 inline PROTOBUF_ALWAYS_INLINE void _internal_set_required_if(const std::string& value);
693 std::string* _internal_mutable_required_if();
694 public:
695
696 // optional string omit_if = 2;
697 bool has_omit_if() const;
698 private:
699 bool _internal_has_omit_if() const;
700 public:
701 void clear_omit_if();
702 const std::string& omit_if() const;
703 template <typename ArgT0 = const std::string&, typename... ArgT>
704 void set_omit_if(ArgT0&& arg0, ArgT... args);
705 std::string* mutable_omit_if();
706 PROTOBUF_NODISCARD std::string* release_omit_if();
707 void set_allocated_omit_if(std::string* omit_if);
708 private:
709 const std::string& _internal_omit_if() const;
710 inline PROTOBUF_ALWAYS_INLINE void _internal_set_omit_if(const std::string& value);
711 std::string* _internal_mutable_omit_if();
712 public:
713
714 // optional string only_if = 3;
715 bool has_only_if() const;
716 private:
717 bool _internal_has_only_if() const;
718 public:
719 void clear_only_if();
720 const std::string& only_if() const;
721 template <typename ArgT0 = const std::string&, typename... ArgT>
722 void set_only_if(ArgT0&& arg0, ArgT... args);
723 std::string* mutable_only_if();
724 PROTOBUF_NODISCARD std::string* release_only_if();
725 void set_allocated_only_if(std::string* only_if);
726 private:
727 const std::string& _internal_only_if() const;
728 inline PROTOBUF_ALWAYS_INLINE void _internal_set_only_if(const std::string& value);
729 std::string* _internal_mutable_only_if();
730 public:
731
732 // optional string min = 10;
733 bool has_min() const;
734 private:
735 bool _internal_has_min() const;
736 public:
737 void clear_min();
738 const std::string& min() const;
739 template <typename ArgT0 = const std::string&, typename... ArgT>
740 void set_min(ArgT0&& arg0, ArgT... args);
741 std::string* mutable_min();
742 PROTOBUF_NODISCARD std::string* release_min();
743 void set_allocated_min(std::string* min);
744 private:
745 const std::string& _internal_min() const;
746 inline PROTOBUF_ALWAYS_INLINE void _internal_set_min(const std::string& value);
747 std::string* _internal_mutable_min();
748 public:
749
750 // optional string max = 11;
751 bool has_max() const;
752 private:
753 bool _internal_has_max() const;
754 public:
755 void clear_max();
756 const std::string& max() const;
757 template <typename ArgT0 = const std::string&, typename... ArgT>
758 void set_max(ArgT0&& arg0, ArgT... args);
759 std::string* mutable_max();
760 PROTOBUF_NODISCARD std::string* release_max();
761 void set_allocated_max(std::string* max);
762 private:
763 const std::string& _internal_max() const;
764 inline PROTOBUF_ALWAYS_INLINE void _internal_set_max(const std::string& value);
765 std::string* _internal_mutable_max();
766 public:
767
768 // @@protoc_insertion_point(class_scope:dccl.DCCLFieldOptions.Conditions)
769 private:
770 class _Internal;
771
772 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
773 typedef void InternalArenaConstructable_;
774 typedef void DestructorSkippable_;
775 struct Impl_ {
776 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
777 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
778 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr required_if_;
779 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr omit_if_;
780 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr only_if_;
781 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr min_;
782 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr max_;
783 };
784 union { Impl_ _impl_; };
785 friend struct ::TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto;
786};
787// -------------------------------------------------------------------
788
789class DCCLFieldOptions final :
790 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dccl.DCCLFieldOptions) */ {
791 public:
792 inline DCCLFieldOptions() : DCCLFieldOptions(nullptr) {}
793 ~DCCLFieldOptions() override;
794 explicit PROTOBUF_CONSTEXPR DCCLFieldOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
795
796 DCCLFieldOptions(const DCCLFieldOptions& from);
797 DCCLFieldOptions(DCCLFieldOptions&& from) noexcept
798 : DCCLFieldOptions() {
799 *this = ::std::move(from);
800 }
801
802 inline DCCLFieldOptions& operator=(const DCCLFieldOptions& from) {
803 CopyFrom(from);
804 return *this;
805 }
806 inline DCCLFieldOptions& operator=(DCCLFieldOptions&& from) noexcept {
807 if (this == &from) return *this;
808 if (GetOwningArena() == from.GetOwningArena()
809 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
810 && GetOwningArena() != nullptr
811 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
812 ) {
813 InternalSwap(&from);
814 } else {
815 CopyFrom(from);
816 }
817 return *this;
818 }
819
820 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
821 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
822 }
823 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
824 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
825 }
826
827 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
828 return GetDescriptor();
829 }
830 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
831 return default_instance().GetMetadata().descriptor;
832 }
833 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
834 return default_instance().GetMetadata().reflection;
835 }
836 static const DCCLFieldOptions& default_instance() {
837 return *internal_default_instance();
838 }
839 static inline const DCCLFieldOptions* internal_default_instance() {
840 return reinterpret_cast<const DCCLFieldOptions*>(
841 &_DCCLFieldOptions_default_instance_);
842 }
843 static constexpr int kIndexInFileMessages =
844 3;
845
846 friend void swap(DCCLFieldOptions& a, DCCLFieldOptions& b) {
847 a.Swap(&b);
848 }
849 inline void Swap(DCCLFieldOptions* other) {
850 if (other == this) return;
851 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
852 if (GetOwningArena() != nullptr &&
853 GetOwningArena() == other->GetOwningArena()) {
854 #else // PROTOBUF_FORCE_COPY_IN_SWAP
855 if (GetOwningArena() == other->GetOwningArena()) {
856 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
857 InternalSwap(other);
858 } else {
859 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
860 }
861 }
862 void UnsafeArenaSwap(DCCLFieldOptions* other) {
863 if (other == this) return;
864 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
865 InternalSwap(other);
866 }
867
868 // implements Message ----------------------------------------------
869
870 DCCLFieldOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
871 return CreateMaybeMessage<DCCLFieldOptions>(arena);
872 }
873 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
874 void CopyFrom(const DCCLFieldOptions& from);
875 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
876 void MergeFrom( const DCCLFieldOptions& from) {
877 DCCLFieldOptions::MergeImpl(*this, from);
878 }
879 private:
880 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
881 public:
882 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
883 bool IsInitialized() const final;
884
885 size_t ByteSizeLong() const final;
886 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
887 uint8_t* _InternalSerialize(
888 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
889 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
890
891 private:
892 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
893 void SharedDtor();
894 void SetCachedSize(int size) const final;
895 void InternalSwap(DCCLFieldOptions* other);
896
897 private:
898 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
899 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
900 return "dccl.DCCLFieldOptions";
901 }
902 protected:
903 explicit DCCLFieldOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
904 bool is_message_owned = false);
905 public:
906
907 static const ClassData _class_data_;
908 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
909
910 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
911
912 // nested types ----------------------------------------------------
913
914 typedef DCCLFieldOptions_Units Units;
915 typedef DCCLFieldOptions_Conditions Conditions;
916
917 // accessors -------------------------------------------------------
918
919 enum : int {
920 kCodecFieldNumber = 1,
921 kStaticValueFieldNumber = 8,
922 kDescriptionFieldNumber = 20,
923 kUnitsFieldNumber = 30,
924 kDynamicConditionsFieldNumber = 40,
925 kOmitFieldNumber = 2,
926 kInHeadFieldNumber = 3,
927 kPrecisionFieldNumber = 4,
928 kMinFieldNumber = 5,
929 kMaxFieldNumber = 6,
930 kMaxLengthFieldNumber = 9,
931 kMaxRepeatFieldNumber = 10,
932 kMinRepeatFieldNumber = 13,
933 kNumDaysFieldNumber = 7,
934 kPackedEnumFieldNumber = 11,
935 kResolutionFieldNumber = 12,
936 };
937 // optional string codec = 1 [default = "dccl.default2"];
938 bool has_codec() const;
939 private:
940 bool _internal_has_codec() const;
941 public:
942 void clear_codec();
943 const std::string& codec() const;
944 template <typename ArgT0 = const std::string&, typename... ArgT>
945 void set_codec(ArgT0&& arg0, ArgT... args);
946 std::string* mutable_codec();
947 PROTOBUF_NODISCARD std::string* release_codec();
948 void set_allocated_codec(std::string* codec);
949 private:
950 const std::string& _internal_codec() const;
951 inline PROTOBUF_ALWAYS_INLINE void _internal_set_codec(const std::string& value);
952 std::string* _internal_mutable_codec();
953 public:
954
955 // optional string static_value = 8 [default = ""];
956 bool has_static_value() const;
957 private:
958 bool _internal_has_static_value() const;
959 public:
960 void clear_static_value();
961 const std::string& static_value() const;
962 template <typename ArgT0 = const std::string&, typename... ArgT>
963 void set_static_value(ArgT0&& arg0, ArgT... args);
964 std::string* mutable_static_value();
965 PROTOBUF_NODISCARD std::string* release_static_value();
966 void set_allocated_static_value(std::string* static_value);
967 private:
968 const std::string& _internal_static_value() const;
969 inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_value(const std::string& value);
970 std::string* _internal_mutable_static_value();
971 public:
972
973 // optional string description = 20;
974 bool has_description() const;
975 private:
976 bool _internal_has_description() const;
977 public:
978 void clear_description();
979 const std::string& description() const;
980 template <typename ArgT0 = const std::string&, typename... ArgT>
981 void set_description(ArgT0&& arg0, ArgT... args);
982 std::string* mutable_description();
983 PROTOBUF_NODISCARD std::string* release_description();
984 void set_allocated_description(std::string* description);
985 private:
986 const std::string& _internal_description() const;
987 inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
988 std::string* _internal_mutable_description();
989 public:
990
991 // optional .dccl.DCCLFieldOptions.Units units = 30;
992 bool has_units() const;
993 private:
994 bool _internal_has_units() const;
995 public:
996 void clear_units();
997 const ::dccl::DCCLFieldOptions_Units& units() const;
998 PROTOBUF_NODISCARD ::dccl::DCCLFieldOptions_Units* release_units();
999 ::dccl::DCCLFieldOptions_Units* mutable_units();
1000 void set_allocated_units(::dccl::DCCLFieldOptions_Units* units);
1001 private:
1002 const ::dccl::DCCLFieldOptions_Units& _internal_units() const;
1003 ::dccl::DCCLFieldOptions_Units* _internal_mutable_units();
1004 public:
1005 void unsafe_arena_set_allocated_units(
1006 ::dccl::DCCLFieldOptions_Units* units);
1007 ::dccl::DCCLFieldOptions_Units* unsafe_arena_release_units();
1008
1009 // optional .dccl.DCCLFieldOptions.Conditions dynamic_conditions = 40;
1010 bool has_dynamic_conditions() const;
1011 private:
1012 bool _internal_has_dynamic_conditions() const;
1013 public:
1014 void clear_dynamic_conditions();
1015 const ::dccl::DCCLFieldOptions_Conditions& dynamic_conditions() const;
1016 PROTOBUF_NODISCARD ::dccl::DCCLFieldOptions_Conditions* release_dynamic_conditions();
1017 ::dccl::DCCLFieldOptions_Conditions* mutable_dynamic_conditions();
1018 void set_allocated_dynamic_conditions(::dccl::DCCLFieldOptions_Conditions* dynamic_conditions);
1019 private:
1020 const ::dccl::DCCLFieldOptions_Conditions& _internal_dynamic_conditions() const;
1021 ::dccl::DCCLFieldOptions_Conditions* _internal_mutable_dynamic_conditions();
1022 public:
1023 void unsafe_arena_set_allocated_dynamic_conditions(
1024 ::dccl::DCCLFieldOptions_Conditions* dynamic_conditions);
1025 ::dccl::DCCLFieldOptions_Conditions* unsafe_arena_release_dynamic_conditions();
1026
1027 // optional bool omit = 2 [default = false];
1028 bool has_omit() const;
1029 private:
1030 bool _internal_has_omit() const;
1031 public:
1032 void clear_omit();
1033 bool omit() const;
1034 void set_omit(bool value);
1035 private:
1036 bool _internal_omit() const;
1037 void _internal_set_omit(bool value);
1038 public:
1039
1040 // optional bool in_head = 3 [default = false];
1041 bool has_in_head() const;
1042 private:
1043 bool _internal_has_in_head() const;
1044 public:
1045 void clear_in_head();
1046 bool in_head() const;
1047 void set_in_head(bool value);
1048 private:
1049 bool _internal_in_head() const;
1050 void _internal_set_in_head(bool value);
1051 public:
1052
1053 // optional int32 precision = 4 [default = 0];
1054 bool has_precision() const;
1055 private:
1056 bool _internal_has_precision() const;
1057 public:
1058 void clear_precision();
1059 int32_t precision() const;
1060 void set_precision(int32_t value);
1061 private:
1062 int32_t _internal_precision() const;
1063 void _internal_set_precision(int32_t value);
1064 public:
1065
1066 // optional double min = 5;
1067 bool has_min() const;
1068 private:
1069 bool _internal_has_min() const;
1070 public:
1071 void clear_min();
1072 double min() const;
1073 void set_min(double value);
1074 private:
1075 double _internal_min() const;
1076 void _internal_set_min(double value);
1077 public:
1078
1079 // optional double max = 6;
1080 bool has_max() const;
1081 private:
1082 bool _internal_has_max() const;
1083 public:
1084 void clear_max();
1085 double max() const;
1086 void set_max(double value);
1087 private:
1088 double _internal_max() const;
1089 void _internal_set_max(double value);
1090 public:
1091
1092 // optional uint32 max_length = 9;
1093 bool has_max_length() const;
1094 private:
1095 bool _internal_has_max_length() const;
1096 public:
1097 void clear_max_length();
1098 uint32_t max_length() const;
1099 void set_max_length(uint32_t value);
1100 private:
1101 uint32_t _internal_max_length() const;
1102 void _internal_set_max_length(uint32_t value);
1103 public:
1104
1105 // optional uint32 max_repeat = 10;
1106 bool has_max_repeat() const;
1107 private:
1108 bool _internal_has_max_repeat() const;
1109 public:
1110 void clear_max_repeat();
1111 uint32_t max_repeat() const;
1112 void set_max_repeat(uint32_t value);
1113 private:
1114 uint32_t _internal_max_repeat() const;
1115 void _internal_set_max_repeat(uint32_t value);
1116 public:
1117
1118 // optional uint32 min_repeat = 13 [default = 0];
1119 bool has_min_repeat() const;
1120 private:
1121 bool _internal_has_min_repeat() const;
1122 public:
1123 void clear_min_repeat();
1124 uint32_t min_repeat() const;
1125 void set_min_repeat(uint32_t value);
1126 private:
1127 uint32_t _internal_min_repeat() const;
1128 void _internal_set_min_repeat(uint32_t value);
1129 public:
1130
1131 // optional uint32 num_days = 7 [default = 1];
1132 bool has_num_days() const;
1133 private:
1134 bool _internal_has_num_days() const;
1135 public:
1136 void clear_num_days();
1137 uint32_t num_days() const;
1138 void set_num_days(uint32_t value);
1139 private:
1140 uint32_t _internal_num_days() const;
1141 void _internal_set_num_days(uint32_t value);
1142 public:
1143
1144 // optional bool packed_enum = 11 [default = true];
1145 bool has_packed_enum() const;
1146 private:
1147 bool _internal_has_packed_enum() const;
1148 public:
1149 void clear_packed_enum();
1150 bool packed_enum() const;
1151 void set_packed_enum(bool value);
1152 private:
1153 bool _internal_packed_enum() const;
1154 void _internal_set_packed_enum(bool value);
1155 public:
1156
1157 // optional double resolution = 12 [default = 1];
1158 bool has_resolution() const;
1159 private:
1160 bool _internal_has_resolution() const;
1161 public:
1162 void clear_resolution();
1163 double resolution() const;
1164 void set_resolution(double value);
1165 private:
1166 double _internal_resolution() const;
1167 void _internal_set_resolution(double value);
1168 public:
1169
1170
1171 template <typename _proto_TypeTraits,
1172 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1173 bool _is_packed>
1174 inline bool HasExtension(
1175 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1176 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
1177
1178 return _impl_._extensions_.Has(id.number());
1179 }
1180
1181 template <typename _proto_TypeTraits,
1182 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1183 bool _is_packed>
1184 inline void ClearExtension(
1185 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1186 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
1187 _impl_._extensions_.ClearExtension(id.number());
1188
1189 }
1190
1191 template <typename _proto_TypeTraits,
1192 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1193 bool _is_packed>
1194 inline int ExtensionSize(
1195 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1196 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
1197
1198 return _impl_._extensions_.ExtensionSize(id.number());
1199 }
1200
1201 template <typename _proto_TypeTraits,
1202 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1203 bool _is_packed>
1204 inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
1205 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1206 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
1207
1208 return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
1209 id.default_value());
1210 }
1211
1212 template <typename _proto_TypeTraits,
1213 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1214 bool _is_packed>
1215 inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
1216 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1217 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
1218
1219 return _proto_TypeTraits::Mutable(id.number(), _field_type,
1220 &_impl_._extensions_);
1221 }
1222
1223 template <typename _proto_TypeTraits,
1224 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1225 bool _is_packed>
1226 inline void SetExtension(
1227 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1228 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1229 typename _proto_TypeTraits::Singular::ConstType value) {
1230 _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
1231
1232 }
1233
1234 template <typename _proto_TypeTraits,
1235 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1236 bool _is_packed>
1237 inline void SetAllocatedExtension(
1238 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1239 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1240 typename _proto_TypeTraits::Singular::MutableType value) {
1241 _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
1242 &_impl_._extensions_);
1243
1244 }
1245 template <typename _proto_TypeTraits,
1246 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1247 bool _is_packed>
1248 inline void UnsafeArenaSetAllocatedExtension(
1249 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1250 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1251 typename _proto_TypeTraits::Singular::MutableType value) {
1252 _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
1253 value, &_impl_._extensions_);
1254
1255 }
1256 template <typename _proto_TypeTraits,
1257 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1258 bool _is_packed>
1259 PROTOBUF_NODISCARD inline
1260 typename _proto_TypeTraits::Singular::MutableType
1261 ReleaseExtension(
1262 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1263 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
1264
1265 return _proto_TypeTraits::Release(id.number(), _field_type,
1266 &_impl_._extensions_);
1267 }
1268 template <typename _proto_TypeTraits,
1269 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1270 bool _is_packed>
1271 inline typename _proto_TypeTraits::Singular::MutableType
1272 UnsafeArenaReleaseExtension(
1273 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1274 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
1275
1276 return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
1277 &_impl_._extensions_);
1278 }
1279
1280 template <typename _proto_TypeTraits,
1281 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1282 bool _is_packed>
1283 inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
1284 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1285 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1286 int index) const {
1287
1288 return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
1289 }
1290
1291 template <typename _proto_TypeTraits,
1292 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1293 bool _is_packed>
1294 inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
1295 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1296 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1297 int index) {
1298
1299 return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
1300 }
1301
1302 template <typename _proto_TypeTraits,
1303 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1304 bool _is_packed>
1305 inline void SetExtension(
1306 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1307 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1308 int index, typename _proto_TypeTraits::Repeated::ConstType value) {
1309 _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
1310
1311 }
1312
1313 template <typename _proto_TypeTraits,
1314 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1315 bool _is_packed>
1316 inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
1317 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1318 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
1319 typename _proto_TypeTraits::Repeated::MutableType to_add =
1320 _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
1321
1322 return to_add;
1323 }
1324
1325 template <typename _proto_TypeTraits,
1326 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1327 bool _is_packed>
1328 inline void AddExtension(
1329 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1330 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
1331 typename _proto_TypeTraits::Repeated::ConstType value) {
1332 _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
1333 &_impl_._extensions_);
1334
1335 }
1336
1337 template <typename _proto_TypeTraits,
1338 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1339 bool _is_packed>
1340 inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
1341 GetRepeatedExtension(
1342 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1343 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
1344
1345 return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
1346 }
1347
1348 template <typename _proto_TypeTraits,
1349 ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
1350 bool _is_packed>
1351 inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
1352 MutableRepeatedExtension(
1353 const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
1354 DCCLFieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
1355
1356 return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
1357 _is_packed, &_impl_._extensions_);
1358 }
1359
1360 // @@protoc_insertion_point(class_scope:dccl.DCCLFieldOptions)
1361 private:
1362 class _Internal;
1363
1364 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1365 typedef void InternalArenaConstructable_;
1366 typedef void DestructorSkippable_;
1367 struct Impl_ {
1368 ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
1369
1370 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1371 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1372 static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_codec_;
1373 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codec_;
1374 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static_value_;
1375 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
1376 ::dccl::DCCLFieldOptions_Units* units_;
1377 ::dccl::DCCLFieldOptions_Conditions* dynamic_conditions_;
1378 bool omit_;
1379 bool in_head_;
1380 int32_t precision_;
1381 double min_;
1382 double max_;
1383 uint32_t max_length_;
1384 uint32_t max_repeat_;
1385 uint32_t min_repeat_;
1386 uint32_t num_days_;
1387 bool packed_enum_;
1388 double resolution_;
1389 };
1390 union { Impl_ _impl_; };
1391 friend struct ::TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto;
1392};
1393// -------------------------------------------------------------------
1394
1395class DCCLMessageOptions final :
1396 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dccl.DCCLMessageOptions) */ {
1397 public:
1398 inline DCCLMessageOptions() : DCCLMessageOptions(nullptr) {}
1399 ~DCCLMessageOptions() override;
1400 explicit PROTOBUF_CONSTEXPR DCCLMessageOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1401
1402 DCCLMessageOptions(const DCCLMessageOptions& from);
1403 DCCLMessageOptions(DCCLMessageOptions&& from) noexcept
1404 : DCCLMessageOptions() {
1405 *this = ::std::move(from);
1406 }
1407
1408 inline DCCLMessageOptions& operator=(const DCCLMessageOptions& from) {
1409 CopyFrom(from);
1410 return *this;
1411 }
1412 inline DCCLMessageOptions& operator=(DCCLMessageOptions&& from) noexcept {
1413 if (this == &from) return *this;
1414 if (GetOwningArena() == from.GetOwningArena()
1415 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1416 && GetOwningArena() != nullptr
1417 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1418 ) {
1419 InternalSwap(&from);
1420 } else {
1421 CopyFrom(from);
1422 }
1423 return *this;
1424 }
1425
1426 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1427 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1428 }
1429 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1430 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1431 }
1432
1433 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1434 return GetDescriptor();
1435 }
1436 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1437 return default_instance().GetMetadata().descriptor;
1438 }
1439 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1440 return default_instance().GetMetadata().reflection;
1441 }
1442 static const DCCLMessageOptions& default_instance() {
1443 return *internal_default_instance();
1444 }
1445 static inline const DCCLMessageOptions* internal_default_instance() {
1446 return reinterpret_cast<const DCCLMessageOptions*>(
1447 &_DCCLMessageOptions_default_instance_);
1448 }
1449 static constexpr int kIndexInFileMessages =
1450 4;
1451
1452 friend void swap(DCCLMessageOptions& a, DCCLMessageOptions& b) {
1453 a.Swap(&b);
1454 }
1455 inline void Swap(DCCLMessageOptions* other) {
1456 if (other == this) return;
1457 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1458 if (GetOwningArena() != nullptr &&
1459 GetOwningArena() == other->GetOwningArena()) {
1460 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1461 if (GetOwningArena() == other->GetOwningArena()) {
1462 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1463 InternalSwap(other);
1464 } else {
1465 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1466 }
1467 }
1468 void UnsafeArenaSwap(DCCLMessageOptions* other) {
1469 if (other == this) return;
1470 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1471 InternalSwap(other);
1472 }
1473
1474 // implements Message ----------------------------------------------
1475
1476 DCCLMessageOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1477 return CreateMaybeMessage<DCCLMessageOptions>(arena);
1478 }
1479 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1480 void CopyFrom(const DCCLMessageOptions& from);
1481 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1482 void MergeFrom( const DCCLMessageOptions& from) {
1483 DCCLMessageOptions::MergeImpl(*this, from);
1484 }
1485 private:
1486 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1487 public:
1488 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1489 bool IsInitialized() const final;
1490
1491 size_t ByteSizeLong() const final;
1492 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1493 uint8_t* _InternalSerialize(
1494 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1495 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1496
1497 private:
1498 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1499 void SharedDtor();
1500 void SetCachedSize(int size) const final;
1501 void InternalSwap(DCCLMessageOptions* other);
1502
1503 private:
1504 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1505 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1506 return "dccl.DCCLMessageOptions";
1507 }
1508 protected:
1509 explicit DCCLMessageOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1510 bool is_message_owned = false);
1511 public:
1512
1513 static const ClassData _class_data_;
1514 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1515
1516 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1517
1518 // nested types ----------------------------------------------------
1519
1520 // accessors -------------------------------------------------------
1521
1522 enum : int {
1523 kCodecFieldNumber = 3,
1524 kCodecGroupFieldNumber = 4,
1525 kUnitSystemFieldNumber = 30,
1526 kIdFieldNumber = 1,
1527 kMaxBytesFieldNumber = 2,
1528 kCodecVersionFieldNumber = 5,
1529 kOmitIdFieldNumber = 10,
1530 };
1531 // optional string codec = 3;
1532 bool has_codec() const;
1533 private:
1534 bool _internal_has_codec() const;
1535 public:
1536 void clear_codec();
1537 const std::string& codec() const;
1538 template <typename ArgT0 = const std::string&, typename... ArgT>
1539 void set_codec(ArgT0&& arg0, ArgT... args);
1540 std::string* mutable_codec();
1541 PROTOBUF_NODISCARD std::string* release_codec();
1542 void set_allocated_codec(std::string* codec);
1543 private:
1544 const std::string& _internal_codec() const;
1545 inline PROTOBUF_ALWAYS_INLINE void _internal_set_codec(const std::string& value);
1546 std::string* _internal_mutable_codec();
1547 public:
1548
1549 // optional string codec_group = 4;
1550 bool has_codec_group() const;
1551 private:
1552 bool _internal_has_codec_group() const;
1553 public:
1554 void clear_codec_group();
1555 const std::string& codec_group() const;
1556 template <typename ArgT0 = const std::string&, typename... ArgT>
1557 void set_codec_group(ArgT0&& arg0, ArgT... args);
1558 std::string* mutable_codec_group();
1559 PROTOBUF_NODISCARD std::string* release_codec_group();
1560 void set_allocated_codec_group(std::string* codec_group);
1561 private:
1562 const std::string& _internal_codec_group() const;
1563 inline PROTOBUF_ALWAYS_INLINE void _internal_set_codec_group(const std::string& value);
1564 std::string* _internal_mutable_codec_group();
1565 public:
1566
1567 // optional string unit_system = 30 [default = "si"];
1568 bool has_unit_system() const;
1569 private:
1570 bool _internal_has_unit_system() const;
1571 public:
1572 void clear_unit_system();
1573 const std::string& unit_system() const;
1574 template <typename ArgT0 = const std::string&, typename... ArgT>
1575 void set_unit_system(ArgT0&& arg0, ArgT... args);
1576 std::string* mutable_unit_system();
1577 PROTOBUF_NODISCARD std::string* release_unit_system();
1578 void set_allocated_unit_system(std::string* unit_system);
1579 private:
1580 const std::string& _internal_unit_system() const;
1581 inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit_system(const std::string& value);
1582 std::string* _internal_mutable_unit_system();
1583 public:
1584
1585 // optional int32 id = 1;
1586 bool has_id() const;
1587 private:
1588 bool _internal_has_id() const;
1589 public:
1590 void clear_id();
1591 int32_t id() const;
1592 void set_id(int32_t value);
1593 private:
1594 int32_t _internal_id() const;
1595 void _internal_set_id(int32_t value);
1596 public:
1597
1598 // optional uint32 max_bytes = 2;
1599 bool has_max_bytes() const;
1600 private:
1601 bool _internal_has_max_bytes() const;
1602 public:
1603 void clear_max_bytes();
1604 uint32_t max_bytes() const;
1605 void set_max_bytes(uint32_t value);
1606 private:
1607 uint32_t _internal_max_bytes() const;
1608 void _internal_set_max_bytes(uint32_t value);
1609 public:
1610
1611 // optional int32 codec_version = 5;
1612 bool has_codec_version() const;
1613 private:
1614 bool _internal_has_codec_version() const;
1615 public:
1616 void clear_codec_version();
1617 int32_t codec_version() const;
1618 void set_codec_version(int32_t value);
1619 private:
1620 int32_t _internal_codec_version() const;
1621 void _internal_set_codec_version(int32_t value);
1622 public:
1623
1624 // optional bool omit_id = 10 [default = false];
1625 bool has_omit_id() const;
1626 private:
1627 bool _internal_has_omit_id() const;
1628 public:
1629 void clear_omit_id();
1630 bool omit_id() const;
1631 void set_omit_id(bool value);
1632 private:
1633 bool _internal_omit_id() const;
1634 void _internal_set_omit_id(bool value);
1635 public:
1636
1637 // @@protoc_insertion_point(class_scope:dccl.DCCLMessageOptions)
1638 private:
1639 class _Internal;
1640
1641 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1642 typedef void InternalArenaConstructable_;
1643 typedef void DestructorSkippable_;
1644 struct Impl_ {
1645 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1646 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1647 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codec_;
1648 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codec_group_;
1649 static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_unit_system_;
1650 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unit_system_;
1651 int32_t id_;
1652 uint32_t max_bytes_;
1653 int32_t codec_version_;
1654 bool omit_id_;
1655 };
1656 union { Impl_ _impl_; };
1657 friend struct ::TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto;
1658};
1659// ===================================================================
1660
1661static const int kFieldFieldNumber = 1012;
1662extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::FieldOptions,
1663 ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::dccl::DCCLFieldOptions >, 11, false >
1664 field;
1665static const int kMsgFieldNumber = 1012;
1666extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::MessageOptions,
1667 ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::dccl::DCCLMessageOptions >, 11, false >
1668 msg;
1669
1670// ===================================================================
1671
1672#ifdef __GNUC__
1673 #pragma GCC diagnostic push
1674 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1675#endif // __GNUC__
1676// DCCLFieldOptions_Units_CustomUnit
1677
1678// required string unit = 1;
1679inline bool DCCLFieldOptions_Units_CustomUnit::_internal_has_unit() const {
1680 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1681 return value;
1682}
1683inline bool DCCLFieldOptions_Units_CustomUnit::has_unit() const {
1684 return _internal_has_unit();
1685}
1686inline void DCCLFieldOptions_Units_CustomUnit::clear_unit() {
1687 _impl_.unit_.ClearToEmpty();
1688 _impl_._has_bits_[0] &= ~0x00000001u;
1689}
1690inline const std::string& DCCLFieldOptions_Units_CustomUnit::unit() const {
1691 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.CustomUnit.unit)
1692 return _internal_unit();
1693}
1694template <typename ArgT0, typename... ArgT>
1695inline PROTOBUF_ALWAYS_INLINE
1696void DCCLFieldOptions_Units_CustomUnit::set_unit(ArgT0&& arg0, ArgT... args) {
1697 _impl_._has_bits_[0] |= 0x00000001u;
1698 _impl_.unit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1699 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.CustomUnit.unit)
1700}
1701inline std::string* DCCLFieldOptions_Units_CustomUnit::mutable_unit() {
1702 std::string* _s = _internal_mutable_unit();
1703 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.CustomUnit.unit)
1704 return _s;
1705}
1706inline const std::string& DCCLFieldOptions_Units_CustomUnit::_internal_unit() const {
1707 return _impl_.unit_.Get();
1708}
1709inline void DCCLFieldOptions_Units_CustomUnit::_internal_set_unit(const std::string& value) {
1710 _impl_._has_bits_[0] |= 0x00000001u;
1711 _impl_.unit_.Set(value, GetArenaForAllocation());
1712}
1713inline std::string* DCCLFieldOptions_Units_CustomUnit::_internal_mutable_unit() {
1714 _impl_._has_bits_[0] |= 0x00000001u;
1715 return _impl_.unit_.Mutable(GetArenaForAllocation());
1716}
1717inline std::string* DCCLFieldOptions_Units_CustomUnit::release_unit() {
1718 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.CustomUnit.unit)
1719 if (!_internal_has_unit()) {
1720 return nullptr;
1721 }
1722 _impl_._has_bits_[0] &= ~0x00000001u;
1723 auto* p = _impl_.unit_.Release();
1724#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1725 if (_impl_.unit_.IsDefault()) {
1726 _impl_.unit_.Set("", GetArenaForAllocation());
1727 }
1728#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1729 return p;
1730}
1731inline void DCCLFieldOptions_Units_CustomUnit::set_allocated_unit(std::string* unit) {
1732 if (unit != nullptr) {
1733 _impl_._has_bits_[0] |= 0x00000001u;
1734 } else {
1735 _impl_._has_bits_[0] &= ~0x00000001u;
1736 }
1737 _impl_.unit_.SetAllocated(unit, GetArenaForAllocation());
1738#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1739 if (_impl_.unit_.IsDefault()) {
1740 _impl_.unit_.Set("", GetArenaForAllocation());
1741 }
1742#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1743 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.CustomUnit.unit)
1744}
1745
1746// optional string header = 2;
1747inline bool DCCLFieldOptions_Units_CustomUnit::_internal_has_header() const {
1748 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1749 return value;
1750}
1751inline bool DCCLFieldOptions_Units_CustomUnit::has_header() const {
1752 return _internal_has_header();
1753}
1754inline void DCCLFieldOptions_Units_CustomUnit::clear_header() {
1755 _impl_.header_.ClearToEmpty();
1756 _impl_._has_bits_[0] &= ~0x00000002u;
1757}
1758inline const std::string& DCCLFieldOptions_Units_CustomUnit::header() const {
1759 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.CustomUnit.header)
1760 return _internal_header();
1761}
1762template <typename ArgT0, typename... ArgT>
1763inline PROTOBUF_ALWAYS_INLINE
1764void DCCLFieldOptions_Units_CustomUnit::set_header(ArgT0&& arg0, ArgT... args) {
1765 _impl_._has_bits_[0] |= 0x00000002u;
1766 _impl_.header_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1767 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.CustomUnit.header)
1768}
1769inline std::string* DCCLFieldOptions_Units_CustomUnit::mutable_header() {
1770 std::string* _s = _internal_mutable_header();
1771 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.CustomUnit.header)
1772 return _s;
1773}
1774inline const std::string& DCCLFieldOptions_Units_CustomUnit::_internal_header() const {
1775 return _impl_.header_.Get();
1776}
1777inline void DCCLFieldOptions_Units_CustomUnit::_internal_set_header(const std::string& value) {
1778 _impl_._has_bits_[0] |= 0x00000002u;
1779 _impl_.header_.Set(value, GetArenaForAllocation());
1780}
1781inline std::string* DCCLFieldOptions_Units_CustomUnit::_internal_mutable_header() {
1782 _impl_._has_bits_[0] |= 0x00000002u;
1783 return _impl_.header_.Mutable(GetArenaForAllocation());
1784}
1785inline std::string* DCCLFieldOptions_Units_CustomUnit::release_header() {
1786 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.CustomUnit.header)
1787 if (!_internal_has_header()) {
1788 return nullptr;
1789 }
1790 _impl_._has_bits_[0] &= ~0x00000002u;
1791 auto* p = _impl_.header_.Release();
1792#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1793 if (_impl_.header_.IsDefault()) {
1794 _impl_.header_.Set("", GetArenaForAllocation());
1795 }
1796#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1797 return p;
1798}
1799inline void DCCLFieldOptions_Units_CustomUnit::set_allocated_header(std::string* header) {
1800 if (header != nullptr) {
1801 _impl_._has_bits_[0] |= 0x00000002u;
1802 } else {
1803 _impl_._has_bits_[0] &= ~0x00000002u;
1804 }
1805 _impl_.header_.SetAllocated(header, GetArenaForAllocation());
1806#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1807 if (_impl_.header_.IsDefault()) {
1808 _impl_.header_.Set("", GetArenaForAllocation());
1809 }
1810#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1811 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.CustomUnit.header)
1812}
1813
1814// -------------------------------------------------------------------
1815
1816// DCCLFieldOptions_Units
1817
1818// optional string base_dimensions = 1;
1819inline bool DCCLFieldOptions_Units::_internal_has_base_dimensions() const {
1820 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1821 return value;
1822}
1823inline bool DCCLFieldOptions_Units::has_base_dimensions() const {
1824 return _internal_has_base_dimensions();
1825}
1826inline void DCCLFieldOptions_Units::clear_base_dimensions() {
1827 _impl_.base_dimensions_.ClearToEmpty();
1828 _impl_._has_bits_[0] &= ~0x00000001u;
1829}
1830inline const std::string& DCCLFieldOptions_Units::base_dimensions() const {
1831 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.base_dimensions)
1832 return _internal_base_dimensions();
1833}
1834template <typename ArgT0, typename... ArgT>
1835inline PROTOBUF_ALWAYS_INLINE
1836void DCCLFieldOptions_Units::set_base_dimensions(ArgT0&& arg0, ArgT... args) {
1837 _impl_._has_bits_[0] |= 0x00000001u;
1838 _impl_.base_dimensions_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1839 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.base_dimensions)
1840}
1841inline std::string* DCCLFieldOptions_Units::mutable_base_dimensions() {
1842 std::string* _s = _internal_mutable_base_dimensions();
1843 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.base_dimensions)
1844 return _s;
1845}
1846inline const std::string& DCCLFieldOptions_Units::_internal_base_dimensions() const {
1847 return _impl_.base_dimensions_.Get();
1848}
1849inline void DCCLFieldOptions_Units::_internal_set_base_dimensions(const std::string& value) {
1850 _impl_._has_bits_[0] |= 0x00000001u;
1851 _impl_.base_dimensions_.Set(value, GetArenaForAllocation());
1852}
1853inline std::string* DCCLFieldOptions_Units::_internal_mutable_base_dimensions() {
1854 _impl_._has_bits_[0] |= 0x00000001u;
1855 return _impl_.base_dimensions_.Mutable(GetArenaForAllocation());
1856}
1857inline std::string* DCCLFieldOptions_Units::release_base_dimensions() {
1858 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.base_dimensions)
1859 if (!_internal_has_base_dimensions()) {
1860 return nullptr;
1861 }
1862 _impl_._has_bits_[0] &= ~0x00000001u;
1863 auto* p = _impl_.base_dimensions_.Release();
1864#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1865 if (_impl_.base_dimensions_.IsDefault()) {
1866 _impl_.base_dimensions_.Set("", GetArenaForAllocation());
1867 }
1868#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1869 return p;
1870}
1871inline void DCCLFieldOptions_Units::set_allocated_base_dimensions(std::string* base_dimensions) {
1872 if (base_dimensions != nullptr) {
1873 _impl_._has_bits_[0] |= 0x00000001u;
1874 } else {
1875 _impl_._has_bits_[0] &= ~0x00000001u;
1876 }
1877 _impl_.base_dimensions_.SetAllocated(base_dimensions, GetArenaForAllocation());
1878#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1879 if (_impl_.base_dimensions_.IsDefault()) {
1880 _impl_.base_dimensions_.Set("", GetArenaForAllocation());
1881 }
1882#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1883 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.base_dimensions)
1884}
1885
1886// optional string derived_dimensions = 2;
1887inline bool DCCLFieldOptions_Units::_internal_has_derived_dimensions() const {
1888 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1889 return value;
1890}
1891inline bool DCCLFieldOptions_Units::has_derived_dimensions() const {
1892 return _internal_has_derived_dimensions();
1893}
1894inline void DCCLFieldOptions_Units::clear_derived_dimensions() {
1895 _impl_.derived_dimensions_.ClearToEmpty();
1896 _impl_._has_bits_[0] &= ~0x00000002u;
1897}
1898inline const std::string& DCCLFieldOptions_Units::derived_dimensions() const {
1899 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.derived_dimensions)
1900 return _internal_derived_dimensions();
1901}
1902template <typename ArgT0, typename... ArgT>
1903inline PROTOBUF_ALWAYS_INLINE
1904void DCCLFieldOptions_Units::set_derived_dimensions(ArgT0&& arg0, ArgT... args) {
1905 _impl_._has_bits_[0] |= 0x00000002u;
1906 _impl_.derived_dimensions_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1907 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.derived_dimensions)
1908}
1909inline std::string* DCCLFieldOptions_Units::mutable_derived_dimensions() {
1910 std::string* _s = _internal_mutable_derived_dimensions();
1911 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.derived_dimensions)
1912 return _s;
1913}
1914inline const std::string& DCCLFieldOptions_Units::_internal_derived_dimensions() const {
1915 return _impl_.derived_dimensions_.Get();
1916}
1917inline void DCCLFieldOptions_Units::_internal_set_derived_dimensions(const std::string& value) {
1918 _impl_._has_bits_[0] |= 0x00000002u;
1919 _impl_.derived_dimensions_.Set(value, GetArenaForAllocation());
1920}
1921inline std::string* DCCLFieldOptions_Units::_internal_mutable_derived_dimensions() {
1922 _impl_._has_bits_[0] |= 0x00000002u;
1923 return _impl_.derived_dimensions_.Mutable(GetArenaForAllocation());
1924}
1925inline std::string* DCCLFieldOptions_Units::release_derived_dimensions() {
1926 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.derived_dimensions)
1927 if (!_internal_has_derived_dimensions()) {
1928 return nullptr;
1929 }
1930 _impl_._has_bits_[0] &= ~0x00000002u;
1931 auto* p = _impl_.derived_dimensions_.Release();
1932#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1933 if (_impl_.derived_dimensions_.IsDefault()) {
1934 _impl_.derived_dimensions_.Set("", GetArenaForAllocation());
1935 }
1936#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1937 return p;
1938}
1939inline void DCCLFieldOptions_Units::set_allocated_derived_dimensions(std::string* derived_dimensions) {
1940 if (derived_dimensions != nullptr) {
1941 _impl_._has_bits_[0] |= 0x00000002u;
1942 } else {
1943 _impl_._has_bits_[0] &= ~0x00000002u;
1944 }
1945 _impl_.derived_dimensions_.SetAllocated(derived_dimensions, GetArenaForAllocation());
1946#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1947 if (_impl_.derived_dimensions_.IsDefault()) {
1948 _impl_.derived_dimensions_.Set("", GetArenaForAllocation());
1949 }
1950#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1951 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.derived_dimensions)
1952}
1953
1954// optional string system = 3 [default = "si"];
1955inline bool DCCLFieldOptions_Units::_internal_has_system() const {
1956 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1957 return value;
1958}
1959inline bool DCCLFieldOptions_Units::has_system() const {
1960 return _internal_has_system();
1961}
1962inline void DCCLFieldOptions_Units::clear_system() {
1963 _impl_.system_.ClearToDefault(::dccl::DCCLFieldOptions_Units::Impl_::_i_give_permission_to_break_this_code_default_system_, GetArenaForAllocation());
1964 _impl_._has_bits_[0] &= ~0x00000004u;
1965}
1966inline const std::string& DCCLFieldOptions_Units::system() const {
1967 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.system)
1968 if (_impl_.system_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_system_.get();
1969 return _internal_system();
1970}
1971template <typename ArgT0, typename... ArgT>
1972inline PROTOBUF_ALWAYS_INLINE
1973void DCCLFieldOptions_Units::set_system(ArgT0&& arg0, ArgT... args) {
1974 _impl_._has_bits_[0] |= 0x00000004u;
1975 _impl_.system_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1976 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.system)
1977}
1978inline std::string* DCCLFieldOptions_Units::mutable_system() {
1979 std::string* _s = _internal_mutable_system();
1980 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.system)
1981 return _s;
1982}
1983inline const std::string& DCCLFieldOptions_Units::_internal_system() const {
1984 return _impl_.system_.Get();
1985}
1986inline void DCCLFieldOptions_Units::_internal_set_system(const std::string& value) {
1987 _impl_._has_bits_[0] |= 0x00000004u;
1988 _impl_.system_.Set(value, GetArenaForAllocation());
1989}
1990inline std::string* DCCLFieldOptions_Units::_internal_mutable_system() {
1991 _impl_._has_bits_[0] |= 0x00000004u;
1992 return _impl_.system_.Mutable(::dccl::DCCLFieldOptions_Units::Impl_::_i_give_permission_to_break_this_code_default_system_, GetArenaForAllocation());
1993}
1994inline std::string* DCCLFieldOptions_Units::release_system() {
1995 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.system)
1996 if (!_internal_has_system()) {
1997 return nullptr;
1998 }
1999 _impl_._has_bits_[0] &= ~0x00000004u;
2000 auto* p = _impl_.system_.Release();
2001 return p;
2002}
2003inline void DCCLFieldOptions_Units::set_allocated_system(std::string* system) {
2004 if (system != nullptr) {
2005 _impl_._has_bits_[0] |= 0x00000004u;
2006 } else {
2007 _impl_._has_bits_[0] &= ~0x00000004u;
2008 }
2009 _impl_.system_.SetAllocated(system, GetArenaForAllocation());
2010 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.system)
2011}
2012
2013// optional bool relative_temperature = 4 [default = false];
2014inline bool DCCLFieldOptions_Units::_internal_has_relative_temperature() const {
2015 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
2016 return value;
2017}
2018inline bool DCCLFieldOptions_Units::has_relative_temperature() const {
2019 return _internal_has_relative_temperature();
2020}
2021inline void DCCLFieldOptions_Units::clear_relative_temperature() {
2022 _impl_.relative_temperature_ = false;
2023 _impl_._has_bits_[0] &= ~0x00000040u;
2024}
2025inline bool DCCLFieldOptions_Units::_internal_relative_temperature() const {
2026 return _impl_.relative_temperature_;
2027}
2028inline bool DCCLFieldOptions_Units::relative_temperature() const {
2029 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.relative_temperature)
2030 return _internal_relative_temperature();
2031}
2032inline void DCCLFieldOptions_Units::_internal_set_relative_temperature(bool value) {
2033 _impl_._has_bits_[0] |= 0x00000040u;
2034 _impl_.relative_temperature_ = value;
2035}
2036inline void DCCLFieldOptions_Units::set_relative_temperature(bool value) {
2037 _internal_set_relative_temperature(value);
2038 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.relative_temperature)
2039}
2040
2041// optional string unit = 5;
2042inline bool DCCLFieldOptions_Units::_internal_has_unit() const {
2043 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2044 return value;
2045}
2046inline bool DCCLFieldOptions_Units::has_unit() const {
2047 return _internal_has_unit();
2048}
2049inline void DCCLFieldOptions_Units::clear_unit() {
2050 _impl_.unit_.ClearToEmpty();
2051 _impl_._has_bits_[0] &= ~0x00000008u;
2052}
2053inline const std::string& DCCLFieldOptions_Units::unit() const {
2054 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.unit)
2055 return _internal_unit();
2056}
2057template <typename ArgT0, typename... ArgT>
2058inline PROTOBUF_ALWAYS_INLINE
2059void DCCLFieldOptions_Units::set_unit(ArgT0&& arg0, ArgT... args) {
2060 _impl_._has_bits_[0] |= 0x00000008u;
2061 _impl_.unit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2062 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.unit)
2063}
2064inline std::string* DCCLFieldOptions_Units::mutable_unit() {
2065 std::string* _s = _internal_mutable_unit();
2066 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.unit)
2067 return _s;
2068}
2069inline const std::string& DCCLFieldOptions_Units::_internal_unit() const {
2070 return _impl_.unit_.Get();
2071}
2072inline void DCCLFieldOptions_Units::_internal_set_unit(const std::string& value) {
2073 _impl_._has_bits_[0] |= 0x00000008u;
2074 _impl_.unit_.Set(value, GetArenaForAllocation());
2075}
2076inline std::string* DCCLFieldOptions_Units::_internal_mutable_unit() {
2077 _impl_._has_bits_[0] |= 0x00000008u;
2078 return _impl_.unit_.Mutable(GetArenaForAllocation());
2079}
2080inline std::string* DCCLFieldOptions_Units::release_unit() {
2081 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.unit)
2082 if (!_internal_has_unit()) {
2083 return nullptr;
2084 }
2085 _impl_._has_bits_[0] &= ~0x00000008u;
2086 auto* p = _impl_.unit_.Release();
2087#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2088 if (_impl_.unit_.IsDefault()) {
2089 _impl_.unit_.Set("", GetArenaForAllocation());
2090 }
2091#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2092 return p;
2093}
2094inline void DCCLFieldOptions_Units::set_allocated_unit(std::string* unit) {
2095 if (unit != nullptr) {
2096 _impl_._has_bits_[0] |= 0x00000008u;
2097 } else {
2098 _impl_._has_bits_[0] &= ~0x00000008u;
2099 }
2100 _impl_.unit_.SetAllocated(unit, GetArenaForAllocation());
2101#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2102 if (_impl_.unit_.IsDefault()) {
2103 _impl_.unit_.Set("", GetArenaForAllocation());
2104 }
2105#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2106 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.unit)
2107}
2108
2109// optional string prefix = 6;
2110inline bool DCCLFieldOptions_Units::_internal_has_prefix() const {
2111 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2112 return value;
2113}
2114inline bool DCCLFieldOptions_Units::has_prefix() const {
2115 return _internal_has_prefix();
2116}
2117inline void DCCLFieldOptions_Units::clear_prefix() {
2118 _impl_.prefix_.ClearToEmpty();
2119 _impl_._has_bits_[0] &= ~0x00000010u;
2120}
2121inline const std::string& DCCLFieldOptions_Units::prefix() const {
2122 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.prefix)
2123 return _internal_prefix();
2124}
2125template <typename ArgT0, typename... ArgT>
2126inline PROTOBUF_ALWAYS_INLINE
2127void DCCLFieldOptions_Units::set_prefix(ArgT0&& arg0, ArgT... args) {
2128 _impl_._has_bits_[0] |= 0x00000010u;
2129 _impl_.prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2130 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Units.prefix)
2131}
2132inline std::string* DCCLFieldOptions_Units::mutable_prefix() {
2133 std::string* _s = _internal_mutable_prefix();
2134 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.prefix)
2135 return _s;
2136}
2137inline const std::string& DCCLFieldOptions_Units::_internal_prefix() const {
2138 return _impl_.prefix_.Get();
2139}
2140inline void DCCLFieldOptions_Units::_internal_set_prefix(const std::string& value) {
2141 _impl_._has_bits_[0] |= 0x00000010u;
2142 _impl_.prefix_.Set(value, GetArenaForAllocation());
2143}
2144inline std::string* DCCLFieldOptions_Units::_internal_mutable_prefix() {
2145 _impl_._has_bits_[0] |= 0x00000010u;
2146 return _impl_.prefix_.Mutable(GetArenaForAllocation());
2147}
2148inline std::string* DCCLFieldOptions_Units::release_prefix() {
2149 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.prefix)
2150 if (!_internal_has_prefix()) {
2151 return nullptr;
2152 }
2153 _impl_._has_bits_[0] &= ~0x00000010u;
2154 auto* p = _impl_.prefix_.Release();
2155#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2156 if (_impl_.prefix_.IsDefault()) {
2157 _impl_.prefix_.Set("", GetArenaForAllocation());
2158 }
2159#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2160 return p;
2161}
2162inline void DCCLFieldOptions_Units::set_allocated_prefix(std::string* prefix) {
2163 if (prefix != nullptr) {
2164 _impl_._has_bits_[0] |= 0x00000010u;
2165 } else {
2166 _impl_._has_bits_[0] &= ~0x00000010u;
2167 }
2168 _impl_.prefix_.SetAllocated(prefix, GetArenaForAllocation());
2169#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2170 if (_impl_.prefix_.IsDefault()) {
2171 _impl_.prefix_.Set("", GetArenaForAllocation());
2172 }
2173#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2174 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.prefix)
2175}
2176
2177// optional .dccl.DCCLFieldOptions.Units.CustomUnit custom = 7;
2178inline bool DCCLFieldOptions_Units::_internal_has_custom() const {
2179 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2180 PROTOBUF_ASSUME(!value || _impl_.custom_ != nullptr);
2181 return value;
2182}
2183inline bool DCCLFieldOptions_Units::has_custom() const {
2184 return _internal_has_custom();
2185}
2186inline void DCCLFieldOptions_Units::clear_custom() {
2187 if (_impl_.custom_ != nullptr) _impl_.custom_->Clear();
2188 _impl_._has_bits_[0] &= ~0x00000020u;
2189}
2190inline const ::dccl::DCCLFieldOptions_Units_CustomUnit& DCCLFieldOptions_Units::_internal_custom() const {
2191 const ::dccl::DCCLFieldOptions_Units_CustomUnit* p = _impl_.custom_;
2192 return p != nullptr ? *p : reinterpret_cast<const ::dccl::DCCLFieldOptions_Units_CustomUnit&>(
2193 ::dccl::_DCCLFieldOptions_Units_CustomUnit_default_instance_);
2194}
2195inline const ::dccl::DCCLFieldOptions_Units_CustomUnit& DCCLFieldOptions_Units::custom() const {
2196 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Units.custom)
2197 return _internal_custom();
2198}
2199inline void DCCLFieldOptions_Units::unsafe_arena_set_allocated_custom(
2200 ::dccl::DCCLFieldOptions_Units_CustomUnit* custom) {
2201 if (GetArenaForAllocation() == nullptr) {
2202 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.custom_);
2203 }
2204 _impl_.custom_ = custom;
2205 if (custom) {
2206 _impl_._has_bits_[0] |= 0x00000020u;
2207 } else {
2208 _impl_._has_bits_[0] &= ~0x00000020u;
2209 }
2210 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dccl.DCCLFieldOptions.Units.custom)
2211}
2212inline ::dccl::DCCLFieldOptions_Units_CustomUnit* DCCLFieldOptions_Units::release_custom() {
2213 _impl_._has_bits_[0] &= ~0x00000020u;
2214 ::dccl::DCCLFieldOptions_Units_CustomUnit* temp = _impl_.custom_;
2215 _impl_.custom_ = nullptr;
2216#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2217 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2218 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2219 if (GetArenaForAllocation() == nullptr) { delete old; }
2220#else // PROTOBUF_FORCE_COPY_IN_RELEASE
2221 if (GetArenaForAllocation() != nullptr) {
2222 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2223 }
2224#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2225 return temp;
2226}
2227inline ::dccl::DCCLFieldOptions_Units_CustomUnit* DCCLFieldOptions_Units::unsafe_arena_release_custom() {
2228 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Units.custom)
2229 _impl_._has_bits_[0] &= ~0x00000020u;
2230 ::dccl::DCCLFieldOptions_Units_CustomUnit* temp = _impl_.custom_;
2231 _impl_.custom_ = nullptr;
2232 return temp;
2233}
2234inline ::dccl::DCCLFieldOptions_Units_CustomUnit* DCCLFieldOptions_Units::_internal_mutable_custom() {
2235 _impl_._has_bits_[0] |= 0x00000020u;
2236 if (_impl_.custom_ == nullptr) {
2237 auto* p = CreateMaybeMessage<::dccl::DCCLFieldOptions_Units_CustomUnit>(GetArenaForAllocation());
2238 _impl_.custom_ = p;
2239 }
2240 return _impl_.custom_;
2241}
2242inline ::dccl::DCCLFieldOptions_Units_CustomUnit* DCCLFieldOptions_Units::mutable_custom() {
2243 ::dccl::DCCLFieldOptions_Units_CustomUnit* _msg = _internal_mutable_custom();
2244 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Units.custom)
2245 return _msg;
2246}
2247inline void DCCLFieldOptions_Units::set_allocated_custom(::dccl::DCCLFieldOptions_Units_CustomUnit* custom) {
2248 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2249 if (message_arena == nullptr) {
2250 delete _impl_.custom_;
2251 }
2252 if (custom) {
2253 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2254 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(custom);
2255 if (message_arena != submessage_arena) {
2256 custom = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2257 message_arena, custom, submessage_arena);
2258 }
2259 _impl_._has_bits_[0] |= 0x00000020u;
2260 } else {
2261 _impl_._has_bits_[0] &= ~0x00000020u;
2262 }
2263 _impl_.custom_ = custom;
2264 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Units.custom)
2265}
2266
2267// -------------------------------------------------------------------
2268
2269// DCCLFieldOptions_Conditions
2270
2271// optional string required_if = 1;
2272inline bool DCCLFieldOptions_Conditions::_internal_has_required_if() const {
2273 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2274 return value;
2275}
2276inline bool DCCLFieldOptions_Conditions::has_required_if() const {
2277 return _internal_has_required_if();
2278}
2279inline void DCCLFieldOptions_Conditions::clear_required_if() {
2280 _impl_.required_if_.ClearToEmpty();
2281 _impl_._has_bits_[0] &= ~0x00000001u;
2282}
2283inline const std::string& DCCLFieldOptions_Conditions::required_if() const {
2284 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Conditions.required_if)
2285 return _internal_required_if();
2286}
2287template <typename ArgT0, typename... ArgT>
2288inline PROTOBUF_ALWAYS_INLINE
2289void DCCLFieldOptions_Conditions::set_required_if(ArgT0&& arg0, ArgT... args) {
2290 _impl_._has_bits_[0] |= 0x00000001u;
2291 _impl_.required_if_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2292 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Conditions.required_if)
2293}
2294inline std::string* DCCLFieldOptions_Conditions::mutable_required_if() {
2295 std::string* _s = _internal_mutable_required_if();
2296 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Conditions.required_if)
2297 return _s;
2298}
2299inline const std::string& DCCLFieldOptions_Conditions::_internal_required_if() const {
2300 return _impl_.required_if_.Get();
2301}
2302inline void DCCLFieldOptions_Conditions::_internal_set_required_if(const std::string& value) {
2303 _impl_._has_bits_[0] |= 0x00000001u;
2304 _impl_.required_if_.Set(value, GetArenaForAllocation());
2305}
2306inline std::string* DCCLFieldOptions_Conditions::_internal_mutable_required_if() {
2307 _impl_._has_bits_[0] |= 0x00000001u;
2308 return _impl_.required_if_.Mutable(GetArenaForAllocation());
2309}
2310inline std::string* DCCLFieldOptions_Conditions::release_required_if() {
2311 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Conditions.required_if)
2312 if (!_internal_has_required_if()) {
2313 return nullptr;
2314 }
2315 _impl_._has_bits_[0] &= ~0x00000001u;
2316 auto* p = _impl_.required_if_.Release();
2317#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2318 if (_impl_.required_if_.IsDefault()) {
2319 _impl_.required_if_.Set("", GetArenaForAllocation());
2320 }
2321#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2322 return p;
2323}
2324inline void DCCLFieldOptions_Conditions::set_allocated_required_if(std::string* required_if) {
2325 if (required_if != nullptr) {
2326 _impl_._has_bits_[0] |= 0x00000001u;
2327 } else {
2328 _impl_._has_bits_[0] &= ~0x00000001u;
2329 }
2330 _impl_.required_if_.SetAllocated(required_if, GetArenaForAllocation());
2331#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2332 if (_impl_.required_if_.IsDefault()) {
2333 _impl_.required_if_.Set("", GetArenaForAllocation());
2334 }
2335#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2336 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Conditions.required_if)
2337}
2338
2339// optional string omit_if = 2;
2340inline bool DCCLFieldOptions_Conditions::_internal_has_omit_if() const {
2341 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2342 return value;
2343}
2344inline bool DCCLFieldOptions_Conditions::has_omit_if() const {
2345 return _internal_has_omit_if();
2346}
2347inline void DCCLFieldOptions_Conditions::clear_omit_if() {
2348 _impl_.omit_if_.ClearToEmpty();
2349 _impl_._has_bits_[0] &= ~0x00000002u;
2350}
2351inline const std::string& DCCLFieldOptions_Conditions::omit_if() const {
2352 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Conditions.omit_if)
2353 return _internal_omit_if();
2354}
2355template <typename ArgT0, typename... ArgT>
2356inline PROTOBUF_ALWAYS_INLINE
2357void DCCLFieldOptions_Conditions::set_omit_if(ArgT0&& arg0, ArgT... args) {
2358 _impl_._has_bits_[0] |= 0x00000002u;
2359 _impl_.omit_if_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2360 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Conditions.omit_if)
2361}
2362inline std::string* DCCLFieldOptions_Conditions::mutable_omit_if() {
2363 std::string* _s = _internal_mutable_omit_if();
2364 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Conditions.omit_if)
2365 return _s;
2366}
2367inline const std::string& DCCLFieldOptions_Conditions::_internal_omit_if() const {
2368 return _impl_.omit_if_.Get();
2369}
2370inline void DCCLFieldOptions_Conditions::_internal_set_omit_if(const std::string& value) {
2371 _impl_._has_bits_[0] |= 0x00000002u;
2372 _impl_.omit_if_.Set(value, GetArenaForAllocation());
2373}
2374inline std::string* DCCLFieldOptions_Conditions::_internal_mutable_omit_if() {
2375 _impl_._has_bits_[0] |= 0x00000002u;
2376 return _impl_.omit_if_.Mutable(GetArenaForAllocation());
2377}
2378inline std::string* DCCLFieldOptions_Conditions::release_omit_if() {
2379 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Conditions.omit_if)
2380 if (!_internal_has_omit_if()) {
2381 return nullptr;
2382 }
2383 _impl_._has_bits_[0] &= ~0x00000002u;
2384 auto* p = _impl_.omit_if_.Release();
2385#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2386 if (_impl_.omit_if_.IsDefault()) {
2387 _impl_.omit_if_.Set("", GetArenaForAllocation());
2388 }
2389#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2390 return p;
2391}
2392inline void DCCLFieldOptions_Conditions::set_allocated_omit_if(std::string* omit_if) {
2393 if (omit_if != nullptr) {
2394 _impl_._has_bits_[0] |= 0x00000002u;
2395 } else {
2396 _impl_._has_bits_[0] &= ~0x00000002u;
2397 }
2398 _impl_.omit_if_.SetAllocated(omit_if, GetArenaForAllocation());
2399#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2400 if (_impl_.omit_if_.IsDefault()) {
2401 _impl_.omit_if_.Set("", GetArenaForAllocation());
2402 }
2403#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2404 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Conditions.omit_if)
2405}
2406
2407// optional string only_if = 3;
2408inline bool DCCLFieldOptions_Conditions::_internal_has_only_if() const {
2409 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2410 return value;
2411}
2412inline bool DCCLFieldOptions_Conditions::has_only_if() const {
2413 return _internal_has_only_if();
2414}
2415inline void DCCLFieldOptions_Conditions::clear_only_if() {
2416 _impl_.only_if_.ClearToEmpty();
2417 _impl_._has_bits_[0] &= ~0x00000004u;
2418}
2419inline const std::string& DCCLFieldOptions_Conditions::only_if() const {
2420 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Conditions.only_if)
2421 return _internal_only_if();
2422}
2423template <typename ArgT0, typename... ArgT>
2424inline PROTOBUF_ALWAYS_INLINE
2425void DCCLFieldOptions_Conditions::set_only_if(ArgT0&& arg0, ArgT... args) {
2426 _impl_._has_bits_[0] |= 0x00000004u;
2427 _impl_.only_if_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2428 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Conditions.only_if)
2429}
2430inline std::string* DCCLFieldOptions_Conditions::mutable_only_if() {
2431 std::string* _s = _internal_mutable_only_if();
2432 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Conditions.only_if)
2433 return _s;
2434}
2435inline const std::string& DCCLFieldOptions_Conditions::_internal_only_if() const {
2436 return _impl_.only_if_.Get();
2437}
2438inline void DCCLFieldOptions_Conditions::_internal_set_only_if(const std::string& value) {
2439 _impl_._has_bits_[0] |= 0x00000004u;
2440 _impl_.only_if_.Set(value, GetArenaForAllocation());
2441}
2442inline std::string* DCCLFieldOptions_Conditions::_internal_mutable_only_if() {
2443 _impl_._has_bits_[0] |= 0x00000004u;
2444 return _impl_.only_if_.Mutable(GetArenaForAllocation());
2445}
2446inline std::string* DCCLFieldOptions_Conditions::release_only_if() {
2447 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Conditions.only_if)
2448 if (!_internal_has_only_if()) {
2449 return nullptr;
2450 }
2451 _impl_._has_bits_[0] &= ~0x00000004u;
2452 auto* p = _impl_.only_if_.Release();
2453#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2454 if (_impl_.only_if_.IsDefault()) {
2455 _impl_.only_if_.Set("", GetArenaForAllocation());
2456 }
2457#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2458 return p;
2459}
2460inline void DCCLFieldOptions_Conditions::set_allocated_only_if(std::string* only_if) {
2461 if (only_if != nullptr) {
2462 _impl_._has_bits_[0] |= 0x00000004u;
2463 } else {
2464 _impl_._has_bits_[0] &= ~0x00000004u;
2465 }
2466 _impl_.only_if_.SetAllocated(only_if, GetArenaForAllocation());
2467#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2468 if (_impl_.only_if_.IsDefault()) {
2469 _impl_.only_if_.Set("", GetArenaForAllocation());
2470 }
2471#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2472 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Conditions.only_if)
2473}
2474
2475// optional string min = 10;
2476inline bool DCCLFieldOptions_Conditions::_internal_has_min() const {
2477 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2478 return value;
2479}
2480inline bool DCCLFieldOptions_Conditions::has_min() const {
2481 return _internal_has_min();
2482}
2483inline void DCCLFieldOptions_Conditions::clear_min() {
2484 _impl_.min_.ClearToEmpty();
2485 _impl_._has_bits_[0] &= ~0x00000008u;
2486}
2487inline const std::string& DCCLFieldOptions_Conditions::min() const {
2488 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Conditions.min)
2489 return _internal_min();
2490}
2491template <typename ArgT0, typename... ArgT>
2492inline PROTOBUF_ALWAYS_INLINE
2493void DCCLFieldOptions_Conditions::set_min(ArgT0&& arg0, ArgT... args) {
2494 _impl_._has_bits_[0] |= 0x00000008u;
2495 _impl_.min_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2496 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Conditions.min)
2497}
2498inline std::string* DCCLFieldOptions_Conditions::mutable_min() {
2499 std::string* _s = _internal_mutable_min();
2500 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Conditions.min)
2501 return _s;
2502}
2503inline const std::string& DCCLFieldOptions_Conditions::_internal_min() const {
2504 return _impl_.min_.Get();
2505}
2506inline void DCCLFieldOptions_Conditions::_internal_set_min(const std::string& value) {
2507 _impl_._has_bits_[0] |= 0x00000008u;
2508 _impl_.min_.Set(value, GetArenaForAllocation());
2509}
2510inline std::string* DCCLFieldOptions_Conditions::_internal_mutable_min() {
2511 _impl_._has_bits_[0] |= 0x00000008u;
2512 return _impl_.min_.Mutable(GetArenaForAllocation());
2513}
2514inline std::string* DCCLFieldOptions_Conditions::release_min() {
2515 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Conditions.min)
2516 if (!_internal_has_min()) {
2517 return nullptr;
2518 }
2519 _impl_._has_bits_[0] &= ~0x00000008u;
2520 auto* p = _impl_.min_.Release();
2521#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2522 if (_impl_.min_.IsDefault()) {
2523 _impl_.min_.Set("", GetArenaForAllocation());
2524 }
2525#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2526 return p;
2527}
2528inline void DCCLFieldOptions_Conditions::set_allocated_min(std::string* min) {
2529 if (min != nullptr) {
2530 _impl_._has_bits_[0] |= 0x00000008u;
2531 } else {
2532 _impl_._has_bits_[0] &= ~0x00000008u;
2533 }
2534 _impl_.min_.SetAllocated(min, GetArenaForAllocation());
2535#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2536 if (_impl_.min_.IsDefault()) {
2537 _impl_.min_.Set("", GetArenaForAllocation());
2538 }
2539#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2540 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Conditions.min)
2541}
2542
2543// optional string max = 11;
2544inline bool DCCLFieldOptions_Conditions::_internal_has_max() const {
2545 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2546 return value;
2547}
2548inline bool DCCLFieldOptions_Conditions::has_max() const {
2549 return _internal_has_max();
2550}
2551inline void DCCLFieldOptions_Conditions::clear_max() {
2552 _impl_.max_.ClearToEmpty();
2553 _impl_._has_bits_[0] &= ~0x00000010u;
2554}
2555inline const std::string& DCCLFieldOptions_Conditions::max() const {
2556 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.Conditions.max)
2557 return _internal_max();
2558}
2559template <typename ArgT0, typename... ArgT>
2560inline PROTOBUF_ALWAYS_INLINE
2561void DCCLFieldOptions_Conditions::set_max(ArgT0&& arg0, ArgT... args) {
2562 _impl_._has_bits_[0] |= 0x00000010u;
2563 _impl_.max_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2564 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.Conditions.max)
2565}
2566inline std::string* DCCLFieldOptions_Conditions::mutable_max() {
2567 std::string* _s = _internal_mutable_max();
2568 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.Conditions.max)
2569 return _s;
2570}
2571inline const std::string& DCCLFieldOptions_Conditions::_internal_max() const {
2572 return _impl_.max_.Get();
2573}
2574inline void DCCLFieldOptions_Conditions::_internal_set_max(const std::string& value) {
2575 _impl_._has_bits_[0] |= 0x00000010u;
2576 _impl_.max_.Set(value, GetArenaForAllocation());
2577}
2578inline std::string* DCCLFieldOptions_Conditions::_internal_mutable_max() {
2579 _impl_._has_bits_[0] |= 0x00000010u;
2580 return _impl_.max_.Mutable(GetArenaForAllocation());
2581}
2582inline std::string* DCCLFieldOptions_Conditions::release_max() {
2583 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.Conditions.max)
2584 if (!_internal_has_max()) {
2585 return nullptr;
2586 }
2587 _impl_._has_bits_[0] &= ~0x00000010u;
2588 auto* p = _impl_.max_.Release();
2589#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2590 if (_impl_.max_.IsDefault()) {
2591 _impl_.max_.Set("", GetArenaForAllocation());
2592 }
2593#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2594 return p;
2595}
2596inline void DCCLFieldOptions_Conditions::set_allocated_max(std::string* max) {
2597 if (max != nullptr) {
2598 _impl_._has_bits_[0] |= 0x00000010u;
2599 } else {
2600 _impl_._has_bits_[0] &= ~0x00000010u;
2601 }
2602 _impl_.max_.SetAllocated(max, GetArenaForAllocation());
2603#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2604 if (_impl_.max_.IsDefault()) {
2605 _impl_.max_.Set("", GetArenaForAllocation());
2606 }
2607#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2608 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.Conditions.max)
2609}
2610
2611// -------------------------------------------------------------------
2612
2613// DCCLFieldOptions
2614
2615// optional string codec = 1 [default = "dccl.default2"];
2616inline bool DCCLFieldOptions::_internal_has_codec() const {
2617 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2618 return value;
2619}
2620inline bool DCCLFieldOptions::has_codec() const {
2621 return _internal_has_codec();
2622}
2623inline void DCCLFieldOptions::clear_codec() {
2624 _impl_.codec_.ClearToDefault(::dccl::DCCLFieldOptions::Impl_::_i_give_permission_to_break_this_code_default_codec_, GetArenaForAllocation());
2625 _impl_._has_bits_[0] &= ~0x00000001u;
2626}
2627inline const std::string& DCCLFieldOptions::codec() const {
2628 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.codec)
2629 if (_impl_.codec_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_codec_.get();
2630 return _internal_codec();
2631}
2632template <typename ArgT0, typename... ArgT>
2633inline PROTOBUF_ALWAYS_INLINE
2634void DCCLFieldOptions::set_codec(ArgT0&& arg0, ArgT... args) {
2635 _impl_._has_bits_[0] |= 0x00000001u;
2636 _impl_.codec_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2637 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.codec)
2638}
2639inline std::string* DCCLFieldOptions::mutable_codec() {
2640 std::string* _s = _internal_mutable_codec();
2641 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.codec)
2642 return _s;
2643}
2644inline const std::string& DCCLFieldOptions::_internal_codec() const {
2645 return _impl_.codec_.Get();
2646}
2647inline void DCCLFieldOptions::_internal_set_codec(const std::string& value) {
2648 _impl_._has_bits_[0] |= 0x00000001u;
2649 _impl_.codec_.Set(value, GetArenaForAllocation());
2650}
2651inline std::string* DCCLFieldOptions::_internal_mutable_codec() {
2652 _impl_._has_bits_[0] |= 0x00000001u;
2653 return _impl_.codec_.Mutable(::dccl::DCCLFieldOptions::Impl_::_i_give_permission_to_break_this_code_default_codec_, GetArenaForAllocation());
2654}
2655inline std::string* DCCLFieldOptions::release_codec() {
2656 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.codec)
2657 if (!_internal_has_codec()) {
2658 return nullptr;
2659 }
2660 _impl_._has_bits_[0] &= ~0x00000001u;
2661 auto* p = _impl_.codec_.Release();
2662 return p;
2663}
2664inline void DCCLFieldOptions::set_allocated_codec(std::string* codec) {
2665 if (codec != nullptr) {
2666 _impl_._has_bits_[0] |= 0x00000001u;
2667 } else {
2668 _impl_._has_bits_[0] &= ~0x00000001u;
2669 }
2670 _impl_.codec_.SetAllocated(codec, GetArenaForAllocation());
2671 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.codec)
2672}
2673
2674// optional bool omit = 2 [default = false];
2675inline bool DCCLFieldOptions::_internal_has_omit() const {
2676 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2677 return value;
2678}
2679inline bool DCCLFieldOptions::has_omit() const {
2680 return _internal_has_omit();
2681}
2682inline void DCCLFieldOptions::clear_omit() {
2683 _impl_.omit_ = false;
2684 _impl_._has_bits_[0] &= ~0x00000020u;
2685}
2686inline bool DCCLFieldOptions::_internal_omit() const {
2687 return _impl_.omit_;
2688}
2689inline bool DCCLFieldOptions::omit() const {
2690 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.omit)
2691 return _internal_omit();
2692}
2693inline void DCCLFieldOptions::_internal_set_omit(bool value) {
2694 _impl_._has_bits_[0] |= 0x00000020u;
2695 _impl_.omit_ = value;
2696}
2697inline void DCCLFieldOptions::set_omit(bool value) {
2698 _internal_set_omit(value);
2699 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.omit)
2700}
2701
2702// optional bool in_head = 3 [default = false];
2703inline bool DCCLFieldOptions::_internal_has_in_head() const {
2704 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
2705 return value;
2706}
2707inline bool DCCLFieldOptions::has_in_head() const {
2708 return _internal_has_in_head();
2709}
2710inline void DCCLFieldOptions::clear_in_head() {
2711 _impl_.in_head_ = false;
2712 _impl_._has_bits_[0] &= ~0x00000040u;
2713}
2714inline bool DCCLFieldOptions::_internal_in_head() const {
2715 return _impl_.in_head_;
2716}
2717inline bool DCCLFieldOptions::in_head() const {
2718 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.in_head)
2719 return _internal_in_head();
2720}
2721inline void DCCLFieldOptions::_internal_set_in_head(bool value) {
2722 _impl_._has_bits_[0] |= 0x00000040u;
2723 _impl_.in_head_ = value;
2724}
2725inline void DCCLFieldOptions::set_in_head(bool value) {
2726 _internal_set_in_head(value);
2727 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.in_head)
2728}
2729
2730// optional int32 precision = 4 [default = 0];
2731inline bool DCCLFieldOptions::_internal_has_precision() const {
2732 bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
2733 return value;
2734}
2735inline bool DCCLFieldOptions::has_precision() const {
2736 return _internal_has_precision();
2737}
2738inline void DCCLFieldOptions::clear_precision() {
2739 _impl_.precision_ = 0;
2740 _impl_._has_bits_[0] &= ~0x00000080u;
2741}
2742inline int32_t DCCLFieldOptions::_internal_precision() const {
2743 return _impl_.precision_;
2744}
2745inline int32_t DCCLFieldOptions::precision() const {
2746 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.precision)
2747 return _internal_precision();
2748}
2749inline void DCCLFieldOptions::_internal_set_precision(int32_t value) {
2750 _impl_._has_bits_[0] |= 0x00000080u;
2751 _impl_.precision_ = value;
2752}
2753inline void DCCLFieldOptions::set_precision(int32_t value) {
2754 _internal_set_precision(value);
2755 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.precision)
2756}
2757
2758// optional double resolution = 12 [default = 1];
2759inline bool DCCLFieldOptions::_internal_has_resolution() const {
2760 bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
2761 return value;
2762}
2763inline bool DCCLFieldOptions::has_resolution() const {
2764 return _internal_has_resolution();
2765}
2766inline void DCCLFieldOptions::clear_resolution() {
2767 _impl_.resolution_ = 1;
2768 _impl_._has_bits_[0] &= ~0x00008000u;
2769}
2770inline double DCCLFieldOptions::_internal_resolution() const {
2771 return _impl_.resolution_;
2772}
2773inline double DCCLFieldOptions::resolution() const {
2774 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.resolution)
2775 return _internal_resolution();
2776}
2777inline void DCCLFieldOptions::_internal_set_resolution(double value) {
2778 _impl_._has_bits_[0] |= 0x00008000u;
2779 _impl_.resolution_ = value;
2780}
2781inline void DCCLFieldOptions::set_resolution(double value) {
2782 _internal_set_resolution(value);
2783 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.resolution)
2784}
2785
2786// optional double min = 5;
2787inline bool DCCLFieldOptions::_internal_has_min() const {
2788 bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
2789 return value;
2790}
2791inline bool DCCLFieldOptions::has_min() const {
2792 return _internal_has_min();
2793}
2794inline void DCCLFieldOptions::clear_min() {
2795 _impl_.min_ = 0;
2796 _impl_._has_bits_[0] &= ~0x00000100u;
2797}
2798inline double DCCLFieldOptions::_internal_min() const {
2799 return _impl_.min_;
2800}
2801inline double DCCLFieldOptions::min() const {
2802 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.min)
2803 return _internal_min();
2804}
2805inline void DCCLFieldOptions::_internal_set_min(double value) {
2806 _impl_._has_bits_[0] |= 0x00000100u;
2807 _impl_.min_ = value;
2808}
2809inline void DCCLFieldOptions::set_min(double value) {
2810 _internal_set_min(value);
2811 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.min)
2812}
2813
2814// optional double max = 6;
2815inline bool DCCLFieldOptions::_internal_has_max() const {
2816 bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
2817 return value;
2818}
2819inline bool DCCLFieldOptions::has_max() const {
2820 return _internal_has_max();
2821}
2822inline void DCCLFieldOptions::clear_max() {
2823 _impl_.max_ = 0;
2824 _impl_._has_bits_[0] &= ~0x00000200u;
2825}
2826inline double DCCLFieldOptions::_internal_max() const {
2827 return _impl_.max_;
2828}
2829inline double DCCLFieldOptions::max() const {
2830 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.max)
2831 return _internal_max();
2832}
2833inline void DCCLFieldOptions::_internal_set_max(double value) {
2834 _impl_._has_bits_[0] |= 0x00000200u;
2835 _impl_.max_ = value;
2836}
2837inline void DCCLFieldOptions::set_max(double value) {
2838 _internal_set_max(value);
2839 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.max)
2840}
2841
2842// optional uint32 num_days = 7 [default = 1];
2843inline bool DCCLFieldOptions::_internal_has_num_days() const {
2844 bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
2845 return value;
2846}
2847inline bool DCCLFieldOptions::has_num_days() const {
2848 return _internal_has_num_days();
2849}
2850inline void DCCLFieldOptions::clear_num_days() {
2851 _impl_.num_days_ = 1u;
2852 _impl_._has_bits_[0] &= ~0x00002000u;
2853}
2854inline uint32_t DCCLFieldOptions::_internal_num_days() const {
2855 return _impl_.num_days_;
2856}
2857inline uint32_t DCCLFieldOptions::num_days() const {
2858 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.num_days)
2859 return _internal_num_days();
2860}
2861inline void DCCLFieldOptions::_internal_set_num_days(uint32_t value) {
2862 _impl_._has_bits_[0] |= 0x00002000u;
2863 _impl_.num_days_ = value;
2864}
2865inline void DCCLFieldOptions::set_num_days(uint32_t value) {
2866 _internal_set_num_days(value);
2867 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.num_days)
2868}
2869
2870// optional string static_value = 8 [default = ""];
2871inline bool DCCLFieldOptions::_internal_has_static_value() const {
2872 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2873 return value;
2874}
2875inline bool DCCLFieldOptions::has_static_value() const {
2876 return _internal_has_static_value();
2877}
2878inline void DCCLFieldOptions::clear_static_value() {
2879 _impl_.static_value_.ClearToEmpty();
2880 _impl_._has_bits_[0] &= ~0x00000002u;
2881}
2882inline const std::string& DCCLFieldOptions::static_value() const {
2883 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.static_value)
2884 return _internal_static_value();
2885}
2886template <typename ArgT0, typename... ArgT>
2887inline PROTOBUF_ALWAYS_INLINE
2888void DCCLFieldOptions::set_static_value(ArgT0&& arg0, ArgT... args) {
2889 _impl_._has_bits_[0] |= 0x00000002u;
2890 _impl_.static_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2891 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.static_value)
2892}
2893inline std::string* DCCLFieldOptions::mutable_static_value() {
2894 std::string* _s = _internal_mutable_static_value();
2895 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.static_value)
2896 return _s;
2897}
2898inline const std::string& DCCLFieldOptions::_internal_static_value() const {
2899 return _impl_.static_value_.Get();
2900}
2901inline void DCCLFieldOptions::_internal_set_static_value(const std::string& value) {
2902 _impl_._has_bits_[0] |= 0x00000002u;
2903 _impl_.static_value_.Set(value, GetArenaForAllocation());
2904}
2905inline std::string* DCCLFieldOptions::_internal_mutable_static_value() {
2906 _impl_._has_bits_[0] |= 0x00000002u;
2907 return _impl_.static_value_.Mutable(GetArenaForAllocation());
2908}
2909inline std::string* DCCLFieldOptions::release_static_value() {
2910 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.static_value)
2911 if (!_internal_has_static_value()) {
2912 return nullptr;
2913 }
2914 _impl_._has_bits_[0] &= ~0x00000002u;
2915 auto* p = _impl_.static_value_.Release();
2916#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2917 if (_impl_.static_value_.IsDefault()) {
2918 _impl_.static_value_.Set("", GetArenaForAllocation());
2919 }
2920#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2921 return p;
2922}
2923inline void DCCLFieldOptions::set_allocated_static_value(std::string* static_value) {
2924 if (static_value != nullptr) {
2925 _impl_._has_bits_[0] |= 0x00000002u;
2926 } else {
2927 _impl_._has_bits_[0] &= ~0x00000002u;
2928 }
2929 _impl_.static_value_.SetAllocated(static_value, GetArenaForAllocation());
2930#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2931 if (_impl_.static_value_.IsDefault()) {
2932 _impl_.static_value_.Set("", GetArenaForAllocation());
2933 }
2934#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2935 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.static_value)
2936}
2937
2938// optional uint32 max_length = 9;
2939inline bool DCCLFieldOptions::_internal_has_max_length() const {
2940 bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
2941 return value;
2942}
2943inline bool DCCLFieldOptions::has_max_length() const {
2944 return _internal_has_max_length();
2945}
2946inline void DCCLFieldOptions::clear_max_length() {
2947 _impl_.max_length_ = 0u;
2948 _impl_._has_bits_[0] &= ~0x00000400u;
2949}
2950inline uint32_t DCCLFieldOptions::_internal_max_length() const {
2951 return _impl_.max_length_;
2952}
2953inline uint32_t DCCLFieldOptions::max_length() const {
2954 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.max_length)
2955 return _internal_max_length();
2956}
2957inline void DCCLFieldOptions::_internal_set_max_length(uint32_t value) {
2958 _impl_._has_bits_[0] |= 0x00000400u;
2959 _impl_.max_length_ = value;
2960}
2961inline void DCCLFieldOptions::set_max_length(uint32_t value) {
2962 _internal_set_max_length(value);
2963 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.max_length)
2964}
2965
2966// optional uint32 max_repeat = 10;
2967inline bool DCCLFieldOptions::_internal_has_max_repeat() const {
2968 bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
2969 return value;
2970}
2971inline bool DCCLFieldOptions::has_max_repeat() const {
2972 return _internal_has_max_repeat();
2973}
2974inline void DCCLFieldOptions::clear_max_repeat() {
2975 _impl_.max_repeat_ = 0u;
2976 _impl_._has_bits_[0] &= ~0x00000800u;
2977}
2978inline uint32_t DCCLFieldOptions::_internal_max_repeat() const {
2979 return _impl_.max_repeat_;
2980}
2981inline uint32_t DCCLFieldOptions::max_repeat() const {
2982 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.max_repeat)
2983 return _internal_max_repeat();
2984}
2985inline void DCCLFieldOptions::_internal_set_max_repeat(uint32_t value) {
2986 _impl_._has_bits_[0] |= 0x00000800u;
2987 _impl_.max_repeat_ = value;
2988}
2989inline void DCCLFieldOptions::set_max_repeat(uint32_t value) {
2990 _internal_set_max_repeat(value);
2991 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.max_repeat)
2992}
2993
2994// optional uint32 min_repeat = 13 [default = 0];
2995inline bool DCCLFieldOptions::_internal_has_min_repeat() const {
2996 bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
2997 return value;
2998}
2999inline bool DCCLFieldOptions::has_min_repeat() const {
3000 return _internal_has_min_repeat();
3001}
3002inline void DCCLFieldOptions::clear_min_repeat() {
3003 _impl_.min_repeat_ = 0u;
3004 _impl_._has_bits_[0] &= ~0x00001000u;
3005}
3006inline uint32_t DCCLFieldOptions::_internal_min_repeat() const {
3007 return _impl_.min_repeat_;
3008}
3009inline uint32_t DCCLFieldOptions::min_repeat() const {
3010 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.min_repeat)
3011 return _internal_min_repeat();
3012}
3013inline void DCCLFieldOptions::_internal_set_min_repeat(uint32_t value) {
3014 _impl_._has_bits_[0] |= 0x00001000u;
3015 _impl_.min_repeat_ = value;
3016}
3017inline void DCCLFieldOptions::set_min_repeat(uint32_t value) {
3018 _internal_set_min_repeat(value);
3019 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.min_repeat)
3020}
3021
3022// optional bool packed_enum = 11 [default = true];
3023inline bool DCCLFieldOptions::_internal_has_packed_enum() const {
3024 bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
3025 return value;
3026}
3027inline bool DCCLFieldOptions::has_packed_enum() const {
3028 return _internal_has_packed_enum();
3029}
3030inline void DCCLFieldOptions::clear_packed_enum() {
3031 _impl_.packed_enum_ = true;
3032 _impl_._has_bits_[0] &= ~0x00004000u;
3033}
3034inline bool DCCLFieldOptions::_internal_packed_enum() const {
3035 return _impl_.packed_enum_;
3036}
3037inline bool DCCLFieldOptions::packed_enum() const {
3038 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.packed_enum)
3039 return _internal_packed_enum();
3040}
3041inline void DCCLFieldOptions::_internal_set_packed_enum(bool value) {
3042 _impl_._has_bits_[0] |= 0x00004000u;
3043 _impl_.packed_enum_ = value;
3044}
3045inline void DCCLFieldOptions::set_packed_enum(bool value) {
3046 _internal_set_packed_enum(value);
3047 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.packed_enum)
3048}
3049
3050// optional string description = 20;
3051inline bool DCCLFieldOptions::_internal_has_description() const {
3052 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3053 return value;
3054}
3055inline bool DCCLFieldOptions::has_description() const {
3056 return _internal_has_description();
3057}
3058inline void DCCLFieldOptions::clear_description() {
3059 _impl_.description_.ClearToEmpty();
3060 _impl_._has_bits_[0] &= ~0x00000004u;
3061}
3062inline const std::string& DCCLFieldOptions::description() const {
3063 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.description)
3064 return _internal_description();
3065}
3066template <typename ArgT0, typename... ArgT>
3067inline PROTOBUF_ALWAYS_INLINE
3068void DCCLFieldOptions::set_description(ArgT0&& arg0, ArgT... args) {
3069 _impl_._has_bits_[0] |= 0x00000004u;
3070 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3071 // @@protoc_insertion_point(field_set:dccl.DCCLFieldOptions.description)
3072}
3073inline std::string* DCCLFieldOptions::mutable_description() {
3074 std::string* _s = _internal_mutable_description();
3075 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.description)
3076 return _s;
3077}
3078inline const std::string& DCCLFieldOptions::_internal_description() const {
3079 return _impl_.description_.Get();
3080}
3081inline void DCCLFieldOptions::_internal_set_description(const std::string& value) {
3082 _impl_._has_bits_[0] |= 0x00000004u;
3083 _impl_.description_.Set(value, GetArenaForAllocation());
3084}
3085inline std::string* DCCLFieldOptions::_internal_mutable_description() {
3086 _impl_._has_bits_[0] |= 0x00000004u;
3087 return _impl_.description_.Mutable(GetArenaForAllocation());
3088}
3089inline std::string* DCCLFieldOptions::release_description() {
3090 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.description)
3091 if (!_internal_has_description()) {
3092 return nullptr;
3093 }
3094 _impl_._has_bits_[0] &= ~0x00000004u;
3095 auto* p = _impl_.description_.Release();
3096#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3097 if (_impl_.description_.IsDefault()) {
3098 _impl_.description_.Set("", GetArenaForAllocation());
3099 }
3100#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3101 return p;
3102}
3103inline void DCCLFieldOptions::set_allocated_description(std::string* description) {
3104 if (description != nullptr) {
3105 _impl_._has_bits_[0] |= 0x00000004u;
3106 } else {
3107 _impl_._has_bits_[0] &= ~0x00000004u;
3108 }
3109 _impl_.description_.SetAllocated(description, GetArenaForAllocation());
3110#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3111 if (_impl_.description_.IsDefault()) {
3112 _impl_.description_.Set("", GetArenaForAllocation());
3113 }
3114#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3115 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.description)
3116}
3117
3118// optional .dccl.DCCLFieldOptions.Units units = 30;
3119inline bool DCCLFieldOptions::_internal_has_units() const {
3120 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3121 PROTOBUF_ASSUME(!value || _impl_.units_ != nullptr);
3122 return value;
3123}
3124inline bool DCCLFieldOptions::has_units() const {
3125 return _internal_has_units();
3126}
3127inline void DCCLFieldOptions::clear_units() {
3128 if (_impl_.units_ != nullptr) _impl_.units_->Clear();
3129 _impl_._has_bits_[0] &= ~0x00000008u;
3130}
3131inline const ::dccl::DCCLFieldOptions_Units& DCCLFieldOptions::_internal_units() const {
3132 const ::dccl::DCCLFieldOptions_Units* p = _impl_.units_;
3133 return p != nullptr ? *p : reinterpret_cast<const ::dccl::DCCLFieldOptions_Units&>(
3134 ::dccl::_DCCLFieldOptions_Units_default_instance_);
3135}
3136inline const ::dccl::DCCLFieldOptions_Units& DCCLFieldOptions::units() const {
3137 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.units)
3138 return _internal_units();
3139}
3140inline void DCCLFieldOptions::unsafe_arena_set_allocated_units(
3141 ::dccl::DCCLFieldOptions_Units* units) {
3142 if (GetArenaForAllocation() == nullptr) {
3143 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.units_);
3144 }
3145 _impl_.units_ = units;
3146 if (units) {
3147 _impl_._has_bits_[0] |= 0x00000008u;
3148 } else {
3149 _impl_._has_bits_[0] &= ~0x00000008u;
3150 }
3151 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dccl.DCCLFieldOptions.units)
3152}
3153inline ::dccl::DCCLFieldOptions_Units* DCCLFieldOptions::release_units() {
3154 _impl_._has_bits_[0] &= ~0x00000008u;
3155 ::dccl::DCCLFieldOptions_Units* temp = _impl_.units_;
3156 _impl_.units_ = nullptr;
3157#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3158 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3159 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3160 if (GetArenaForAllocation() == nullptr) { delete old; }
3161#else // PROTOBUF_FORCE_COPY_IN_RELEASE
3162 if (GetArenaForAllocation() != nullptr) {
3163 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3164 }
3165#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3166 return temp;
3167}
3168inline ::dccl::DCCLFieldOptions_Units* DCCLFieldOptions::unsafe_arena_release_units() {
3169 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.units)
3170 _impl_._has_bits_[0] &= ~0x00000008u;
3171 ::dccl::DCCLFieldOptions_Units* temp = _impl_.units_;
3172 _impl_.units_ = nullptr;
3173 return temp;
3174}
3175inline ::dccl::DCCLFieldOptions_Units* DCCLFieldOptions::_internal_mutable_units() {
3176 _impl_._has_bits_[0] |= 0x00000008u;
3177 if (_impl_.units_ == nullptr) {
3178 auto* p = CreateMaybeMessage<::dccl::DCCLFieldOptions_Units>(GetArenaForAllocation());
3179 _impl_.units_ = p;
3180 }
3181 return _impl_.units_;
3182}
3183inline ::dccl::DCCLFieldOptions_Units* DCCLFieldOptions::mutable_units() {
3184 ::dccl::DCCLFieldOptions_Units* _msg = _internal_mutable_units();
3185 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.units)
3186 return _msg;
3187}
3188inline void DCCLFieldOptions::set_allocated_units(::dccl::DCCLFieldOptions_Units* units) {
3189 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3190 if (message_arena == nullptr) {
3191 delete _impl_.units_;
3192 }
3193 if (units) {
3194 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3195 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(units);
3196 if (message_arena != submessage_arena) {
3197 units = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3198 message_arena, units, submessage_arena);
3199 }
3200 _impl_._has_bits_[0] |= 0x00000008u;
3201 } else {
3202 _impl_._has_bits_[0] &= ~0x00000008u;
3203 }
3204 _impl_.units_ = units;
3205 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.units)
3206}
3207
3208// optional .dccl.DCCLFieldOptions.Conditions dynamic_conditions = 40;
3209inline bool DCCLFieldOptions::_internal_has_dynamic_conditions() const {
3210 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
3211 PROTOBUF_ASSUME(!value || _impl_.dynamic_conditions_ != nullptr);
3212 return value;
3213}
3214inline bool DCCLFieldOptions::has_dynamic_conditions() const {
3215 return _internal_has_dynamic_conditions();
3216}
3217inline void DCCLFieldOptions::clear_dynamic_conditions() {
3218 if (_impl_.dynamic_conditions_ != nullptr) _impl_.dynamic_conditions_->Clear();
3219 _impl_._has_bits_[0] &= ~0x00000010u;
3220}
3221inline const ::dccl::DCCLFieldOptions_Conditions& DCCLFieldOptions::_internal_dynamic_conditions() const {
3222 const ::dccl::DCCLFieldOptions_Conditions* p = _impl_.dynamic_conditions_;
3223 return p != nullptr ? *p : reinterpret_cast<const ::dccl::DCCLFieldOptions_Conditions&>(
3224 ::dccl::_DCCLFieldOptions_Conditions_default_instance_);
3225}
3226inline const ::dccl::DCCLFieldOptions_Conditions& DCCLFieldOptions::dynamic_conditions() const {
3227 // @@protoc_insertion_point(field_get:dccl.DCCLFieldOptions.dynamic_conditions)
3228 return _internal_dynamic_conditions();
3229}
3230inline void DCCLFieldOptions::unsafe_arena_set_allocated_dynamic_conditions(
3231 ::dccl::DCCLFieldOptions_Conditions* dynamic_conditions) {
3232 if (GetArenaForAllocation() == nullptr) {
3233 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dynamic_conditions_);
3234 }
3235 _impl_.dynamic_conditions_ = dynamic_conditions;
3236 if (dynamic_conditions) {
3237 _impl_._has_bits_[0] |= 0x00000010u;
3238 } else {
3239 _impl_._has_bits_[0] &= ~0x00000010u;
3240 }
3241 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dccl.DCCLFieldOptions.dynamic_conditions)
3242}
3243inline ::dccl::DCCLFieldOptions_Conditions* DCCLFieldOptions::release_dynamic_conditions() {
3244 _impl_._has_bits_[0] &= ~0x00000010u;
3245 ::dccl::DCCLFieldOptions_Conditions* temp = _impl_.dynamic_conditions_;
3246 _impl_.dynamic_conditions_ = nullptr;
3247#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3248 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3249 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3250 if (GetArenaForAllocation() == nullptr) { delete old; }
3251#else // PROTOBUF_FORCE_COPY_IN_RELEASE
3252 if (GetArenaForAllocation() != nullptr) {
3253 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3254 }
3255#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3256 return temp;
3257}
3258inline ::dccl::DCCLFieldOptions_Conditions* DCCLFieldOptions::unsafe_arena_release_dynamic_conditions() {
3259 // @@protoc_insertion_point(field_release:dccl.DCCLFieldOptions.dynamic_conditions)
3260 _impl_._has_bits_[0] &= ~0x00000010u;
3261 ::dccl::DCCLFieldOptions_Conditions* temp = _impl_.dynamic_conditions_;
3262 _impl_.dynamic_conditions_ = nullptr;
3263 return temp;
3264}
3265inline ::dccl::DCCLFieldOptions_Conditions* DCCLFieldOptions::_internal_mutable_dynamic_conditions() {
3266 _impl_._has_bits_[0] |= 0x00000010u;
3267 if (_impl_.dynamic_conditions_ == nullptr) {
3268 auto* p = CreateMaybeMessage<::dccl::DCCLFieldOptions_Conditions>(GetArenaForAllocation());
3269 _impl_.dynamic_conditions_ = p;
3270 }
3271 return _impl_.dynamic_conditions_;
3272}
3273inline ::dccl::DCCLFieldOptions_Conditions* DCCLFieldOptions::mutable_dynamic_conditions() {
3274 ::dccl::DCCLFieldOptions_Conditions* _msg = _internal_mutable_dynamic_conditions();
3275 // @@protoc_insertion_point(field_mutable:dccl.DCCLFieldOptions.dynamic_conditions)
3276 return _msg;
3277}
3278inline void DCCLFieldOptions::set_allocated_dynamic_conditions(::dccl::DCCLFieldOptions_Conditions* dynamic_conditions) {
3279 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3280 if (message_arena == nullptr) {
3281 delete _impl_.dynamic_conditions_;
3282 }
3283 if (dynamic_conditions) {
3284 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3285 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dynamic_conditions);
3286 if (message_arena != submessage_arena) {
3287 dynamic_conditions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3288 message_arena, dynamic_conditions, submessage_arena);
3289 }
3290 _impl_._has_bits_[0] |= 0x00000010u;
3291 } else {
3292 _impl_._has_bits_[0] &= ~0x00000010u;
3293 }
3294 _impl_.dynamic_conditions_ = dynamic_conditions;
3295 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLFieldOptions.dynamic_conditions)
3296}
3297
3298// -------------------------------------------------------------------
3299
3300// DCCLMessageOptions
3301
3302// optional int32 id = 1;
3303inline bool DCCLMessageOptions::_internal_has_id() const {
3304 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3305 return value;
3306}
3307inline bool DCCLMessageOptions::has_id() const {
3308 return _internal_has_id();
3309}
3310inline void DCCLMessageOptions::clear_id() {
3311 _impl_.id_ = 0;
3312 _impl_._has_bits_[0] &= ~0x00000008u;
3313}
3314inline int32_t DCCLMessageOptions::_internal_id() const {
3315 return _impl_.id_;
3316}
3317inline int32_t DCCLMessageOptions::id() const {
3318 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.id)
3319 return _internal_id();
3320}
3321inline void DCCLMessageOptions::_internal_set_id(int32_t value) {
3322 _impl_._has_bits_[0] |= 0x00000008u;
3323 _impl_.id_ = value;
3324}
3325inline void DCCLMessageOptions::set_id(int32_t value) {
3326 _internal_set_id(value);
3327 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.id)
3328}
3329
3330// optional uint32 max_bytes = 2;
3331inline bool DCCLMessageOptions::_internal_has_max_bytes() const {
3332 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
3333 return value;
3334}
3335inline bool DCCLMessageOptions::has_max_bytes() const {
3336 return _internal_has_max_bytes();
3337}
3338inline void DCCLMessageOptions::clear_max_bytes() {
3339 _impl_.max_bytes_ = 0u;
3340 _impl_._has_bits_[0] &= ~0x00000010u;
3341}
3342inline uint32_t DCCLMessageOptions::_internal_max_bytes() const {
3343 return _impl_.max_bytes_;
3344}
3345inline uint32_t DCCLMessageOptions::max_bytes() const {
3346 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.max_bytes)
3347 return _internal_max_bytes();
3348}
3349inline void DCCLMessageOptions::_internal_set_max_bytes(uint32_t value) {
3350 _impl_._has_bits_[0] |= 0x00000010u;
3351 _impl_.max_bytes_ = value;
3352}
3353inline void DCCLMessageOptions::set_max_bytes(uint32_t value) {
3354 _internal_set_max_bytes(value);
3355 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.max_bytes)
3356}
3357
3358// optional string codec = 3;
3359inline bool DCCLMessageOptions::_internal_has_codec() const {
3360 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3361 return value;
3362}
3363inline bool DCCLMessageOptions::has_codec() const {
3364 return _internal_has_codec();
3365}
3366inline void DCCLMessageOptions::clear_codec() {
3367 _impl_.codec_.ClearToEmpty();
3368 _impl_._has_bits_[0] &= ~0x00000001u;
3369}
3370inline const std::string& DCCLMessageOptions::codec() const {
3371 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.codec)
3372 return _internal_codec();
3373}
3374template <typename ArgT0, typename... ArgT>
3375inline PROTOBUF_ALWAYS_INLINE
3376void DCCLMessageOptions::set_codec(ArgT0&& arg0, ArgT... args) {
3377 _impl_._has_bits_[0] |= 0x00000001u;
3378 _impl_.codec_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3379 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.codec)
3380}
3381inline std::string* DCCLMessageOptions::mutable_codec() {
3382 std::string* _s = _internal_mutable_codec();
3383 // @@protoc_insertion_point(field_mutable:dccl.DCCLMessageOptions.codec)
3384 return _s;
3385}
3386inline const std::string& DCCLMessageOptions::_internal_codec() const {
3387 return _impl_.codec_.Get();
3388}
3389inline void DCCLMessageOptions::_internal_set_codec(const std::string& value) {
3390 _impl_._has_bits_[0] |= 0x00000001u;
3391 _impl_.codec_.Set(value, GetArenaForAllocation());
3392}
3393inline std::string* DCCLMessageOptions::_internal_mutable_codec() {
3394 _impl_._has_bits_[0] |= 0x00000001u;
3395 return _impl_.codec_.Mutable(GetArenaForAllocation());
3396}
3397inline std::string* DCCLMessageOptions::release_codec() {
3398 // @@protoc_insertion_point(field_release:dccl.DCCLMessageOptions.codec)
3399 if (!_internal_has_codec()) {
3400 return nullptr;
3401 }
3402 _impl_._has_bits_[0] &= ~0x00000001u;
3403 auto* p = _impl_.codec_.Release();
3404#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3405 if (_impl_.codec_.IsDefault()) {
3406 _impl_.codec_.Set("", GetArenaForAllocation());
3407 }
3408#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3409 return p;
3410}
3411inline void DCCLMessageOptions::set_allocated_codec(std::string* codec) {
3412 if (codec != nullptr) {
3413 _impl_._has_bits_[0] |= 0x00000001u;
3414 } else {
3415 _impl_._has_bits_[0] &= ~0x00000001u;
3416 }
3417 _impl_.codec_.SetAllocated(codec, GetArenaForAllocation());
3418#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3419 if (_impl_.codec_.IsDefault()) {
3420 _impl_.codec_.Set("", GetArenaForAllocation());
3421 }
3422#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3423 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLMessageOptions.codec)
3424}
3425
3426// optional string codec_group = 4;
3427inline bool DCCLMessageOptions::_internal_has_codec_group() const {
3428 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3429 return value;
3430}
3431inline bool DCCLMessageOptions::has_codec_group() const {
3432 return _internal_has_codec_group();
3433}
3434inline void DCCLMessageOptions::clear_codec_group() {
3435 _impl_.codec_group_.ClearToEmpty();
3436 _impl_._has_bits_[0] &= ~0x00000002u;
3437}
3438inline const std::string& DCCLMessageOptions::codec_group() const {
3439 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.codec_group)
3440 return _internal_codec_group();
3441}
3442template <typename ArgT0, typename... ArgT>
3443inline PROTOBUF_ALWAYS_INLINE
3444void DCCLMessageOptions::set_codec_group(ArgT0&& arg0, ArgT... args) {
3445 _impl_._has_bits_[0] |= 0x00000002u;
3446 _impl_.codec_group_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3447 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.codec_group)
3448}
3449inline std::string* DCCLMessageOptions::mutable_codec_group() {
3450 std::string* _s = _internal_mutable_codec_group();
3451 // @@protoc_insertion_point(field_mutable:dccl.DCCLMessageOptions.codec_group)
3452 return _s;
3453}
3454inline const std::string& DCCLMessageOptions::_internal_codec_group() const {
3455 return _impl_.codec_group_.Get();
3456}
3457inline void DCCLMessageOptions::_internal_set_codec_group(const std::string& value) {
3458 _impl_._has_bits_[0] |= 0x00000002u;
3459 _impl_.codec_group_.Set(value, GetArenaForAllocation());
3460}
3461inline std::string* DCCLMessageOptions::_internal_mutable_codec_group() {
3462 _impl_._has_bits_[0] |= 0x00000002u;
3463 return _impl_.codec_group_.Mutable(GetArenaForAllocation());
3464}
3465inline std::string* DCCLMessageOptions::release_codec_group() {
3466 // @@protoc_insertion_point(field_release:dccl.DCCLMessageOptions.codec_group)
3467 if (!_internal_has_codec_group()) {
3468 return nullptr;
3469 }
3470 _impl_._has_bits_[0] &= ~0x00000002u;
3471 auto* p = _impl_.codec_group_.Release();
3472#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3473 if (_impl_.codec_group_.IsDefault()) {
3474 _impl_.codec_group_.Set("", GetArenaForAllocation());
3475 }
3476#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3477 return p;
3478}
3479inline void DCCLMessageOptions::set_allocated_codec_group(std::string* codec_group) {
3480 if (codec_group != nullptr) {
3481 _impl_._has_bits_[0] |= 0x00000002u;
3482 } else {
3483 _impl_._has_bits_[0] &= ~0x00000002u;
3484 }
3485 _impl_.codec_group_.SetAllocated(codec_group, GetArenaForAllocation());
3486#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3487 if (_impl_.codec_group_.IsDefault()) {
3488 _impl_.codec_group_.Set("", GetArenaForAllocation());
3489 }
3490#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3491 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLMessageOptions.codec_group)
3492}
3493
3494// optional int32 codec_version = 5;
3495inline bool DCCLMessageOptions::_internal_has_codec_version() const {
3496 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
3497 return value;
3498}
3499inline bool DCCLMessageOptions::has_codec_version() const {
3500 return _internal_has_codec_version();
3501}
3502inline void DCCLMessageOptions::clear_codec_version() {
3503 _impl_.codec_version_ = 0;
3504 _impl_._has_bits_[0] &= ~0x00000020u;
3505}
3506inline int32_t DCCLMessageOptions::_internal_codec_version() const {
3507 return _impl_.codec_version_;
3508}
3509inline int32_t DCCLMessageOptions::codec_version() const {
3510 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.codec_version)
3511 return _internal_codec_version();
3512}
3513inline void DCCLMessageOptions::_internal_set_codec_version(int32_t value) {
3514 _impl_._has_bits_[0] |= 0x00000020u;
3515 _impl_.codec_version_ = value;
3516}
3517inline void DCCLMessageOptions::set_codec_version(int32_t value) {
3518 _internal_set_codec_version(value);
3519 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.codec_version)
3520}
3521
3522// optional bool omit_id = 10 [default = false];
3523inline bool DCCLMessageOptions::_internal_has_omit_id() const {
3524 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
3525 return value;
3526}
3527inline bool DCCLMessageOptions::has_omit_id() const {
3528 return _internal_has_omit_id();
3529}
3530inline void DCCLMessageOptions::clear_omit_id() {
3531 _impl_.omit_id_ = false;
3532 _impl_._has_bits_[0] &= ~0x00000040u;
3533}
3534inline bool DCCLMessageOptions::_internal_omit_id() const {
3535 return _impl_.omit_id_;
3536}
3537inline bool DCCLMessageOptions::omit_id() const {
3538 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.omit_id)
3539 return _internal_omit_id();
3540}
3541inline void DCCLMessageOptions::_internal_set_omit_id(bool value) {
3542 _impl_._has_bits_[0] |= 0x00000040u;
3543 _impl_.omit_id_ = value;
3544}
3545inline void DCCLMessageOptions::set_omit_id(bool value) {
3546 _internal_set_omit_id(value);
3547 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.omit_id)
3548}
3549
3550// optional string unit_system = 30 [default = "si"];
3551inline bool DCCLMessageOptions::_internal_has_unit_system() const {
3552 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3553 return value;
3554}
3555inline bool DCCLMessageOptions::has_unit_system() const {
3556 return _internal_has_unit_system();
3557}
3558inline void DCCLMessageOptions::clear_unit_system() {
3559 _impl_.unit_system_.ClearToDefault(::dccl::DCCLMessageOptions::Impl_::_i_give_permission_to_break_this_code_default_unit_system_, GetArenaForAllocation());
3560 _impl_._has_bits_[0] &= ~0x00000004u;
3561}
3562inline const std::string& DCCLMessageOptions::unit_system() const {
3563 // @@protoc_insertion_point(field_get:dccl.DCCLMessageOptions.unit_system)
3564 if (_impl_.unit_system_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_unit_system_.get();
3565 return _internal_unit_system();
3566}
3567template <typename ArgT0, typename... ArgT>
3568inline PROTOBUF_ALWAYS_INLINE
3569void DCCLMessageOptions::set_unit_system(ArgT0&& arg0, ArgT... args) {
3570 _impl_._has_bits_[0] |= 0x00000004u;
3571 _impl_.unit_system_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3572 // @@protoc_insertion_point(field_set:dccl.DCCLMessageOptions.unit_system)
3573}
3574inline std::string* DCCLMessageOptions::mutable_unit_system() {
3575 std::string* _s = _internal_mutable_unit_system();
3576 // @@protoc_insertion_point(field_mutable:dccl.DCCLMessageOptions.unit_system)
3577 return _s;
3578}
3579inline const std::string& DCCLMessageOptions::_internal_unit_system() const {
3580 return _impl_.unit_system_.Get();
3581}
3582inline void DCCLMessageOptions::_internal_set_unit_system(const std::string& value) {
3583 _impl_._has_bits_[0] |= 0x00000004u;
3584 _impl_.unit_system_.Set(value, GetArenaForAllocation());
3585}
3586inline std::string* DCCLMessageOptions::_internal_mutable_unit_system() {
3587 _impl_._has_bits_[0] |= 0x00000004u;
3588 return _impl_.unit_system_.Mutable(::dccl::DCCLMessageOptions::Impl_::_i_give_permission_to_break_this_code_default_unit_system_, GetArenaForAllocation());
3589}
3590inline std::string* DCCLMessageOptions::release_unit_system() {
3591 // @@protoc_insertion_point(field_release:dccl.DCCLMessageOptions.unit_system)
3592 if (!_internal_has_unit_system()) {
3593 return nullptr;
3594 }
3595 _impl_._has_bits_[0] &= ~0x00000004u;
3596 auto* p = _impl_.unit_system_.Release();
3597 return p;
3598}
3599inline void DCCLMessageOptions::set_allocated_unit_system(std::string* unit_system) {
3600 if (unit_system != nullptr) {
3601 _impl_._has_bits_[0] |= 0x00000004u;
3602 } else {
3603 _impl_._has_bits_[0] &= ~0x00000004u;
3604 }
3605 _impl_.unit_system_.SetAllocated(unit_system, GetArenaForAllocation());
3606 // @@protoc_insertion_point(field_set_allocated:dccl.DCCLMessageOptions.unit_system)
3607}
3608
3609#ifdef __GNUC__
3610 #pragma GCC diagnostic pop
3611#endif // __GNUC__
3612// -------------------------------------------------------------------
3613
3614// -------------------------------------------------------------------
3615
3616// -------------------------------------------------------------------
3617
3618// -------------------------------------------------------------------
3619
3620
3621// @@protoc_insertion_point(namespace_scope)
3622
3623} // namespace dccl
3624
3625// @@protoc_insertion_point(global_scope)
3626
3627#include <google/protobuf/port_undef.inc>
3628#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto
dccl::DCCLFieldOptions_Conditions
Definition option_extensions.pb.h:545
dccl::DCCLFieldOptions_Units_CustomUnit
Definition option_extensions.pb.h:77
dccl::DCCLFieldOptions_Units
Definition option_extensions.pb.h:262
dccl
Dynamic Compact Control Language namespace.
Definition any.h:47
TableStruct_dccl_2fapps_2fpb_5fplugin_2foption_5fextensions_2eproto
Definition option_extensions.pb.h:44