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