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