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