1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: translate_event.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_translate_5fevent_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_translate_5fevent_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_translate_5fevent_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_translate_5fevent_2eproto {
43 static const uint32_t offsets[];
44 };
45 namespace metrics {
46 class TranslateEventProto;
47 struct TranslateEventProtoDefaultTypeInternal;
48 extern TranslateEventProtoDefaultTypeInternal _TranslateEventProto_default_instance_;
49 } // namespace metrics
50 PROTOBUF_NAMESPACE_OPEN
51 template<> ::metrics::TranslateEventProto* Arena::CreateMaybeMessage<::metrics::TranslateEventProto>(Arena*);
52 PROTOBUF_NAMESPACE_CLOSE
53 namespace metrics {
54
55 enum TranslateEventProto_RankerResponse : int {
56 TranslateEventProto_RankerResponse_SHOW = 0,
57 TranslateEventProto_RankerResponse_DONT_SHOW = 1,
58 TranslateEventProto_RankerResponse_NOT_QUERIED = 2
59 };
60 bool TranslateEventProto_RankerResponse_IsValid(int value);
61 constexpr TranslateEventProto_RankerResponse TranslateEventProto_RankerResponse_RankerResponse_MIN = TranslateEventProto_RankerResponse_SHOW;
62 constexpr TranslateEventProto_RankerResponse TranslateEventProto_RankerResponse_RankerResponse_MAX = TranslateEventProto_RankerResponse_NOT_QUERIED;
63 constexpr int TranslateEventProto_RankerResponse_RankerResponse_ARRAYSIZE = TranslateEventProto_RankerResponse_RankerResponse_MAX + 1;
64
65 const std::string& TranslateEventProto_RankerResponse_Name(TranslateEventProto_RankerResponse value);
66 template<typename T>
TranslateEventProto_RankerResponse_Name(T enum_t_value)67 inline const std::string& TranslateEventProto_RankerResponse_Name(T enum_t_value) {
68 static_assert(::std::is_same<T, TranslateEventProto_RankerResponse>::value ||
69 ::std::is_integral<T>::value,
70 "Incorrect type passed to function TranslateEventProto_RankerResponse_Name.");
71 return TranslateEventProto_RankerResponse_Name(static_cast<TranslateEventProto_RankerResponse>(enum_t_value));
72 }
73 bool TranslateEventProto_RankerResponse_Parse(
74 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TranslateEventProto_RankerResponse* value);
75 enum TranslateEventProto_EventType : int {
76 TranslateEventProto_EventType_UNKNOWN = 0,
77 TranslateEventProto_EventType_USER_DECLINE = 1,
78 TranslateEventProto_EventType_USER_ACCEPT = 2,
79 TranslateEventProto_EventType_USER_DISMISS = 3,
80 TranslateEventProto_EventType_USER_IGNORE = 4,
81 TranslateEventProto_EventType_USER_NEVER_TRANSLATE_LANGUAGE = 5,
82 TranslateEventProto_EventType_USER_NEVER_TRANSLATE_SITE = 6,
83 TranslateEventProto_EventType_USER_ALWAYS_TRANSLATE_LANGUAGE = 7,
84 TranslateEventProto_EventType_USER_CONTEXT_MENU_TRANSLATE = 8,
85 TranslateEventProto_EventType_USER_REVERT = 9,
86 TranslateEventProto_EventType_AUTOMATICALLY_TRANSLATED = 10,
87 TranslateEventProto_EventType_AUTO_TRANSLATION_BY_PREF = 25,
88 TranslateEventProto_EventType_AUTO_TRANSLATION_BY_LINK = 26,
89 TranslateEventProto_EventType_DISABLED_BY_PREF = 11,
90 TranslateEventProto_EventType_LANGUAGE_DISABLED_BY_USER_CONFIG = 12,
91 TranslateEventProto_EventType_URL_DISABLED_BY_USER_CONFIG = 13,
92 TranslateEventProto_EventType_LANGUAGE_DISABLED_BY_AUTO_BLACKLIST = 14,
93 TranslateEventProto_EventType_DISABLED_BY_RANKER = 15,
94 TranslateEventProto_EventType_UNSUPPORTED_LANGUAGE = 16,
95 TranslateEventProto_EventType_UNSUPPORTED_URL = 17,
96 TranslateEventProto_EventType_MATCHES_PREVIOUS_LANGUAGE = 18,
97 TranslateEventProto_EventType_BROWSER_WINDOW_IS_INVALID = 19,
98 TranslateEventProto_EventType_BROWSER_WINDOW_NOT_ACTIVE = 20,
99 TranslateEventProto_EventType_BROWSER_WINDOW_IS_MINIMIZED = 21,
100 TranslateEventProto_EventType_WEB_CONTENTS_NOT_ACTIVE = 22,
101 TranslateEventProto_EventType_EDITABLE_FIELD_IS_ACTIVE = 23,
102 TranslateEventProto_EventType_LANGUAGE_IN_ULP = 24,
103 TranslateEventProto_EventType_INITIALIZATION_ERROR = 27
104 };
105 bool TranslateEventProto_EventType_IsValid(int value);
106 constexpr TranslateEventProto_EventType TranslateEventProto_EventType_EventType_MIN = TranslateEventProto_EventType_UNKNOWN;
107 constexpr TranslateEventProto_EventType TranslateEventProto_EventType_EventType_MAX = TranslateEventProto_EventType_INITIALIZATION_ERROR;
108 constexpr int TranslateEventProto_EventType_EventType_ARRAYSIZE = TranslateEventProto_EventType_EventType_MAX + 1;
109
110 const std::string& TranslateEventProto_EventType_Name(TranslateEventProto_EventType value);
111 template<typename T>
TranslateEventProto_EventType_Name(T enum_t_value)112 inline const std::string& TranslateEventProto_EventType_Name(T enum_t_value) {
113 static_assert(::std::is_same<T, TranslateEventProto_EventType>::value ||
114 ::std::is_integral<T>::value,
115 "Incorrect type passed to function TranslateEventProto_EventType_Name.");
116 return TranslateEventProto_EventType_Name(static_cast<TranslateEventProto_EventType>(enum_t_value));
117 }
118 bool TranslateEventProto_EventType_Parse(
119 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TranslateEventProto_EventType* value);
120 // ===================================================================
121
122 class TranslateEventProto final :
123 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.TranslateEventProto) */ {
124 public:
TranslateEventProto()125 inline TranslateEventProto() : TranslateEventProto(nullptr) {}
126 ~TranslateEventProto() override;
127 explicit PROTOBUF_CONSTEXPR TranslateEventProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
128
129 TranslateEventProto(const TranslateEventProto& from);
TranslateEventProto(TranslateEventProto && from)130 TranslateEventProto(TranslateEventProto&& from) noexcept
131 : TranslateEventProto() {
132 *this = ::std::move(from);
133 }
134
135 inline TranslateEventProto& operator=(const TranslateEventProto& from) {
136 CopyFrom(from);
137 return *this;
138 }
139 inline TranslateEventProto& operator=(TranslateEventProto&& from) noexcept {
140 if (this == &from) return *this;
141 if (GetOwningArena() == from.GetOwningArena()
142 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
143 && GetOwningArena() != nullptr
144 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
145 ) {
146 InternalSwap(&from);
147 } else {
148 CopyFrom(from);
149 }
150 return *this;
151 }
152
unknown_fields()153 inline const std::string& unknown_fields() const {
154 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
155 }
mutable_unknown_fields()156 inline std::string* mutable_unknown_fields() {
157 return _internal_metadata_.mutable_unknown_fields<std::string>();
158 }
159
default_instance()160 static const TranslateEventProto& default_instance() {
161 return *internal_default_instance();
162 }
internal_default_instance()163 static inline const TranslateEventProto* internal_default_instance() {
164 return reinterpret_cast<const TranslateEventProto*>(
165 &_TranslateEventProto_default_instance_);
166 }
167 static constexpr int kIndexInFileMessages =
168 0;
169
swap(TranslateEventProto & a,TranslateEventProto & b)170 friend void swap(TranslateEventProto& a, TranslateEventProto& b) {
171 a.Swap(&b);
172 }
Swap(TranslateEventProto * other)173 PROTOBUF_NOINLINE void Swap(TranslateEventProto* other) {
174 if (other == this) return;
175 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
176 if (GetOwningArena() != nullptr &&
177 GetOwningArena() == other->GetOwningArena()) {
178 #else // PROTOBUF_FORCE_COPY_IN_SWAP
179 if (GetOwningArena() == other->GetOwningArena()) {
180 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
181 InternalSwap(other);
182 } else {
183 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
184 }
185 }
186 void UnsafeArenaSwap(TranslateEventProto* other) {
187 if (other == this) return;
188 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
189 InternalSwap(other);
190 }
191
192 // implements Message ----------------------------------------------
193
194 TranslateEventProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
195 return CreateMaybeMessage<TranslateEventProto>(arena);
196 }
197 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
198 void CopyFrom(const TranslateEventProto& from);
199 void MergeFrom(const TranslateEventProto& from);
200 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
201 bool IsInitialized() const final;
202
203 size_t ByteSizeLong() const final;
204 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
205 uint8_t* _InternalSerialize(
206 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
207 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
208
209 private:
210 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
211 void SharedDtor();
212 void SetCachedSize(int size) const;
213 void InternalSwap(TranslateEventProto* other);
214
215 private:
216 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
217 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
218 return "metrics.TranslateEventProto";
219 }
220 protected:
221 explicit TranslateEventProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
222 bool is_message_owned = false);
223 public:
224
225 std::string GetTypeName() const final;
226
227 // nested types ----------------------------------------------------
228
229 typedef TranslateEventProto_RankerResponse RankerResponse;
230 static constexpr RankerResponse SHOW =
231 TranslateEventProto_RankerResponse_SHOW;
232 static constexpr RankerResponse DONT_SHOW =
233 TranslateEventProto_RankerResponse_DONT_SHOW;
234 static constexpr RankerResponse NOT_QUERIED =
235 TranslateEventProto_RankerResponse_NOT_QUERIED;
236 static inline bool RankerResponse_IsValid(int value) {
237 return TranslateEventProto_RankerResponse_IsValid(value);
238 }
239 static constexpr RankerResponse RankerResponse_MIN =
240 TranslateEventProto_RankerResponse_RankerResponse_MIN;
241 static constexpr RankerResponse RankerResponse_MAX =
242 TranslateEventProto_RankerResponse_RankerResponse_MAX;
243 static constexpr int RankerResponse_ARRAYSIZE =
244 TranslateEventProto_RankerResponse_RankerResponse_ARRAYSIZE;
245 template<typename T>
246 static inline const std::string& RankerResponse_Name(T enum_t_value) {
247 static_assert(::std::is_same<T, RankerResponse>::value ||
248 ::std::is_integral<T>::value,
249 "Incorrect type passed to function RankerResponse_Name.");
250 return TranslateEventProto_RankerResponse_Name(enum_t_value);
251 }
252 static inline bool RankerResponse_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
253 RankerResponse* value) {
254 return TranslateEventProto_RankerResponse_Parse(name, value);
255 }
256
257 typedef TranslateEventProto_EventType EventType;
258 static constexpr EventType UNKNOWN =
259 TranslateEventProto_EventType_UNKNOWN;
260 static constexpr EventType USER_DECLINE =
261 TranslateEventProto_EventType_USER_DECLINE;
262 static constexpr EventType USER_ACCEPT =
263 TranslateEventProto_EventType_USER_ACCEPT;
264 static constexpr EventType USER_DISMISS =
265 TranslateEventProto_EventType_USER_DISMISS;
266 static constexpr EventType USER_IGNORE =
267 TranslateEventProto_EventType_USER_IGNORE;
268 static constexpr EventType USER_NEVER_TRANSLATE_LANGUAGE =
269 TranslateEventProto_EventType_USER_NEVER_TRANSLATE_LANGUAGE;
270 static constexpr EventType USER_NEVER_TRANSLATE_SITE =
271 TranslateEventProto_EventType_USER_NEVER_TRANSLATE_SITE;
272 static constexpr EventType USER_ALWAYS_TRANSLATE_LANGUAGE =
273 TranslateEventProto_EventType_USER_ALWAYS_TRANSLATE_LANGUAGE;
274 static constexpr EventType USER_CONTEXT_MENU_TRANSLATE =
275 TranslateEventProto_EventType_USER_CONTEXT_MENU_TRANSLATE;
276 static constexpr EventType USER_REVERT =
277 TranslateEventProto_EventType_USER_REVERT;
278 static constexpr EventType AUTOMATICALLY_TRANSLATED =
279 TranslateEventProto_EventType_AUTOMATICALLY_TRANSLATED;
280 static constexpr EventType AUTO_TRANSLATION_BY_PREF =
281 TranslateEventProto_EventType_AUTO_TRANSLATION_BY_PREF;
282 static constexpr EventType AUTO_TRANSLATION_BY_LINK =
283 TranslateEventProto_EventType_AUTO_TRANSLATION_BY_LINK;
284 static constexpr EventType DISABLED_BY_PREF =
285 TranslateEventProto_EventType_DISABLED_BY_PREF;
286 static constexpr EventType LANGUAGE_DISABLED_BY_USER_CONFIG =
287 TranslateEventProto_EventType_LANGUAGE_DISABLED_BY_USER_CONFIG;
288 static constexpr EventType URL_DISABLED_BY_USER_CONFIG =
289 TranslateEventProto_EventType_URL_DISABLED_BY_USER_CONFIG;
290 static constexpr EventType LANGUAGE_DISABLED_BY_AUTO_BLACKLIST =
291 TranslateEventProto_EventType_LANGUAGE_DISABLED_BY_AUTO_BLACKLIST;
292 static constexpr EventType DISABLED_BY_RANKER =
293 TranslateEventProto_EventType_DISABLED_BY_RANKER;
294 static constexpr EventType UNSUPPORTED_LANGUAGE =
295 TranslateEventProto_EventType_UNSUPPORTED_LANGUAGE;
296 static constexpr EventType UNSUPPORTED_URL =
297 TranslateEventProto_EventType_UNSUPPORTED_URL;
298 static constexpr EventType MATCHES_PREVIOUS_LANGUAGE =
299 TranslateEventProto_EventType_MATCHES_PREVIOUS_LANGUAGE;
300 static constexpr EventType BROWSER_WINDOW_IS_INVALID =
301 TranslateEventProto_EventType_BROWSER_WINDOW_IS_INVALID;
302 static constexpr EventType BROWSER_WINDOW_NOT_ACTIVE =
303 TranslateEventProto_EventType_BROWSER_WINDOW_NOT_ACTIVE;
304 static constexpr EventType BROWSER_WINDOW_IS_MINIMIZED =
305 TranslateEventProto_EventType_BROWSER_WINDOW_IS_MINIMIZED;
306 static constexpr EventType WEB_CONTENTS_NOT_ACTIVE =
307 TranslateEventProto_EventType_WEB_CONTENTS_NOT_ACTIVE;
308 static constexpr EventType EDITABLE_FIELD_IS_ACTIVE =
309 TranslateEventProto_EventType_EDITABLE_FIELD_IS_ACTIVE;
310 static constexpr EventType LANGUAGE_IN_ULP =
311 TranslateEventProto_EventType_LANGUAGE_IN_ULP;
312 static constexpr EventType INITIALIZATION_ERROR =
313 TranslateEventProto_EventType_INITIALIZATION_ERROR;
314 static inline bool EventType_IsValid(int value) {
315 return TranslateEventProto_EventType_IsValid(value);
316 }
317 static constexpr EventType EventType_MIN =
318 TranslateEventProto_EventType_EventType_MIN;
319 static constexpr EventType EventType_MAX =
320 TranslateEventProto_EventType_EventType_MAX;
321 static constexpr int EventType_ARRAYSIZE =
322 TranslateEventProto_EventType_EventType_ARRAYSIZE;
323 template<typename T>
324 static inline const std::string& EventType_Name(T enum_t_value) {
325 static_assert(::std::is_same<T, EventType>::value ||
326 ::std::is_integral<T>::value,
327 "Incorrect type passed to function EventType_Name.");
328 return TranslateEventProto_EventType_Name(enum_t_value);
329 }
330 static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
331 EventType* value) {
332 return TranslateEventProto_EventType_Parse(name, value);
333 }
334
335 // accessors -------------------------------------------------------
336
337 enum : int {
338 kLanguageListFieldNumber = 6,
339 kDecisionOverridesFieldNumber = 15,
340 kSourceLanguageFieldNumber = 1,
341 kTargetLanguageFieldNumber = 2,
342 kModifiedSourceLanguageFieldNumber = 12,
343 kModifiedTargetLanguageFieldNumber = 13,
344 kCountryFieldNumber = 14,
345 kAcceptCountFieldNumber = 3,
346 kDeclineCountFieldNumber = 4,
347 kIgnoreCountFieldNumber = 5,
348 kRankerVersionFieldNumber = 7,
349 kRankerRequestTimestampSecFieldNumber = 8,
350 kEventTimestampSecFieldNumber = 11,
351 kEventTypeFieldNumber = 10,
352 kRankerResponseFieldNumber = 9,
353 };
354 // repeated string language_list = 6;
355 int language_list_size() const;
356 private:
357 int _internal_language_list_size() const;
358 public:
359 void clear_language_list();
360 const std::string& language_list(int index) const;
361 std::string* mutable_language_list(int index);
362 void set_language_list(int index, const std::string& value);
363 void set_language_list(int index, std::string&& value);
364 void set_language_list(int index, const char* value);
365 void set_language_list(int index, const char* value, size_t size);
366 std::string* add_language_list();
367 void add_language_list(const std::string& value);
368 void add_language_list(std::string&& value);
369 void add_language_list(const char* value);
370 void add_language_list(const char* value, size_t size);
371 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& language_list() const;
372 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_language_list();
373 private:
374 const std::string& _internal_language_list(int index) const;
375 std::string* _internal_add_language_list();
376 public:
377
378 // repeated .metrics.TranslateEventProto.EventType decision_overrides = 15;
379 int decision_overrides_size() const;
380 private:
381 int _internal_decision_overrides_size() const;
382 public:
383 void clear_decision_overrides();
384 private:
385 ::metrics::TranslateEventProto_EventType _internal_decision_overrides(int index) const;
386 void _internal_add_decision_overrides(::metrics::TranslateEventProto_EventType value);
387 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_decision_overrides();
388 public:
389 ::metrics::TranslateEventProto_EventType decision_overrides(int index) const;
390 void set_decision_overrides(int index, ::metrics::TranslateEventProto_EventType value);
391 void add_decision_overrides(::metrics::TranslateEventProto_EventType value);
392 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& decision_overrides() const;
393 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_decision_overrides();
394
395 // optional string source_language = 1;
396 bool has_source_language() const;
397 private:
398 bool _internal_has_source_language() const;
399 public:
400 void clear_source_language();
401 const std::string& source_language() const;
402 template <typename ArgT0 = const std::string&, typename... ArgT>
403 void set_source_language(ArgT0&& arg0, ArgT... args);
404 std::string* mutable_source_language();
405 PROTOBUF_NODISCARD std::string* release_source_language();
406 void set_allocated_source_language(std::string* source_language);
407 private:
408 const std::string& _internal_source_language() const;
409 inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_language(const std::string& value);
410 std::string* _internal_mutable_source_language();
411 public:
412
413 // optional string target_language = 2;
414 bool has_target_language() const;
415 private:
416 bool _internal_has_target_language() const;
417 public:
418 void clear_target_language();
419 const std::string& target_language() const;
420 template <typename ArgT0 = const std::string&, typename... ArgT>
421 void set_target_language(ArgT0&& arg0, ArgT... args);
422 std::string* mutable_target_language();
423 PROTOBUF_NODISCARD std::string* release_target_language();
424 void set_allocated_target_language(std::string* target_language);
425 private:
426 const std::string& _internal_target_language() const;
427 inline PROTOBUF_ALWAYS_INLINE void _internal_set_target_language(const std::string& value);
428 std::string* _internal_mutable_target_language();
429 public:
430
431 // optional string modified_source_language = 12;
432 bool has_modified_source_language() const;
433 private:
434 bool _internal_has_modified_source_language() const;
435 public:
436 void clear_modified_source_language();
437 const std::string& modified_source_language() const;
438 template <typename ArgT0 = const std::string&, typename... ArgT>
439 void set_modified_source_language(ArgT0&& arg0, ArgT... args);
440 std::string* mutable_modified_source_language();
441 PROTOBUF_NODISCARD std::string* release_modified_source_language();
442 void set_allocated_modified_source_language(std::string* modified_source_language);
443 private:
444 const std::string& _internal_modified_source_language() const;
445 inline PROTOBUF_ALWAYS_INLINE void _internal_set_modified_source_language(const std::string& value);
446 std::string* _internal_mutable_modified_source_language();
447 public:
448
449 // optional string modified_target_language = 13;
450 bool has_modified_target_language() const;
451 private:
452 bool _internal_has_modified_target_language() const;
453 public:
454 void clear_modified_target_language();
455 const std::string& modified_target_language() const;
456 template <typename ArgT0 = const std::string&, typename... ArgT>
457 void set_modified_target_language(ArgT0&& arg0, ArgT... args);
458 std::string* mutable_modified_target_language();
459 PROTOBUF_NODISCARD std::string* release_modified_target_language();
460 void set_allocated_modified_target_language(std::string* modified_target_language);
461 private:
462 const std::string& _internal_modified_target_language() const;
463 inline PROTOBUF_ALWAYS_INLINE void _internal_set_modified_target_language(const std::string& value);
464 std::string* _internal_mutable_modified_target_language();
465 public:
466
467 // optional string country = 14;
468 bool has_country() const;
469 private:
470 bool _internal_has_country() const;
471 public:
472 void clear_country();
473 const std::string& country() const;
474 template <typename ArgT0 = const std::string&, typename... ArgT>
475 void set_country(ArgT0&& arg0, ArgT... args);
476 std::string* mutable_country();
477 PROTOBUF_NODISCARD std::string* release_country();
478 void set_allocated_country(std::string* country);
479 private:
480 const std::string& _internal_country() const;
481 inline PROTOBUF_ALWAYS_INLINE void _internal_set_country(const std::string& value);
482 std::string* _internal_mutable_country();
483 public:
484
485 // optional int32 accept_count = 3;
486 bool has_accept_count() const;
487 private:
488 bool _internal_has_accept_count() const;
489 public:
490 void clear_accept_count();
491 int32_t accept_count() const;
492 void set_accept_count(int32_t value);
493 private:
494 int32_t _internal_accept_count() const;
495 void _internal_set_accept_count(int32_t value);
496 public:
497
498 // optional int32 decline_count = 4;
499 bool has_decline_count() const;
500 private:
501 bool _internal_has_decline_count() const;
502 public:
503 void clear_decline_count();
504 int32_t decline_count() const;
505 void set_decline_count(int32_t value);
506 private:
507 int32_t _internal_decline_count() const;
508 void _internal_set_decline_count(int32_t value);
509 public:
510
511 // optional int32 ignore_count = 5;
512 bool has_ignore_count() const;
513 private:
514 bool _internal_has_ignore_count() const;
515 public:
516 void clear_ignore_count();
517 int32_t ignore_count() const;
518 void set_ignore_count(int32_t value);
519 private:
520 int32_t _internal_ignore_count() const;
521 void _internal_set_ignore_count(int32_t value);
522 public:
523
524 // optional uint32 ranker_version = 7;
525 bool has_ranker_version() const;
526 private:
527 bool _internal_has_ranker_version() const;
528 public:
529 void clear_ranker_version();
530 uint32_t ranker_version() const;
531 void set_ranker_version(uint32_t value);
532 private:
533 uint32_t _internal_ranker_version() const;
534 void _internal_set_ranker_version(uint32_t value);
535 public:
536
537 // optional int64 ranker_request_timestamp_sec = 8;
538 bool has_ranker_request_timestamp_sec() const;
539 private:
540 bool _internal_has_ranker_request_timestamp_sec() const;
541 public:
542 void clear_ranker_request_timestamp_sec();
543 int64_t ranker_request_timestamp_sec() const;
544 void set_ranker_request_timestamp_sec(int64_t value);
545 private:
546 int64_t _internal_ranker_request_timestamp_sec() const;
547 void _internal_set_ranker_request_timestamp_sec(int64_t value);
548 public:
549
550 // optional int64 event_timestamp_sec = 11;
551 bool has_event_timestamp_sec() const;
552 private:
553 bool _internal_has_event_timestamp_sec() const;
554 public:
555 void clear_event_timestamp_sec();
556 int64_t event_timestamp_sec() const;
557 void set_event_timestamp_sec(int64_t value);
558 private:
559 int64_t _internal_event_timestamp_sec() const;
560 void _internal_set_event_timestamp_sec(int64_t value);
561 public:
562
563 // optional .metrics.TranslateEventProto.EventType event_type = 10;
564 bool has_event_type() const;
565 private:
566 bool _internal_has_event_type() const;
567 public:
568 void clear_event_type();
569 ::metrics::TranslateEventProto_EventType event_type() const;
570 void set_event_type(::metrics::TranslateEventProto_EventType value);
571 private:
572 ::metrics::TranslateEventProto_EventType _internal_event_type() const;
573 void _internal_set_event_type(::metrics::TranslateEventProto_EventType value);
574 public:
575
576 // optional .metrics.TranslateEventProto.RankerResponse ranker_response = 9 [default = NOT_QUERIED];
577 bool has_ranker_response() const;
578 private:
579 bool _internal_has_ranker_response() const;
580 public:
581 void clear_ranker_response();
582 ::metrics::TranslateEventProto_RankerResponse ranker_response() const;
583 void set_ranker_response(::metrics::TranslateEventProto_RankerResponse value);
584 private:
585 ::metrics::TranslateEventProto_RankerResponse _internal_ranker_response() const;
586 void _internal_set_ranker_response(::metrics::TranslateEventProto_RankerResponse value);
587 public:
588
589 // @@protoc_insertion_point(class_scope:metrics.TranslateEventProto)
590 private:
591 class _Internal;
592
593 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
594 typedef void InternalArenaConstructable_;
595 typedef void DestructorSkippable_;
596 struct Impl_ {
597 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
598 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
599 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> language_list_;
600 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> decision_overrides_;
601 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_language_;
602 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr target_language_;
603 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modified_source_language_;
604 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modified_target_language_;
605 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr country_;
606 int32_t accept_count_;
607 int32_t decline_count_;
608 int32_t ignore_count_;
609 uint32_t ranker_version_;
610 int64_t ranker_request_timestamp_sec_;
611 int64_t event_timestamp_sec_;
612 int event_type_;
613 int ranker_response_;
614 };
615 union { Impl_ _impl_; };
616 friend struct ::TableStruct_translate_5fevent_2eproto;
617 };
618 // ===================================================================
619
620
621 // ===================================================================
622
623 #ifdef __GNUC__
624 #pragma GCC diagnostic push
625 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
626 #endif // __GNUC__
627 // TranslateEventProto
628
629 // optional string source_language = 1;
_internal_has_source_language()630 inline bool TranslateEventProto::_internal_has_source_language() const {
631 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
632 return value;
633 }
has_source_language()634 inline bool TranslateEventProto::has_source_language() const {
635 return _internal_has_source_language();
636 }
clear_source_language()637 inline void TranslateEventProto::clear_source_language() {
638 _impl_.source_language_.ClearToEmpty();
639 _impl_._has_bits_[0] &= ~0x00000001u;
640 }
source_language()641 inline const std::string& TranslateEventProto::source_language() const {
642 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.source_language)
643 return _internal_source_language();
644 }
645 template <typename ArgT0, typename... ArgT>
646 inline PROTOBUF_ALWAYS_INLINE
set_source_language(ArgT0 && arg0,ArgT...args)647 void TranslateEventProto::set_source_language(ArgT0&& arg0, ArgT... args) {
648 _impl_._has_bits_[0] |= 0x00000001u;
649 _impl_.source_language_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
650 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.source_language)
651 }
mutable_source_language()652 inline std::string* TranslateEventProto::mutable_source_language() {
653 std::string* _s = _internal_mutable_source_language();
654 // @@protoc_insertion_point(field_mutable:metrics.TranslateEventProto.source_language)
655 return _s;
656 }
_internal_source_language()657 inline const std::string& TranslateEventProto::_internal_source_language() const {
658 return _impl_.source_language_.Get();
659 }
_internal_set_source_language(const std::string & value)660 inline void TranslateEventProto::_internal_set_source_language(const std::string& value) {
661 _impl_._has_bits_[0] |= 0x00000001u;
662 _impl_.source_language_.Set(value, GetArenaForAllocation());
663 }
_internal_mutable_source_language()664 inline std::string* TranslateEventProto::_internal_mutable_source_language() {
665 _impl_._has_bits_[0] |= 0x00000001u;
666 return _impl_.source_language_.Mutable(GetArenaForAllocation());
667 }
release_source_language()668 inline std::string* TranslateEventProto::release_source_language() {
669 // @@protoc_insertion_point(field_release:metrics.TranslateEventProto.source_language)
670 if (!_internal_has_source_language()) {
671 return nullptr;
672 }
673 _impl_._has_bits_[0] &= ~0x00000001u;
674 auto* p = _impl_.source_language_.Release();
675 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
676 if (_impl_.source_language_.IsDefault()) {
677 _impl_.source_language_.Set("", GetArenaForAllocation());
678 }
679 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
680 return p;
681 }
set_allocated_source_language(std::string * source_language)682 inline void TranslateEventProto::set_allocated_source_language(std::string* source_language) {
683 if (source_language != nullptr) {
684 _impl_._has_bits_[0] |= 0x00000001u;
685 } else {
686 _impl_._has_bits_[0] &= ~0x00000001u;
687 }
688 _impl_.source_language_.SetAllocated(source_language, GetArenaForAllocation());
689 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
690 if (_impl_.source_language_.IsDefault()) {
691 _impl_.source_language_.Set("", GetArenaForAllocation());
692 }
693 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
694 // @@protoc_insertion_point(field_set_allocated:metrics.TranslateEventProto.source_language)
695 }
696
697 // optional string target_language = 2;
_internal_has_target_language()698 inline bool TranslateEventProto::_internal_has_target_language() const {
699 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
700 return value;
701 }
has_target_language()702 inline bool TranslateEventProto::has_target_language() const {
703 return _internal_has_target_language();
704 }
clear_target_language()705 inline void TranslateEventProto::clear_target_language() {
706 _impl_.target_language_.ClearToEmpty();
707 _impl_._has_bits_[0] &= ~0x00000002u;
708 }
target_language()709 inline const std::string& TranslateEventProto::target_language() const {
710 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.target_language)
711 return _internal_target_language();
712 }
713 template <typename ArgT0, typename... ArgT>
714 inline PROTOBUF_ALWAYS_INLINE
set_target_language(ArgT0 && arg0,ArgT...args)715 void TranslateEventProto::set_target_language(ArgT0&& arg0, ArgT... args) {
716 _impl_._has_bits_[0] |= 0x00000002u;
717 _impl_.target_language_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
718 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.target_language)
719 }
mutable_target_language()720 inline std::string* TranslateEventProto::mutable_target_language() {
721 std::string* _s = _internal_mutable_target_language();
722 // @@protoc_insertion_point(field_mutable:metrics.TranslateEventProto.target_language)
723 return _s;
724 }
_internal_target_language()725 inline const std::string& TranslateEventProto::_internal_target_language() const {
726 return _impl_.target_language_.Get();
727 }
_internal_set_target_language(const std::string & value)728 inline void TranslateEventProto::_internal_set_target_language(const std::string& value) {
729 _impl_._has_bits_[0] |= 0x00000002u;
730 _impl_.target_language_.Set(value, GetArenaForAllocation());
731 }
_internal_mutable_target_language()732 inline std::string* TranslateEventProto::_internal_mutable_target_language() {
733 _impl_._has_bits_[0] |= 0x00000002u;
734 return _impl_.target_language_.Mutable(GetArenaForAllocation());
735 }
release_target_language()736 inline std::string* TranslateEventProto::release_target_language() {
737 // @@protoc_insertion_point(field_release:metrics.TranslateEventProto.target_language)
738 if (!_internal_has_target_language()) {
739 return nullptr;
740 }
741 _impl_._has_bits_[0] &= ~0x00000002u;
742 auto* p = _impl_.target_language_.Release();
743 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
744 if (_impl_.target_language_.IsDefault()) {
745 _impl_.target_language_.Set("", GetArenaForAllocation());
746 }
747 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
748 return p;
749 }
set_allocated_target_language(std::string * target_language)750 inline void TranslateEventProto::set_allocated_target_language(std::string* target_language) {
751 if (target_language != nullptr) {
752 _impl_._has_bits_[0] |= 0x00000002u;
753 } else {
754 _impl_._has_bits_[0] &= ~0x00000002u;
755 }
756 _impl_.target_language_.SetAllocated(target_language, GetArenaForAllocation());
757 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
758 if (_impl_.target_language_.IsDefault()) {
759 _impl_.target_language_.Set("", GetArenaForAllocation());
760 }
761 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
762 // @@protoc_insertion_point(field_set_allocated:metrics.TranslateEventProto.target_language)
763 }
764
765 // optional string country = 14;
_internal_has_country()766 inline bool TranslateEventProto::_internal_has_country() const {
767 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
768 return value;
769 }
has_country()770 inline bool TranslateEventProto::has_country() const {
771 return _internal_has_country();
772 }
clear_country()773 inline void TranslateEventProto::clear_country() {
774 _impl_.country_.ClearToEmpty();
775 _impl_._has_bits_[0] &= ~0x00000010u;
776 }
country()777 inline const std::string& TranslateEventProto::country() const {
778 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.country)
779 return _internal_country();
780 }
781 template <typename ArgT0, typename... ArgT>
782 inline PROTOBUF_ALWAYS_INLINE
set_country(ArgT0 && arg0,ArgT...args)783 void TranslateEventProto::set_country(ArgT0&& arg0, ArgT... args) {
784 _impl_._has_bits_[0] |= 0x00000010u;
785 _impl_.country_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
786 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.country)
787 }
mutable_country()788 inline std::string* TranslateEventProto::mutable_country() {
789 std::string* _s = _internal_mutable_country();
790 // @@protoc_insertion_point(field_mutable:metrics.TranslateEventProto.country)
791 return _s;
792 }
_internal_country()793 inline const std::string& TranslateEventProto::_internal_country() const {
794 return _impl_.country_.Get();
795 }
_internal_set_country(const std::string & value)796 inline void TranslateEventProto::_internal_set_country(const std::string& value) {
797 _impl_._has_bits_[0] |= 0x00000010u;
798 _impl_.country_.Set(value, GetArenaForAllocation());
799 }
_internal_mutable_country()800 inline std::string* TranslateEventProto::_internal_mutable_country() {
801 _impl_._has_bits_[0] |= 0x00000010u;
802 return _impl_.country_.Mutable(GetArenaForAllocation());
803 }
release_country()804 inline std::string* TranslateEventProto::release_country() {
805 // @@protoc_insertion_point(field_release:metrics.TranslateEventProto.country)
806 if (!_internal_has_country()) {
807 return nullptr;
808 }
809 _impl_._has_bits_[0] &= ~0x00000010u;
810 auto* p = _impl_.country_.Release();
811 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
812 if (_impl_.country_.IsDefault()) {
813 _impl_.country_.Set("", GetArenaForAllocation());
814 }
815 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
816 return p;
817 }
set_allocated_country(std::string * country)818 inline void TranslateEventProto::set_allocated_country(std::string* country) {
819 if (country != nullptr) {
820 _impl_._has_bits_[0] |= 0x00000010u;
821 } else {
822 _impl_._has_bits_[0] &= ~0x00000010u;
823 }
824 _impl_.country_.SetAllocated(country, GetArenaForAllocation());
825 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
826 if (_impl_.country_.IsDefault()) {
827 _impl_.country_.Set("", GetArenaForAllocation());
828 }
829 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
830 // @@protoc_insertion_point(field_set_allocated:metrics.TranslateEventProto.country)
831 }
832
833 // optional int32 accept_count = 3;
_internal_has_accept_count()834 inline bool TranslateEventProto::_internal_has_accept_count() const {
835 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
836 return value;
837 }
has_accept_count()838 inline bool TranslateEventProto::has_accept_count() const {
839 return _internal_has_accept_count();
840 }
clear_accept_count()841 inline void TranslateEventProto::clear_accept_count() {
842 _impl_.accept_count_ = 0;
843 _impl_._has_bits_[0] &= ~0x00000020u;
844 }
_internal_accept_count()845 inline int32_t TranslateEventProto::_internal_accept_count() const {
846 return _impl_.accept_count_;
847 }
accept_count()848 inline int32_t TranslateEventProto::accept_count() const {
849 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.accept_count)
850 return _internal_accept_count();
851 }
_internal_set_accept_count(int32_t value)852 inline void TranslateEventProto::_internal_set_accept_count(int32_t value) {
853 _impl_._has_bits_[0] |= 0x00000020u;
854 _impl_.accept_count_ = value;
855 }
set_accept_count(int32_t value)856 inline void TranslateEventProto::set_accept_count(int32_t value) {
857 _internal_set_accept_count(value);
858 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.accept_count)
859 }
860
861 // optional int32 decline_count = 4;
_internal_has_decline_count()862 inline bool TranslateEventProto::_internal_has_decline_count() const {
863 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
864 return value;
865 }
has_decline_count()866 inline bool TranslateEventProto::has_decline_count() const {
867 return _internal_has_decline_count();
868 }
clear_decline_count()869 inline void TranslateEventProto::clear_decline_count() {
870 _impl_.decline_count_ = 0;
871 _impl_._has_bits_[0] &= ~0x00000040u;
872 }
_internal_decline_count()873 inline int32_t TranslateEventProto::_internal_decline_count() const {
874 return _impl_.decline_count_;
875 }
decline_count()876 inline int32_t TranslateEventProto::decline_count() const {
877 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.decline_count)
878 return _internal_decline_count();
879 }
_internal_set_decline_count(int32_t value)880 inline void TranslateEventProto::_internal_set_decline_count(int32_t value) {
881 _impl_._has_bits_[0] |= 0x00000040u;
882 _impl_.decline_count_ = value;
883 }
set_decline_count(int32_t value)884 inline void TranslateEventProto::set_decline_count(int32_t value) {
885 _internal_set_decline_count(value);
886 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.decline_count)
887 }
888
889 // optional int32 ignore_count = 5;
_internal_has_ignore_count()890 inline bool TranslateEventProto::_internal_has_ignore_count() const {
891 bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
892 return value;
893 }
has_ignore_count()894 inline bool TranslateEventProto::has_ignore_count() const {
895 return _internal_has_ignore_count();
896 }
clear_ignore_count()897 inline void TranslateEventProto::clear_ignore_count() {
898 _impl_.ignore_count_ = 0;
899 _impl_._has_bits_[0] &= ~0x00000080u;
900 }
_internal_ignore_count()901 inline int32_t TranslateEventProto::_internal_ignore_count() const {
902 return _impl_.ignore_count_;
903 }
ignore_count()904 inline int32_t TranslateEventProto::ignore_count() const {
905 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.ignore_count)
906 return _internal_ignore_count();
907 }
_internal_set_ignore_count(int32_t value)908 inline void TranslateEventProto::_internal_set_ignore_count(int32_t value) {
909 _impl_._has_bits_[0] |= 0x00000080u;
910 _impl_.ignore_count_ = value;
911 }
set_ignore_count(int32_t value)912 inline void TranslateEventProto::set_ignore_count(int32_t value) {
913 _internal_set_ignore_count(value);
914 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.ignore_count)
915 }
916
917 // repeated string language_list = 6;
_internal_language_list_size()918 inline int TranslateEventProto::_internal_language_list_size() const {
919 return _impl_.language_list_.size();
920 }
language_list_size()921 inline int TranslateEventProto::language_list_size() const {
922 return _internal_language_list_size();
923 }
clear_language_list()924 inline void TranslateEventProto::clear_language_list() {
925 _impl_.language_list_.Clear();
926 }
add_language_list()927 inline std::string* TranslateEventProto::add_language_list() {
928 std::string* _s = _internal_add_language_list();
929 // @@protoc_insertion_point(field_add_mutable:metrics.TranslateEventProto.language_list)
930 return _s;
931 }
_internal_language_list(int index)932 inline const std::string& TranslateEventProto::_internal_language_list(int index) const {
933 return _impl_.language_list_.Get(index);
934 }
language_list(int index)935 inline const std::string& TranslateEventProto::language_list(int index) const {
936 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.language_list)
937 return _internal_language_list(index);
938 }
mutable_language_list(int index)939 inline std::string* TranslateEventProto::mutable_language_list(int index) {
940 // @@protoc_insertion_point(field_mutable:metrics.TranslateEventProto.language_list)
941 return _impl_.language_list_.Mutable(index);
942 }
set_language_list(int index,const std::string & value)943 inline void TranslateEventProto::set_language_list(int index, const std::string& value) {
944 _impl_.language_list_.Mutable(index)->assign(value);
945 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.language_list)
946 }
set_language_list(int index,std::string && value)947 inline void TranslateEventProto::set_language_list(int index, std::string&& value) {
948 _impl_.language_list_.Mutable(index)->assign(std::move(value));
949 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.language_list)
950 }
set_language_list(int index,const char * value)951 inline void TranslateEventProto::set_language_list(int index, const char* value) {
952 GOOGLE_DCHECK(value != nullptr);
953 _impl_.language_list_.Mutable(index)->assign(value);
954 // @@protoc_insertion_point(field_set_char:metrics.TranslateEventProto.language_list)
955 }
set_language_list(int index,const char * value,size_t size)956 inline void TranslateEventProto::set_language_list(int index, const char* value, size_t size) {
957 _impl_.language_list_.Mutable(index)->assign(
958 reinterpret_cast<const char*>(value), size);
959 // @@protoc_insertion_point(field_set_pointer:metrics.TranslateEventProto.language_list)
960 }
_internal_add_language_list()961 inline std::string* TranslateEventProto::_internal_add_language_list() {
962 return _impl_.language_list_.Add();
963 }
add_language_list(const std::string & value)964 inline void TranslateEventProto::add_language_list(const std::string& value) {
965 _impl_.language_list_.Add()->assign(value);
966 // @@protoc_insertion_point(field_add:metrics.TranslateEventProto.language_list)
967 }
add_language_list(std::string && value)968 inline void TranslateEventProto::add_language_list(std::string&& value) {
969 _impl_.language_list_.Add(std::move(value));
970 // @@protoc_insertion_point(field_add:metrics.TranslateEventProto.language_list)
971 }
add_language_list(const char * value)972 inline void TranslateEventProto::add_language_list(const char* value) {
973 GOOGLE_DCHECK(value != nullptr);
974 _impl_.language_list_.Add()->assign(value);
975 // @@protoc_insertion_point(field_add_char:metrics.TranslateEventProto.language_list)
976 }
add_language_list(const char * value,size_t size)977 inline void TranslateEventProto::add_language_list(const char* value, size_t size) {
978 _impl_.language_list_.Add()->assign(reinterpret_cast<const char*>(value), size);
979 // @@protoc_insertion_point(field_add_pointer:metrics.TranslateEventProto.language_list)
980 }
981 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
language_list()982 TranslateEventProto::language_list() const {
983 // @@protoc_insertion_point(field_list:metrics.TranslateEventProto.language_list)
984 return _impl_.language_list_;
985 }
986 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_language_list()987 TranslateEventProto::mutable_language_list() {
988 // @@protoc_insertion_point(field_mutable_list:metrics.TranslateEventProto.language_list)
989 return &_impl_.language_list_;
990 }
991
992 // optional uint32 ranker_version = 7;
_internal_has_ranker_version()993 inline bool TranslateEventProto::_internal_has_ranker_version() const {
994 bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
995 return value;
996 }
has_ranker_version()997 inline bool TranslateEventProto::has_ranker_version() const {
998 return _internal_has_ranker_version();
999 }
clear_ranker_version()1000 inline void TranslateEventProto::clear_ranker_version() {
1001 _impl_.ranker_version_ = 0u;
1002 _impl_._has_bits_[0] &= ~0x00000100u;
1003 }
_internal_ranker_version()1004 inline uint32_t TranslateEventProto::_internal_ranker_version() const {
1005 return _impl_.ranker_version_;
1006 }
ranker_version()1007 inline uint32_t TranslateEventProto::ranker_version() const {
1008 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.ranker_version)
1009 return _internal_ranker_version();
1010 }
_internal_set_ranker_version(uint32_t value)1011 inline void TranslateEventProto::_internal_set_ranker_version(uint32_t value) {
1012 _impl_._has_bits_[0] |= 0x00000100u;
1013 _impl_.ranker_version_ = value;
1014 }
set_ranker_version(uint32_t value)1015 inline void TranslateEventProto::set_ranker_version(uint32_t value) {
1016 _internal_set_ranker_version(value);
1017 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.ranker_version)
1018 }
1019
1020 // optional int64 ranker_request_timestamp_sec = 8;
_internal_has_ranker_request_timestamp_sec()1021 inline bool TranslateEventProto::_internal_has_ranker_request_timestamp_sec() const {
1022 bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
1023 return value;
1024 }
has_ranker_request_timestamp_sec()1025 inline bool TranslateEventProto::has_ranker_request_timestamp_sec() const {
1026 return _internal_has_ranker_request_timestamp_sec();
1027 }
clear_ranker_request_timestamp_sec()1028 inline void TranslateEventProto::clear_ranker_request_timestamp_sec() {
1029 _impl_.ranker_request_timestamp_sec_ = int64_t{0};
1030 _impl_._has_bits_[0] &= ~0x00000200u;
1031 }
_internal_ranker_request_timestamp_sec()1032 inline int64_t TranslateEventProto::_internal_ranker_request_timestamp_sec() const {
1033 return _impl_.ranker_request_timestamp_sec_;
1034 }
ranker_request_timestamp_sec()1035 inline int64_t TranslateEventProto::ranker_request_timestamp_sec() const {
1036 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.ranker_request_timestamp_sec)
1037 return _internal_ranker_request_timestamp_sec();
1038 }
_internal_set_ranker_request_timestamp_sec(int64_t value)1039 inline void TranslateEventProto::_internal_set_ranker_request_timestamp_sec(int64_t value) {
1040 _impl_._has_bits_[0] |= 0x00000200u;
1041 _impl_.ranker_request_timestamp_sec_ = value;
1042 }
set_ranker_request_timestamp_sec(int64_t value)1043 inline void TranslateEventProto::set_ranker_request_timestamp_sec(int64_t value) {
1044 _internal_set_ranker_request_timestamp_sec(value);
1045 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.ranker_request_timestamp_sec)
1046 }
1047
1048 // optional .metrics.TranslateEventProto.RankerResponse ranker_response = 9 [default = NOT_QUERIED];
_internal_has_ranker_response()1049 inline bool TranslateEventProto::_internal_has_ranker_response() const {
1050 bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
1051 return value;
1052 }
has_ranker_response()1053 inline bool TranslateEventProto::has_ranker_response() const {
1054 return _internal_has_ranker_response();
1055 }
clear_ranker_response()1056 inline void TranslateEventProto::clear_ranker_response() {
1057 _impl_.ranker_response_ = 2;
1058 _impl_._has_bits_[0] &= ~0x00001000u;
1059 }
_internal_ranker_response()1060 inline ::metrics::TranslateEventProto_RankerResponse TranslateEventProto::_internal_ranker_response() const {
1061 return static_cast< ::metrics::TranslateEventProto_RankerResponse >(_impl_.ranker_response_);
1062 }
ranker_response()1063 inline ::metrics::TranslateEventProto_RankerResponse TranslateEventProto::ranker_response() const {
1064 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.ranker_response)
1065 return _internal_ranker_response();
1066 }
_internal_set_ranker_response(::metrics::TranslateEventProto_RankerResponse value)1067 inline void TranslateEventProto::_internal_set_ranker_response(::metrics::TranslateEventProto_RankerResponse value) {
1068 assert(::metrics::TranslateEventProto_RankerResponse_IsValid(value));
1069 _impl_._has_bits_[0] |= 0x00001000u;
1070 _impl_.ranker_response_ = value;
1071 }
set_ranker_response(::metrics::TranslateEventProto_RankerResponse value)1072 inline void TranslateEventProto::set_ranker_response(::metrics::TranslateEventProto_RankerResponse value) {
1073 _internal_set_ranker_response(value);
1074 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.ranker_response)
1075 }
1076
1077 // optional .metrics.TranslateEventProto.EventType event_type = 10;
_internal_has_event_type()1078 inline bool TranslateEventProto::_internal_has_event_type() const {
1079 bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
1080 return value;
1081 }
has_event_type()1082 inline bool TranslateEventProto::has_event_type() const {
1083 return _internal_has_event_type();
1084 }
clear_event_type()1085 inline void TranslateEventProto::clear_event_type() {
1086 _impl_.event_type_ = 0;
1087 _impl_._has_bits_[0] &= ~0x00000800u;
1088 }
_internal_event_type()1089 inline ::metrics::TranslateEventProto_EventType TranslateEventProto::_internal_event_type() const {
1090 return static_cast< ::metrics::TranslateEventProto_EventType >(_impl_.event_type_);
1091 }
event_type()1092 inline ::metrics::TranslateEventProto_EventType TranslateEventProto::event_type() const {
1093 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.event_type)
1094 return _internal_event_type();
1095 }
_internal_set_event_type(::metrics::TranslateEventProto_EventType value)1096 inline void TranslateEventProto::_internal_set_event_type(::metrics::TranslateEventProto_EventType value) {
1097 assert(::metrics::TranslateEventProto_EventType_IsValid(value));
1098 _impl_._has_bits_[0] |= 0x00000800u;
1099 _impl_.event_type_ = value;
1100 }
set_event_type(::metrics::TranslateEventProto_EventType value)1101 inline void TranslateEventProto::set_event_type(::metrics::TranslateEventProto_EventType value) {
1102 _internal_set_event_type(value);
1103 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.event_type)
1104 }
1105
1106 // repeated .metrics.TranslateEventProto.EventType decision_overrides = 15;
_internal_decision_overrides_size()1107 inline int TranslateEventProto::_internal_decision_overrides_size() const {
1108 return _impl_.decision_overrides_.size();
1109 }
decision_overrides_size()1110 inline int TranslateEventProto::decision_overrides_size() const {
1111 return _internal_decision_overrides_size();
1112 }
clear_decision_overrides()1113 inline void TranslateEventProto::clear_decision_overrides() {
1114 _impl_.decision_overrides_.Clear();
1115 }
_internal_decision_overrides(int index)1116 inline ::metrics::TranslateEventProto_EventType TranslateEventProto::_internal_decision_overrides(int index) const {
1117 return static_cast< ::metrics::TranslateEventProto_EventType >(_impl_.decision_overrides_.Get(index));
1118 }
decision_overrides(int index)1119 inline ::metrics::TranslateEventProto_EventType TranslateEventProto::decision_overrides(int index) const {
1120 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.decision_overrides)
1121 return _internal_decision_overrides(index);
1122 }
set_decision_overrides(int index,::metrics::TranslateEventProto_EventType value)1123 inline void TranslateEventProto::set_decision_overrides(int index, ::metrics::TranslateEventProto_EventType value) {
1124 assert(::metrics::TranslateEventProto_EventType_IsValid(value));
1125 _impl_.decision_overrides_.Set(index, value);
1126 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.decision_overrides)
1127 }
_internal_add_decision_overrides(::metrics::TranslateEventProto_EventType value)1128 inline void TranslateEventProto::_internal_add_decision_overrides(::metrics::TranslateEventProto_EventType value) {
1129 assert(::metrics::TranslateEventProto_EventType_IsValid(value));
1130 _impl_.decision_overrides_.Add(value);
1131 }
add_decision_overrides(::metrics::TranslateEventProto_EventType value)1132 inline void TranslateEventProto::add_decision_overrides(::metrics::TranslateEventProto_EventType value) {
1133 _internal_add_decision_overrides(value);
1134 // @@protoc_insertion_point(field_add:metrics.TranslateEventProto.decision_overrides)
1135 }
1136 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
decision_overrides()1137 TranslateEventProto::decision_overrides() const {
1138 // @@protoc_insertion_point(field_list:metrics.TranslateEventProto.decision_overrides)
1139 return _impl_.decision_overrides_;
1140 }
1141 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
_internal_mutable_decision_overrides()1142 TranslateEventProto::_internal_mutable_decision_overrides() {
1143 return &_impl_.decision_overrides_;
1144 }
1145 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
mutable_decision_overrides()1146 TranslateEventProto::mutable_decision_overrides() {
1147 // @@protoc_insertion_point(field_mutable_list:metrics.TranslateEventProto.decision_overrides)
1148 return _internal_mutable_decision_overrides();
1149 }
1150
1151 // optional int64 event_timestamp_sec = 11;
_internal_has_event_timestamp_sec()1152 inline bool TranslateEventProto::_internal_has_event_timestamp_sec() const {
1153 bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
1154 return value;
1155 }
has_event_timestamp_sec()1156 inline bool TranslateEventProto::has_event_timestamp_sec() const {
1157 return _internal_has_event_timestamp_sec();
1158 }
clear_event_timestamp_sec()1159 inline void TranslateEventProto::clear_event_timestamp_sec() {
1160 _impl_.event_timestamp_sec_ = int64_t{0};
1161 _impl_._has_bits_[0] &= ~0x00000400u;
1162 }
_internal_event_timestamp_sec()1163 inline int64_t TranslateEventProto::_internal_event_timestamp_sec() const {
1164 return _impl_.event_timestamp_sec_;
1165 }
event_timestamp_sec()1166 inline int64_t TranslateEventProto::event_timestamp_sec() const {
1167 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.event_timestamp_sec)
1168 return _internal_event_timestamp_sec();
1169 }
_internal_set_event_timestamp_sec(int64_t value)1170 inline void TranslateEventProto::_internal_set_event_timestamp_sec(int64_t value) {
1171 _impl_._has_bits_[0] |= 0x00000400u;
1172 _impl_.event_timestamp_sec_ = value;
1173 }
set_event_timestamp_sec(int64_t value)1174 inline void TranslateEventProto::set_event_timestamp_sec(int64_t value) {
1175 _internal_set_event_timestamp_sec(value);
1176 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.event_timestamp_sec)
1177 }
1178
1179 // optional string modified_source_language = 12;
_internal_has_modified_source_language()1180 inline bool TranslateEventProto::_internal_has_modified_source_language() const {
1181 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1182 return value;
1183 }
has_modified_source_language()1184 inline bool TranslateEventProto::has_modified_source_language() const {
1185 return _internal_has_modified_source_language();
1186 }
clear_modified_source_language()1187 inline void TranslateEventProto::clear_modified_source_language() {
1188 _impl_.modified_source_language_.ClearToEmpty();
1189 _impl_._has_bits_[0] &= ~0x00000004u;
1190 }
modified_source_language()1191 inline const std::string& TranslateEventProto::modified_source_language() const {
1192 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.modified_source_language)
1193 return _internal_modified_source_language();
1194 }
1195 template <typename ArgT0, typename... ArgT>
1196 inline PROTOBUF_ALWAYS_INLINE
set_modified_source_language(ArgT0 && arg0,ArgT...args)1197 void TranslateEventProto::set_modified_source_language(ArgT0&& arg0, ArgT... args) {
1198 _impl_._has_bits_[0] |= 0x00000004u;
1199 _impl_.modified_source_language_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1200 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.modified_source_language)
1201 }
mutable_modified_source_language()1202 inline std::string* TranslateEventProto::mutable_modified_source_language() {
1203 std::string* _s = _internal_mutable_modified_source_language();
1204 // @@protoc_insertion_point(field_mutable:metrics.TranslateEventProto.modified_source_language)
1205 return _s;
1206 }
_internal_modified_source_language()1207 inline const std::string& TranslateEventProto::_internal_modified_source_language() const {
1208 return _impl_.modified_source_language_.Get();
1209 }
_internal_set_modified_source_language(const std::string & value)1210 inline void TranslateEventProto::_internal_set_modified_source_language(const std::string& value) {
1211 _impl_._has_bits_[0] |= 0x00000004u;
1212 _impl_.modified_source_language_.Set(value, GetArenaForAllocation());
1213 }
_internal_mutable_modified_source_language()1214 inline std::string* TranslateEventProto::_internal_mutable_modified_source_language() {
1215 _impl_._has_bits_[0] |= 0x00000004u;
1216 return _impl_.modified_source_language_.Mutable(GetArenaForAllocation());
1217 }
release_modified_source_language()1218 inline std::string* TranslateEventProto::release_modified_source_language() {
1219 // @@protoc_insertion_point(field_release:metrics.TranslateEventProto.modified_source_language)
1220 if (!_internal_has_modified_source_language()) {
1221 return nullptr;
1222 }
1223 _impl_._has_bits_[0] &= ~0x00000004u;
1224 auto* p = _impl_.modified_source_language_.Release();
1225 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1226 if (_impl_.modified_source_language_.IsDefault()) {
1227 _impl_.modified_source_language_.Set("", GetArenaForAllocation());
1228 }
1229 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1230 return p;
1231 }
set_allocated_modified_source_language(std::string * modified_source_language)1232 inline void TranslateEventProto::set_allocated_modified_source_language(std::string* modified_source_language) {
1233 if (modified_source_language != nullptr) {
1234 _impl_._has_bits_[0] |= 0x00000004u;
1235 } else {
1236 _impl_._has_bits_[0] &= ~0x00000004u;
1237 }
1238 _impl_.modified_source_language_.SetAllocated(modified_source_language, GetArenaForAllocation());
1239 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1240 if (_impl_.modified_source_language_.IsDefault()) {
1241 _impl_.modified_source_language_.Set("", GetArenaForAllocation());
1242 }
1243 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1244 // @@protoc_insertion_point(field_set_allocated:metrics.TranslateEventProto.modified_source_language)
1245 }
1246
1247 // optional string modified_target_language = 13;
_internal_has_modified_target_language()1248 inline bool TranslateEventProto::_internal_has_modified_target_language() const {
1249 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1250 return value;
1251 }
has_modified_target_language()1252 inline bool TranslateEventProto::has_modified_target_language() const {
1253 return _internal_has_modified_target_language();
1254 }
clear_modified_target_language()1255 inline void TranslateEventProto::clear_modified_target_language() {
1256 _impl_.modified_target_language_.ClearToEmpty();
1257 _impl_._has_bits_[0] &= ~0x00000008u;
1258 }
modified_target_language()1259 inline const std::string& TranslateEventProto::modified_target_language() const {
1260 // @@protoc_insertion_point(field_get:metrics.TranslateEventProto.modified_target_language)
1261 return _internal_modified_target_language();
1262 }
1263 template <typename ArgT0, typename... ArgT>
1264 inline PROTOBUF_ALWAYS_INLINE
set_modified_target_language(ArgT0 && arg0,ArgT...args)1265 void TranslateEventProto::set_modified_target_language(ArgT0&& arg0, ArgT... args) {
1266 _impl_._has_bits_[0] |= 0x00000008u;
1267 _impl_.modified_target_language_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1268 // @@protoc_insertion_point(field_set:metrics.TranslateEventProto.modified_target_language)
1269 }
mutable_modified_target_language()1270 inline std::string* TranslateEventProto::mutable_modified_target_language() {
1271 std::string* _s = _internal_mutable_modified_target_language();
1272 // @@protoc_insertion_point(field_mutable:metrics.TranslateEventProto.modified_target_language)
1273 return _s;
1274 }
_internal_modified_target_language()1275 inline const std::string& TranslateEventProto::_internal_modified_target_language() const {
1276 return _impl_.modified_target_language_.Get();
1277 }
_internal_set_modified_target_language(const std::string & value)1278 inline void TranslateEventProto::_internal_set_modified_target_language(const std::string& value) {
1279 _impl_._has_bits_[0] |= 0x00000008u;
1280 _impl_.modified_target_language_.Set(value, GetArenaForAllocation());
1281 }
_internal_mutable_modified_target_language()1282 inline std::string* TranslateEventProto::_internal_mutable_modified_target_language() {
1283 _impl_._has_bits_[0] |= 0x00000008u;
1284 return _impl_.modified_target_language_.Mutable(GetArenaForAllocation());
1285 }
release_modified_target_language()1286 inline std::string* TranslateEventProto::release_modified_target_language() {
1287 // @@protoc_insertion_point(field_release:metrics.TranslateEventProto.modified_target_language)
1288 if (!_internal_has_modified_target_language()) {
1289 return nullptr;
1290 }
1291 _impl_._has_bits_[0] &= ~0x00000008u;
1292 auto* p = _impl_.modified_target_language_.Release();
1293 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1294 if (_impl_.modified_target_language_.IsDefault()) {
1295 _impl_.modified_target_language_.Set("", GetArenaForAllocation());
1296 }
1297 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1298 return p;
1299 }
set_allocated_modified_target_language(std::string * modified_target_language)1300 inline void TranslateEventProto::set_allocated_modified_target_language(std::string* modified_target_language) {
1301 if (modified_target_language != nullptr) {
1302 _impl_._has_bits_[0] |= 0x00000008u;
1303 } else {
1304 _impl_._has_bits_[0] &= ~0x00000008u;
1305 }
1306 _impl_.modified_target_language_.SetAllocated(modified_target_language, GetArenaForAllocation());
1307 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1308 if (_impl_.modified_target_language_.IsDefault()) {
1309 _impl_.modified_target_language_.Set("", GetArenaForAllocation());
1310 }
1311 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1312 // @@protoc_insertion_point(field_set_allocated:metrics.TranslateEventProto.modified_target_language)
1313 }
1314
1315 #ifdef __GNUC__
1316 #pragma GCC diagnostic pop
1317 #endif // __GNUC__
1318
1319 // @@protoc_insertion_point(namespace_scope)
1320
1321 } // namespace metrics
1322
1323 PROTOBUF_NAMESPACE_OPEN
1324
1325 template <> struct is_proto_enum< ::metrics::TranslateEventProto_RankerResponse> : ::std::true_type {};
1326 template <> struct is_proto_enum< ::metrics::TranslateEventProto_EventType> : ::std::true_type {};
1327
1328 PROTOBUF_NAMESPACE_CLOSE
1329
1330 // @@protoc_insertion_point(global_scope)
1331
1332 #include <google/protobuf/port_undef.inc>
1333 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_translate_5fevent_2eproto
1334