1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: structured_data.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_structured_5fdata_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_structured_5fdata_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/message_lite.h>
29 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
30 #include <google/protobuf/extension_set.h> // IWYU pragma: export
31 #include <google/protobuf/generated_enum_util.h>
32 // @@protoc_insertion_point(includes)
33 #include <google/protobuf/port_def.inc>
34 #define PROTOBUF_INTERNAL_EXPORT_structured_5fdata_2eproto
35 PROTOBUF_NAMESPACE_OPEN
36 namespace internal {
37 class AnyMetadata;
38 } // namespace internal
39 PROTOBUF_NAMESPACE_CLOSE
40
41 // Internal implementation detail -- do not use these members.
42 struct TableStruct_structured_5fdata_2eproto {
43 static const uint32_t offsets[];
44 };
45 namespace metrics {
46 class StructuredDataProto;
47 struct StructuredDataProtoDefaultTypeInternal;
48 extern StructuredDataProtoDefaultTypeInternal _StructuredDataProto_default_instance_;
49 class StructuredEventProto;
50 struct StructuredEventProtoDefaultTypeInternal;
51 extern StructuredEventProtoDefaultTypeInternal _StructuredEventProto_default_instance_;
52 class StructuredEventProto_EventSequenceMetadata;
53 struct StructuredEventProto_EventSequenceMetadataDefaultTypeInternal;
54 extern StructuredEventProto_EventSequenceMetadataDefaultTypeInternal _StructuredEventProto_EventSequenceMetadata_default_instance_;
55 class StructuredEventProto_Metric;
56 struct StructuredEventProto_MetricDefaultTypeInternal;
57 extern StructuredEventProto_MetricDefaultTypeInternal _StructuredEventProto_Metric_default_instance_;
58 class StructuredEventProto_Metric_RepeatedInt64;
59 struct StructuredEventProto_Metric_RepeatedInt64DefaultTypeInternal;
60 extern StructuredEventProto_Metric_RepeatedInt64DefaultTypeInternal _StructuredEventProto_Metric_RepeatedInt64_default_instance_;
61 } // namespace metrics
62 PROTOBUF_NAMESPACE_OPEN
63 template<> ::metrics::StructuredDataProto* Arena::CreateMaybeMessage<::metrics::StructuredDataProto>(Arena*);
64 template<> ::metrics::StructuredEventProto* Arena::CreateMaybeMessage<::metrics::StructuredEventProto>(Arena*);
65 template<> ::metrics::StructuredEventProto_EventSequenceMetadata* Arena::CreateMaybeMessage<::metrics::StructuredEventProto_EventSequenceMetadata>(Arena*);
66 template<> ::metrics::StructuredEventProto_Metric* Arena::CreateMaybeMessage<::metrics::StructuredEventProto_Metric>(Arena*);
67 template<> ::metrics::StructuredEventProto_Metric_RepeatedInt64* Arena::CreateMaybeMessage<::metrics::StructuredEventProto_Metric_RepeatedInt64>(Arena*);
68 PROTOBUF_NAMESPACE_CLOSE
69 namespace metrics {
70
71 enum StructuredEventProto_EventType : int {
72 StructuredEventProto_EventType_UNKNOWN = 0,
73 StructuredEventProto_EventType_REGULAR = 1,
74 StructuredEventProto_EventType_RAW_STRING = 2,
75 StructuredEventProto_EventType_SEQUENCE = 3
76 };
77 bool StructuredEventProto_EventType_IsValid(int value);
78 constexpr StructuredEventProto_EventType StructuredEventProto_EventType_EventType_MIN = StructuredEventProto_EventType_UNKNOWN;
79 constexpr StructuredEventProto_EventType StructuredEventProto_EventType_EventType_MAX = StructuredEventProto_EventType_SEQUENCE;
80 constexpr int StructuredEventProto_EventType_EventType_ARRAYSIZE = StructuredEventProto_EventType_EventType_MAX + 1;
81
82 const std::string& StructuredEventProto_EventType_Name(StructuredEventProto_EventType value);
83 template<typename T>
StructuredEventProto_EventType_Name(T enum_t_value)84 inline const std::string& StructuredEventProto_EventType_Name(T enum_t_value) {
85 static_assert(::std::is_same<T, StructuredEventProto_EventType>::value ||
86 ::std::is_integral<T>::value,
87 "Incorrect type passed to function StructuredEventProto_EventType_Name.");
88 return StructuredEventProto_EventType_Name(static_cast<StructuredEventProto_EventType>(enum_t_value));
89 }
90 bool StructuredEventProto_EventType_Parse(
91 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StructuredEventProto_EventType* value);
92 enum StructuredEventProto_PrimaryUserSegment : int {
93 StructuredEventProto_PrimaryUserSegment_UNKNOWN_PRIMARY_USER_TYPE = 0,
94 StructuredEventProto_PrimaryUserSegment_UNMANAGED = 1,
95 StructuredEventProto_PrimaryUserSegment_K12 = 2,
96 StructuredEventProto_PrimaryUserSegment_UNIVERSITY = 3,
97 StructuredEventProto_PrimaryUserSegment_NON_PROFIT = 4,
98 StructuredEventProto_PrimaryUserSegment_ENTERPRISE_ORGANIZATION = 5,
99 StructuredEventProto_PrimaryUserSegment_KIOS_APP = 6,
100 StructuredEventProto_PrimaryUserSegment_MANAGED_GUEST_SESSION = 7,
101 StructuredEventProto_PrimaryUserSegment_DEMO_MODE = 8
102 };
103 bool StructuredEventProto_PrimaryUserSegment_IsValid(int value);
104 constexpr StructuredEventProto_PrimaryUserSegment StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_MIN = StructuredEventProto_PrimaryUserSegment_UNKNOWN_PRIMARY_USER_TYPE;
105 constexpr StructuredEventProto_PrimaryUserSegment StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_MAX = StructuredEventProto_PrimaryUserSegment_DEMO_MODE;
106 constexpr int StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_ARRAYSIZE = StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_MAX + 1;
107
108 const std::string& StructuredEventProto_PrimaryUserSegment_Name(StructuredEventProto_PrimaryUserSegment value);
109 template<typename T>
StructuredEventProto_PrimaryUserSegment_Name(T enum_t_value)110 inline const std::string& StructuredEventProto_PrimaryUserSegment_Name(T enum_t_value) {
111 static_assert(::std::is_same<T, StructuredEventProto_PrimaryUserSegment>::value ||
112 ::std::is_integral<T>::value,
113 "Incorrect type passed to function StructuredEventProto_PrimaryUserSegment_Name.");
114 return StructuredEventProto_PrimaryUserSegment_Name(static_cast<StructuredEventProto_PrimaryUserSegment>(enum_t_value));
115 }
116 bool StructuredEventProto_PrimaryUserSegment_Parse(
117 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StructuredEventProto_PrimaryUserSegment* value);
118 enum StructuredDataProto_DeviceSegment : int {
119 StructuredDataProto_DeviceSegment_UNKNOWN = 0,
120 StructuredDataProto_DeviceSegment_CONSUMER = 1,
121 StructuredDataProto_DeviceSegment_EDUCATION = 2,
122 StructuredDataProto_DeviceSegment_ENTERPRISE = 3
123 };
124 bool StructuredDataProto_DeviceSegment_IsValid(int value);
125 constexpr StructuredDataProto_DeviceSegment StructuredDataProto_DeviceSegment_DeviceSegment_MIN = StructuredDataProto_DeviceSegment_UNKNOWN;
126 constexpr StructuredDataProto_DeviceSegment StructuredDataProto_DeviceSegment_DeviceSegment_MAX = StructuredDataProto_DeviceSegment_ENTERPRISE;
127 constexpr int StructuredDataProto_DeviceSegment_DeviceSegment_ARRAYSIZE = StructuredDataProto_DeviceSegment_DeviceSegment_MAX + 1;
128
129 const std::string& StructuredDataProto_DeviceSegment_Name(StructuredDataProto_DeviceSegment value);
130 template<typename T>
StructuredDataProto_DeviceSegment_Name(T enum_t_value)131 inline const std::string& StructuredDataProto_DeviceSegment_Name(T enum_t_value) {
132 static_assert(::std::is_same<T, StructuredDataProto_DeviceSegment>::value ||
133 ::std::is_integral<T>::value,
134 "Incorrect type passed to function StructuredDataProto_DeviceSegment_Name.");
135 return StructuredDataProto_DeviceSegment_Name(static_cast<StructuredDataProto_DeviceSegment>(enum_t_value));
136 }
137 bool StructuredDataProto_DeviceSegment_Parse(
138 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StructuredDataProto_DeviceSegment* value);
139 // ===================================================================
140
141 class StructuredEventProto_Metric_RepeatedInt64 final :
142 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.StructuredEventProto.Metric.RepeatedInt64) */ {
143 public:
StructuredEventProto_Metric_RepeatedInt64()144 inline StructuredEventProto_Metric_RepeatedInt64() : StructuredEventProto_Metric_RepeatedInt64(nullptr) {}
145 ~StructuredEventProto_Metric_RepeatedInt64() override;
146 explicit PROTOBUF_CONSTEXPR StructuredEventProto_Metric_RepeatedInt64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
147
148 StructuredEventProto_Metric_RepeatedInt64(const StructuredEventProto_Metric_RepeatedInt64& from);
StructuredEventProto_Metric_RepeatedInt64(StructuredEventProto_Metric_RepeatedInt64 && from)149 StructuredEventProto_Metric_RepeatedInt64(StructuredEventProto_Metric_RepeatedInt64&& from) noexcept
150 : StructuredEventProto_Metric_RepeatedInt64() {
151 *this = ::std::move(from);
152 }
153
154 inline StructuredEventProto_Metric_RepeatedInt64& operator=(const StructuredEventProto_Metric_RepeatedInt64& from) {
155 CopyFrom(from);
156 return *this;
157 }
158 inline StructuredEventProto_Metric_RepeatedInt64& operator=(StructuredEventProto_Metric_RepeatedInt64&& from) noexcept {
159 if (this == &from) return *this;
160 if (GetOwningArena() == from.GetOwningArena()
161 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
162 && GetOwningArena() != nullptr
163 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
164 ) {
165 InternalSwap(&from);
166 } else {
167 CopyFrom(from);
168 }
169 return *this;
170 }
171
unknown_fields()172 inline const std::string& unknown_fields() const {
173 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
174 }
mutable_unknown_fields()175 inline std::string* mutable_unknown_fields() {
176 return _internal_metadata_.mutable_unknown_fields<std::string>();
177 }
178
default_instance()179 static const StructuredEventProto_Metric_RepeatedInt64& default_instance() {
180 return *internal_default_instance();
181 }
internal_default_instance()182 static inline const StructuredEventProto_Metric_RepeatedInt64* internal_default_instance() {
183 return reinterpret_cast<const StructuredEventProto_Metric_RepeatedInt64*>(
184 &_StructuredEventProto_Metric_RepeatedInt64_default_instance_);
185 }
186 static constexpr int kIndexInFileMessages =
187 0;
188
swap(StructuredEventProto_Metric_RepeatedInt64 & a,StructuredEventProto_Metric_RepeatedInt64 & b)189 friend void swap(StructuredEventProto_Metric_RepeatedInt64& a, StructuredEventProto_Metric_RepeatedInt64& b) {
190 a.Swap(&b);
191 }
Swap(StructuredEventProto_Metric_RepeatedInt64 * other)192 PROTOBUF_NOINLINE void Swap(StructuredEventProto_Metric_RepeatedInt64* other) {
193 if (other == this) return;
194 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
195 if (GetOwningArena() != nullptr &&
196 GetOwningArena() == other->GetOwningArena()) {
197 #else // PROTOBUF_FORCE_COPY_IN_SWAP
198 if (GetOwningArena() == other->GetOwningArena()) {
199 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
200 InternalSwap(other);
201 } else {
202 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
203 }
204 }
205 void UnsafeArenaSwap(StructuredEventProto_Metric_RepeatedInt64* other) {
206 if (other == this) return;
207 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
208 InternalSwap(other);
209 }
210
211 // implements Message ----------------------------------------------
212
213 StructuredEventProto_Metric_RepeatedInt64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
214 return CreateMaybeMessage<StructuredEventProto_Metric_RepeatedInt64>(arena);
215 }
216 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
217 void CopyFrom(const StructuredEventProto_Metric_RepeatedInt64& from);
218 void MergeFrom(const StructuredEventProto_Metric_RepeatedInt64& from);
219 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
220 bool IsInitialized() const final;
221
222 size_t ByteSizeLong() const final;
223 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
224 uint8_t* _InternalSerialize(
225 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
226 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
227
228 private:
229 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
230 void SharedDtor();
231 void SetCachedSize(int size) const;
232 void InternalSwap(StructuredEventProto_Metric_RepeatedInt64* other);
233
234 private:
235 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
236 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
237 return "metrics.StructuredEventProto.Metric.RepeatedInt64";
238 }
239 protected:
240 explicit StructuredEventProto_Metric_RepeatedInt64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
241 bool is_message_owned = false);
242 public:
243
244 std::string GetTypeName() const final;
245
246 // nested types ----------------------------------------------------
247
248 // accessors -------------------------------------------------------
249
250 enum : int {
251 kValuesFieldNumber = 1,
252 };
253 // repeated int64 values = 1 [packed = true];
254 int values_size() const;
255 private:
256 int _internal_values_size() const;
257 public:
258 void clear_values();
259 private:
260 int64_t _internal_values(int index) const;
261 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
262 _internal_values() const;
263 void _internal_add_values(int64_t value);
264 ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
265 _internal_mutable_values();
266 public:
267 int64_t values(int index) const;
268 void set_values(int index, int64_t value);
269 void add_values(int64_t value);
270 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
271 values() const;
272 ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
273 mutable_values();
274
275 // @@protoc_insertion_point(class_scope:metrics.StructuredEventProto.Metric.RepeatedInt64)
276 private:
277 class _Internal;
278
279 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
280 typedef void InternalArenaConstructable_;
281 typedef void DestructorSkippable_;
282 struct Impl_ {
283 ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > values_;
284 mutable std::atomic<int> _values_cached_byte_size_;
285 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
286 };
287 union { Impl_ _impl_; };
288 friend struct ::TableStruct_structured_5fdata_2eproto;
289 };
290 // -------------------------------------------------------------------
291
292 class StructuredEventProto_Metric final :
293 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.StructuredEventProto.Metric) */ {
294 public:
StructuredEventProto_Metric()295 inline StructuredEventProto_Metric() : StructuredEventProto_Metric(nullptr) {}
296 ~StructuredEventProto_Metric() override;
297 explicit PROTOBUF_CONSTEXPR StructuredEventProto_Metric(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
298
299 StructuredEventProto_Metric(const StructuredEventProto_Metric& from);
StructuredEventProto_Metric(StructuredEventProto_Metric && from)300 StructuredEventProto_Metric(StructuredEventProto_Metric&& from) noexcept
301 : StructuredEventProto_Metric() {
302 *this = ::std::move(from);
303 }
304
305 inline StructuredEventProto_Metric& operator=(const StructuredEventProto_Metric& from) {
306 CopyFrom(from);
307 return *this;
308 }
309 inline StructuredEventProto_Metric& operator=(StructuredEventProto_Metric&& from) noexcept {
310 if (this == &from) return *this;
311 if (GetOwningArena() == from.GetOwningArena()
312 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
313 && GetOwningArena() != nullptr
314 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
315 ) {
316 InternalSwap(&from);
317 } else {
318 CopyFrom(from);
319 }
320 return *this;
321 }
322
unknown_fields()323 inline const std::string& unknown_fields() const {
324 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
325 }
mutable_unknown_fields()326 inline std::string* mutable_unknown_fields() {
327 return _internal_metadata_.mutable_unknown_fields<std::string>();
328 }
329
default_instance()330 static const StructuredEventProto_Metric& default_instance() {
331 return *internal_default_instance();
332 }
333 enum ValueCase {
334 kValueHmac = 2,
335 kValueInt64 = 3,
336 kValueString = 4,
337 kValueDouble = 5,
338 kValueRepeatedInt64 = 6,
339 VALUE_NOT_SET = 0,
340 };
341
internal_default_instance()342 static inline const StructuredEventProto_Metric* internal_default_instance() {
343 return reinterpret_cast<const StructuredEventProto_Metric*>(
344 &_StructuredEventProto_Metric_default_instance_);
345 }
346 static constexpr int kIndexInFileMessages =
347 1;
348
swap(StructuredEventProto_Metric & a,StructuredEventProto_Metric & b)349 friend void swap(StructuredEventProto_Metric& a, StructuredEventProto_Metric& b) {
350 a.Swap(&b);
351 }
Swap(StructuredEventProto_Metric * other)352 PROTOBUF_NOINLINE void Swap(StructuredEventProto_Metric* other) {
353 if (other == this) return;
354 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
355 if (GetOwningArena() != nullptr &&
356 GetOwningArena() == other->GetOwningArena()) {
357 #else // PROTOBUF_FORCE_COPY_IN_SWAP
358 if (GetOwningArena() == other->GetOwningArena()) {
359 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
360 InternalSwap(other);
361 } else {
362 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
363 }
364 }
365 void UnsafeArenaSwap(StructuredEventProto_Metric* other) {
366 if (other == this) return;
367 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
368 InternalSwap(other);
369 }
370
371 // implements Message ----------------------------------------------
372
373 StructuredEventProto_Metric* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
374 return CreateMaybeMessage<StructuredEventProto_Metric>(arena);
375 }
376 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
377 void CopyFrom(const StructuredEventProto_Metric& from);
378 void MergeFrom(const StructuredEventProto_Metric& from);
379 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
380 bool IsInitialized() const final;
381
382 size_t ByteSizeLong() const final;
383 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
384 uint8_t* _InternalSerialize(
385 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
386 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
387
388 private:
389 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
390 void SharedDtor();
391 void SetCachedSize(int size) const;
392 void InternalSwap(StructuredEventProto_Metric* other);
393
394 private:
395 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
396 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
397 return "metrics.StructuredEventProto.Metric";
398 }
399 protected:
400 explicit StructuredEventProto_Metric(::PROTOBUF_NAMESPACE_ID::Arena* arena,
401 bool is_message_owned = false);
402 public:
403
404 std::string GetTypeName() const final;
405
406 // nested types ----------------------------------------------------
407
408 typedef StructuredEventProto_Metric_RepeatedInt64 RepeatedInt64;
409
410 // accessors -------------------------------------------------------
411
412 enum : int {
413 kNameHashFieldNumber = 1,
414 kValueHmacFieldNumber = 2,
415 kValueInt64FieldNumber = 3,
416 kValueStringFieldNumber = 4,
417 kValueDoubleFieldNumber = 5,
418 kValueRepeatedInt64FieldNumber = 6,
419 };
420 // optional fixed64 name_hash = 1;
421 bool has_name_hash() const;
422 private:
423 bool _internal_has_name_hash() const;
424 public:
425 void clear_name_hash();
426 uint64_t name_hash() const;
427 void set_name_hash(uint64_t value);
428 private:
429 uint64_t _internal_name_hash() const;
430 void _internal_set_name_hash(uint64_t value);
431 public:
432
433 // fixed64 value_hmac = 2;
434 bool has_value_hmac() const;
435 private:
436 bool _internal_has_value_hmac() const;
437 public:
438 void clear_value_hmac();
439 uint64_t value_hmac() const;
440 void set_value_hmac(uint64_t value);
441 private:
442 uint64_t _internal_value_hmac() const;
443 void _internal_set_value_hmac(uint64_t value);
444 public:
445
446 // int64 value_int64 = 3;
447 bool has_value_int64() const;
448 private:
449 bool _internal_has_value_int64() const;
450 public:
451 void clear_value_int64();
452 int64_t value_int64() const;
453 void set_value_int64(int64_t value);
454 private:
455 int64_t _internal_value_int64() const;
456 void _internal_set_value_int64(int64_t value);
457 public:
458
459 // string value_string = 4;
460 bool has_value_string() const;
461 private:
462 bool _internal_has_value_string() const;
463 public:
464 void clear_value_string();
465 const std::string& value_string() const;
466 template <typename ArgT0 = const std::string&, typename... ArgT>
467 void set_value_string(ArgT0&& arg0, ArgT... args);
468 std::string* mutable_value_string();
469 PROTOBUF_NODISCARD std::string* release_value_string();
470 void set_allocated_value_string(std::string* value_string);
471 private:
472 const std::string& _internal_value_string() const;
473 inline PROTOBUF_ALWAYS_INLINE void _internal_set_value_string(const std::string& value);
474 std::string* _internal_mutable_value_string();
475 public:
476
477 // double value_double = 5;
478 bool has_value_double() const;
479 private:
480 bool _internal_has_value_double() const;
481 public:
482 void clear_value_double();
483 double value_double() const;
484 void set_value_double(double value);
485 private:
486 double _internal_value_double() const;
487 void _internal_set_value_double(double value);
488 public:
489
490 // .metrics.StructuredEventProto.Metric.RepeatedInt64 value_repeated_int64 = 6;
491 bool has_value_repeated_int64() const;
492 private:
493 bool _internal_has_value_repeated_int64() const;
494 public:
495 void clear_value_repeated_int64();
496 const ::metrics::StructuredEventProto_Metric_RepeatedInt64& value_repeated_int64() const;
497 PROTOBUF_NODISCARD ::metrics::StructuredEventProto_Metric_RepeatedInt64* release_value_repeated_int64();
498 ::metrics::StructuredEventProto_Metric_RepeatedInt64* mutable_value_repeated_int64();
499 void set_allocated_value_repeated_int64(::metrics::StructuredEventProto_Metric_RepeatedInt64* value_repeated_int64);
500 private:
501 const ::metrics::StructuredEventProto_Metric_RepeatedInt64& _internal_value_repeated_int64() const;
502 ::metrics::StructuredEventProto_Metric_RepeatedInt64* _internal_mutable_value_repeated_int64();
503 public:
504 void unsafe_arena_set_allocated_value_repeated_int64(
505 ::metrics::StructuredEventProto_Metric_RepeatedInt64* value_repeated_int64);
506 ::metrics::StructuredEventProto_Metric_RepeatedInt64* unsafe_arena_release_value_repeated_int64();
507
508 void clear_value();
509 ValueCase value_case() const;
510 // @@protoc_insertion_point(class_scope:metrics.StructuredEventProto.Metric)
511 private:
512 class _Internal;
513 void set_has_value_hmac();
514 void set_has_value_int64();
515 void set_has_value_string();
516 void set_has_value_double();
517 void set_has_value_repeated_int64();
518
519 inline bool has_value() const;
520 inline void clear_has_value();
521
522 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
523 typedef void InternalArenaConstructable_;
524 typedef void DestructorSkippable_;
525 struct Impl_ {
526 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
527 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
528 uint64_t name_hash_;
529 union ValueUnion {
530 constexpr ValueUnion() : _constinit_{} {}
531 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
532 uint64_t value_hmac_;
533 int64_t value_int64_;
534 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_string_;
535 double value_double_;
536 ::metrics::StructuredEventProto_Metric_RepeatedInt64* value_repeated_int64_;
537 } value_;
538 uint32_t _oneof_case_[1];
539
540 };
541 union { Impl_ _impl_; };
542 friend struct ::TableStruct_structured_5fdata_2eproto;
543 };
544 // -------------------------------------------------------------------
545
546 class StructuredEventProto_EventSequenceMetadata final :
547 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.StructuredEventProto.EventSequenceMetadata) */ {
548 public:
StructuredEventProto_EventSequenceMetadata()549 inline StructuredEventProto_EventSequenceMetadata() : StructuredEventProto_EventSequenceMetadata(nullptr) {}
550 ~StructuredEventProto_EventSequenceMetadata() override;
551 explicit PROTOBUF_CONSTEXPR StructuredEventProto_EventSequenceMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
552
553 StructuredEventProto_EventSequenceMetadata(const StructuredEventProto_EventSequenceMetadata& from);
StructuredEventProto_EventSequenceMetadata(StructuredEventProto_EventSequenceMetadata && from)554 StructuredEventProto_EventSequenceMetadata(StructuredEventProto_EventSequenceMetadata&& from) noexcept
555 : StructuredEventProto_EventSequenceMetadata() {
556 *this = ::std::move(from);
557 }
558
559 inline StructuredEventProto_EventSequenceMetadata& operator=(const StructuredEventProto_EventSequenceMetadata& from) {
560 CopyFrom(from);
561 return *this;
562 }
563 inline StructuredEventProto_EventSequenceMetadata& operator=(StructuredEventProto_EventSequenceMetadata&& from) noexcept {
564 if (this == &from) return *this;
565 if (GetOwningArena() == from.GetOwningArena()
566 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
567 && GetOwningArena() != nullptr
568 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
569 ) {
570 InternalSwap(&from);
571 } else {
572 CopyFrom(from);
573 }
574 return *this;
575 }
576
unknown_fields()577 inline const std::string& unknown_fields() const {
578 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
579 }
mutable_unknown_fields()580 inline std::string* mutable_unknown_fields() {
581 return _internal_metadata_.mutable_unknown_fields<std::string>();
582 }
583
default_instance()584 static const StructuredEventProto_EventSequenceMetadata& default_instance() {
585 return *internal_default_instance();
586 }
internal_default_instance()587 static inline const StructuredEventProto_EventSequenceMetadata* internal_default_instance() {
588 return reinterpret_cast<const StructuredEventProto_EventSequenceMetadata*>(
589 &_StructuredEventProto_EventSequenceMetadata_default_instance_);
590 }
591 static constexpr int kIndexInFileMessages =
592 2;
593
swap(StructuredEventProto_EventSequenceMetadata & a,StructuredEventProto_EventSequenceMetadata & b)594 friend void swap(StructuredEventProto_EventSequenceMetadata& a, StructuredEventProto_EventSequenceMetadata& b) {
595 a.Swap(&b);
596 }
Swap(StructuredEventProto_EventSequenceMetadata * other)597 PROTOBUF_NOINLINE void Swap(StructuredEventProto_EventSequenceMetadata* other) {
598 if (other == this) return;
599 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
600 if (GetOwningArena() != nullptr &&
601 GetOwningArena() == other->GetOwningArena()) {
602 #else // PROTOBUF_FORCE_COPY_IN_SWAP
603 if (GetOwningArena() == other->GetOwningArena()) {
604 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
605 InternalSwap(other);
606 } else {
607 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
608 }
609 }
610 void UnsafeArenaSwap(StructuredEventProto_EventSequenceMetadata* other) {
611 if (other == this) return;
612 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
613 InternalSwap(other);
614 }
615
616 // implements Message ----------------------------------------------
617
618 StructuredEventProto_EventSequenceMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
619 return CreateMaybeMessage<StructuredEventProto_EventSequenceMetadata>(arena);
620 }
621 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
622 void CopyFrom(const StructuredEventProto_EventSequenceMetadata& from);
623 void MergeFrom(const StructuredEventProto_EventSequenceMetadata& from);
624 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
625 bool IsInitialized() const final;
626
627 size_t ByteSizeLong() const final;
628 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
629 uint8_t* _InternalSerialize(
630 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
631 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
632
633 private:
634 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
635 void SharedDtor();
636 void SetCachedSize(int size) const;
637 void InternalSwap(StructuredEventProto_EventSequenceMetadata* other);
638
639 private:
640 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
641 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
642 return "metrics.StructuredEventProto.EventSequenceMetadata";
643 }
644 protected:
645 explicit StructuredEventProto_EventSequenceMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
646 bool is_message_owned = false);
647 public:
648
649 std::string GetTypeName() const final;
650
651 // nested types ----------------------------------------------------
652
653 // accessors -------------------------------------------------------
654
655 enum : int {
656 kEventUniqueIdFieldNumber = 1,
657 kSystemUptimeFieldNumber = 2,
658 kResetCounterFieldNumber = 3,
659 kClientIdRotationWeeksFieldNumber = 4,
660 kPrimaryUserSegmentFieldNumber = 5,
661 };
662 // optional fixed64 event_unique_id = 1;
663 bool has_event_unique_id() const;
664 private:
665 bool _internal_has_event_unique_id() const;
666 public:
667 void clear_event_unique_id();
668 uint64_t event_unique_id() const;
669 void set_event_unique_id(uint64_t value);
670 private:
671 uint64_t _internal_event_unique_id() const;
672 void _internal_set_event_unique_id(uint64_t value);
673 public:
674
675 // optional int64 system_uptime = 2;
676 bool has_system_uptime() const;
677 private:
678 bool _internal_has_system_uptime() const;
679 public:
680 void clear_system_uptime();
681 int64_t system_uptime() const;
682 void set_system_uptime(int64_t value);
683 private:
684 int64_t _internal_system_uptime() const;
685 void _internal_set_system_uptime(int64_t value);
686 public:
687
688 // optional int64 reset_counter = 3;
689 bool has_reset_counter() const;
690 private:
691 bool _internal_has_reset_counter() const;
692 public:
693 void clear_reset_counter();
694 int64_t reset_counter() const;
695 void set_reset_counter(int64_t value);
696 private:
697 int64_t _internal_reset_counter() const;
698 void _internal_set_reset_counter(int64_t value);
699 public:
700
701 // optional uint32 client_id_rotation_weeks = 4;
702 bool has_client_id_rotation_weeks() const;
703 private:
704 bool _internal_has_client_id_rotation_weeks() const;
705 public:
706 void clear_client_id_rotation_weeks();
707 uint32_t client_id_rotation_weeks() const;
708 void set_client_id_rotation_weeks(uint32_t value);
709 private:
710 uint32_t _internal_client_id_rotation_weeks() const;
711 void _internal_set_client_id_rotation_weeks(uint32_t value);
712 public:
713
714 // optional .metrics.StructuredEventProto.PrimaryUserSegment primary_user_segment = 5;
715 bool has_primary_user_segment() const;
716 private:
717 bool _internal_has_primary_user_segment() const;
718 public:
719 void clear_primary_user_segment();
720 ::metrics::StructuredEventProto_PrimaryUserSegment primary_user_segment() const;
721 void set_primary_user_segment(::metrics::StructuredEventProto_PrimaryUserSegment value);
722 private:
723 ::metrics::StructuredEventProto_PrimaryUserSegment _internal_primary_user_segment() const;
724 void _internal_set_primary_user_segment(::metrics::StructuredEventProto_PrimaryUserSegment value);
725 public:
726
727 // @@protoc_insertion_point(class_scope:metrics.StructuredEventProto.EventSequenceMetadata)
728 private:
729 class _Internal;
730
731 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
732 typedef void InternalArenaConstructable_;
733 typedef void DestructorSkippable_;
734 struct Impl_ {
735 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
736 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
737 uint64_t event_unique_id_;
738 int64_t system_uptime_;
739 int64_t reset_counter_;
740 uint32_t client_id_rotation_weeks_;
741 int primary_user_segment_;
742 };
743 union { Impl_ _impl_; };
744 friend struct ::TableStruct_structured_5fdata_2eproto;
745 };
746 // -------------------------------------------------------------------
747
748 class StructuredEventProto final :
749 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.StructuredEventProto) */ {
750 public:
StructuredEventProto()751 inline StructuredEventProto() : StructuredEventProto(nullptr) {}
752 ~StructuredEventProto() override;
753 explicit PROTOBUF_CONSTEXPR StructuredEventProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
754
755 StructuredEventProto(const StructuredEventProto& from);
StructuredEventProto(StructuredEventProto && from)756 StructuredEventProto(StructuredEventProto&& from) noexcept
757 : StructuredEventProto() {
758 *this = ::std::move(from);
759 }
760
761 inline StructuredEventProto& operator=(const StructuredEventProto& from) {
762 CopyFrom(from);
763 return *this;
764 }
765 inline StructuredEventProto& operator=(StructuredEventProto&& from) noexcept {
766 if (this == &from) return *this;
767 if (GetOwningArena() == from.GetOwningArena()
768 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
769 && GetOwningArena() != nullptr
770 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
771 ) {
772 InternalSwap(&from);
773 } else {
774 CopyFrom(from);
775 }
776 return *this;
777 }
778
unknown_fields()779 inline const std::string& unknown_fields() const {
780 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
781 }
mutable_unknown_fields()782 inline std::string* mutable_unknown_fields() {
783 return _internal_metadata_.mutable_unknown_fields<std::string>();
784 }
785
default_instance()786 static const StructuredEventProto& default_instance() {
787 return *internal_default_instance();
788 }
internal_default_instance()789 static inline const StructuredEventProto* internal_default_instance() {
790 return reinterpret_cast<const StructuredEventProto*>(
791 &_StructuredEventProto_default_instance_);
792 }
793 static constexpr int kIndexInFileMessages =
794 3;
795
swap(StructuredEventProto & a,StructuredEventProto & b)796 friend void swap(StructuredEventProto& a, StructuredEventProto& b) {
797 a.Swap(&b);
798 }
Swap(StructuredEventProto * other)799 PROTOBUF_NOINLINE void Swap(StructuredEventProto* other) {
800 if (other == this) return;
801 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
802 if (GetOwningArena() != nullptr &&
803 GetOwningArena() == other->GetOwningArena()) {
804 #else // PROTOBUF_FORCE_COPY_IN_SWAP
805 if (GetOwningArena() == other->GetOwningArena()) {
806 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
807 InternalSwap(other);
808 } else {
809 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
810 }
811 }
812 void UnsafeArenaSwap(StructuredEventProto* other) {
813 if (other == this) return;
814 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
815 InternalSwap(other);
816 }
817
818 // implements Message ----------------------------------------------
819
820 StructuredEventProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
821 return CreateMaybeMessage<StructuredEventProto>(arena);
822 }
823 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
824 void CopyFrom(const StructuredEventProto& from);
825 void MergeFrom(const StructuredEventProto& from);
826 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
827 bool IsInitialized() const final;
828
829 size_t ByteSizeLong() const final;
830 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
831 uint8_t* _InternalSerialize(
832 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
833 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
834
835 private:
836 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
837 void SharedDtor();
838 void SetCachedSize(int size) const;
839 void InternalSwap(StructuredEventProto* other);
840
841 private:
842 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
843 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
844 return "metrics.StructuredEventProto";
845 }
846 protected:
847 explicit StructuredEventProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
848 bool is_message_owned = false);
849 public:
850
851 std::string GetTypeName() const final;
852
853 // nested types ----------------------------------------------------
854
855 typedef StructuredEventProto_Metric Metric;
856 typedef StructuredEventProto_EventSequenceMetadata EventSequenceMetadata;
857
858 typedef StructuredEventProto_EventType EventType;
859 static constexpr EventType UNKNOWN =
860 StructuredEventProto_EventType_UNKNOWN;
861 static constexpr EventType REGULAR =
862 StructuredEventProto_EventType_REGULAR;
863 static constexpr EventType RAW_STRING =
864 StructuredEventProto_EventType_RAW_STRING;
865 static constexpr EventType SEQUENCE =
866 StructuredEventProto_EventType_SEQUENCE;
867 static inline bool EventType_IsValid(int value) {
868 return StructuredEventProto_EventType_IsValid(value);
869 }
870 static constexpr EventType EventType_MIN =
871 StructuredEventProto_EventType_EventType_MIN;
872 static constexpr EventType EventType_MAX =
873 StructuredEventProto_EventType_EventType_MAX;
874 static constexpr int EventType_ARRAYSIZE =
875 StructuredEventProto_EventType_EventType_ARRAYSIZE;
876 template<typename T>
877 static inline const std::string& EventType_Name(T enum_t_value) {
878 static_assert(::std::is_same<T, EventType>::value ||
879 ::std::is_integral<T>::value,
880 "Incorrect type passed to function EventType_Name.");
881 return StructuredEventProto_EventType_Name(enum_t_value);
882 }
883 static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
884 EventType* value) {
885 return StructuredEventProto_EventType_Parse(name, value);
886 }
887
888 typedef StructuredEventProto_PrimaryUserSegment PrimaryUserSegment;
889 static constexpr PrimaryUserSegment UNKNOWN_PRIMARY_USER_TYPE =
890 StructuredEventProto_PrimaryUserSegment_UNKNOWN_PRIMARY_USER_TYPE;
891 static constexpr PrimaryUserSegment UNMANAGED =
892 StructuredEventProto_PrimaryUserSegment_UNMANAGED;
893 static constexpr PrimaryUserSegment K12 =
894 StructuredEventProto_PrimaryUserSegment_K12;
895 static constexpr PrimaryUserSegment UNIVERSITY =
896 StructuredEventProto_PrimaryUserSegment_UNIVERSITY;
897 static constexpr PrimaryUserSegment NON_PROFIT =
898 StructuredEventProto_PrimaryUserSegment_NON_PROFIT;
899 static constexpr PrimaryUserSegment ENTERPRISE_ORGANIZATION =
900 StructuredEventProto_PrimaryUserSegment_ENTERPRISE_ORGANIZATION;
901 static constexpr PrimaryUserSegment KIOS_APP =
902 StructuredEventProto_PrimaryUserSegment_KIOS_APP;
903 static constexpr PrimaryUserSegment MANAGED_GUEST_SESSION =
904 StructuredEventProto_PrimaryUserSegment_MANAGED_GUEST_SESSION;
905 static constexpr PrimaryUserSegment DEMO_MODE =
906 StructuredEventProto_PrimaryUserSegment_DEMO_MODE;
907 static inline bool PrimaryUserSegment_IsValid(int value) {
908 return StructuredEventProto_PrimaryUserSegment_IsValid(value);
909 }
910 static constexpr PrimaryUserSegment PrimaryUserSegment_MIN =
911 StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_MIN;
912 static constexpr PrimaryUserSegment PrimaryUserSegment_MAX =
913 StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_MAX;
914 static constexpr int PrimaryUserSegment_ARRAYSIZE =
915 StructuredEventProto_PrimaryUserSegment_PrimaryUserSegment_ARRAYSIZE;
916 template<typename T>
917 static inline const std::string& PrimaryUserSegment_Name(T enum_t_value) {
918 static_assert(::std::is_same<T, PrimaryUserSegment>::value ||
919 ::std::is_integral<T>::value,
920 "Incorrect type passed to function PrimaryUserSegment_Name.");
921 return StructuredEventProto_PrimaryUserSegment_Name(enum_t_value);
922 }
923 static inline bool PrimaryUserSegment_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
924 PrimaryUserSegment* value) {
925 return StructuredEventProto_PrimaryUserSegment_Parse(name, value);
926 }
927
928 // accessors -------------------------------------------------------
929
930 enum : int {
931 kMetricsFieldNumber = 3,
932 kEventSequenceMetadataFieldNumber = 6,
933 kProfileEventIdFieldNumber = 1,
934 kEventNameHashFieldNumber = 2,
935 kProjectNameHashFieldNumber = 5,
936 kUserProjectIdFieldNumber = 7,
937 kDeviceProjectIdFieldNumber = 8,
938 kEventTypeFieldNumber = 4,
939 };
940 // repeated .metrics.StructuredEventProto.Metric metrics = 3;
941 int metrics_size() const;
942 private:
943 int _internal_metrics_size() const;
944 public:
945 void clear_metrics();
946 ::metrics::StructuredEventProto_Metric* mutable_metrics(int index);
947 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto_Metric >*
948 mutable_metrics();
949 private:
950 const ::metrics::StructuredEventProto_Metric& _internal_metrics(int index) const;
951 ::metrics::StructuredEventProto_Metric* _internal_add_metrics();
952 public:
953 const ::metrics::StructuredEventProto_Metric& metrics(int index) const;
954 ::metrics::StructuredEventProto_Metric* add_metrics();
955 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto_Metric >&
956 metrics() const;
957
958 // optional .metrics.StructuredEventProto.EventSequenceMetadata event_sequence_metadata = 6;
959 bool has_event_sequence_metadata() const;
960 private:
961 bool _internal_has_event_sequence_metadata() const;
962 public:
963 void clear_event_sequence_metadata();
964 const ::metrics::StructuredEventProto_EventSequenceMetadata& event_sequence_metadata() const;
965 PROTOBUF_NODISCARD ::metrics::StructuredEventProto_EventSequenceMetadata* release_event_sequence_metadata();
966 ::metrics::StructuredEventProto_EventSequenceMetadata* mutable_event_sequence_metadata();
967 void set_allocated_event_sequence_metadata(::metrics::StructuredEventProto_EventSequenceMetadata* event_sequence_metadata);
968 private:
969 const ::metrics::StructuredEventProto_EventSequenceMetadata& _internal_event_sequence_metadata() const;
970 ::metrics::StructuredEventProto_EventSequenceMetadata* _internal_mutable_event_sequence_metadata();
971 public:
972 void unsafe_arena_set_allocated_event_sequence_metadata(
973 ::metrics::StructuredEventProto_EventSequenceMetadata* event_sequence_metadata);
974 ::metrics::StructuredEventProto_EventSequenceMetadata* unsafe_arena_release_event_sequence_metadata();
975
976 // optional fixed64 profile_event_id = 1;
977 bool has_profile_event_id() const;
978 private:
979 bool _internal_has_profile_event_id() const;
980 public:
981 void clear_profile_event_id();
982 uint64_t profile_event_id() const;
983 void set_profile_event_id(uint64_t value);
984 private:
985 uint64_t _internal_profile_event_id() const;
986 void _internal_set_profile_event_id(uint64_t value);
987 public:
988
989 // optional fixed64 event_name_hash = 2;
990 bool has_event_name_hash() const;
991 private:
992 bool _internal_has_event_name_hash() const;
993 public:
994 void clear_event_name_hash();
995 uint64_t event_name_hash() const;
996 void set_event_name_hash(uint64_t value);
997 private:
998 uint64_t _internal_event_name_hash() const;
999 void _internal_set_event_name_hash(uint64_t value);
1000 public:
1001
1002 // optional fixed64 project_name_hash = 5;
1003 bool has_project_name_hash() const;
1004 private:
1005 bool _internal_has_project_name_hash() const;
1006 public:
1007 void clear_project_name_hash();
1008 uint64_t project_name_hash() const;
1009 void set_project_name_hash(uint64_t value);
1010 private:
1011 uint64_t _internal_project_name_hash() const;
1012 void _internal_set_project_name_hash(uint64_t value);
1013 public:
1014
1015 // optional fixed64 user_project_id = 7;
1016 bool has_user_project_id() const;
1017 private:
1018 bool _internal_has_user_project_id() const;
1019 public:
1020 void clear_user_project_id();
1021 uint64_t user_project_id() const;
1022 void set_user_project_id(uint64_t value);
1023 private:
1024 uint64_t _internal_user_project_id() const;
1025 void _internal_set_user_project_id(uint64_t value);
1026 public:
1027
1028 // optional fixed64 device_project_id = 8;
1029 bool has_device_project_id() const;
1030 private:
1031 bool _internal_has_device_project_id() const;
1032 public:
1033 void clear_device_project_id();
1034 uint64_t device_project_id() const;
1035 void set_device_project_id(uint64_t value);
1036 private:
1037 uint64_t _internal_device_project_id() const;
1038 void _internal_set_device_project_id(uint64_t value);
1039 public:
1040
1041 // optional .metrics.StructuredEventProto.EventType event_type = 4;
1042 bool has_event_type() const;
1043 private:
1044 bool _internal_has_event_type() const;
1045 public:
1046 void clear_event_type();
1047 ::metrics::StructuredEventProto_EventType event_type() const;
1048 void set_event_type(::metrics::StructuredEventProto_EventType value);
1049 private:
1050 ::metrics::StructuredEventProto_EventType _internal_event_type() const;
1051 void _internal_set_event_type(::metrics::StructuredEventProto_EventType value);
1052 public:
1053
1054 // @@protoc_insertion_point(class_scope:metrics.StructuredEventProto)
1055 private:
1056 class _Internal;
1057
1058 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1059 typedef void InternalArenaConstructable_;
1060 typedef void DestructorSkippable_;
1061 struct Impl_ {
1062 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1063 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1064 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto_Metric > metrics_;
1065 ::metrics::StructuredEventProto_EventSequenceMetadata* event_sequence_metadata_;
1066 uint64_t profile_event_id_;
1067 uint64_t event_name_hash_;
1068 uint64_t project_name_hash_;
1069 uint64_t user_project_id_;
1070 uint64_t device_project_id_;
1071 int event_type_;
1072 };
1073 union { Impl_ _impl_; };
1074 friend struct ::TableStruct_structured_5fdata_2eproto;
1075 };
1076 // -------------------------------------------------------------------
1077
1078 class StructuredDataProto final :
1079 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.StructuredDataProto) */ {
1080 public:
StructuredDataProto()1081 inline StructuredDataProto() : StructuredDataProto(nullptr) {}
1082 ~StructuredDataProto() override;
1083 explicit PROTOBUF_CONSTEXPR StructuredDataProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1084
1085 StructuredDataProto(const StructuredDataProto& from);
StructuredDataProto(StructuredDataProto && from)1086 StructuredDataProto(StructuredDataProto&& from) noexcept
1087 : StructuredDataProto() {
1088 *this = ::std::move(from);
1089 }
1090
1091 inline StructuredDataProto& operator=(const StructuredDataProto& from) {
1092 CopyFrom(from);
1093 return *this;
1094 }
1095 inline StructuredDataProto& operator=(StructuredDataProto&& from) noexcept {
1096 if (this == &from) return *this;
1097 if (GetOwningArena() == from.GetOwningArena()
1098 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1099 && GetOwningArena() != nullptr
1100 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1101 ) {
1102 InternalSwap(&from);
1103 } else {
1104 CopyFrom(from);
1105 }
1106 return *this;
1107 }
1108
unknown_fields()1109 inline const std::string& unknown_fields() const {
1110 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1111 }
mutable_unknown_fields()1112 inline std::string* mutable_unknown_fields() {
1113 return _internal_metadata_.mutable_unknown_fields<std::string>();
1114 }
1115
default_instance()1116 static const StructuredDataProto& default_instance() {
1117 return *internal_default_instance();
1118 }
internal_default_instance()1119 static inline const StructuredDataProto* internal_default_instance() {
1120 return reinterpret_cast<const StructuredDataProto*>(
1121 &_StructuredDataProto_default_instance_);
1122 }
1123 static constexpr int kIndexInFileMessages =
1124 4;
1125
swap(StructuredDataProto & a,StructuredDataProto & b)1126 friend void swap(StructuredDataProto& a, StructuredDataProto& b) {
1127 a.Swap(&b);
1128 }
Swap(StructuredDataProto * other)1129 PROTOBUF_NOINLINE void Swap(StructuredDataProto* other) {
1130 if (other == this) return;
1131 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1132 if (GetOwningArena() != nullptr &&
1133 GetOwningArena() == other->GetOwningArena()) {
1134 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1135 if (GetOwningArena() == other->GetOwningArena()) {
1136 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1137 InternalSwap(other);
1138 } else {
1139 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1140 }
1141 }
1142 void UnsafeArenaSwap(StructuredDataProto* other) {
1143 if (other == this) return;
1144 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1145 InternalSwap(other);
1146 }
1147
1148 // implements Message ----------------------------------------------
1149
1150 StructuredDataProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1151 return CreateMaybeMessage<StructuredDataProto>(arena);
1152 }
1153 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1154 void CopyFrom(const StructuredDataProto& from);
1155 void MergeFrom(const StructuredDataProto& from);
1156 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1157 bool IsInitialized() const final;
1158
1159 size_t ByteSizeLong() const final;
1160 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1161 uint8_t* _InternalSerialize(
1162 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1163 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1164
1165 private:
1166 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1167 void SharedDtor();
1168 void SetCachedSize(int size) const;
1169 void InternalSwap(StructuredDataProto* other);
1170
1171 private:
1172 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1173 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1174 return "metrics.StructuredDataProto";
1175 }
1176 protected:
1177 explicit StructuredDataProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1178 bool is_message_owned = false);
1179 public:
1180
1181 std::string GetTypeName() const final;
1182
1183 // nested types ----------------------------------------------------
1184
1185 typedef StructuredDataProto_DeviceSegment DeviceSegment;
1186 static constexpr DeviceSegment UNKNOWN =
1187 StructuredDataProto_DeviceSegment_UNKNOWN;
1188 static constexpr DeviceSegment CONSUMER =
1189 StructuredDataProto_DeviceSegment_CONSUMER;
1190 static constexpr DeviceSegment EDUCATION =
1191 StructuredDataProto_DeviceSegment_EDUCATION;
1192 static constexpr DeviceSegment ENTERPRISE =
1193 StructuredDataProto_DeviceSegment_ENTERPRISE;
1194 static inline bool DeviceSegment_IsValid(int value) {
1195 return StructuredDataProto_DeviceSegment_IsValid(value);
1196 }
1197 static constexpr DeviceSegment DeviceSegment_MIN =
1198 StructuredDataProto_DeviceSegment_DeviceSegment_MIN;
1199 static constexpr DeviceSegment DeviceSegment_MAX =
1200 StructuredDataProto_DeviceSegment_DeviceSegment_MAX;
1201 static constexpr int DeviceSegment_ARRAYSIZE =
1202 StructuredDataProto_DeviceSegment_DeviceSegment_ARRAYSIZE;
1203 template<typename T>
1204 static inline const std::string& DeviceSegment_Name(T enum_t_value) {
1205 static_assert(::std::is_same<T, DeviceSegment>::value ||
1206 ::std::is_integral<T>::value,
1207 "Incorrect type passed to function DeviceSegment_Name.");
1208 return StructuredDataProto_DeviceSegment_Name(enum_t_value);
1209 }
1210 static inline bool DeviceSegment_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1211 DeviceSegment* value) {
1212 return StructuredDataProto_DeviceSegment_Parse(name, value);
1213 }
1214
1215 // accessors -------------------------------------------------------
1216
1217 enum : int {
1218 kEventsFieldNumber = 1,
1219 kIsDeviceEnrolledFieldNumber = 2,
1220 kDeviceSegmentFieldNumber = 3,
1221 };
1222 // repeated .metrics.StructuredEventProto events = 1;
1223 int events_size() const;
1224 private:
1225 int _internal_events_size() const;
1226 public:
1227 void clear_events();
1228 ::metrics::StructuredEventProto* mutable_events(int index);
1229 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto >*
1230 mutable_events();
1231 private:
1232 const ::metrics::StructuredEventProto& _internal_events(int index) const;
1233 ::metrics::StructuredEventProto* _internal_add_events();
1234 public:
1235 const ::metrics::StructuredEventProto& events(int index) const;
1236 ::metrics::StructuredEventProto* add_events();
1237 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto >&
1238 events() const;
1239
1240 // optional bool is_device_enrolled = 2 [deprecated = true];
1241 PROTOBUF_DEPRECATED bool has_is_device_enrolled() const;
1242 private:
1243 bool _internal_has_is_device_enrolled() const;
1244 public:
1245 PROTOBUF_DEPRECATED void clear_is_device_enrolled();
1246 PROTOBUF_DEPRECATED bool is_device_enrolled() const;
1247 PROTOBUF_DEPRECATED void set_is_device_enrolled(bool value);
1248 private:
1249 bool _internal_is_device_enrolled() const;
1250 void _internal_set_is_device_enrolled(bool value);
1251 public:
1252
1253 // optional .metrics.StructuredDataProto.DeviceSegment device_segment = 3;
1254 bool has_device_segment() const;
1255 private:
1256 bool _internal_has_device_segment() const;
1257 public:
1258 void clear_device_segment();
1259 ::metrics::StructuredDataProto_DeviceSegment device_segment() const;
1260 void set_device_segment(::metrics::StructuredDataProto_DeviceSegment value);
1261 private:
1262 ::metrics::StructuredDataProto_DeviceSegment _internal_device_segment() const;
1263 void _internal_set_device_segment(::metrics::StructuredDataProto_DeviceSegment value);
1264 public:
1265
1266 // @@protoc_insertion_point(class_scope:metrics.StructuredDataProto)
1267 private:
1268 class _Internal;
1269
1270 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1271 typedef void InternalArenaConstructable_;
1272 typedef void DestructorSkippable_;
1273 struct Impl_ {
1274 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1275 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1276 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto > events_;
1277 bool is_device_enrolled_;
1278 int device_segment_;
1279 };
1280 union { Impl_ _impl_; };
1281 friend struct ::TableStruct_structured_5fdata_2eproto;
1282 };
1283 // ===================================================================
1284
1285
1286 // ===================================================================
1287
1288 #ifdef __GNUC__
1289 #pragma GCC diagnostic push
1290 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1291 #endif // __GNUC__
1292 // StructuredEventProto_Metric_RepeatedInt64
1293
1294 // repeated int64 values = 1 [packed = true];
_internal_values_size()1295 inline int StructuredEventProto_Metric_RepeatedInt64::_internal_values_size() const {
1296 return _impl_.values_.size();
1297 }
values_size()1298 inline int StructuredEventProto_Metric_RepeatedInt64::values_size() const {
1299 return _internal_values_size();
1300 }
clear_values()1301 inline void StructuredEventProto_Metric_RepeatedInt64::clear_values() {
1302 _impl_.values_.Clear();
1303 }
_internal_values(int index)1304 inline int64_t StructuredEventProto_Metric_RepeatedInt64::_internal_values(int index) const {
1305 return _impl_.values_.Get(index);
1306 }
values(int index)1307 inline int64_t StructuredEventProto_Metric_RepeatedInt64::values(int index) const {
1308 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.RepeatedInt64.values)
1309 return _internal_values(index);
1310 }
set_values(int index,int64_t value)1311 inline void StructuredEventProto_Metric_RepeatedInt64::set_values(int index, int64_t value) {
1312 _impl_.values_.Set(index, value);
1313 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.Metric.RepeatedInt64.values)
1314 }
_internal_add_values(int64_t value)1315 inline void StructuredEventProto_Metric_RepeatedInt64::_internal_add_values(int64_t value) {
1316 _impl_.values_.Add(value);
1317 }
add_values(int64_t value)1318 inline void StructuredEventProto_Metric_RepeatedInt64::add_values(int64_t value) {
1319 _internal_add_values(value);
1320 // @@protoc_insertion_point(field_add:metrics.StructuredEventProto.Metric.RepeatedInt64.values)
1321 }
1322 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_values()1323 StructuredEventProto_Metric_RepeatedInt64::_internal_values() const {
1324 return _impl_.values_;
1325 }
1326 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
values()1327 StructuredEventProto_Metric_RepeatedInt64::values() const {
1328 // @@protoc_insertion_point(field_list:metrics.StructuredEventProto.Metric.RepeatedInt64.values)
1329 return _internal_values();
1330 }
1331 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_values()1332 StructuredEventProto_Metric_RepeatedInt64::_internal_mutable_values() {
1333 return &_impl_.values_;
1334 }
1335 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_values()1336 StructuredEventProto_Metric_RepeatedInt64::mutable_values() {
1337 // @@protoc_insertion_point(field_mutable_list:metrics.StructuredEventProto.Metric.RepeatedInt64.values)
1338 return _internal_mutable_values();
1339 }
1340
1341 // -------------------------------------------------------------------
1342
1343 // StructuredEventProto_Metric
1344
1345 // optional fixed64 name_hash = 1;
_internal_has_name_hash()1346 inline bool StructuredEventProto_Metric::_internal_has_name_hash() const {
1347 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1348 return value;
1349 }
has_name_hash()1350 inline bool StructuredEventProto_Metric::has_name_hash() const {
1351 return _internal_has_name_hash();
1352 }
clear_name_hash()1353 inline void StructuredEventProto_Metric::clear_name_hash() {
1354 _impl_.name_hash_ = uint64_t{0u};
1355 _impl_._has_bits_[0] &= ~0x00000001u;
1356 }
_internal_name_hash()1357 inline uint64_t StructuredEventProto_Metric::_internal_name_hash() const {
1358 return _impl_.name_hash_;
1359 }
name_hash()1360 inline uint64_t StructuredEventProto_Metric::name_hash() const {
1361 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.name_hash)
1362 return _internal_name_hash();
1363 }
_internal_set_name_hash(uint64_t value)1364 inline void StructuredEventProto_Metric::_internal_set_name_hash(uint64_t value) {
1365 _impl_._has_bits_[0] |= 0x00000001u;
1366 _impl_.name_hash_ = value;
1367 }
set_name_hash(uint64_t value)1368 inline void StructuredEventProto_Metric::set_name_hash(uint64_t value) {
1369 _internal_set_name_hash(value);
1370 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.Metric.name_hash)
1371 }
1372
1373 // fixed64 value_hmac = 2;
_internal_has_value_hmac()1374 inline bool StructuredEventProto_Metric::_internal_has_value_hmac() const {
1375 return value_case() == kValueHmac;
1376 }
has_value_hmac()1377 inline bool StructuredEventProto_Metric::has_value_hmac() const {
1378 return _internal_has_value_hmac();
1379 }
set_has_value_hmac()1380 inline void StructuredEventProto_Metric::set_has_value_hmac() {
1381 _impl_._oneof_case_[0] = kValueHmac;
1382 }
clear_value_hmac()1383 inline void StructuredEventProto_Metric::clear_value_hmac() {
1384 if (_internal_has_value_hmac()) {
1385 _impl_.value_.value_hmac_ = uint64_t{0u};
1386 clear_has_value();
1387 }
1388 }
_internal_value_hmac()1389 inline uint64_t StructuredEventProto_Metric::_internal_value_hmac() const {
1390 if (_internal_has_value_hmac()) {
1391 return _impl_.value_.value_hmac_;
1392 }
1393 return uint64_t{0u};
1394 }
_internal_set_value_hmac(uint64_t value)1395 inline void StructuredEventProto_Metric::_internal_set_value_hmac(uint64_t value) {
1396 if (!_internal_has_value_hmac()) {
1397 clear_value();
1398 set_has_value_hmac();
1399 }
1400 _impl_.value_.value_hmac_ = value;
1401 }
value_hmac()1402 inline uint64_t StructuredEventProto_Metric::value_hmac() const {
1403 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.value_hmac)
1404 return _internal_value_hmac();
1405 }
set_value_hmac(uint64_t value)1406 inline void StructuredEventProto_Metric::set_value_hmac(uint64_t value) {
1407 _internal_set_value_hmac(value);
1408 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.Metric.value_hmac)
1409 }
1410
1411 // int64 value_int64 = 3;
_internal_has_value_int64()1412 inline bool StructuredEventProto_Metric::_internal_has_value_int64() const {
1413 return value_case() == kValueInt64;
1414 }
has_value_int64()1415 inline bool StructuredEventProto_Metric::has_value_int64() const {
1416 return _internal_has_value_int64();
1417 }
set_has_value_int64()1418 inline void StructuredEventProto_Metric::set_has_value_int64() {
1419 _impl_._oneof_case_[0] = kValueInt64;
1420 }
clear_value_int64()1421 inline void StructuredEventProto_Metric::clear_value_int64() {
1422 if (_internal_has_value_int64()) {
1423 _impl_.value_.value_int64_ = int64_t{0};
1424 clear_has_value();
1425 }
1426 }
_internal_value_int64()1427 inline int64_t StructuredEventProto_Metric::_internal_value_int64() const {
1428 if (_internal_has_value_int64()) {
1429 return _impl_.value_.value_int64_;
1430 }
1431 return int64_t{0};
1432 }
_internal_set_value_int64(int64_t value)1433 inline void StructuredEventProto_Metric::_internal_set_value_int64(int64_t value) {
1434 if (!_internal_has_value_int64()) {
1435 clear_value();
1436 set_has_value_int64();
1437 }
1438 _impl_.value_.value_int64_ = value;
1439 }
value_int64()1440 inline int64_t StructuredEventProto_Metric::value_int64() const {
1441 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.value_int64)
1442 return _internal_value_int64();
1443 }
set_value_int64(int64_t value)1444 inline void StructuredEventProto_Metric::set_value_int64(int64_t value) {
1445 _internal_set_value_int64(value);
1446 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.Metric.value_int64)
1447 }
1448
1449 // string value_string = 4;
_internal_has_value_string()1450 inline bool StructuredEventProto_Metric::_internal_has_value_string() const {
1451 return value_case() == kValueString;
1452 }
has_value_string()1453 inline bool StructuredEventProto_Metric::has_value_string() const {
1454 return _internal_has_value_string();
1455 }
set_has_value_string()1456 inline void StructuredEventProto_Metric::set_has_value_string() {
1457 _impl_._oneof_case_[0] = kValueString;
1458 }
clear_value_string()1459 inline void StructuredEventProto_Metric::clear_value_string() {
1460 if (_internal_has_value_string()) {
1461 _impl_.value_.value_string_.Destroy();
1462 clear_has_value();
1463 }
1464 }
value_string()1465 inline const std::string& StructuredEventProto_Metric::value_string() const {
1466 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.value_string)
1467 return _internal_value_string();
1468 }
1469 template <typename ArgT0, typename... ArgT>
set_value_string(ArgT0 && arg0,ArgT...args)1470 inline void StructuredEventProto_Metric::set_value_string(ArgT0&& arg0, ArgT... args) {
1471 if (!_internal_has_value_string()) {
1472 clear_value();
1473 set_has_value_string();
1474 _impl_.value_.value_string_.InitDefault();
1475 }
1476 _impl_.value_.value_string_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1477 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.Metric.value_string)
1478 }
mutable_value_string()1479 inline std::string* StructuredEventProto_Metric::mutable_value_string() {
1480 std::string* _s = _internal_mutable_value_string();
1481 // @@protoc_insertion_point(field_mutable:metrics.StructuredEventProto.Metric.value_string)
1482 return _s;
1483 }
_internal_value_string()1484 inline const std::string& StructuredEventProto_Metric::_internal_value_string() const {
1485 if (_internal_has_value_string()) {
1486 return _impl_.value_.value_string_.Get();
1487 }
1488 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
1489 }
_internal_set_value_string(const std::string & value)1490 inline void StructuredEventProto_Metric::_internal_set_value_string(const std::string& value) {
1491 if (!_internal_has_value_string()) {
1492 clear_value();
1493 set_has_value_string();
1494 _impl_.value_.value_string_.InitDefault();
1495 }
1496 _impl_.value_.value_string_.Set(value, GetArenaForAllocation());
1497 }
_internal_mutable_value_string()1498 inline std::string* StructuredEventProto_Metric::_internal_mutable_value_string() {
1499 if (!_internal_has_value_string()) {
1500 clear_value();
1501 set_has_value_string();
1502 _impl_.value_.value_string_.InitDefault();
1503 }
1504 return _impl_.value_.value_string_.Mutable( GetArenaForAllocation());
1505 }
release_value_string()1506 inline std::string* StructuredEventProto_Metric::release_value_string() {
1507 // @@protoc_insertion_point(field_release:metrics.StructuredEventProto.Metric.value_string)
1508 if (_internal_has_value_string()) {
1509 clear_has_value();
1510 return _impl_.value_.value_string_.Release();
1511 } else {
1512 return nullptr;
1513 }
1514 }
set_allocated_value_string(std::string * value_string)1515 inline void StructuredEventProto_Metric::set_allocated_value_string(std::string* value_string) {
1516 if (has_value()) {
1517 clear_value();
1518 }
1519 if (value_string != nullptr) {
1520 set_has_value_string();
1521 _impl_.value_.value_string_.InitAllocated(value_string, GetArenaForAllocation());
1522 }
1523 // @@protoc_insertion_point(field_set_allocated:metrics.StructuredEventProto.Metric.value_string)
1524 }
1525
1526 // double value_double = 5;
_internal_has_value_double()1527 inline bool StructuredEventProto_Metric::_internal_has_value_double() const {
1528 return value_case() == kValueDouble;
1529 }
has_value_double()1530 inline bool StructuredEventProto_Metric::has_value_double() const {
1531 return _internal_has_value_double();
1532 }
set_has_value_double()1533 inline void StructuredEventProto_Metric::set_has_value_double() {
1534 _impl_._oneof_case_[0] = kValueDouble;
1535 }
clear_value_double()1536 inline void StructuredEventProto_Metric::clear_value_double() {
1537 if (_internal_has_value_double()) {
1538 _impl_.value_.value_double_ = 0;
1539 clear_has_value();
1540 }
1541 }
_internal_value_double()1542 inline double StructuredEventProto_Metric::_internal_value_double() const {
1543 if (_internal_has_value_double()) {
1544 return _impl_.value_.value_double_;
1545 }
1546 return 0;
1547 }
_internal_set_value_double(double value)1548 inline void StructuredEventProto_Metric::_internal_set_value_double(double value) {
1549 if (!_internal_has_value_double()) {
1550 clear_value();
1551 set_has_value_double();
1552 }
1553 _impl_.value_.value_double_ = value;
1554 }
value_double()1555 inline double StructuredEventProto_Metric::value_double() const {
1556 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.value_double)
1557 return _internal_value_double();
1558 }
set_value_double(double value)1559 inline void StructuredEventProto_Metric::set_value_double(double value) {
1560 _internal_set_value_double(value);
1561 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.Metric.value_double)
1562 }
1563
1564 // .metrics.StructuredEventProto.Metric.RepeatedInt64 value_repeated_int64 = 6;
_internal_has_value_repeated_int64()1565 inline bool StructuredEventProto_Metric::_internal_has_value_repeated_int64() const {
1566 return value_case() == kValueRepeatedInt64;
1567 }
has_value_repeated_int64()1568 inline bool StructuredEventProto_Metric::has_value_repeated_int64() const {
1569 return _internal_has_value_repeated_int64();
1570 }
set_has_value_repeated_int64()1571 inline void StructuredEventProto_Metric::set_has_value_repeated_int64() {
1572 _impl_._oneof_case_[0] = kValueRepeatedInt64;
1573 }
clear_value_repeated_int64()1574 inline void StructuredEventProto_Metric::clear_value_repeated_int64() {
1575 if (_internal_has_value_repeated_int64()) {
1576 if (GetArenaForAllocation() == nullptr) {
1577 delete _impl_.value_.value_repeated_int64_;
1578 }
1579 clear_has_value();
1580 }
1581 }
release_value_repeated_int64()1582 inline ::metrics::StructuredEventProto_Metric_RepeatedInt64* StructuredEventProto_Metric::release_value_repeated_int64() {
1583 // @@protoc_insertion_point(field_release:metrics.StructuredEventProto.Metric.value_repeated_int64)
1584 if (_internal_has_value_repeated_int64()) {
1585 clear_has_value();
1586 ::metrics::StructuredEventProto_Metric_RepeatedInt64* temp = _impl_.value_.value_repeated_int64_;
1587 if (GetArenaForAllocation() != nullptr) {
1588 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1589 }
1590 _impl_.value_.value_repeated_int64_ = nullptr;
1591 return temp;
1592 } else {
1593 return nullptr;
1594 }
1595 }
_internal_value_repeated_int64()1596 inline const ::metrics::StructuredEventProto_Metric_RepeatedInt64& StructuredEventProto_Metric::_internal_value_repeated_int64() const {
1597 return _internal_has_value_repeated_int64()
1598 ? *_impl_.value_.value_repeated_int64_
1599 : reinterpret_cast< ::metrics::StructuredEventProto_Metric_RepeatedInt64&>(::metrics::_StructuredEventProto_Metric_RepeatedInt64_default_instance_);
1600 }
value_repeated_int64()1601 inline const ::metrics::StructuredEventProto_Metric_RepeatedInt64& StructuredEventProto_Metric::value_repeated_int64() const {
1602 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.Metric.value_repeated_int64)
1603 return _internal_value_repeated_int64();
1604 }
unsafe_arena_release_value_repeated_int64()1605 inline ::metrics::StructuredEventProto_Metric_RepeatedInt64* StructuredEventProto_Metric::unsafe_arena_release_value_repeated_int64() {
1606 // @@protoc_insertion_point(field_unsafe_arena_release:metrics.StructuredEventProto.Metric.value_repeated_int64)
1607 if (_internal_has_value_repeated_int64()) {
1608 clear_has_value();
1609 ::metrics::StructuredEventProto_Metric_RepeatedInt64* temp = _impl_.value_.value_repeated_int64_;
1610 _impl_.value_.value_repeated_int64_ = nullptr;
1611 return temp;
1612 } else {
1613 return nullptr;
1614 }
1615 }
unsafe_arena_set_allocated_value_repeated_int64(::metrics::StructuredEventProto_Metric_RepeatedInt64 * value_repeated_int64)1616 inline void StructuredEventProto_Metric::unsafe_arena_set_allocated_value_repeated_int64(::metrics::StructuredEventProto_Metric_RepeatedInt64* value_repeated_int64) {
1617 clear_value();
1618 if (value_repeated_int64) {
1619 set_has_value_repeated_int64();
1620 _impl_.value_.value_repeated_int64_ = value_repeated_int64;
1621 }
1622 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.StructuredEventProto.Metric.value_repeated_int64)
1623 }
_internal_mutable_value_repeated_int64()1624 inline ::metrics::StructuredEventProto_Metric_RepeatedInt64* StructuredEventProto_Metric::_internal_mutable_value_repeated_int64() {
1625 if (!_internal_has_value_repeated_int64()) {
1626 clear_value();
1627 set_has_value_repeated_int64();
1628 _impl_.value_.value_repeated_int64_ = CreateMaybeMessage< ::metrics::StructuredEventProto_Metric_RepeatedInt64 >(GetArenaForAllocation());
1629 }
1630 return _impl_.value_.value_repeated_int64_;
1631 }
mutable_value_repeated_int64()1632 inline ::metrics::StructuredEventProto_Metric_RepeatedInt64* StructuredEventProto_Metric::mutable_value_repeated_int64() {
1633 ::metrics::StructuredEventProto_Metric_RepeatedInt64* _msg = _internal_mutable_value_repeated_int64();
1634 // @@protoc_insertion_point(field_mutable:metrics.StructuredEventProto.Metric.value_repeated_int64)
1635 return _msg;
1636 }
1637
has_value()1638 inline bool StructuredEventProto_Metric::has_value() const {
1639 return value_case() != VALUE_NOT_SET;
1640 }
clear_has_value()1641 inline void StructuredEventProto_Metric::clear_has_value() {
1642 _impl_._oneof_case_[0] = VALUE_NOT_SET;
1643 }
value_case()1644 inline StructuredEventProto_Metric::ValueCase StructuredEventProto_Metric::value_case() const {
1645 return StructuredEventProto_Metric::ValueCase(_impl_._oneof_case_[0]);
1646 }
1647 // -------------------------------------------------------------------
1648
1649 // StructuredEventProto_EventSequenceMetadata
1650
1651 // optional fixed64 event_unique_id = 1;
_internal_has_event_unique_id()1652 inline bool StructuredEventProto_EventSequenceMetadata::_internal_has_event_unique_id() const {
1653 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1654 return value;
1655 }
has_event_unique_id()1656 inline bool StructuredEventProto_EventSequenceMetadata::has_event_unique_id() const {
1657 return _internal_has_event_unique_id();
1658 }
clear_event_unique_id()1659 inline void StructuredEventProto_EventSequenceMetadata::clear_event_unique_id() {
1660 _impl_.event_unique_id_ = uint64_t{0u};
1661 _impl_._has_bits_[0] &= ~0x00000001u;
1662 }
_internal_event_unique_id()1663 inline uint64_t StructuredEventProto_EventSequenceMetadata::_internal_event_unique_id() const {
1664 return _impl_.event_unique_id_;
1665 }
event_unique_id()1666 inline uint64_t StructuredEventProto_EventSequenceMetadata::event_unique_id() const {
1667 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.EventSequenceMetadata.event_unique_id)
1668 return _internal_event_unique_id();
1669 }
_internal_set_event_unique_id(uint64_t value)1670 inline void StructuredEventProto_EventSequenceMetadata::_internal_set_event_unique_id(uint64_t value) {
1671 _impl_._has_bits_[0] |= 0x00000001u;
1672 _impl_.event_unique_id_ = value;
1673 }
set_event_unique_id(uint64_t value)1674 inline void StructuredEventProto_EventSequenceMetadata::set_event_unique_id(uint64_t value) {
1675 _internal_set_event_unique_id(value);
1676 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.EventSequenceMetadata.event_unique_id)
1677 }
1678
1679 // optional int64 system_uptime = 2;
_internal_has_system_uptime()1680 inline bool StructuredEventProto_EventSequenceMetadata::_internal_has_system_uptime() const {
1681 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1682 return value;
1683 }
has_system_uptime()1684 inline bool StructuredEventProto_EventSequenceMetadata::has_system_uptime() const {
1685 return _internal_has_system_uptime();
1686 }
clear_system_uptime()1687 inline void StructuredEventProto_EventSequenceMetadata::clear_system_uptime() {
1688 _impl_.system_uptime_ = int64_t{0};
1689 _impl_._has_bits_[0] &= ~0x00000002u;
1690 }
_internal_system_uptime()1691 inline int64_t StructuredEventProto_EventSequenceMetadata::_internal_system_uptime() const {
1692 return _impl_.system_uptime_;
1693 }
system_uptime()1694 inline int64_t StructuredEventProto_EventSequenceMetadata::system_uptime() const {
1695 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.EventSequenceMetadata.system_uptime)
1696 return _internal_system_uptime();
1697 }
_internal_set_system_uptime(int64_t value)1698 inline void StructuredEventProto_EventSequenceMetadata::_internal_set_system_uptime(int64_t value) {
1699 _impl_._has_bits_[0] |= 0x00000002u;
1700 _impl_.system_uptime_ = value;
1701 }
set_system_uptime(int64_t value)1702 inline void StructuredEventProto_EventSequenceMetadata::set_system_uptime(int64_t value) {
1703 _internal_set_system_uptime(value);
1704 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.EventSequenceMetadata.system_uptime)
1705 }
1706
1707 // optional int64 reset_counter = 3;
_internal_has_reset_counter()1708 inline bool StructuredEventProto_EventSequenceMetadata::_internal_has_reset_counter() const {
1709 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1710 return value;
1711 }
has_reset_counter()1712 inline bool StructuredEventProto_EventSequenceMetadata::has_reset_counter() const {
1713 return _internal_has_reset_counter();
1714 }
clear_reset_counter()1715 inline void StructuredEventProto_EventSequenceMetadata::clear_reset_counter() {
1716 _impl_.reset_counter_ = int64_t{0};
1717 _impl_._has_bits_[0] &= ~0x00000004u;
1718 }
_internal_reset_counter()1719 inline int64_t StructuredEventProto_EventSequenceMetadata::_internal_reset_counter() const {
1720 return _impl_.reset_counter_;
1721 }
reset_counter()1722 inline int64_t StructuredEventProto_EventSequenceMetadata::reset_counter() const {
1723 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.EventSequenceMetadata.reset_counter)
1724 return _internal_reset_counter();
1725 }
_internal_set_reset_counter(int64_t value)1726 inline void StructuredEventProto_EventSequenceMetadata::_internal_set_reset_counter(int64_t value) {
1727 _impl_._has_bits_[0] |= 0x00000004u;
1728 _impl_.reset_counter_ = value;
1729 }
set_reset_counter(int64_t value)1730 inline void StructuredEventProto_EventSequenceMetadata::set_reset_counter(int64_t value) {
1731 _internal_set_reset_counter(value);
1732 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.EventSequenceMetadata.reset_counter)
1733 }
1734
1735 // optional uint32 client_id_rotation_weeks = 4;
_internal_has_client_id_rotation_weeks()1736 inline bool StructuredEventProto_EventSequenceMetadata::_internal_has_client_id_rotation_weeks() const {
1737 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1738 return value;
1739 }
has_client_id_rotation_weeks()1740 inline bool StructuredEventProto_EventSequenceMetadata::has_client_id_rotation_weeks() const {
1741 return _internal_has_client_id_rotation_weeks();
1742 }
clear_client_id_rotation_weeks()1743 inline void StructuredEventProto_EventSequenceMetadata::clear_client_id_rotation_weeks() {
1744 _impl_.client_id_rotation_weeks_ = 0u;
1745 _impl_._has_bits_[0] &= ~0x00000008u;
1746 }
_internal_client_id_rotation_weeks()1747 inline uint32_t StructuredEventProto_EventSequenceMetadata::_internal_client_id_rotation_weeks() const {
1748 return _impl_.client_id_rotation_weeks_;
1749 }
client_id_rotation_weeks()1750 inline uint32_t StructuredEventProto_EventSequenceMetadata::client_id_rotation_weeks() const {
1751 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.EventSequenceMetadata.client_id_rotation_weeks)
1752 return _internal_client_id_rotation_weeks();
1753 }
_internal_set_client_id_rotation_weeks(uint32_t value)1754 inline void StructuredEventProto_EventSequenceMetadata::_internal_set_client_id_rotation_weeks(uint32_t value) {
1755 _impl_._has_bits_[0] |= 0x00000008u;
1756 _impl_.client_id_rotation_weeks_ = value;
1757 }
set_client_id_rotation_weeks(uint32_t value)1758 inline void StructuredEventProto_EventSequenceMetadata::set_client_id_rotation_weeks(uint32_t value) {
1759 _internal_set_client_id_rotation_weeks(value);
1760 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.EventSequenceMetadata.client_id_rotation_weeks)
1761 }
1762
1763 // optional .metrics.StructuredEventProto.PrimaryUserSegment primary_user_segment = 5;
_internal_has_primary_user_segment()1764 inline bool StructuredEventProto_EventSequenceMetadata::_internal_has_primary_user_segment() const {
1765 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
1766 return value;
1767 }
has_primary_user_segment()1768 inline bool StructuredEventProto_EventSequenceMetadata::has_primary_user_segment() const {
1769 return _internal_has_primary_user_segment();
1770 }
clear_primary_user_segment()1771 inline void StructuredEventProto_EventSequenceMetadata::clear_primary_user_segment() {
1772 _impl_.primary_user_segment_ = 0;
1773 _impl_._has_bits_[0] &= ~0x00000010u;
1774 }
_internal_primary_user_segment()1775 inline ::metrics::StructuredEventProto_PrimaryUserSegment StructuredEventProto_EventSequenceMetadata::_internal_primary_user_segment() const {
1776 return static_cast< ::metrics::StructuredEventProto_PrimaryUserSegment >(_impl_.primary_user_segment_);
1777 }
primary_user_segment()1778 inline ::metrics::StructuredEventProto_PrimaryUserSegment StructuredEventProto_EventSequenceMetadata::primary_user_segment() const {
1779 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.EventSequenceMetadata.primary_user_segment)
1780 return _internal_primary_user_segment();
1781 }
_internal_set_primary_user_segment(::metrics::StructuredEventProto_PrimaryUserSegment value)1782 inline void StructuredEventProto_EventSequenceMetadata::_internal_set_primary_user_segment(::metrics::StructuredEventProto_PrimaryUserSegment value) {
1783 assert(::metrics::StructuredEventProto_PrimaryUserSegment_IsValid(value));
1784 _impl_._has_bits_[0] |= 0x00000010u;
1785 _impl_.primary_user_segment_ = value;
1786 }
set_primary_user_segment(::metrics::StructuredEventProto_PrimaryUserSegment value)1787 inline void StructuredEventProto_EventSequenceMetadata::set_primary_user_segment(::metrics::StructuredEventProto_PrimaryUserSegment value) {
1788 _internal_set_primary_user_segment(value);
1789 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.EventSequenceMetadata.primary_user_segment)
1790 }
1791
1792 // -------------------------------------------------------------------
1793
1794 // StructuredEventProto
1795
1796 // optional fixed64 profile_event_id = 1;
_internal_has_profile_event_id()1797 inline bool StructuredEventProto::_internal_has_profile_event_id() const {
1798 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1799 return value;
1800 }
has_profile_event_id()1801 inline bool StructuredEventProto::has_profile_event_id() const {
1802 return _internal_has_profile_event_id();
1803 }
clear_profile_event_id()1804 inline void StructuredEventProto::clear_profile_event_id() {
1805 _impl_.profile_event_id_ = uint64_t{0u};
1806 _impl_._has_bits_[0] &= ~0x00000002u;
1807 }
_internal_profile_event_id()1808 inline uint64_t StructuredEventProto::_internal_profile_event_id() const {
1809 return _impl_.profile_event_id_;
1810 }
profile_event_id()1811 inline uint64_t StructuredEventProto::profile_event_id() const {
1812 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.profile_event_id)
1813 return _internal_profile_event_id();
1814 }
_internal_set_profile_event_id(uint64_t value)1815 inline void StructuredEventProto::_internal_set_profile_event_id(uint64_t value) {
1816 _impl_._has_bits_[0] |= 0x00000002u;
1817 _impl_.profile_event_id_ = value;
1818 }
set_profile_event_id(uint64_t value)1819 inline void StructuredEventProto::set_profile_event_id(uint64_t value) {
1820 _internal_set_profile_event_id(value);
1821 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.profile_event_id)
1822 }
1823
1824 // optional fixed64 user_project_id = 7;
_internal_has_user_project_id()1825 inline bool StructuredEventProto::_internal_has_user_project_id() const {
1826 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
1827 return value;
1828 }
has_user_project_id()1829 inline bool StructuredEventProto::has_user_project_id() const {
1830 return _internal_has_user_project_id();
1831 }
clear_user_project_id()1832 inline void StructuredEventProto::clear_user_project_id() {
1833 _impl_.user_project_id_ = uint64_t{0u};
1834 _impl_._has_bits_[0] &= ~0x00000010u;
1835 }
_internal_user_project_id()1836 inline uint64_t StructuredEventProto::_internal_user_project_id() const {
1837 return _impl_.user_project_id_;
1838 }
user_project_id()1839 inline uint64_t StructuredEventProto::user_project_id() const {
1840 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.user_project_id)
1841 return _internal_user_project_id();
1842 }
_internal_set_user_project_id(uint64_t value)1843 inline void StructuredEventProto::_internal_set_user_project_id(uint64_t value) {
1844 _impl_._has_bits_[0] |= 0x00000010u;
1845 _impl_.user_project_id_ = value;
1846 }
set_user_project_id(uint64_t value)1847 inline void StructuredEventProto::set_user_project_id(uint64_t value) {
1848 _internal_set_user_project_id(value);
1849 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.user_project_id)
1850 }
1851
1852 // optional fixed64 device_project_id = 8;
_internal_has_device_project_id()1853 inline bool StructuredEventProto::_internal_has_device_project_id() const {
1854 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
1855 return value;
1856 }
has_device_project_id()1857 inline bool StructuredEventProto::has_device_project_id() const {
1858 return _internal_has_device_project_id();
1859 }
clear_device_project_id()1860 inline void StructuredEventProto::clear_device_project_id() {
1861 _impl_.device_project_id_ = uint64_t{0u};
1862 _impl_._has_bits_[0] &= ~0x00000020u;
1863 }
_internal_device_project_id()1864 inline uint64_t StructuredEventProto::_internal_device_project_id() const {
1865 return _impl_.device_project_id_;
1866 }
device_project_id()1867 inline uint64_t StructuredEventProto::device_project_id() const {
1868 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.device_project_id)
1869 return _internal_device_project_id();
1870 }
_internal_set_device_project_id(uint64_t value)1871 inline void StructuredEventProto::_internal_set_device_project_id(uint64_t value) {
1872 _impl_._has_bits_[0] |= 0x00000020u;
1873 _impl_.device_project_id_ = value;
1874 }
set_device_project_id(uint64_t value)1875 inline void StructuredEventProto::set_device_project_id(uint64_t value) {
1876 _internal_set_device_project_id(value);
1877 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.device_project_id)
1878 }
1879
1880 // optional fixed64 event_name_hash = 2;
_internal_has_event_name_hash()1881 inline bool StructuredEventProto::_internal_has_event_name_hash() const {
1882 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1883 return value;
1884 }
has_event_name_hash()1885 inline bool StructuredEventProto::has_event_name_hash() const {
1886 return _internal_has_event_name_hash();
1887 }
clear_event_name_hash()1888 inline void StructuredEventProto::clear_event_name_hash() {
1889 _impl_.event_name_hash_ = uint64_t{0u};
1890 _impl_._has_bits_[0] &= ~0x00000004u;
1891 }
_internal_event_name_hash()1892 inline uint64_t StructuredEventProto::_internal_event_name_hash() const {
1893 return _impl_.event_name_hash_;
1894 }
event_name_hash()1895 inline uint64_t StructuredEventProto::event_name_hash() const {
1896 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.event_name_hash)
1897 return _internal_event_name_hash();
1898 }
_internal_set_event_name_hash(uint64_t value)1899 inline void StructuredEventProto::_internal_set_event_name_hash(uint64_t value) {
1900 _impl_._has_bits_[0] |= 0x00000004u;
1901 _impl_.event_name_hash_ = value;
1902 }
set_event_name_hash(uint64_t value)1903 inline void StructuredEventProto::set_event_name_hash(uint64_t value) {
1904 _internal_set_event_name_hash(value);
1905 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.event_name_hash)
1906 }
1907
1908 // repeated .metrics.StructuredEventProto.Metric metrics = 3;
_internal_metrics_size()1909 inline int StructuredEventProto::_internal_metrics_size() const {
1910 return _impl_.metrics_.size();
1911 }
metrics_size()1912 inline int StructuredEventProto::metrics_size() const {
1913 return _internal_metrics_size();
1914 }
clear_metrics()1915 inline void StructuredEventProto::clear_metrics() {
1916 _impl_.metrics_.Clear();
1917 }
mutable_metrics(int index)1918 inline ::metrics::StructuredEventProto_Metric* StructuredEventProto::mutable_metrics(int index) {
1919 // @@protoc_insertion_point(field_mutable:metrics.StructuredEventProto.metrics)
1920 return _impl_.metrics_.Mutable(index);
1921 }
1922 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto_Metric >*
mutable_metrics()1923 StructuredEventProto::mutable_metrics() {
1924 // @@protoc_insertion_point(field_mutable_list:metrics.StructuredEventProto.metrics)
1925 return &_impl_.metrics_;
1926 }
_internal_metrics(int index)1927 inline const ::metrics::StructuredEventProto_Metric& StructuredEventProto::_internal_metrics(int index) const {
1928 return _impl_.metrics_.Get(index);
1929 }
metrics(int index)1930 inline const ::metrics::StructuredEventProto_Metric& StructuredEventProto::metrics(int index) const {
1931 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.metrics)
1932 return _internal_metrics(index);
1933 }
_internal_add_metrics()1934 inline ::metrics::StructuredEventProto_Metric* StructuredEventProto::_internal_add_metrics() {
1935 return _impl_.metrics_.Add();
1936 }
add_metrics()1937 inline ::metrics::StructuredEventProto_Metric* StructuredEventProto::add_metrics() {
1938 ::metrics::StructuredEventProto_Metric* _add = _internal_add_metrics();
1939 // @@protoc_insertion_point(field_add:metrics.StructuredEventProto.metrics)
1940 return _add;
1941 }
1942 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto_Metric >&
metrics()1943 StructuredEventProto::metrics() const {
1944 // @@protoc_insertion_point(field_list:metrics.StructuredEventProto.metrics)
1945 return _impl_.metrics_;
1946 }
1947
1948 // optional .metrics.StructuredEventProto.EventType event_type = 4;
_internal_has_event_type()1949 inline bool StructuredEventProto::_internal_has_event_type() const {
1950 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
1951 return value;
1952 }
has_event_type()1953 inline bool StructuredEventProto::has_event_type() const {
1954 return _internal_has_event_type();
1955 }
clear_event_type()1956 inline void StructuredEventProto::clear_event_type() {
1957 _impl_.event_type_ = 0;
1958 _impl_._has_bits_[0] &= ~0x00000040u;
1959 }
_internal_event_type()1960 inline ::metrics::StructuredEventProto_EventType StructuredEventProto::_internal_event_type() const {
1961 return static_cast< ::metrics::StructuredEventProto_EventType >(_impl_.event_type_);
1962 }
event_type()1963 inline ::metrics::StructuredEventProto_EventType StructuredEventProto::event_type() const {
1964 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.event_type)
1965 return _internal_event_type();
1966 }
_internal_set_event_type(::metrics::StructuredEventProto_EventType value)1967 inline void StructuredEventProto::_internal_set_event_type(::metrics::StructuredEventProto_EventType value) {
1968 assert(::metrics::StructuredEventProto_EventType_IsValid(value));
1969 _impl_._has_bits_[0] |= 0x00000040u;
1970 _impl_.event_type_ = value;
1971 }
set_event_type(::metrics::StructuredEventProto_EventType value)1972 inline void StructuredEventProto::set_event_type(::metrics::StructuredEventProto_EventType value) {
1973 _internal_set_event_type(value);
1974 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.event_type)
1975 }
1976
1977 // optional fixed64 project_name_hash = 5;
_internal_has_project_name_hash()1978 inline bool StructuredEventProto::_internal_has_project_name_hash() const {
1979 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1980 return value;
1981 }
has_project_name_hash()1982 inline bool StructuredEventProto::has_project_name_hash() const {
1983 return _internal_has_project_name_hash();
1984 }
clear_project_name_hash()1985 inline void StructuredEventProto::clear_project_name_hash() {
1986 _impl_.project_name_hash_ = uint64_t{0u};
1987 _impl_._has_bits_[0] &= ~0x00000008u;
1988 }
_internal_project_name_hash()1989 inline uint64_t StructuredEventProto::_internal_project_name_hash() const {
1990 return _impl_.project_name_hash_;
1991 }
project_name_hash()1992 inline uint64_t StructuredEventProto::project_name_hash() const {
1993 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.project_name_hash)
1994 return _internal_project_name_hash();
1995 }
_internal_set_project_name_hash(uint64_t value)1996 inline void StructuredEventProto::_internal_set_project_name_hash(uint64_t value) {
1997 _impl_._has_bits_[0] |= 0x00000008u;
1998 _impl_.project_name_hash_ = value;
1999 }
set_project_name_hash(uint64_t value)2000 inline void StructuredEventProto::set_project_name_hash(uint64_t value) {
2001 _internal_set_project_name_hash(value);
2002 // @@protoc_insertion_point(field_set:metrics.StructuredEventProto.project_name_hash)
2003 }
2004
2005 // optional .metrics.StructuredEventProto.EventSequenceMetadata event_sequence_metadata = 6;
_internal_has_event_sequence_metadata()2006 inline bool StructuredEventProto::_internal_has_event_sequence_metadata() const {
2007 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2008 PROTOBUF_ASSUME(!value || _impl_.event_sequence_metadata_ != nullptr);
2009 return value;
2010 }
has_event_sequence_metadata()2011 inline bool StructuredEventProto::has_event_sequence_metadata() const {
2012 return _internal_has_event_sequence_metadata();
2013 }
clear_event_sequence_metadata()2014 inline void StructuredEventProto::clear_event_sequence_metadata() {
2015 if (_impl_.event_sequence_metadata_ != nullptr) _impl_.event_sequence_metadata_->Clear();
2016 _impl_._has_bits_[0] &= ~0x00000001u;
2017 }
_internal_event_sequence_metadata()2018 inline const ::metrics::StructuredEventProto_EventSequenceMetadata& StructuredEventProto::_internal_event_sequence_metadata() const {
2019 const ::metrics::StructuredEventProto_EventSequenceMetadata* p = _impl_.event_sequence_metadata_;
2020 return p != nullptr ? *p : reinterpret_cast<const ::metrics::StructuredEventProto_EventSequenceMetadata&>(
2021 ::metrics::_StructuredEventProto_EventSequenceMetadata_default_instance_);
2022 }
event_sequence_metadata()2023 inline const ::metrics::StructuredEventProto_EventSequenceMetadata& StructuredEventProto::event_sequence_metadata() const {
2024 // @@protoc_insertion_point(field_get:metrics.StructuredEventProto.event_sequence_metadata)
2025 return _internal_event_sequence_metadata();
2026 }
unsafe_arena_set_allocated_event_sequence_metadata(::metrics::StructuredEventProto_EventSequenceMetadata * event_sequence_metadata)2027 inline void StructuredEventProto::unsafe_arena_set_allocated_event_sequence_metadata(
2028 ::metrics::StructuredEventProto_EventSequenceMetadata* event_sequence_metadata) {
2029 if (GetArenaForAllocation() == nullptr) {
2030 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.event_sequence_metadata_);
2031 }
2032 _impl_.event_sequence_metadata_ = event_sequence_metadata;
2033 if (event_sequence_metadata) {
2034 _impl_._has_bits_[0] |= 0x00000001u;
2035 } else {
2036 _impl_._has_bits_[0] &= ~0x00000001u;
2037 }
2038 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.StructuredEventProto.event_sequence_metadata)
2039 }
release_event_sequence_metadata()2040 inline ::metrics::StructuredEventProto_EventSequenceMetadata* StructuredEventProto::release_event_sequence_metadata() {
2041 _impl_._has_bits_[0] &= ~0x00000001u;
2042 ::metrics::StructuredEventProto_EventSequenceMetadata* temp = _impl_.event_sequence_metadata_;
2043 _impl_.event_sequence_metadata_ = nullptr;
2044 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2045 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2046 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2047 if (GetArenaForAllocation() == nullptr) { delete old; }
2048 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2049 if (GetArenaForAllocation() != nullptr) {
2050 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2051 }
2052 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2053 return temp;
2054 }
unsafe_arena_release_event_sequence_metadata()2055 inline ::metrics::StructuredEventProto_EventSequenceMetadata* StructuredEventProto::unsafe_arena_release_event_sequence_metadata() {
2056 // @@protoc_insertion_point(field_release:metrics.StructuredEventProto.event_sequence_metadata)
2057 _impl_._has_bits_[0] &= ~0x00000001u;
2058 ::metrics::StructuredEventProto_EventSequenceMetadata* temp = _impl_.event_sequence_metadata_;
2059 _impl_.event_sequence_metadata_ = nullptr;
2060 return temp;
2061 }
_internal_mutable_event_sequence_metadata()2062 inline ::metrics::StructuredEventProto_EventSequenceMetadata* StructuredEventProto::_internal_mutable_event_sequence_metadata() {
2063 _impl_._has_bits_[0] |= 0x00000001u;
2064 if (_impl_.event_sequence_metadata_ == nullptr) {
2065 auto* p = CreateMaybeMessage<::metrics::StructuredEventProto_EventSequenceMetadata>(GetArenaForAllocation());
2066 _impl_.event_sequence_metadata_ = p;
2067 }
2068 return _impl_.event_sequence_metadata_;
2069 }
mutable_event_sequence_metadata()2070 inline ::metrics::StructuredEventProto_EventSequenceMetadata* StructuredEventProto::mutable_event_sequence_metadata() {
2071 ::metrics::StructuredEventProto_EventSequenceMetadata* _msg = _internal_mutable_event_sequence_metadata();
2072 // @@protoc_insertion_point(field_mutable:metrics.StructuredEventProto.event_sequence_metadata)
2073 return _msg;
2074 }
set_allocated_event_sequence_metadata(::metrics::StructuredEventProto_EventSequenceMetadata * event_sequence_metadata)2075 inline void StructuredEventProto::set_allocated_event_sequence_metadata(::metrics::StructuredEventProto_EventSequenceMetadata* event_sequence_metadata) {
2076 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2077 if (message_arena == nullptr) {
2078 delete _impl_.event_sequence_metadata_;
2079 }
2080 if (event_sequence_metadata) {
2081 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2082 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(event_sequence_metadata);
2083 if (message_arena != submessage_arena) {
2084 event_sequence_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2085 message_arena, event_sequence_metadata, submessage_arena);
2086 }
2087 _impl_._has_bits_[0] |= 0x00000001u;
2088 } else {
2089 _impl_._has_bits_[0] &= ~0x00000001u;
2090 }
2091 _impl_.event_sequence_metadata_ = event_sequence_metadata;
2092 // @@protoc_insertion_point(field_set_allocated:metrics.StructuredEventProto.event_sequence_metadata)
2093 }
2094
2095 // -------------------------------------------------------------------
2096
2097 // StructuredDataProto
2098
2099 // repeated .metrics.StructuredEventProto events = 1;
_internal_events_size()2100 inline int StructuredDataProto::_internal_events_size() const {
2101 return _impl_.events_.size();
2102 }
events_size()2103 inline int StructuredDataProto::events_size() const {
2104 return _internal_events_size();
2105 }
clear_events()2106 inline void StructuredDataProto::clear_events() {
2107 _impl_.events_.Clear();
2108 }
mutable_events(int index)2109 inline ::metrics::StructuredEventProto* StructuredDataProto::mutable_events(int index) {
2110 // @@protoc_insertion_point(field_mutable:metrics.StructuredDataProto.events)
2111 return _impl_.events_.Mutable(index);
2112 }
2113 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto >*
mutable_events()2114 StructuredDataProto::mutable_events() {
2115 // @@protoc_insertion_point(field_mutable_list:metrics.StructuredDataProto.events)
2116 return &_impl_.events_;
2117 }
_internal_events(int index)2118 inline const ::metrics::StructuredEventProto& StructuredDataProto::_internal_events(int index) const {
2119 return _impl_.events_.Get(index);
2120 }
events(int index)2121 inline const ::metrics::StructuredEventProto& StructuredDataProto::events(int index) const {
2122 // @@protoc_insertion_point(field_get:metrics.StructuredDataProto.events)
2123 return _internal_events(index);
2124 }
_internal_add_events()2125 inline ::metrics::StructuredEventProto* StructuredDataProto::_internal_add_events() {
2126 return _impl_.events_.Add();
2127 }
add_events()2128 inline ::metrics::StructuredEventProto* StructuredDataProto::add_events() {
2129 ::metrics::StructuredEventProto* _add = _internal_add_events();
2130 // @@protoc_insertion_point(field_add:metrics.StructuredDataProto.events)
2131 return _add;
2132 }
2133 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::StructuredEventProto >&
events()2134 StructuredDataProto::events() const {
2135 // @@protoc_insertion_point(field_list:metrics.StructuredDataProto.events)
2136 return _impl_.events_;
2137 }
2138
2139 // optional bool is_device_enrolled = 2 [deprecated = true];
_internal_has_is_device_enrolled()2140 inline bool StructuredDataProto::_internal_has_is_device_enrolled() const {
2141 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2142 return value;
2143 }
has_is_device_enrolled()2144 inline bool StructuredDataProto::has_is_device_enrolled() const {
2145 return _internal_has_is_device_enrolled();
2146 }
clear_is_device_enrolled()2147 inline void StructuredDataProto::clear_is_device_enrolled() {
2148 _impl_.is_device_enrolled_ = false;
2149 _impl_._has_bits_[0] &= ~0x00000001u;
2150 }
_internal_is_device_enrolled()2151 inline bool StructuredDataProto::_internal_is_device_enrolled() const {
2152 return _impl_.is_device_enrolled_;
2153 }
is_device_enrolled()2154 inline bool StructuredDataProto::is_device_enrolled() const {
2155 // @@protoc_insertion_point(field_get:metrics.StructuredDataProto.is_device_enrolled)
2156 return _internal_is_device_enrolled();
2157 }
_internal_set_is_device_enrolled(bool value)2158 inline void StructuredDataProto::_internal_set_is_device_enrolled(bool value) {
2159 _impl_._has_bits_[0] |= 0x00000001u;
2160 _impl_.is_device_enrolled_ = value;
2161 }
set_is_device_enrolled(bool value)2162 inline void StructuredDataProto::set_is_device_enrolled(bool value) {
2163 _internal_set_is_device_enrolled(value);
2164 // @@protoc_insertion_point(field_set:metrics.StructuredDataProto.is_device_enrolled)
2165 }
2166
2167 // optional .metrics.StructuredDataProto.DeviceSegment device_segment = 3;
_internal_has_device_segment()2168 inline bool StructuredDataProto::_internal_has_device_segment() const {
2169 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2170 return value;
2171 }
has_device_segment()2172 inline bool StructuredDataProto::has_device_segment() const {
2173 return _internal_has_device_segment();
2174 }
clear_device_segment()2175 inline void StructuredDataProto::clear_device_segment() {
2176 _impl_.device_segment_ = 0;
2177 _impl_._has_bits_[0] &= ~0x00000002u;
2178 }
_internal_device_segment()2179 inline ::metrics::StructuredDataProto_DeviceSegment StructuredDataProto::_internal_device_segment() const {
2180 return static_cast< ::metrics::StructuredDataProto_DeviceSegment >(_impl_.device_segment_);
2181 }
device_segment()2182 inline ::metrics::StructuredDataProto_DeviceSegment StructuredDataProto::device_segment() const {
2183 // @@protoc_insertion_point(field_get:metrics.StructuredDataProto.device_segment)
2184 return _internal_device_segment();
2185 }
_internal_set_device_segment(::metrics::StructuredDataProto_DeviceSegment value)2186 inline void StructuredDataProto::_internal_set_device_segment(::metrics::StructuredDataProto_DeviceSegment value) {
2187 assert(::metrics::StructuredDataProto_DeviceSegment_IsValid(value));
2188 _impl_._has_bits_[0] |= 0x00000002u;
2189 _impl_.device_segment_ = value;
2190 }
set_device_segment(::metrics::StructuredDataProto_DeviceSegment value)2191 inline void StructuredDataProto::set_device_segment(::metrics::StructuredDataProto_DeviceSegment value) {
2192 _internal_set_device_segment(value);
2193 // @@protoc_insertion_point(field_set:metrics.StructuredDataProto.device_segment)
2194 }
2195
2196 #ifdef __GNUC__
2197 #pragma GCC diagnostic pop
2198 #endif // __GNUC__
2199 // -------------------------------------------------------------------
2200
2201 // -------------------------------------------------------------------
2202
2203 // -------------------------------------------------------------------
2204
2205 // -------------------------------------------------------------------
2206
2207
2208 // @@protoc_insertion_point(namespace_scope)
2209
2210 } // namespace metrics
2211
2212 PROTOBUF_NAMESPACE_OPEN
2213
2214 template <> struct is_proto_enum< ::metrics::StructuredEventProto_EventType> : ::std::true_type {};
2215 template <> struct is_proto_enum< ::metrics::StructuredEventProto_PrimaryUserSegment> : ::std::true_type {};
2216 template <> struct is_proto_enum< ::metrics::StructuredDataProto_DeviceSegment> : ::std::true_type {};
2217
2218 PROTOBUF_NAMESPACE_CLOSE
2219
2220 // @@protoc_insertion_point(global_scope)
2221
2222 #include <google/protobuf/port_undef.inc>
2223 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_structured_5fdata_2eproto
2224