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