1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: google/protobuf/wrappers.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fwrappers_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fwrappers_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 3021004 < 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// @@protoc_insertion_point(includes)
34#include <google/protobuf/port_def.inc>
35#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fwrappers_2eproto PROTOBUF_EXPORT
36PROTOBUF_NAMESPACE_OPEN
37namespace internal {
38class AnyMetadata;
39} // namespace internal
40PROTOBUF_NAMESPACE_CLOSE
41
42// Internal implementation detail -- do not use these members.
43struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fwrappers_2eproto {
44 static const uint32_t offsets[];
45};
46PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fwrappers_2eproto;
47PROTOBUF_NAMESPACE_OPEN
48class BoolValue;
49struct BoolValueDefaultTypeInternal;
50PROTOBUF_EXPORT extern BoolValueDefaultTypeInternal _BoolValue_default_instance_;
51class BytesValue;
52struct BytesValueDefaultTypeInternal;
53PROTOBUF_EXPORT extern BytesValueDefaultTypeInternal _BytesValue_default_instance_;
54class DoubleValue;
55struct DoubleValueDefaultTypeInternal;
56PROTOBUF_EXPORT extern DoubleValueDefaultTypeInternal _DoubleValue_default_instance_;
57class FloatValue;
58struct FloatValueDefaultTypeInternal;
59PROTOBUF_EXPORT extern FloatValueDefaultTypeInternal _FloatValue_default_instance_;
60class Int32Value;
61struct Int32ValueDefaultTypeInternal;
62PROTOBUF_EXPORT extern Int32ValueDefaultTypeInternal _Int32Value_default_instance_;
63class Int64Value;
64struct Int64ValueDefaultTypeInternal;
65PROTOBUF_EXPORT extern Int64ValueDefaultTypeInternal _Int64Value_default_instance_;
66class StringValue;
67struct StringValueDefaultTypeInternal;
68PROTOBUF_EXPORT extern StringValueDefaultTypeInternal _StringValue_default_instance_;
69class UInt32Value;
70struct UInt32ValueDefaultTypeInternal;
71PROTOBUF_EXPORT extern UInt32ValueDefaultTypeInternal _UInt32Value_default_instance_;
72class UInt64Value;
73struct UInt64ValueDefaultTypeInternal;
74PROTOBUF_EXPORT extern UInt64ValueDefaultTypeInternal _UInt64Value_default_instance_;
75PROTOBUF_NAMESPACE_CLOSE
76PROTOBUF_NAMESPACE_OPEN
77template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BoolValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(Arena*);
78template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BytesValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BytesValue>(Arena*);
79template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DoubleValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DoubleValue>(Arena*);
80template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FloatValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FloatValue>(Arena*);
81template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int32Value>(Arena*);
82template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int64Value>(Arena*);
83template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::StringValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(Arena*);
84template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt32Value>(Arena*);
85template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt64Value>(Arena*);
86PROTOBUF_NAMESPACE_CLOSE
87PROTOBUF_NAMESPACE_OPEN
88
89// ===================================================================
90
91class PROTOBUF_EXPORT DoubleValue final :
92 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */ {
93 public:
94 inline DoubleValue() : DoubleValue(nullptr) {}
95 ~DoubleValue() override;
96 explicit PROTOBUF_CONSTEXPR DoubleValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
97
98 DoubleValue(const DoubleValue& from);
99 DoubleValue(DoubleValue&& from) noexcept
100 : DoubleValue() {
101 *this = ::std::move(from);
102 }
103
104 inline DoubleValue& operator=(const DoubleValue& from) {
105 CopyFrom(from);
106 return *this;
107 }
108 inline DoubleValue& operator=(DoubleValue&& from) noexcept {
109 if (this == &from) return *this;
110 if (GetOwningArena() == from.GetOwningArena()
111 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
112 && GetOwningArena() != nullptr
113 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
114 ) {
115 InternalSwap(other: &from);
116 } else {
117 CopyFrom(from);
118 }
119 return *this;
120 }
121
122 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
123 return GetDescriptor();
124 }
125 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
126 return default_instance().GetMetadata().descriptor;
127 }
128 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
129 return default_instance().GetMetadata().reflection;
130 }
131 static const DoubleValue& default_instance() {
132 return *internal_default_instance();
133 }
134 static inline const DoubleValue* internal_default_instance() {
135 return reinterpret_cast<const DoubleValue*>(
136 &_DoubleValue_default_instance_);
137 }
138 static constexpr int kIndexInFileMessages =
139 0;
140
141 friend void swap(DoubleValue& a, DoubleValue& b) {
142 a.Swap(other: &b);
143 }
144 inline void Swap(DoubleValue* other) {
145 if (other == this) return;
146 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
147 if (GetOwningArena() != nullptr &&
148 GetOwningArena() == other->GetOwningArena()) {
149 #else // PROTOBUF_FORCE_COPY_IN_SWAP
150 if (GetOwningArena() == other->GetOwningArena()) {
151 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
152 InternalSwap(other);
153 } else {
154 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
155 }
156 }
157 void UnsafeArenaSwap(DoubleValue* other) {
158 if (other == this) return;
159 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
160 InternalSwap(other);
161 }
162
163 // implements Message ----------------------------------------------
164
165 DoubleValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
166 return CreateMaybeMessage<DoubleValue>(arena);
167 }
168 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
169 void CopyFrom(const DoubleValue& from);
170 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
171 void MergeFrom( const DoubleValue& from) {
172 DoubleValue::MergeImpl(to_msg&: *this, from_msg: from);
173 }
174 private:
175 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
176 public:
177 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
178 bool IsInitialized() const final;
179
180 size_t ByteSizeLong() const final;
181 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
182 uint8_t* _InternalSerialize(
183 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
184 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
185
186 private:
187 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
188 void SharedDtor();
189 void SetCachedSize(int size) const final;
190 void InternalSwap(DoubleValue* other);
191
192 private:
193 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
194 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
195 return "google.protobuf.DoubleValue";
196 }
197 protected:
198 explicit DoubleValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
199 bool is_message_owned = false);
200 public:
201
202 static const ClassData _class_data_;
203 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
204
205 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
206
207 // nested types ----------------------------------------------------
208
209 // accessors -------------------------------------------------------
210
211 enum : int {
212 kValueFieldNumber = 1,
213 };
214 // double value = 1;
215 void clear_value();
216 double value() const;
217 void set_value(double value);
218 private:
219 double _internal_value() const;
220 void _internal_set_value(double value);
221 public:
222
223 // @@protoc_insertion_point(class_scope:google.protobuf.DoubleValue)
224 private:
225 class _Internal;
226
227 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
228 typedef void InternalArenaConstructable_;
229 typedef void DestructorSkippable_;
230 struct Impl_ {
231 double value_;
232 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
233 };
234 union { Impl_ _impl_; };
235 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
236};
237// -------------------------------------------------------------------
238
239class PROTOBUF_EXPORT FloatValue final :
240 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */ {
241 public:
242 inline FloatValue() : FloatValue(nullptr) {}
243 ~FloatValue() override;
244 explicit PROTOBUF_CONSTEXPR FloatValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
245
246 FloatValue(const FloatValue& from);
247 FloatValue(FloatValue&& from) noexcept
248 : FloatValue() {
249 *this = ::std::move(from);
250 }
251
252 inline FloatValue& operator=(const FloatValue& from) {
253 CopyFrom(from);
254 return *this;
255 }
256 inline FloatValue& operator=(FloatValue&& from) noexcept {
257 if (this == &from) return *this;
258 if (GetOwningArena() == from.GetOwningArena()
259 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
260 && GetOwningArena() != nullptr
261 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
262 ) {
263 InternalSwap(other: &from);
264 } else {
265 CopyFrom(from);
266 }
267 return *this;
268 }
269
270 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
271 return GetDescriptor();
272 }
273 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
274 return default_instance().GetMetadata().descriptor;
275 }
276 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
277 return default_instance().GetMetadata().reflection;
278 }
279 static const FloatValue& default_instance() {
280 return *internal_default_instance();
281 }
282 static inline const FloatValue* internal_default_instance() {
283 return reinterpret_cast<const FloatValue*>(
284 &_FloatValue_default_instance_);
285 }
286 static constexpr int kIndexInFileMessages =
287 1;
288
289 friend void swap(FloatValue& a, FloatValue& b) {
290 a.Swap(other: &b);
291 }
292 inline void Swap(FloatValue* other) {
293 if (other == this) return;
294 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
295 if (GetOwningArena() != nullptr &&
296 GetOwningArena() == other->GetOwningArena()) {
297 #else // PROTOBUF_FORCE_COPY_IN_SWAP
298 if (GetOwningArena() == other->GetOwningArena()) {
299 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
300 InternalSwap(other);
301 } else {
302 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
303 }
304 }
305 void UnsafeArenaSwap(FloatValue* other) {
306 if (other == this) return;
307 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
308 InternalSwap(other);
309 }
310
311 // implements Message ----------------------------------------------
312
313 FloatValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
314 return CreateMaybeMessage<FloatValue>(arena);
315 }
316 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
317 void CopyFrom(const FloatValue& from);
318 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
319 void MergeFrom( const FloatValue& from) {
320 FloatValue::MergeImpl(to_msg&: *this, from_msg: from);
321 }
322 private:
323 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
324 public:
325 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
326 bool IsInitialized() const final;
327
328 size_t ByteSizeLong() const final;
329 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
330 uint8_t* _InternalSerialize(
331 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
332 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
333
334 private:
335 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
336 void SharedDtor();
337 void SetCachedSize(int size) const final;
338 void InternalSwap(FloatValue* other);
339
340 private:
341 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
342 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
343 return "google.protobuf.FloatValue";
344 }
345 protected:
346 explicit FloatValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
347 bool is_message_owned = false);
348 public:
349
350 static const ClassData _class_data_;
351 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
352
353 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
354
355 // nested types ----------------------------------------------------
356
357 // accessors -------------------------------------------------------
358
359 enum : int {
360 kValueFieldNumber = 1,
361 };
362 // float value = 1;
363 void clear_value();
364 float value() const;
365 void set_value(float value);
366 private:
367 float _internal_value() const;
368 void _internal_set_value(float value);
369 public:
370
371 // @@protoc_insertion_point(class_scope:google.protobuf.FloatValue)
372 private:
373 class _Internal;
374
375 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
376 typedef void InternalArenaConstructable_;
377 typedef void DestructorSkippable_;
378 struct Impl_ {
379 float value_;
380 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
381 };
382 union { Impl_ _impl_; };
383 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
384};
385// -------------------------------------------------------------------
386
387class PROTOBUF_EXPORT Int64Value final :
388 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */ {
389 public:
390 inline Int64Value() : Int64Value(nullptr) {}
391 ~Int64Value() override;
392 explicit PROTOBUF_CONSTEXPR Int64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
393
394 Int64Value(const Int64Value& from);
395 Int64Value(Int64Value&& from) noexcept
396 : Int64Value() {
397 *this = ::std::move(from);
398 }
399
400 inline Int64Value& operator=(const Int64Value& from) {
401 CopyFrom(from);
402 return *this;
403 }
404 inline Int64Value& operator=(Int64Value&& from) noexcept {
405 if (this == &from) return *this;
406 if (GetOwningArena() == from.GetOwningArena()
407 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
408 && GetOwningArena() != nullptr
409 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
410 ) {
411 InternalSwap(other: &from);
412 } else {
413 CopyFrom(from);
414 }
415 return *this;
416 }
417
418 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
419 return GetDescriptor();
420 }
421 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
422 return default_instance().GetMetadata().descriptor;
423 }
424 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
425 return default_instance().GetMetadata().reflection;
426 }
427 static const Int64Value& default_instance() {
428 return *internal_default_instance();
429 }
430 static inline const Int64Value* internal_default_instance() {
431 return reinterpret_cast<const Int64Value*>(
432 &_Int64Value_default_instance_);
433 }
434 static constexpr int kIndexInFileMessages =
435 2;
436
437 friend void swap(Int64Value& a, Int64Value& b) {
438 a.Swap(other: &b);
439 }
440 inline void Swap(Int64Value* other) {
441 if (other == this) return;
442 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
443 if (GetOwningArena() != nullptr &&
444 GetOwningArena() == other->GetOwningArena()) {
445 #else // PROTOBUF_FORCE_COPY_IN_SWAP
446 if (GetOwningArena() == other->GetOwningArena()) {
447 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
448 InternalSwap(other);
449 } else {
450 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
451 }
452 }
453 void UnsafeArenaSwap(Int64Value* other) {
454 if (other == this) return;
455 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
456 InternalSwap(other);
457 }
458
459 // implements Message ----------------------------------------------
460
461 Int64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
462 return CreateMaybeMessage<Int64Value>(arena);
463 }
464 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
465 void CopyFrom(const Int64Value& from);
466 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
467 void MergeFrom( const Int64Value& from) {
468 Int64Value::MergeImpl(to_msg&: *this, from_msg: from);
469 }
470 private:
471 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
472 public:
473 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
474 bool IsInitialized() const final;
475
476 size_t ByteSizeLong() const final;
477 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
478 uint8_t* _InternalSerialize(
479 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
480 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
481
482 private:
483 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
484 void SharedDtor();
485 void SetCachedSize(int size) const final;
486 void InternalSwap(Int64Value* other);
487
488 private:
489 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
490 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
491 return "google.protobuf.Int64Value";
492 }
493 protected:
494 explicit Int64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
495 bool is_message_owned = false);
496 public:
497
498 static const ClassData _class_data_;
499 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
500
501 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
502
503 // nested types ----------------------------------------------------
504
505 // accessors -------------------------------------------------------
506
507 enum : int {
508 kValueFieldNumber = 1,
509 };
510 // int64 value = 1;
511 void clear_value();
512 int64_t value() const;
513 void set_value(int64_t value);
514 private:
515 int64_t _internal_value() const;
516 void _internal_set_value(int64_t value);
517 public:
518
519 // @@protoc_insertion_point(class_scope:google.protobuf.Int64Value)
520 private:
521 class _Internal;
522
523 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
524 typedef void InternalArenaConstructable_;
525 typedef void DestructorSkippable_;
526 struct Impl_ {
527 int64_t value_;
528 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
529 };
530 union { Impl_ _impl_; };
531 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
532};
533// -------------------------------------------------------------------
534
535class PROTOBUF_EXPORT UInt64Value final :
536 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */ {
537 public:
538 inline UInt64Value() : UInt64Value(nullptr) {}
539 ~UInt64Value() override;
540 explicit PROTOBUF_CONSTEXPR UInt64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
541
542 UInt64Value(const UInt64Value& from);
543 UInt64Value(UInt64Value&& from) noexcept
544 : UInt64Value() {
545 *this = ::std::move(from);
546 }
547
548 inline UInt64Value& operator=(const UInt64Value& from) {
549 CopyFrom(from);
550 return *this;
551 }
552 inline UInt64Value& operator=(UInt64Value&& from) noexcept {
553 if (this == &from) return *this;
554 if (GetOwningArena() == from.GetOwningArena()
555 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
556 && GetOwningArena() != nullptr
557 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
558 ) {
559 InternalSwap(other: &from);
560 } else {
561 CopyFrom(from);
562 }
563 return *this;
564 }
565
566 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
567 return GetDescriptor();
568 }
569 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
570 return default_instance().GetMetadata().descriptor;
571 }
572 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
573 return default_instance().GetMetadata().reflection;
574 }
575 static const UInt64Value& default_instance() {
576 return *internal_default_instance();
577 }
578 static inline const UInt64Value* internal_default_instance() {
579 return reinterpret_cast<const UInt64Value*>(
580 &_UInt64Value_default_instance_);
581 }
582 static constexpr int kIndexInFileMessages =
583 3;
584
585 friend void swap(UInt64Value& a, UInt64Value& b) {
586 a.Swap(other: &b);
587 }
588 inline void Swap(UInt64Value* other) {
589 if (other == this) return;
590 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
591 if (GetOwningArena() != nullptr &&
592 GetOwningArena() == other->GetOwningArena()) {
593 #else // PROTOBUF_FORCE_COPY_IN_SWAP
594 if (GetOwningArena() == other->GetOwningArena()) {
595 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
596 InternalSwap(other);
597 } else {
598 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
599 }
600 }
601 void UnsafeArenaSwap(UInt64Value* other) {
602 if (other == this) return;
603 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
604 InternalSwap(other);
605 }
606
607 // implements Message ----------------------------------------------
608
609 UInt64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
610 return CreateMaybeMessage<UInt64Value>(arena);
611 }
612 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
613 void CopyFrom(const UInt64Value& from);
614 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
615 void MergeFrom( const UInt64Value& from) {
616 UInt64Value::MergeImpl(to_msg&: *this, from_msg: from);
617 }
618 private:
619 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
620 public:
621 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
622 bool IsInitialized() const final;
623
624 size_t ByteSizeLong() const final;
625 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
626 uint8_t* _InternalSerialize(
627 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
628 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
629
630 private:
631 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
632 void SharedDtor();
633 void SetCachedSize(int size) const final;
634 void InternalSwap(UInt64Value* other);
635
636 private:
637 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
638 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
639 return "google.protobuf.UInt64Value";
640 }
641 protected:
642 explicit UInt64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
643 bool is_message_owned = false);
644 public:
645
646 static const ClassData _class_data_;
647 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
648
649 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
650
651 // nested types ----------------------------------------------------
652
653 // accessors -------------------------------------------------------
654
655 enum : int {
656 kValueFieldNumber = 1,
657 };
658 // uint64 value = 1;
659 void clear_value();
660 uint64_t value() const;
661 void set_value(uint64_t value);
662 private:
663 uint64_t _internal_value() const;
664 void _internal_set_value(uint64_t value);
665 public:
666
667 // @@protoc_insertion_point(class_scope:google.protobuf.UInt64Value)
668 private:
669 class _Internal;
670
671 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
672 typedef void InternalArenaConstructable_;
673 typedef void DestructorSkippable_;
674 struct Impl_ {
675 uint64_t value_;
676 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
677 };
678 union { Impl_ _impl_; };
679 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
680};
681// -------------------------------------------------------------------
682
683class PROTOBUF_EXPORT Int32Value final :
684 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */ {
685 public:
686 inline Int32Value() : Int32Value(nullptr) {}
687 ~Int32Value() override;
688 explicit PROTOBUF_CONSTEXPR Int32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
689
690 Int32Value(const Int32Value& from);
691 Int32Value(Int32Value&& from) noexcept
692 : Int32Value() {
693 *this = ::std::move(from);
694 }
695
696 inline Int32Value& operator=(const Int32Value& from) {
697 CopyFrom(from);
698 return *this;
699 }
700 inline Int32Value& operator=(Int32Value&& from) noexcept {
701 if (this == &from) return *this;
702 if (GetOwningArena() == from.GetOwningArena()
703 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
704 && GetOwningArena() != nullptr
705 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
706 ) {
707 InternalSwap(other: &from);
708 } else {
709 CopyFrom(from);
710 }
711 return *this;
712 }
713
714 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
715 return GetDescriptor();
716 }
717 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
718 return default_instance().GetMetadata().descriptor;
719 }
720 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
721 return default_instance().GetMetadata().reflection;
722 }
723 static const Int32Value& default_instance() {
724 return *internal_default_instance();
725 }
726 static inline const Int32Value* internal_default_instance() {
727 return reinterpret_cast<const Int32Value*>(
728 &_Int32Value_default_instance_);
729 }
730 static constexpr int kIndexInFileMessages =
731 4;
732
733 friend void swap(Int32Value& a, Int32Value& b) {
734 a.Swap(other: &b);
735 }
736 inline void Swap(Int32Value* other) {
737 if (other == this) return;
738 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
739 if (GetOwningArena() != nullptr &&
740 GetOwningArena() == other->GetOwningArena()) {
741 #else // PROTOBUF_FORCE_COPY_IN_SWAP
742 if (GetOwningArena() == other->GetOwningArena()) {
743 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
744 InternalSwap(other);
745 } else {
746 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
747 }
748 }
749 void UnsafeArenaSwap(Int32Value* other) {
750 if (other == this) return;
751 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
752 InternalSwap(other);
753 }
754
755 // implements Message ----------------------------------------------
756
757 Int32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
758 return CreateMaybeMessage<Int32Value>(arena);
759 }
760 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
761 void CopyFrom(const Int32Value& from);
762 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
763 void MergeFrom( const Int32Value& from) {
764 Int32Value::MergeImpl(to_msg&: *this, from_msg: from);
765 }
766 private:
767 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
768 public:
769 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
770 bool IsInitialized() const final;
771
772 size_t ByteSizeLong() const final;
773 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
774 uint8_t* _InternalSerialize(
775 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
776 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
777
778 private:
779 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
780 void SharedDtor();
781 void SetCachedSize(int size) const final;
782 void InternalSwap(Int32Value* other);
783
784 private:
785 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
786 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
787 return "google.protobuf.Int32Value";
788 }
789 protected:
790 explicit Int32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
791 bool is_message_owned = false);
792 public:
793
794 static const ClassData _class_data_;
795 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
796
797 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
798
799 // nested types ----------------------------------------------------
800
801 // accessors -------------------------------------------------------
802
803 enum : int {
804 kValueFieldNumber = 1,
805 };
806 // int32 value = 1;
807 void clear_value();
808 int32_t value() const;
809 void set_value(int32_t value);
810 private:
811 int32_t _internal_value() const;
812 void _internal_set_value(int32_t value);
813 public:
814
815 // @@protoc_insertion_point(class_scope:google.protobuf.Int32Value)
816 private:
817 class _Internal;
818
819 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
820 typedef void InternalArenaConstructable_;
821 typedef void DestructorSkippable_;
822 struct Impl_ {
823 int32_t value_;
824 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
825 };
826 union { Impl_ _impl_; };
827 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
828};
829// -------------------------------------------------------------------
830
831class PROTOBUF_EXPORT UInt32Value final :
832 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */ {
833 public:
834 inline UInt32Value() : UInt32Value(nullptr) {}
835 ~UInt32Value() override;
836 explicit PROTOBUF_CONSTEXPR UInt32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
837
838 UInt32Value(const UInt32Value& from);
839 UInt32Value(UInt32Value&& from) noexcept
840 : UInt32Value() {
841 *this = ::std::move(from);
842 }
843
844 inline UInt32Value& operator=(const UInt32Value& from) {
845 CopyFrom(from);
846 return *this;
847 }
848 inline UInt32Value& operator=(UInt32Value&& from) noexcept {
849 if (this == &from) return *this;
850 if (GetOwningArena() == from.GetOwningArena()
851 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
852 && GetOwningArena() != nullptr
853 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
854 ) {
855 InternalSwap(other: &from);
856 } else {
857 CopyFrom(from);
858 }
859 return *this;
860 }
861
862 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
863 return GetDescriptor();
864 }
865 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
866 return default_instance().GetMetadata().descriptor;
867 }
868 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
869 return default_instance().GetMetadata().reflection;
870 }
871 static const UInt32Value& default_instance() {
872 return *internal_default_instance();
873 }
874 static inline const UInt32Value* internal_default_instance() {
875 return reinterpret_cast<const UInt32Value*>(
876 &_UInt32Value_default_instance_);
877 }
878 static constexpr int kIndexInFileMessages =
879 5;
880
881 friend void swap(UInt32Value& a, UInt32Value& b) {
882 a.Swap(other: &b);
883 }
884 inline void Swap(UInt32Value* other) {
885 if (other == this) return;
886 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
887 if (GetOwningArena() != nullptr &&
888 GetOwningArena() == other->GetOwningArena()) {
889 #else // PROTOBUF_FORCE_COPY_IN_SWAP
890 if (GetOwningArena() == other->GetOwningArena()) {
891 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
892 InternalSwap(other);
893 } else {
894 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
895 }
896 }
897 void UnsafeArenaSwap(UInt32Value* other) {
898 if (other == this) return;
899 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
900 InternalSwap(other);
901 }
902
903 // implements Message ----------------------------------------------
904
905 UInt32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
906 return CreateMaybeMessage<UInt32Value>(arena);
907 }
908 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
909 void CopyFrom(const UInt32Value& from);
910 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
911 void MergeFrom( const UInt32Value& from) {
912 UInt32Value::MergeImpl(to_msg&: *this, from_msg: from);
913 }
914 private:
915 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
916 public:
917 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
918 bool IsInitialized() const final;
919
920 size_t ByteSizeLong() const final;
921 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
922 uint8_t* _InternalSerialize(
923 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
924 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
925
926 private:
927 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
928 void SharedDtor();
929 void SetCachedSize(int size) const final;
930 void InternalSwap(UInt32Value* other);
931
932 private:
933 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
934 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
935 return "google.protobuf.UInt32Value";
936 }
937 protected:
938 explicit UInt32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
939 bool is_message_owned = false);
940 public:
941
942 static const ClassData _class_data_;
943 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
944
945 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
946
947 // nested types ----------------------------------------------------
948
949 // accessors -------------------------------------------------------
950
951 enum : int {
952 kValueFieldNumber = 1,
953 };
954 // uint32 value = 1;
955 void clear_value();
956 uint32_t value() const;
957 void set_value(uint32_t value);
958 private:
959 uint32_t _internal_value() const;
960 void _internal_set_value(uint32_t value);
961 public:
962
963 // @@protoc_insertion_point(class_scope:google.protobuf.UInt32Value)
964 private:
965 class _Internal;
966
967 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
968 typedef void InternalArenaConstructable_;
969 typedef void DestructorSkippable_;
970 struct Impl_ {
971 uint32_t value_;
972 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
973 };
974 union { Impl_ _impl_; };
975 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
976};
977// -------------------------------------------------------------------
978
979class PROTOBUF_EXPORT BoolValue final :
980 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */ {
981 public:
982 inline BoolValue() : BoolValue(nullptr) {}
983 ~BoolValue() override;
984 explicit PROTOBUF_CONSTEXPR BoolValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
985
986 BoolValue(const BoolValue& from);
987 BoolValue(BoolValue&& from) noexcept
988 : BoolValue() {
989 *this = ::std::move(from);
990 }
991
992 inline BoolValue& operator=(const BoolValue& from) {
993 CopyFrom(from);
994 return *this;
995 }
996 inline BoolValue& operator=(BoolValue&& from) noexcept {
997 if (this == &from) return *this;
998 if (GetOwningArena() == from.GetOwningArena()
999 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1000 && GetOwningArena() != nullptr
1001 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1002 ) {
1003 InternalSwap(other: &from);
1004 } else {
1005 CopyFrom(from);
1006 }
1007 return *this;
1008 }
1009
1010 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1011 return GetDescriptor();
1012 }
1013 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1014 return default_instance().GetMetadata().descriptor;
1015 }
1016 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1017 return default_instance().GetMetadata().reflection;
1018 }
1019 static const BoolValue& default_instance() {
1020 return *internal_default_instance();
1021 }
1022 static inline const BoolValue* internal_default_instance() {
1023 return reinterpret_cast<const BoolValue*>(
1024 &_BoolValue_default_instance_);
1025 }
1026 static constexpr int kIndexInFileMessages =
1027 6;
1028
1029 friend void swap(BoolValue& a, BoolValue& b) {
1030 a.Swap(other: &b);
1031 }
1032 inline void Swap(BoolValue* other) {
1033 if (other == this) return;
1034 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1035 if (GetOwningArena() != nullptr &&
1036 GetOwningArena() == other->GetOwningArena()) {
1037 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1038 if (GetOwningArena() == other->GetOwningArena()) {
1039 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1040 InternalSwap(other);
1041 } else {
1042 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
1043 }
1044 }
1045 void UnsafeArenaSwap(BoolValue* other) {
1046 if (other == this) return;
1047 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1048 InternalSwap(other);
1049 }
1050
1051 // implements Message ----------------------------------------------
1052
1053 BoolValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1054 return CreateMaybeMessage<BoolValue>(arena);
1055 }
1056 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1057 void CopyFrom(const BoolValue& from);
1058 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1059 void MergeFrom( const BoolValue& from) {
1060 BoolValue::MergeImpl(to_msg&: *this, from_msg: from);
1061 }
1062 private:
1063 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1064 public:
1065 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1066 bool IsInitialized() const final;
1067
1068 size_t ByteSizeLong() const final;
1069 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1070 uint8_t* _InternalSerialize(
1071 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1072 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1073
1074 private:
1075 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1076 void SharedDtor();
1077 void SetCachedSize(int size) const final;
1078 void InternalSwap(BoolValue* other);
1079
1080 private:
1081 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1082 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1083 return "google.protobuf.BoolValue";
1084 }
1085 protected:
1086 explicit BoolValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1087 bool is_message_owned = false);
1088 public:
1089
1090 static const ClassData _class_data_;
1091 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1092
1093 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1094
1095 // nested types ----------------------------------------------------
1096
1097 // accessors -------------------------------------------------------
1098
1099 enum : int {
1100 kValueFieldNumber = 1,
1101 };
1102 // bool value = 1;
1103 void clear_value();
1104 bool value() const;
1105 void set_value(bool value);
1106 private:
1107 bool _internal_value() const;
1108 void _internal_set_value(bool value);
1109 public:
1110
1111 // @@protoc_insertion_point(class_scope:google.protobuf.BoolValue)
1112 private:
1113 class _Internal;
1114
1115 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1116 typedef void InternalArenaConstructable_;
1117 typedef void DestructorSkippable_;
1118 struct Impl_ {
1119 bool value_;
1120 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1121 };
1122 union { Impl_ _impl_; };
1123 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
1124};
1125// -------------------------------------------------------------------
1126
1127class PROTOBUF_EXPORT StringValue final :
1128 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */ {
1129 public:
1130 inline StringValue() : StringValue(nullptr) {}
1131 ~StringValue() override;
1132 explicit PROTOBUF_CONSTEXPR StringValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1133
1134 StringValue(const StringValue& from);
1135 StringValue(StringValue&& from) noexcept
1136 : StringValue() {
1137 *this = ::std::move(from);
1138 }
1139
1140 inline StringValue& operator=(const StringValue& from) {
1141 CopyFrom(from);
1142 return *this;
1143 }
1144 inline StringValue& operator=(StringValue&& from) noexcept {
1145 if (this == &from) return *this;
1146 if (GetOwningArena() == from.GetOwningArena()
1147 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1148 && GetOwningArena() != nullptr
1149 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1150 ) {
1151 InternalSwap(other: &from);
1152 } else {
1153 CopyFrom(from);
1154 }
1155 return *this;
1156 }
1157
1158 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1159 return GetDescriptor();
1160 }
1161 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1162 return default_instance().GetMetadata().descriptor;
1163 }
1164 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1165 return default_instance().GetMetadata().reflection;
1166 }
1167 static const StringValue& default_instance() {
1168 return *internal_default_instance();
1169 }
1170 static inline const StringValue* internal_default_instance() {
1171 return reinterpret_cast<const StringValue*>(
1172 &_StringValue_default_instance_);
1173 }
1174 static constexpr int kIndexInFileMessages =
1175 7;
1176
1177 friend void swap(StringValue& a, StringValue& b) {
1178 a.Swap(other: &b);
1179 }
1180 inline void Swap(StringValue* other) {
1181 if (other == this) return;
1182 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1183 if (GetOwningArena() != nullptr &&
1184 GetOwningArena() == other->GetOwningArena()) {
1185 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1186 if (GetOwningArena() == other->GetOwningArena()) {
1187 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1188 InternalSwap(other);
1189 } else {
1190 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
1191 }
1192 }
1193 void UnsafeArenaSwap(StringValue* other) {
1194 if (other == this) return;
1195 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1196 InternalSwap(other);
1197 }
1198
1199 // implements Message ----------------------------------------------
1200
1201 StringValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1202 return CreateMaybeMessage<StringValue>(arena);
1203 }
1204 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1205 void CopyFrom(const StringValue& from);
1206 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1207 void MergeFrom( const StringValue& from) {
1208 StringValue::MergeImpl(to_msg&: *this, from_msg: from);
1209 }
1210 private:
1211 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1212 public:
1213 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1214 bool IsInitialized() const final;
1215
1216 size_t ByteSizeLong() const final;
1217 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1218 uint8_t* _InternalSerialize(
1219 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1220 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1221
1222 private:
1223 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1224 void SharedDtor();
1225 void SetCachedSize(int size) const final;
1226 void InternalSwap(StringValue* other);
1227
1228 private:
1229 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1230 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1231 return "google.protobuf.StringValue";
1232 }
1233 protected:
1234 explicit StringValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1235 bool is_message_owned = false);
1236 public:
1237
1238 static const ClassData _class_data_;
1239 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1240
1241 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1242
1243 // nested types ----------------------------------------------------
1244
1245 // accessors -------------------------------------------------------
1246
1247 enum : int {
1248 kValueFieldNumber = 1,
1249 };
1250 // string value = 1;
1251 void clear_value();
1252 const std::string& value() const;
1253 template <typename ArgT0 = const std::string&, typename... ArgT>
1254 void set_value(ArgT0&& arg0, ArgT... args);
1255 std::string* mutable_value();
1256 PROTOBUF_NODISCARD std::string* release_value();
1257 void set_allocated_value(std::string* value);
1258 private:
1259 const std::string& _internal_value() const;
1260 inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
1261 std::string* _internal_mutable_value();
1262 public:
1263
1264 // @@protoc_insertion_point(class_scope:google.protobuf.StringValue)
1265 private:
1266 class _Internal;
1267
1268 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1269 typedef void InternalArenaConstructable_;
1270 typedef void DestructorSkippable_;
1271 struct Impl_ {
1272 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
1273 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1274 };
1275 union { Impl_ _impl_; };
1276 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
1277};
1278// -------------------------------------------------------------------
1279
1280class PROTOBUF_EXPORT BytesValue final :
1281 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */ {
1282 public:
1283 inline BytesValue() : BytesValue(nullptr) {}
1284 ~BytesValue() override;
1285 explicit PROTOBUF_CONSTEXPR BytesValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1286
1287 BytesValue(const BytesValue& from);
1288 BytesValue(BytesValue&& from) noexcept
1289 : BytesValue() {
1290 *this = ::std::move(from);
1291 }
1292
1293 inline BytesValue& operator=(const BytesValue& from) {
1294 CopyFrom(from);
1295 return *this;
1296 }
1297 inline BytesValue& operator=(BytesValue&& from) noexcept {
1298 if (this == &from) return *this;
1299 if (GetOwningArena() == from.GetOwningArena()
1300 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1301 && GetOwningArena() != nullptr
1302 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1303 ) {
1304 InternalSwap(other: &from);
1305 } else {
1306 CopyFrom(from);
1307 }
1308 return *this;
1309 }
1310
1311 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1312 return GetDescriptor();
1313 }
1314 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1315 return default_instance().GetMetadata().descriptor;
1316 }
1317 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1318 return default_instance().GetMetadata().reflection;
1319 }
1320 static const BytesValue& default_instance() {
1321 return *internal_default_instance();
1322 }
1323 static inline const BytesValue* internal_default_instance() {
1324 return reinterpret_cast<const BytesValue*>(
1325 &_BytesValue_default_instance_);
1326 }
1327 static constexpr int kIndexInFileMessages =
1328 8;
1329
1330 friend void swap(BytesValue& a, BytesValue& b) {
1331 a.Swap(other: &b);
1332 }
1333 inline void Swap(BytesValue* other) {
1334 if (other == this) return;
1335 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1336 if (GetOwningArena() != nullptr &&
1337 GetOwningArena() == other->GetOwningArena()) {
1338 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1339 if (GetOwningArena() == other->GetOwningArena()) {
1340 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1341 InternalSwap(other);
1342 } else {
1343 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
1344 }
1345 }
1346 void UnsafeArenaSwap(BytesValue* other) {
1347 if (other == this) return;
1348 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1349 InternalSwap(other);
1350 }
1351
1352 // implements Message ----------------------------------------------
1353
1354 BytesValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1355 return CreateMaybeMessage<BytesValue>(arena);
1356 }
1357 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1358 void CopyFrom(const BytesValue& from);
1359 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1360 void MergeFrom( const BytesValue& from) {
1361 BytesValue::MergeImpl(to_msg&: *this, from_msg: from);
1362 }
1363 private:
1364 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1365 public:
1366 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1367 bool IsInitialized() const final;
1368
1369 size_t ByteSizeLong() const final;
1370 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1371 uint8_t* _InternalSerialize(
1372 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1373 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1374
1375 private:
1376 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1377 void SharedDtor();
1378 void SetCachedSize(int size) const final;
1379 void InternalSwap(BytesValue* other);
1380
1381 private:
1382 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1383 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1384 return "google.protobuf.BytesValue";
1385 }
1386 protected:
1387 explicit BytesValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1388 bool is_message_owned = false);
1389 public:
1390
1391 static const ClassData _class_data_;
1392 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1393
1394 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1395
1396 // nested types ----------------------------------------------------
1397
1398 // accessors -------------------------------------------------------
1399
1400 enum : int {
1401 kValueFieldNumber = 1,
1402 };
1403 // bytes value = 1;
1404 void clear_value();
1405 const std::string& value() const;
1406 template <typename ArgT0 = const std::string&, typename... ArgT>
1407 void set_value(ArgT0&& arg0, ArgT... args);
1408 std::string* mutable_value();
1409 PROTOBUF_NODISCARD std::string* release_value();
1410 void set_allocated_value(std::string* value);
1411 private:
1412 const std::string& _internal_value() const;
1413 inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
1414 std::string* _internal_mutable_value();
1415 public:
1416
1417 // @@protoc_insertion_point(class_scope:google.protobuf.BytesValue)
1418 private:
1419 class _Internal;
1420
1421 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1422 typedef void InternalArenaConstructable_;
1423 typedef void DestructorSkippable_;
1424 struct Impl_ {
1425 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
1426 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1427 };
1428 union { Impl_ _impl_; };
1429 friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
1430};
1431// ===================================================================
1432
1433
1434// ===================================================================
1435
1436#ifdef __GNUC__
1437 #pragma GCC diagnostic push
1438 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1439#endif // __GNUC__
1440// DoubleValue
1441
1442// double value = 1;
1443inline void DoubleValue::clear_value() {
1444 _impl_.value_ = 0;
1445}
1446inline double DoubleValue::_internal_value() const {
1447 return _impl_.value_;
1448}
1449inline double DoubleValue::value() const {
1450 // @@protoc_insertion_point(field_get:google.protobuf.DoubleValue.value)
1451 return _internal_value();
1452}
1453inline void DoubleValue::_internal_set_value(double value) {
1454
1455 _impl_.value_ = value;
1456}
1457inline void DoubleValue::set_value(double value) {
1458 _internal_set_value(value);
1459 // @@protoc_insertion_point(field_set:google.protobuf.DoubleValue.value)
1460}
1461
1462// -------------------------------------------------------------------
1463
1464// FloatValue
1465
1466// float value = 1;
1467inline void FloatValue::clear_value() {
1468 _impl_.value_ = 0;
1469}
1470inline float FloatValue::_internal_value() const {
1471 return _impl_.value_;
1472}
1473inline float FloatValue::value() const {
1474 // @@protoc_insertion_point(field_get:google.protobuf.FloatValue.value)
1475 return _internal_value();
1476}
1477inline void FloatValue::_internal_set_value(float value) {
1478
1479 _impl_.value_ = value;
1480}
1481inline void FloatValue::set_value(float value) {
1482 _internal_set_value(value);
1483 // @@protoc_insertion_point(field_set:google.protobuf.FloatValue.value)
1484}
1485
1486// -------------------------------------------------------------------
1487
1488// Int64Value
1489
1490// int64 value = 1;
1491inline void Int64Value::clear_value() {
1492 _impl_.value_ = int64_t{0};
1493}
1494inline int64_t Int64Value::_internal_value() const {
1495 return _impl_.value_;
1496}
1497inline int64_t Int64Value::value() const {
1498 // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value)
1499 return _internal_value();
1500}
1501inline void Int64Value::_internal_set_value(int64_t value) {
1502
1503 _impl_.value_ = value;
1504}
1505inline void Int64Value::set_value(int64_t value) {
1506 _internal_set_value(value);
1507 // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value)
1508}
1509
1510// -------------------------------------------------------------------
1511
1512// UInt64Value
1513
1514// uint64 value = 1;
1515inline void UInt64Value::clear_value() {
1516 _impl_.value_ = uint64_t{0u};
1517}
1518inline uint64_t UInt64Value::_internal_value() const {
1519 return _impl_.value_;
1520}
1521inline uint64_t UInt64Value::value() const {
1522 // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value)
1523 return _internal_value();
1524}
1525inline void UInt64Value::_internal_set_value(uint64_t value) {
1526
1527 _impl_.value_ = value;
1528}
1529inline void UInt64Value::set_value(uint64_t value) {
1530 _internal_set_value(value);
1531 // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value)
1532}
1533
1534// -------------------------------------------------------------------
1535
1536// Int32Value
1537
1538// int32 value = 1;
1539inline void Int32Value::clear_value() {
1540 _impl_.value_ = 0;
1541}
1542inline int32_t Int32Value::_internal_value() const {
1543 return _impl_.value_;
1544}
1545inline int32_t Int32Value::value() const {
1546 // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value)
1547 return _internal_value();
1548}
1549inline void Int32Value::_internal_set_value(int32_t value) {
1550
1551 _impl_.value_ = value;
1552}
1553inline void Int32Value::set_value(int32_t value) {
1554 _internal_set_value(value);
1555 // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value)
1556}
1557
1558// -------------------------------------------------------------------
1559
1560// UInt32Value
1561
1562// uint32 value = 1;
1563inline void UInt32Value::clear_value() {
1564 _impl_.value_ = 0u;
1565}
1566inline uint32_t UInt32Value::_internal_value() const {
1567 return _impl_.value_;
1568}
1569inline uint32_t UInt32Value::value() const {
1570 // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value)
1571 return _internal_value();
1572}
1573inline void UInt32Value::_internal_set_value(uint32_t value) {
1574
1575 _impl_.value_ = value;
1576}
1577inline void UInt32Value::set_value(uint32_t value) {
1578 _internal_set_value(value);
1579 // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value)
1580}
1581
1582// -------------------------------------------------------------------
1583
1584// BoolValue
1585
1586// bool value = 1;
1587inline void BoolValue::clear_value() {
1588 _impl_.value_ = false;
1589}
1590inline bool BoolValue::_internal_value() const {
1591 return _impl_.value_;
1592}
1593inline bool BoolValue::value() const {
1594 // @@protoc_insertion_point(field_get:google.protobuf.BoolValue.value)
1595 return _internal_value();
1596}
1597inline void BoolValue::_internal_set_value(bool value) {
1598
1599 _impl_.value_ = value;
1600}
1601inline void BoolValue::set_value(bool value) {
1602 _internal_set_value(value);
1603 // @@protoc_insertion_point(field_set:google.protobuf.BoolValue.value)
1604}
1605
1606// -------------------------------------------------------------------
1607
1608// StringValue
1609
1610// string value = 1;
1611inline void StringValue::clear_value() {
1612 _impl_.value_.ClearToEmpty();
1613}
1614inline const std::string& StringValue::value() const {
1615 // @@protoc_insertion_point(field_get:google.protobuf.StringValue.value)
1616 return _internal_value();
1617}
1618template <typename ArgT0, typename... ArgT>
1619inline PROTOBUF_ALWAYS_INLINE
1620void StringValue::set_value(ArgT0&& arg0, ArgT... args) {
1621
1622 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1623 // @@protoc_insertion_point(field_set:google.protobuf.StringValue.value)
1624}
1625inline std::string* StringValue::mutable_value() {
1626 std::string* _s = _internal_mutable_value();
1627 // @@protoc_insertion_point(field_mutable:google.protobuf.StringValue.value)
1628 return _s;
1629}
1630inline const std::string& StringValue::_internal_value() const {
1631 return _impl_.value_.Get();
1632}
1633inline void StringValue::_internal_set_value(const std::string& value) {
1634
1635 _impl_.value_.Set(value, arena: GetArenaForAllocation());
1636}
1637inline std::string* StringValue::_internal_mutable_value() {
1638
1639 return _impl_.value_.Mutable(arena: GetArenaForAllocation());
1640}
1641inline std::string* StringValue::release_value() {
1642 // @@protoc_insertion_point(field_release:google.protobuf.StringValue.value)
1643 return _impl_.value_.Release();
1644}
1645inline void StringValue::set_allocated_value(std::string* value) {
1646 if (value != nullptr) {
1647
1648 } else {
1649
1650 }
1651 _impl_.value_.SetAllocated(value, arena: GetArenaForAllocation());
1652#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1653 if (_impl_.value_.IsDefault()) {
1654 _impl_.value_.Set("", GetArenaForAllocation());
1655 }
1656#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1657 // @@protoc_insertion_point(field_set_allocated:google.protobuf.StringValue.value)
1658}
1659
1660// -------------------------------------------------------------------
1661
1662// BytesValue
1663
1664// bytes value = 1;
1665inline void BytesValue::clear_value() {
1666 _impl_.value_.ClearToEmpty();
1667}
1668inline const std::string& BytesValue::value() const {
1669 // @@protoc_insertion_point(field_get:google.protobuf.BytesValue.value)
1670 return _internal_value();
1671}
1672template <typename ArgT0, typename... ArgT>
1673inline PROTOBUF_ALWAYS_INLINE
1674void BytesValue::set_value(ArgT0&& arg0, ArgT... args) {
1675
1676 _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1677 // @@protoc_insertion_point(field_set:google.protobuf.BytesValue.value)
1678}
1679inline std::string* BytesValue::mutable_value() {
1680 std::string* _s = _internal_mutable_value();
1681 // @@protoc_insertion_point(field_mutable:google.protobuf.BytesValue.value)
1682 return _s;
1683}
1684inline const std::string& BytesValue::_internal_value() const {
1685 return _impl_.value_.Get();
1686}
1687inline void BytesValue::_internal_set_value(const std::string& value) {
1688
1689 _impl_.value_.Set(value, arena: GetArenaForAllocation());
1690}
1691inline std::string* BytesValue::_internal_mutable_value() {
1692
1693 return _impl_.value_.Mutable(arena: GetArenaForAllocation());
1694}
1695inline std::string* BytesValue::release_value() {
1696 // @@protoc_insertion_point(field_release:google.protobuf.BytesValue.value)
1697 return _impl_.value_.Release();
1698}
1699inline void BytesValue::set_allocated_value(std::string* value) {
1700 if (value != nullptr) {
1701
1702 } else {
1703
1704 }
1705 _impl_.value_.SetAllocated(value, arena: GetArenaForAllocation());
1706#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1707 if (_impl_.value_.IsDefault()) {
1708 _impl_.value_.Set("", GetArenaForAllocation());
1709 }
1710#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1711 // @@protoc_insertion_point(field_set_allocated:google.protobuf.BytesValue.value)
1712}
1713
1714#ifdef __GNUC__
1715 #pragma GCC diagnostic pop
1716#endif // __GNUC__
1717// -------------------------------------------------------------------
1718
1719// -------------------------------------------------------------------
1720
1721// -------------------------------------------------------------------
1722
1723// -------------------------------------------------------------------
1724
1725// -------------------------------------------------------------------
1726
1727// -------------------------------------------------------------------
1728
1729// -------------------------------------------------------------------
1730
1731// -------------------------------------------------------------------
1732
1733
1734// @@protoc_insertion_point(namespace_scope)
1735
1736PROTOBUF_NAMESPACE_CLOSE
1737
1738// @@protoc_insertion_point(global_scope)
1739
1740#include <google/protobuf/port_undef.inc>
1741#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fwrappers_2eproto
1742