1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: translate_event.proto
3 
4 #include "translate_event.pb.h"
5 
6 #include <algorithm>
7 
8 #include <google/protobuf/io/coded_stream.h>
9 #include <google/protobuf/extension_set.h>
10 #include <google/protobuf/wire_format_lite.h>
11 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
12 // @@protoc_insertion_point(includes)
13 #include <google/protobuf/port_def.inc>
14 
15 PROTOBUF_PRAGMA_INIT_SEG
16 
17 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
18 namespace _pbi = _pb::internal;
19 
20 namespace metrics {
TranslateEventProto(::_pbi::ConstantInitialized)21 PROTOBUF_CONSTEXPR TranslateEventProto::TranslateEventProto(
22     ::_pbi::ConstantInitialized): _impl_{
23     /*decltype(_impl_._has_bits_)*/{}
24   , /*decltype(_impl_._cached_size_)*/{}
25   , /*decltype(_impl_.language_list_)*/{}
26   , /*decltype(_impl_.decision_overrides_)*/{}
27   , /*decltype(_impl_.source_language_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.target_language_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.modified_source_language_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
30   , /*decltype(_impl_.modified_target_language_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
31   , /*decltype(_impl_.country_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
32   , /*decltype(_impl_.accept_count_)*/0
33   , /*decltype(_impl_.decline_count_)*/0
34   , /*decltype(_impl_.ignore_count_)*/0
35   , /*decltype(_impl_.ranker_version_)*/0u
36   , /*decltype(_impl_.ranker_request_timestamp_sec_)*/int64_t{0}
37   , /*decltype(_impl_.event_timestamp_sec_)*/int64_t{0}
38   , /*decltype(_impl_.event_type_)*/0
39   , /*decltype(_impl_.ranker_response_)*/2} {}
40 struct TranslateEventProtoDefaultTypeInternal {
TranslateEventProtoDefaultTypeInternalmetrics::TranslateEventProtoDefaultTypeInternal41   PROTOBUF_CONSTEXPR TranslateEventProtoDefaultTypeInternal()
42       : _instance(::_pbi::ConstantInitialized{}) {}
~TranslateEventProtoDefaultTypeInternalmetrics::TranslateEventProtoDefaultTypeInternal43   ~TranslateEventProtoDefaultTypeInternal() {}
44   union {
45     TranslateEventProto _instance;
46   };
47 };
48 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TranslateEventProtoDefaultTypeInternal _TranslateEventProto_default_instance_;
49 }  // namespace metrics
50 namespace metrics {
TranslateEventProto_RankerResponse_IsValid(int value)51 bool TranslateEventProto_RankerResponse_IsValid(int value) {
52   switch (value) {
53     case 0:
54     case 1:
55     case 2:
56       return true;
57     default:
58       return false;
59   }
60 }
61 
62 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TranslateEventProto_RankerResponse_strings[3] = {};
63 
64 static const char TranslateEventProto_RankerResponse_names[] =
65   "DONT_SHOW"
66   "NOT_QUERIED"
67   "SHOW";
68 
69 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TranslateEventProto_RankerResponse_entries[] = {
70   { {TranslateEventProto_RankerResponse_names + 0, 9}, 1 },
71   { {TranslateEventProto_RankerResponse_names + 9, 11}, 2 },
72   { {TranslateEventProto_RankerResponse_names + 20, 4}, 0 },
73 };
74 
75 static const int TranslateEventProto_RankerResponse_entries_by_number[] = {
76   2, // 0 -> SHOW
77   0, // 1 -> DONT_SHOW
78   1, // 2 -> NOT_QUERIED
79 };
80 
TranslateEventProto_RankerResponse_Name(TranslateEventProto_RankerResponse value)81 const std::string& TranslateEventProto_RankerResponse_Name(
82     TranslateEventProto_RankerResponse value) {
83   static const bool dummy =
84       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
85           TranslateEventProto_RankerResponse_entries,
86           TranslateEventProto_RankerResponse_entries_by_number,
87           3, TranslateEventProto_RankerResponse_strings);
88   (void) dummy;
89   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
90       TranslateEventProto_RankerResponse_entries,
91       TranslateEventProto_RankerResponse_entries_by_number,
92       3, value);
93   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
94                      TranslateEventProto_RankerResponse_strings[idx].get();
95 }
TranslateEventProto_RankerResponse_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,TranslateEventProto_RankerResponse * value)96 bool TranslateEventProto_RankerResponse_Parse(
97     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TranslateEventProto_RankerResponse* value) {
98   int int_value;
99   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
100       TranslateEventProto_RankerResponse_entries, 3, name, &int_value);
101   if (success) {
102     *value = static_cast<TranslateEventProto_RankerResponse>(int_value);
103   }
104   return success;
105 }
106 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
107 constexpr TranslateEventProto_RankerResponse TranslateEventProto::SHOW;
108 constexpr TranslateEventProto_RankerResponse TranslateEventProto::DONT_SHOW;
109 constexpr TranslateEventProto_RankerResponse TranslateEventProto::NOT_QUERIED;
110 constexpr TranslateEventProto_RankerResponse TranslateEventProto::RankerResponse_MIN;
111 constexpr TranslateEventProto_RankerResponse TranslateEventProto::RankerResponse_MAX;
112 constexpr int TranslateEventProto::RankerResponse_ARRAYSIZE;
113 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
TranslateEventProto_EventType_IsValid(int value)114 bool TranslateEventProto_EventType_IsValid(int value) {
115   switch (value) {
116     case 0:
117     case 1:
118     case 2:
119     case 3:
120     case 4:
121     case 5:
122     case 6:
123     case 7:
124     case 8:
125     case 9:
126     case 10:
127     case 11:
128     case 12:
129     case 13:
130     case 14:
131     case 15:
132     case 16:
133     case 17:
134     case 18:
135     case 19:
136     case 20:
137     case 21:
138     case 22:
139     case 23:
140     case 24:
141     case 25:
142     case 26:
143     case 27:
144       return true;
145     default:
146       return false;
147   }
148 }
149 
150 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TranslateEventProto_EventType_strings[28] = {};
151 
152 static const char TranslateEventProto_EventType_names[] =
153   "AUTOMATICALLY_TRANSLATED"
154   "AUTO_TRANSLATION_BY_LINK"
155   "AUTO_TRANSLATION_BY_PREF"
156   "BROWSER_WINDOW_IS_INVALID"
157   "BROWSER_WINDOW_IS_MINIMIZED"
158   "BROWSER_WINDOW_NOT_ACTIVE"
159   "DISABLED_BY_PREF"
160   "DISABLED_BY_RANKER"
161   "EDITABLE_FIELD_IS_ACTIVE"
162   "INITIALIZATION_ERROR"
163   "LANGUAGE_DISABLED_BY_AUTO_BLACKLIST"
164   "LANGUAGE_DISABLED_BY_USER_CONFIG"
165   "LANGUAGE_IN_ULP"
166   "MATCHES_PREVIOUS_LANGUAGE"
167   "UNKNOWN"
168   "UNSUPPORTED_LANGUAGE"
169   "UNSUPPORTED_URL"
170   "URL_DISABLED_BY_USER_CONFIG"
171   "USER_ACCEPT"
172   "USER_ALWAYS_TRANSLATE_LANGUAGE"
173   "USER_CONTEXT_MENU_TRANSLATE"
174   "USER_DECLINE"
175   "USER_DISMISS"
176   "USER_IGNORE"
177   "USER_NEVER_TRANSLATE_LANGUAGE"
178   "USER_NEVER_TRANSLATE_SITE"
179   "USER_REVERT"
180   "WEB_CONTENTS_NOT_ACTIVE";
181 
182 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TranslateEventProto_EventType_entries[] = {
183   { {TranslateEventProto_EventType_names + 0, 24}, 10 },
184   { {TranslateEventProto_EventType_names + 24, 24}, 26 },
185   { {TranslateEventProto_EventType_names + 48, 24}, 25 },
186   { {TranslateEventProto_EventType_names + 72, 25}, 19 },
187   { {TranslateEventProto_EventType_names + 97, 27}, 21 },
188   { {TranslateEventProto_EventType_names + 124, 25}, 20 },
189   { {TranslateEventProto_EventType_names + 149, 16}, 11 },
190   { {TranslateEventProto_EventType_names + 165, 18}, 15 },
191   { {TranslateEventProto_EventType_names + 183, 24}, 23 },
192   { {TranslateEventProto_EventType_names + 207, 20}, 27 },
193   { {TranslateEventProto_EventType_names + 227, 35}, 14 },
194   { {TranslateEventProto_EventType_names + 262, 32}, 12 },
195   { {TranslateEventProto_EventType_names + 294, 15}, 24 },
196   { {TranslateEventProto_EventType_names + 309, 25}, 18 },
197   { {TranslateEventProto_EventType_names + 334, 7}, 0 },
198   { {TranslateEventProto_EventType_names + 341, 20}, 16 },
199   { {TranslateEventProto_EventType_names + 361, 15}, 17 },
200   { {TranslateEventProto_EventType_names + 376, 27}, 13 },
201   { {TranslateEventProto_EventType_names + 403, 11}, 2 },
202   { {TranslateEventProto_EventType_names + 414, 30}, 7 },
203   { {TranslateEventProto_EventType_names + 444, 27}, 8 },
204   { {TranslateEventProto_EventType_names + 471, 12}, 1 },
205   { {TranslateEventProto_EventType_names + 483, 12}, 3 },
206   { {TranslateEventProto_EventType_names + 495, 11}, 4 },
207   { {TranslateEventProto_EventType_names + 506, 29}, 5 },
208   { {TranslateEventProto_EventType_names + 535, 25}, 6 },
209   { {TranslateEventProto_EventType_names + 560, 11}, 9 },
210   { {TranslateEventProto_EventType_names + 571, 23}, 22 },
211 };
212 
213 static const int TranslateEventProto_EventType_entries_by_number[] = {
214   14, // 0 -> UNKNOWN
215   21, // 1 -> USER_DECLINE
216   18, // 2 -> USER_ACCEPT
217   22, // 3 -> USER_DISMISS
218   23, // 4 -> USER_IGNORE
219   24, // 5 -> USER_NEVER_TRANSLATE_LANGUAGE
220   25, // 6 -> USER_NEVER_TRANSLATE_SITE
221   19, // 7 -> USER_ALWAYS_TRANSLATE_LANGUAGE
222   20, // 8 -> USER_CONTEXT_MENU_TRANSLATE
223   26, // 9 -> USER_REVERT
224   0, // 10 -> AUTOMATICALLY_TRANSLATED
225   6, // 11 -> DISABLED_BY_PREF
226   11, // 12 -> LANGUAGE_DISABLED_BY_USER_CONFIG
227   17, // 13 -> URL_DISABLED_BY_USER_CONFIG
228   10, // 14 -> LANGUAGE_DISABLED_BY_AUTO_BLACKLIST
229   7, // 15 -> DISABLED_BY_RANKER
230   15, // 16 -> UNSUPPORTED_LANGUAGE
231   16, // 17 -> UNSUPPORTED_URL
232   13, // 18 -> MATCHES_PREVIOUS_LANGUAGE
233   3, // 19 -> BROWSER_WINDOW_IS_INVALID
234   5, // 20 -> BROWSER_WINDOW_NOT_ACTIVE
235   4, // 21 -> BROWSER_WINDOW_IS_MINIMIZED
236   27, // 22 -> WEB_CONTENTS_NOT_ACTIVE
237   8, // 23 -> EDITABLE_FIELD_IS_ACTIVE
238   12, // 24 -> LANGUAGE_IN_ULP
239   2, // 25 -> AUTO_TRANSLATION_BY_PREF
240   1, // 26 -> AUTO_TRANSLATION_BY_LINK
241   9, // 27 -> INITIALIZATION_ERROR
242 };
243 
TranslateEventProto_EventType_Name(TranslateEventProto_EventType value)244 const std::string& TranslateEventProto_EventType_Name(
245     TranslateEventProto_EventType value) {
246   static const bool dummy =
247       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
248           TranslateEventProto_EventType_entries,
249           TranslateEventProto_EventType_entries_by_number,
250           28, TranslateEventProto_EventType_strings);
251   (void) dummy;
252   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
253       TranslateEventProto_EventType_entries,
254       TranslateEventProto_EventType_entries_by_number,
255       28, value);
256   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
257                      TranslateEventProto_EventType_strings[idx].get();
258 }
TranslateEventProto_EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,TranslateEventProto_EventType * value)259 bool TranslateEventProto_EventType_Parse(
260     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TranslateEventProto_EventType* value) {
261   int int_value;
262   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
263       TranslateEventProto_EventType_entries, 28, name, &int_value);
264   if (success) {
265     *value = static_cast<TranslateEventProto_EventType>(int_value);
266   }
267   return success;
268 }
269 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
270 constexpr TranslateEventProto_EventType TranslateEventProto::UNKNOWN;
271 constexpr TranslateEventProto_EventType TranslateEventProto::USER_DECLINE;
272 constexpr TranslateEventProto_EventType TranslateEventProto::USER_ACCEPT;
273 constexpr TranslateEventProto_EventType TranslateEventProto::USER_DISMISS;
274 constexpr TranslateEventProto_EventType TranslateEventProto::USER_IGNORE;
275 constexpr TranslateEventProto_EventType TranslateEventProto::USER_NEVER_TRANSLATE_LANGUAGE;
276 constexpr TranslateEventProto_EventType TranslateEventProto::USER_NEVER_TRANSLATE_SITE;
277 constexpr TranslateEventProto_EventType TranslateEventProto::USER_ALWAYS_TRANSLATE_LANGUAGE;
278 constexpr TranslateEventProto_EventType TranslateEventProto::USER_CONTEXT_MENU_TRANSLATE;
279 constexpr TranslateEventProto_EventType TranslateEventProto::USER_REVERT;
280 constexpr TranslateEventProto_EventType TranslateEventProto::AUTOMATICALLY_TRANSLATED;
281 constexpr TranslateEventProto_EventType TranslateEventProto::AUTO_TRANSLATION_BY_PREF;
282 constexpr TranslateEventProto_EventType TranslateEventProto::AUTO_TRANSLATION_BY_LINK;
283 constexpr TranslateEventProto_EventType TranslateEventProto::DISABLED_BY_PREF;
284 constexpr TranslateEventProto_EventType TranslateEventProto::LANGUAGE_DISABLED_BY_USER_CONFIG;
285 constexpr TranslateEventProto_EventType TranslateEventProto::URL_DISABLED_BY_USER_CONFIG;
286 constexpr TranslateEventProto_EventType TranslateEventProto::LANGUAGE_DISABLED_BY_AUTO_BLACKLIST;
287 constexpr TranslateEventProto_EventType TranslateEventProto::DISABLED_BY_RANKER;
288 constexpr TranslateEventProto_EventType TranslateEventProto::UNSUPPORTED_LANGUAGE;
289 constexpr TranslateEventProto_EventType TranslateEventProto::UNSUPPORTED_URL;
290 constexpr TranslateEventProto_EventType TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE;
291 constexpr TranslateEventProto_EventType TranslateEventProto::BROWSER_WINDOW_IS_INVALID;
292 constexpr TranslateEventProto_EventType TranslateEventProto::BROWSER_WINDOW_NOT_ACTIVE;
293 constexpr TranslateEventProto_EventType TranslateEventProto::BROWSER_WINDOW_IS_MINIMIZED;
294 constexpr TranslateEventProto_EventType TranslateEventProto::WEB_CONTENTS_NOT_ACTIVE;
295 constexpr TranslateEventProto_EventType TranslateEventProto::EDITABLE_FIELD_IS_ACTIVE;
296 constexpr TranslateEventProto_EventType TranslateEventProto::LANGUAGE_IN_ULP;
297 constexpr TranslateEventProto_EventType TranslateEventProto::INITIALIZATION_ERROR;
298 constexpr TranslateEventProto_EventType TranslateEventProto::EventType_MIN;
299 constexpr TranslateEventProto_EventType TranslateEventProto::EventType_MAX;
300 constexpr int TranslateEventProto::EventType_ARRAYSIZE;
301 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
302 
303 // ===================================================================
304 
305 class TranslateEventProto::_Internal {
306  public:
307   using HasBits = decltype(std::declval<TranslateEventProto>()._impl_._has_bits_);
set_has_source_language(HasBits * has_bits)308   static void set_has_source_language(HasBits* has_bits) {
309     (*has_bits)[0] |= 1u;
310   }
set_has_target_language(HasBits * has_bits)311   static void set_has_target_language(HasBits* has_bits) {
312     (*has_bits)[0] |= 2u;
313   }
set_has_country(HasBits * has_bits)314   static void set_has_country(HasBits* has_bits) {
315     (*has_bits)[0] |= 16u;
316   }
set_has_accept_count(HasBits * has_bits)317   static void set_has_accept_count(HasBits* has_bits) {
318     (*has_bits)[0] |= 32u;
319   }
set_has_decline_count(HasBits * has_bits)320   static void set_has_decline_count(HasBits* has_bits) {
321     (*has_bits)[0] |= 64u;
322   }
set_has_ignore_count(HasBits * has_bits)323   static void set_has_ignore_count(HasBits* has_bits) {
324     (*has_bits)[0] |= 128u;
325   }
set_has_ranker_version(HasBits * has_bits)326   static void set_has_ranker_version(HasBits* has_bits) {
327     (*has_bits)[0] |= 256u;
328   }
set_has_ranker_request_timestamp_sec(HasBits * has_bits)329   static void set_has_ranker_request_timestamp_sec(HasBits* has_bits) {
330     (*has_bits)[0] |= 512u;
331   }
set_has_ranker_response(HasBits * has_bits)332   static void set_has_ranker_response(HasBits* has_bits) {
333     (*has_bits)[0] |= 4096u;
334   }
set_has_event_type(HasBits * has_bits)335   static void set_has_event_type(HasBits* has_bits) {
336     (*has_bits)[0] |= 2048u;
337   }
set_has_event_timestamp_sec(HasBits * has_bits)338   static void set_has_event_timestamp_sec(HasBits* has_bits) {
339     (*has_bits)[0] |= 1024u;
340   }
set_has_modified_source_language(HasBits * has_bits)341   static void set_has_modified_source_language(HasBits* has_bits) {
342     (*has_bits)[0] |= 4u;
343   }
set_has_modified_target_language(HasBits * has_bits)344   static void set_has_modified_target_language(HasBits* has_bits) {
345     (*has_bits)[0] |= 8u;
346   }
347 };
348 
TranslateEventProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)349 TranslateEventProto::TranslateEventProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
350                          bool is_message_owned)
351   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
352   SharedCtor(arena, is_message_owned);
353   // @@protoc_insertion_point(arena_constructor:metrics.TranslateEventProto)
354 }
TranslateEventProto(const TranslateEventProto & from)355 TranslateEventProto::TranslateEventProto(const TranslateEventProto& from)
356   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
357   TranslateEventProto* const _this = this; (void)_this;
358   new (&_impl_) Impl_{
359       decltype(_impl_._has_bits_){from._impl_._has_bits_}
360     , /*decltype(_impl_._cached_size_)*/{}
361     , decltype(_impl_.language_list_){from._impl_.language_list_}
362     , decltype(_impl_.decision_overrides_){from._impl_.decision_overrides_}
363     , decltype(_impl_.source_language_){}
364     , decltype(_impl_.target_language_){}
365     , decltype(_impl_.modified_source_language_){}
366     , decltype(_impl_.modified_target_language_){}
367     , decltype(_impl_.country_){}
368     , decltype(_impl_.accept_count_){}
369     , decltype(_impl_.decline_count_){}
370     , decltype(_impl_.ignore_count_){}
371     , decltype(_impl_.ranker_version_){}
372     , decltype(_impl_.ranker_request_timestamp_sec_){}
373     , decltype(_impl_.event_timestamp_sec_){}
374     , decltype(_impl_.event_type_){}
375     , decltype(_impl_.ranker_response_){}};
376 
377   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
378   _impl_.source_language_.InitDefault();
379   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
380     _impl_.source_language_.Set("", GetArenaForAllocation());
381   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
382   if (from._internal_has_source_language()) {
383     _this->_impl_.source_language_.Set(from._internal_source_language(),
384       _this->GetArenaForAllocation());
385   }
386   _impl_.target_language_.InitDefault();
387   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
388     _impl_.target_language_.Set("", GetArenaForAllocation());
389   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
390   if (from._internal_has_target_language()) {
391     _this->_impl_.target_language_.Set(from._internal_target_language(),
392       _this->GetArenaForAllocation());
393   }
394   _impl_.modified_source_language_.InitDefault();
395   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
396     _impl_.modified_source_language_.Set("", GetArenaForAllocation());
397   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
398   if (from._internal_has_modified_source_language()) {
399     _this->_impl_.modified_source_language_.Set(from._internal_modified_source_language(),
400       _this->GetArenaForAllocation());
401   }
402   _impl_.modified_target_language_.InitDefault();
403   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
404     _impl_.modified_target_language_.Set("", GetArenaForAllocation());
405   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
406   if (from._internal_has_modified_target_language()) {
407     _this->_impl_.modified_target_language_.Set(from._internal_modified_target_language(),
408       _this->GetArenaForAllocation());
409   }
410   _impl_.country_.InitDefault();
411   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
412     _impl_.country_.Set("", GetArenaForAllocation());
413   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
414   if (from._internal_has_country()) {
415     _this->_impl_.country_.Set(from._internal_country(),
416       _this->GetArenaForAllocation());
417   }
418   ::memcpy(&_impl_.accept_count_, &from._impl_.accept_count_,
419     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ranker_response_) -
420     reinterpret_cast<char*>(&_impl_.accept_count_)) + sizeof(_impl_.ranker_response_));
421   // @@protoc_insertion_point(copy_constructor:metrics.TranslateEventProto)
422 }
423 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)424 inline void TranslateEventProto::SharedCtor(
425     ::_pb::Arena* arena, bool is_message_owned) {
426   (void)arena;
427   (void)is_message_owned;
428   new (&_impl_) Impl_{
429       decltype(_impl_._has_bits_){}
430     , /*decltype(_impl_._cached_size_)*/{}
431     , decltype(_impl_.language_list_){arena}
432     , decltype(_impl_.decision_overrides_){arena}
433     , decltype(_impl_.source_language_){}
434     , decltype(_impl_.target_language_){}
435     , decltype(_impl_.modified_source_language_){}
436     , decltype(_impl_.modified_target_language_){}
437     , decltype(_impl_.country_){}
438     , decltype(_impl_.accept_count_){0}
439     , decltype(_impl_.decline_count_){0}
440     , decltype(_impl_.ignore_count_){0}
441     , decltype(_impl_.ranker_version_){0u}
442     , decltype(_impl_.ranker_request_timestamp_sec_){int64_t{0}}
443     , decltype(_impl_.event_timestamp_sec_){int64_t{0}}
444     , decltype(_impl_.event_type_){0}
445     , decltype(_impl_.ranker_response_){2}
446   };
447   _impl_.source_language_.InitDefault();
448   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
449     _impl_.source_language_.Set("", GetArenaForAllocation());
450   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
451   _impl_.target_language_.InitDefault();
452   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
453     _impl_.target_language_.Set("", GetArenaForAllocation());
454   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
455   _impl_.modified_source_language_.InitDefault();
456   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
457     _impl_.modified_source_language_.Set("", GetArenaForAllocation());
458   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
459   _impl_.modified_target_language_.InitDefault();
460   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
461     _impl_.modified_target_language_.Set("", GetArenaForAllocation());
462   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
463   _impl_.country_.InitDefault();
464   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
465     _impl_.country_.Set("", GetArenaForAllocation());
466   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
467 }
468 
~TranslateEventProto()469 TranslateEventProto::~TranslateEventProto() {
470   // @@protoc_insertion_point(destructor:metrics.TranslateEventProto)
471   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
472   (void)arena;
473     return;
474   }
475   SharedDtor();
476 }
477 
SharedDtor()478 inline void TranslateEventProto::SharedDtor() {
479   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
480   _impl_.language_list_.~RepeatedPtrField();
481   _impl_.decision_overrides_.~RepeatedField();
482   _impl_.source_language_.Destroy();
483   _impl_.target_language_.Destroy();
484   _impl_.modified_source_language_.Destroy();
485   _impl_.modified_target_language_.Destroy();
486   _impl_.country_.Destroy();
487 }
488 
SetCachedSize(int size) const489 void TranslateEventProto::SetCachedSize(int size) const {
490   _impl_._cached_size_.Set(size);
491 }
492 
Clear()493 void TranslateEventProto::Clear() {
494 // @@protoc_insertion_point(message_clear_start:metrics.TranslateEventProto)
495   uint32_t cached_has_bits = 0;
496   // Prevent compiler warnings about cached_has_bits being unused
497   (void) cached_has_bits;
498 
499   _impl_.language_list_.Clear();
500   _impl_.decision_overrides_.Clear();
501   cached_has_bits = _impl_._has_bits_[0];
502   if (cached_has_bits & 0x0000001fu) {
503     if (cached_has_bits & 0x00000001u) {
504       _impl_.source_language_.ClearNonDefaultToEmpty();
505     }
506     if (cached_has_bits & 0x00000002u) {
507       _impl_.target_language_.ClearNonDefaultToEmpty();
508     }
509     if (cached_has_bits & 0x00000004u) {
510       _impl_.modified_source_language_.ClearNonDefaultToEmpty();
511     }
512     if (cached_has_bits & 0x00000008u) {
513       _impl_.modified_target_language_.ClearNonDefaultToEmpty();
514     }
515     if (cached_has_bits & 0x00000010u) {
516       _impl_.country_.ClearNonDefaultToEmpty();
517     }
518   }
519   if (cached_has_bits & 0x000000e0u) {
520     ::memset(&_impl_.accept_count_, 0, static_cast<size_t>(
521         reinterpret_cast<char*>(&_impl_.ignore_count_) -
522         reinterpret_cast<char*>(&_impl_.accept_count_)) + sizeof(_impl_.ignore_count_));
523   }
524   if (cached_has_bits & 0x00001f00u) {
525     ::memset(&_impl_.ranker_version_, 0, static_cast<size_t>(
526         reinterpret_cast<char*>(&_impl_.event_type_) -
527         reinterpret_cast<char*>(&_impl_.ranker_version_)) + sizeof(_impl_.event_type_));
528     _impl_.ranker_response_ = 2;
529   }
530   _impl_._has_bits_.Clear();
531   _internal_metadata_.Clear<std::string>();
532 }
533 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)534 const char* TranslateEventProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
535 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
536   _Internal::HasBits has_bits{};
537   while (!ctx->Done(&ptr)) {
538     uint32_t tag;
539     ptr = ::_pbi::ReadTag(ptr, &tag);
540     switch (tag >> 3) {
541       // optional string source_language = 1;
542       case 1:
543         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
544           auto str = _internal_mutable_source_language();
545           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
546           CHK_(ptr);
547         } else
548           goto handle_unusual;
549         continue;
550       // optional string target_language = 2;
551       case 2:
552         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
553           auto str = _internal_mutable_target_language();
554           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
555           CHK_(ptr);
556         } else
557           goto handle_unusual;
558         continue;
559       // optional int32 accept_count = 3;
560       case 3:
561         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
562           _Internal::set_has_accept_count(&has_bits);
563           _impl_.accept_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
564           CHK_(ptr);
565         } else
566           goto handle_unusual;
567         continue;
568       // optional int32 decline_count = 4;
569       case 4:
570         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
571           _Internal::set_has_decline_count(&has_bits);
572           _impl_.decline_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
573           CHK_(ptr);
574         } else
575           goto handle_unusual;
576         continue;
577       // optional int32 ignore_count = 5;
578       case 5:
579         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
580           _Internal::set_has_ignore_count(&has_bits);
581           _impl_.ignore_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
582           CHK_(ptr);
583         } else
584           goto handle_unusual;
585         continue;
586       // repeated string language_list = 6;
587       case 6:
588         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
589           ptr -= 1;
590           do {
591             ptr += 1;
592             auto str = _internal_add_language_list();
593             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
594             CHK_(ptr);
595             if (!ctx->DataAvailable(ptr)) break;
596           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
597         } else
598           goto handle_unusual;
599         continue;
600       // optional uint32 ranker_version = 7;
601       case 7:
602         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
603           _Internal::set_has_ranker_version(&has_bits);
604           _impl_.ranker_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
605           CHK_(ptr);
606         } else
607           goto handle_unusual;
608         continue;
609       // optional int64 ranker_request_timestamp_sec = 8;
610       case 8:
611         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
612           _Internal::set_has_ranker_request_timestamp_sec(&has_bits);
613           _impl_.ranker_request_timestamp_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
614           CHK_(ptr);
615         } else
616           goto handle_unusual;
617         continue;
618       // optional .metrics.TranslateEventProto.RankerResponse ranker_response = 9 [default = NOT_QUERIED];
619       case 9:
620         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
621           uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
622           CHK_(ptr);
623           if (PROTOBUF_PREDICT_TRUE(::metrics::TranslateEventProto_RankerResponse_IsValid(val))) {
624             _internal_set_ranker_response(static_cast<::metrics::TranslateEventProto_RankerResponse>(val));
625           } else {
626             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
627           }
628         } else
629           goto handle_unusual;
630         continue;
631       // optional .metrics.TranslateEventProto.EventType event_type = 10;
632       case 10:
633         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
634           uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
635           CHK_(ptr);
636           if (PROTOBUF_PREDICT_TRUE(::metrics::TranslateEventProto_EventType_IsValid(val))) {
637             _internal_set_event_type(static_cast<::metrics::TranslateEventProto_EventType>(val));
638           } else {
639             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
640           }
641         } else
642           goto handle_unusual;
643         continue;
644       // optional int64 event_timestamp_sec = 11;
645       case 11:
646         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
647           _Internal::set_has_event_timestamp_sec(&has_bits);
648           _impl_.event_timestamp_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
649           CHK_(ptr);
650         } else
651           goto handle_unusual;
652         continue;
653       // optional string modified_source_language = 12;
654       case 12:
655         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
656           auto str = _internal_mutable_modified_source_language();
657           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
658           CHK_(ptr);
659         } else
660           goto handle_unusual;
661         continue;
662       // optional string modified_target_language = 13;
663       case 13:
664         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
665           auto str = _internal_mutable_modified_target_language();
666           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
667           CHK_(ptr);
668         } else
669           goto handle_unusual;
670         continue;
671       // optional string country = 14;
672       case 14:
673         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
674           auto str = _internal_mutable_country();
675           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
676           CHK_(ptr);
677         } else
678           goto handle_unusual;
679         continue;
680       // repeated .metrics.TranslateEventProto.EventType decision_overrides = 15;
681       case 15:
682         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
683           ptr -= 1;
684           do {
685             ptr += 1;
686             uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
687             CHK_(ptr);
688             if (PROTOBUF_PREDICT_TRUE(::metrics::TranslateEventProto_EventType_IsValid(val))) {
689               _internal_add_decision_overrides(static_cast<::metrics::TranslateEventProto_EventType>(val));
690             } else {
691               ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields());
692             }
693             if (!ctx->DataAvailable(ptr)) break;
694           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<120>(ptr));
695         } else if (static_cast<uint8_t>(tag) == 122) {
696           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_decision_overrides(), ptr, ctx, ::metrics::TranslateEventProto_EventType_IsValid, &_internal_metadata_, 15);
697           CHK_(ptr);
698         } else
699           goto handle_unusual;
700         continue;
701       default:
702         goto handle_unusual;
703     }  // switch
704   handle_unusual:
705     if ((tag == 0) || ((tag & 7) == 4)) {
706       CHK_(ptr);
707       ctx->SetLastTag(tag);
708       goto message_done;
709     }
710     ptr = UnknownFieldParse(
711         tag,
712         _internal_metadata_.mutable_unknown_fields<std::string>(),
713         ptr, ctx);
714     CHK_(ptr != nullptr);
715   }  // while
716 message_done:
717   _impl_._has_bits_.Or(has_bits);
718   return ptr;
719 failure:
720   ptr = nullptr;
721   goto message_done;
722 #undef CHK_
723 }
724 
_InternalSerialize(uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const725 uint8_t* TranslateEventProto::_InternalSerialize(
726     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
727   // @@protoc_insertion_point(serialize_to_array_start:metrics.TranslateEventProto)
728   uint32_t cached_has_bits = 0;
729   (void) cached_has_bits;
730 
731   cached_has_bits = _impl_._has_bits_[0];
732   // optional string source_language = 1;
733   if (cached_has_bits & 0x00000001u) {
734     target = stream->WriteStringMaybeAliased(
735         1, this->_internal_source_language(), target);
736   }
737 
738   // optional string target_language = 2;
739   if (cached_has_bits & 0x00000002u) {
740     target = stream->WriteStringMaybeAliased(
741         2, this->_internal_target_language(), target);
742   }
743 
744   // optional int32 accept_count = 3;
745   if (cached_has_bits & 0x00000020u) {
746     target = stream->EnsureSpace(target);
747     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_accept_count(), target);
748   }
749 
750   // optional int32 decline_count = 4;
751   if (cached_has_bits & 0x00000040u) {
752     target = stream->EnsureSpace(target);
753     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_decline_count(), target);
754   }
755 
756   // optional int32 ignore_count = 5;
757   if (cached_has_bits & 0x00000080u) {
758     target = stream->EnsureSpace(target);
759     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_ignore_count(), target);
760   }
761 
762   // repeated string language_list = 6;
763   for (int i = 0, n = this->_internal_language_list_size(); i < n; i++) {
764     const auto& s = this->_internal_language_list(i);
765     target = stream->WriteString(6, s, target);
766   }
767 
768   // optional uint32 ranker_version = 7;
769   if (cached_has_bits & 0x00000100u) {
770     target = stream->EnsureSpace(target);
771     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_ranker_version(), target);
772   }
773 
774   // optional int64 ranker_request_timestamp_sec = 8;
775   if (cached_has_bits & 0x00000200u) {
776     target = stream->EnsureSpace(target);
777     target = ::_pbi::WireFormatLite::WriteInt64ToArray(8, this->_internal_ranker_request_timestamp_sec(), target);
778   }
779 
780   // optional .metrics.TranslateEventProto.RankerResponse ranker_response = 9 [default = NOT_QUERIED];
781   if (cached_has_bits & 0x00001000u) {
782     target = stream->EnsureSpace(target);
783     target = ::_pbi::WireFormatLite::WriteEnumToArray(
784       9, this->_internal_ranker_response(), target);
785   }
786 
787   // optional .metrics.TranslateEventProto.EventType event_type = 10;
788   if (cached_has_bits & 0x00000800u) {
789     target = stream->EnsureSpace(target);
790     target = ::_pbi::WireFormatLite::WriteEnumToArray(
791       10, this->_internal_event_type(), target);
792   }
793 
794   // optional int64 event_timestamp_sec = 11;
795   if (cached_has_bits & 0x00000400u) {
796     target = stream->EnsureSpace(target);
797     target = ::_pbi::WireFormatLite::WriteInt64ToArray(11, this->_internal_event_timestamp_sec(), target);
798   }
799 
800   // optional string modified_source_language = 12;
801   if (cached_has_bits & 0x00000004u) {
802     target = stream->WriteStringMaybeAliased(
803         12, this->_internal_modified_source_language(), target);
804   }
805 
806   // optional string modified_target_language = 13;
807   if (cached_has_bits & 0x00000008u) {
808     target = stream->WriteStringMaybeAliased(
809         13, this->_internal_modified_target_language(), target);
810   }
811 
812   // optional string country = 14;
813   if (cached_has_bits & 0x00000010u) {
814     target = stream->WriteStringMaybeAliased(
815         14, this->_internal_country(), target);
816   }
817 
818   // repeated .metrics.TranslateEventProto.EventType decision_overrides = 15;
819   for (int i = 0, n = this->_internal_decision_overrides_size(); i < n; i++) {
820     target = stream->EnsureSpace(target);
821     target = ::_pbi::WireFormatLite::WriteEnumToArray(
822         15, this->_internal_decision_overrides(i), target);
823   }
824 
825   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
826     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
827         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
828   }
829   // @@protoc_insertion_point(serialize_to_array_end:metrics.TranslateEventProto)
830   return target;
831 }
832 
ByteSizeLong() const833 size_t TranslateEventProto::ByteSizeLong() const {
834 // @@protoc_insertion_point(message_byte_size_start:metrics.TranslateEventProto)
835   size_t total_size = 0;
836 
837   uint32_t cached_has_bits = 0;
838   // Prevent compiler warnings about cached_has_bits being unused
839   (void) cached_has_bits;
840 
841   // repeated string language_list = 6;
842   total_size += 1 *
843       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.language_list_.size());
844   for (int i = 0, n = _impl_.language_list_.size(); i < n; i++) {
845     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
846       _impl_.language_list_.Get(i));
847   }
848 
849   // repeated .metrics.TranslateEventProto.EventType decision_overrides = 15;
850   {
851     size_t data_size = 0;
852     unsigned int count = static_cast<unsigned int>(this->_internal_decision_overrides_size());for (unsigned int i = 0; i < count; i++) {
853       data_size += ::_pbi::WireFormatLite::EnumSize(
854         this->_internal_decision_overrides(static_cast<int>(i)));
855     }
856     total_size += (1UL * count) + data_size;
857   }
858 
859   cached_has_bits = _impl_._has_bits_[0];
860   if (cached_has_bits & 0x000000ffu) {
861     // optional string source_language = 1;
862     if (cached_has_bits & 0x00000001u) {
863       total_size += 1 +
864         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
865           this->_internal_source_language());
866     }
867 
868     // optional string target_language = 2;
869     if (cached_has_bits & 0x00000002u) {
870       total_size += 1 +
871         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
872           this->_internal_target_language());
873     }
874 
875     // optional string modified_source_language = 12;
876     if (cached_has_bits & 0x00000004u) {
877       total_size += 1 +
878         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
879           this->_internal_modified_source_language());
880     }
881 
882     // optional string modified_target_language = 13;
883     if (cached_has_bits & 0x00000008u) {
884       total_size += 1 +
885         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
886           this->_internal_modified_target_language());
887     }
888 
889     // optional string country = 14;
890     if (cached_has_bits & 0x00000010u) {
891       total_size += 1 +
892         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
893           this->_internal_country());
894     }
895 
896     // optional int32 accept_count = 3;
897     if (cached_has_bits & 0x00000020u) {
898       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_accept_count());
899     }
900 
901     // optional int32 decline_count = 4;
902     if (cached_has_bits & 0x00000040u) {
903       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_decline_count());
904     }
905 
906     // optional int32 ignore_count = 5;
907     if (cached_has_bits & 0x00000080u) {
908       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ignore_count());
909     }
910 
911   }
912   if (cached_has_bits & 0x00001f00u) {
913     // optional uint32 ranker_version = 7;
914     if (cached_has_bits & 0x00000100u) {
915       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ranker_version());
916     }
917 
918     // optional int64 ranker_request_timestamp_sec = 8;
919     if (cached_has_bits & 0x00000200u) {
920       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ranker_request_timestamp_sec());
921     }
922 
923     // optional int64 event_timestamp_sec = 11;
924     if (cached_has_bits & 0x00000400u) {
925       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_event_timestamp_sec());
926     }
927 
928     // optional .metrics.TranslateEventProto.EventType event_type = 10;
929     if (cached_has_bits & 0x00000800u) {
930       total_size += 1 +
931         ::_pbi::WireFormatLite::EnumSize(this->_internal_event_type());
932     }
933 
934     // optional .metrics.TranslateEventProto.RankerResponse ranker_response = 9 [default = NOT_QUERIED];
935     if (cached_has_bits & 0x00001000u) {
936       total_size += 1 +
937         ::_pbi::WireFormatLite::EnumSize(this->_internal_ranker_response());
938     }
939 
940   }
941   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
942     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
943   }
944   int cached_size = ::_pbi::ToCachedSize(total_size);
945   SetCachedSize(cached_size);
946   return total_size;
947 }
948 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)949 void TranslateEventProto::CheckTypeAndMergeFrom(
950     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
951   MergeFrom(*::_pbi::DownCast<const TranslateEventProto*>(
952       &from));
953 }
954 
MergeFrom(const TranslateEventProto & from)955 void TranslateEventProto::MergeFrom(const TranslateEventProto& from) {
956   TranslateEventProto* const _this = this;
957   // @@protoc_insertion_point(class_specific_merge_from_start:metrics.TranslateEventProto)
958   GOOGLE_DCHECK_NE(&from, _this);
959   uint32_t cached_has_bits = 0;
960   (void) cached_has_bits;
961 
962   _this->_impl_.language_list_.MergeFrom(from._impl_.language_list_);
963   _this->_impl_.decision_overrides_.MergeFrom(from._impl_.decision_overrides_);
964   cached_has_bits = from._impl_._has_bits_[0];
965   if (cached_has_bits & 0x000000ffu) {
966     if (cached_has_bits & 0x00000001u) {
967       _this->_internal_set_source_language(from._internal_source_language());
968     }
969     if (cached_has_bits & 0x00000002u) {
970       _this->_internal_set_target_language(from._internal_target_language());
971     }
972     if (cached_has_bits & 0x00000004u) {
973       _this->_internal_set_modified_source_language(from._internal_modified_source_language());
974     }
975     if (cached_has_bits & 0x00000008u) {
976       _this->_internal_set_modified_target_language(from._internal_modified_target_language());
977     }
978     if (cached_has_bits & 0x00000010u) {
979       _this->_internal_set_country(from._internal_country());
980     }
981     if (cached_has_bits & 0x00000020u) {
982       _this->_impl_.accept_count_ = from._impl_.accept_count_;
983     }
984     if (cached_has_bits & 0x00000040u) {
985       _this->_impl_.decline_count_ = from._impl_.decline_count_;
986     }
987     if (cached_has_bits & 0x00000080u) {
988       _this->_impl_.ignore_count_ = from._impl_.ignore_count_;
989     }
990     _this->_impl_._has_bits_[0] |= cached_has_bits;
991   }
992   if (cached_has_bits & 0x00001f00u) {
993     if (cached_has_bits & 0x00000100u) {
994       _this->_impl_.ranker_version_ = from._impl_.ranker_version_;
995     }
996     if (cached_has_bits & 0x00000200u) {
997       _this->_impl_.ranker_request_timestamp_sec_ = from._impl_.ranker_request_timestamp_sec_;
998     }
999     if (cached_has_bits & 0x00000400u) {
1000       _this->_impl_.event_timestamp_sec_ = from._impl_.event_timestamp_sec_;
1001     }
1002     if (cached_has_bits & 0x00000800u) {
1003       _this->_impl_.event_type_ = from._impl_.event_type_;
1004     }
1005     if (cached_has_bits & 0x00001000u) {
1006       _this->_impl_.ranker_response_ = from._impl_.ranker_response_;
1007     }
1008     _this->_impl_._has_bits_[0] |= cached_has_bits;
1009   }
1010   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1011 }
1012 
CopyFrom(const TranslateEventProto & from)1013 void TranslateEventProto::CopyFrom(const TranslateEventProto& from) {
1014 // @@protoc_insertion_point(class_specific_copy_from_start:metrics.TranslateEventProto)
1015   if (&from == this) return;
1016   Clear();
1017   MergeFrom(from);
1018 }
1019 
IsInitialized() const1020 bool TranslateEventProto::IsInitialized() const {
1021   return true;
1022 }
1023 
InternalSwap(TranslateEventProto * other)1024 void TranslateEventProto::InternalSwap(TranslateEventProto* other) {
1025   using std::swap;
1026   auto* lhs_arena = GetArenaForAllocation();
1027   auto* rhs_arena = other->GetArenaForAllocation();
1028   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1029   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1030   _impl_.language_list_.InternalSwap(&other->_impl_.language_list_);
1031   _impl_.decision_overrides_.InternalSwap(&other->_impl_.decision_overrides_);
1032   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1033       &_impl_.source_language_, lhs_arena,
1034       &other->_impl_.source_language_, rhs_arena
1035   );
1036   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1037       &_impl_.target_language_, lhs_arena,
1038       &other->_impl_.target_language_, rhs_arena
1039   );
1040   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1041       &_impl_.modified_source_language_, lhs_arena,
1042       &other->_impl_.modified_source_language_, rhs_arena
1043   );
1044   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1045       &_impl_.modified_target_language_, lhs_arena,
1046       &other->_impl_.modified_target_language_, rhs_arena
1047   );
1048   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1049       &_impl_.country_, lhs_arena,
1050       &other->_impl_.country_, rhs_arena
1051   );
1052   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1053       PROTOBUF_FIELD_OFFSET(TranslateEventProto, _impl_.event_type_)
1054       + sizeof(TranslateEventProto::_impl_.event_type_)
1055       - PROTOBUF_FIELD_OFFSET(TranslateEventProto, _impl_.accept_count_)>(
1056           reinterpret_cast<char*>(&_impl_.accept_count_),
1057           reinterpret_cast<char*>(&other->_impl_.accept_count_));
1058   swap(_impl_.ranker_response_, other->_impl_.ranker_response_);
1059 }
1060 
GetTypeName() const1061 std::string TranslateEventProto::GetTypeName() const {
1062   return "metrics.TranslateEventProto";
1063 }
1064 
1065 
1066 // @@protoc_insertion_point(namespace_scope)
1067 }  // namespace metrics
1068 PROTOBUF_NAMESPACE_OPEN
1069 template<> PROTOBUF_NOINLINE ::metrics::TranslateEventProto*
CreateMaybeMessage(Arena * arena)1070 Arena::CreateMaybeMessage< ::metrics::TranslateEventProto >(Arena* arena) {
1071   return Arena::CreateMessageInternal< ::metrics::TranslateEventProto >(arena);
1072 }
1073 PROTOBUF_NAMESPACE_CLOSE
1074 
1075 // @@protoc_insertion_point(global_scope)
1076 #include <google/protobuf/port_undef.inc>
1077