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