1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: cast_logs.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_cast_5flogs_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_cast_5flogs_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_cast_5flogs_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_cast_5flogs_2eproto {
43   static const uint32_t offsets[];
44 };
45 namespace metrics {
46 class CastLogsProto;
47 struct CastLogsProtoDefaultTypeInternal;
48 extern CastLogsProtoDefaultTypeInternal _CastLogsProto_default_instance_;
49 class CastLogsProto_CastConnectionInfo;
50 struct CastLogsProto_CastConnectionInfoDefaultTypeInternal;
51 extern CastLogsProto_CastConnectionInfoDefaultTypeInternal _CastLogsProto_CastConnectionInfo_default_instance_;
52 class CastLogsProto_CastConnectionInfo_SenderInfo;
53 struct CastLogsProto_CastConnectionInfo_SenderInfoDefaultTypeInternal;
54 extern CastLogsProto_CastConnectionInfo_SenderInfoDefaultTypeInternal _CastLogsProto_CastConnectionInfo_SenderInfo_default_instance_;
55 class CastLogsProto_CastDeviceInfo;
56 struct CastLogsProto_CastDeviceInfoDefaultTypeInternal;
57 extern CastLogsProto_CastDeviceInfoDefaultTypeInternal _CastLogsProto_CastDeviceInfo_default_instance_;
58 class CastLogsProto_CastDeviceInfo_HardwareInfo;
59 struct CastLogsProto_CastDeviceInfo_HardwareInfoDefaultTypeInternal;
60 extern CastLogsProto_CastDeviceInfo_HardwareInfoDefaultTypeInternal _CastLogsProto_CastDeviceInfo_HardwareInfo_default_instance_;
61 class CastLogsProto_CastDeviceMutableInfo;
62 struct CastLogsProto_CastDeviceMutableInfoDefaultTypeInternal;
63 extern CastLogsProto_CastDeviceMutableInfoDefaultTypeInternal _CastLogsProto_CastDeviceMutableInfo_default_instance_;
64 class CastLogsProto_CastEventProto;
65 struct CastLogsProto_CastEventProtoDefaultTypeInternal;
66 extern CastLogsProto_CastEventProtoDefaultTypeInternal _CastLogsProto_CastEventProto_default_instance_;
67 class CastLogsProto_CastEventProto_Metadata;
68 struct CastLogsProto_CastEventProto_MetadataDefaultTypeInternal;
69 extern CastLogsProto_CastEventProto_MetadataDefaultTypeInternal _CastLogsProto_CastEventProto_Metadata_default_instance_;
70 }  // namespace metrics
71 PROTOBUF_NAMESPACE_OPEN
72 template<> ::metrics::CastLogsProto* Arena::CreateMaybeMessage<::metrics::CastLogsProto>(Arena*);
73 template<> ::metrics::CastLogsProto_CastConnectionInfo* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastConnectionInfo>(Arena*);
74 template<> ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastConnectionInfo_SenderInfo>(Arena*);
75 template<> ::metrics::CastLogsProto_CastDeviceInfo* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastDeviceInfo>(Arena*);
76 template<> ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo>(Arena*);
77 template<> ::metrics::CastLogsProto_CastDeviceMutableInfo* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastDeviceMutableInfo>(Arena*);
78 template<> ::metrics::CastLogsProto_CastEventProto* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastEventProto>(Arena*);
79 template<> ::metrics::CastLogsProto_CastEventProto_Metadata* Arena::CreateMaybeMessage<::metrics::CastLogsProto_CastEventProto_Metadata>(Arena*);
80 PROTOBUF_NAMESPACE_CLOSE
81 namespace metrics {
82 
83 enum CastLogsProto_CastDeviceInfo_CastProductType : int {
84   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_UNKNOWN = 0,
85   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_CHROMECAST = 1,
86   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_TV = 2,
87   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_AUDIO = 3,
88   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID_TV = 4,
89   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ASSISTANT = 5,
90   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID_THINGS = 6,
91   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_CHROME_OS = 7,
92   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_FUCHSIA_OS = 8,
93   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_LITE = 9,
94   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_CORE = 10,
95   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_11 = 11,
96   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID_AUTOMOTIVE = 12,
97   CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID = 13
98 };
99 bool CastLogsProto_CastDeviceInfo_CastProductType_IsValid(int value);
100 constexpr CastLogsProto_CastDeviceInfo_CastProductType CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_MIN = CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_UNKNOWN;
101 constexpr CastLogsProto_CastDeviceInfo_CastProductType CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_MAX = CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID;
102 constexpr int CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_ARRAYSIZE = CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_MAX + 1;
103 
104 const std::string& CastLogsProto_CastDeviceInfo_CastProductType_Name(CastLogsProto_CastDeviceInfo_CastProductType value);
105 template<typename T>
CastLogsProto_CastDeviceInfo_CastProductType_Name(T enum_t_value)106 inline const std::string& CastLogsProto_CastDeviceInfo_CastProductType_Name(T enum_t_value) {
107   static_assert(::std::is_same<T, CastLogsProto_CastDeviceInfo_CastProductType>::value ||
108     ::std::is_integral<T>::value,
109     "Incorrect type passed to function CastLogsProto_CastDeviceInfo_CastProductType_Name.");
110   return CastLogsProto_CastDeviceInfo_CastProductType_Name(static_cast<CastLogsProto_CastDeviceInfo_CastProductType>(enum_t_value));
111 }
112 bool CastLogsProto_CastDeviceInfo_CastProductType_Parse(
113     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastDeviceInfo_CastProductType* value);
114 enum CastLogsProto_CastConnectionInfo_SenderInfo_SDKType : int {
115   CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_UNKNOWN = 0,
116   CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_NATIVE = 1,
117   CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_CHROME_EXTENSION = 2
118 };
119 bool CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_IsValid(int value);
120 constexpr CastLogsProto_CastConnectionInfo_SenderInfo_SDKType CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_MIN = CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_UNKNOWN;
121 constexpr CastLogsProto_CastConnectionInfo_SenderInfo_SDKType CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_MAX = CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_CHROME_EXTENSION;
122 constexpr int CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_ARRAYSIZE = CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_MAX + 1;
123 
124 const std::string& CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Name(CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value);
125 template<typename T>
CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Name(T enum_t_value)126 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Name(T enum_t_value) {
127   static_assert(::std::is_same<T, CastLogsProto_CastConnectionInfo_SenderInfo_SDKType>::value ||
128     ::std::is_integral<T>::value,
129     "Incorrect type passed to function CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Name.");
130   return CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Name(static_cast<CastLogsProto_CastConnectionInfo_SenderInfo_SDKType>(enum_t_value));
131 }
132 bool CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Parse(
133     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastConnectionInfo_SenderInfo_SDKType* value);
134 enum CastLogsProto_CastConnectionInfo_SenderInfo_Platform : int {
135   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_OTHER = 0,
136   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_ANDROID = 1,
137   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_IOS = 2,
138   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_WINDOWS = 3,
139   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_OSX = 4,
140   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_CHROMEOS = 5,
141   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_LINUX = 6,
142   CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_CAST = 7
143 };
144 bool CastLogsProto_CastConnectionInfo_SenderInfo_Platform_IsValid(int value);
145 constexpr CastLogsProto_CastConnectionInfo_SenderInfo_Platform CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_MIN = CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_OTHER;
146 constexpr CastLogsProto_CastConnectionInfo_SenderInfo_Platform CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_MAX = CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_CAST;
147 constexpr int CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_ARRAYSIZE = CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_MAX + 1;
148 
149 const std::string& CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Name(CastLogsProto_CastConnectionInfo_SenderInfo_Platform value);
150 template<typename T>
CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Name(T enum_t_value)151 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Name(T enum_t_value) {
152   static_assert(::std::is_same<T, CastLogsProto_CastConnectionInfo_SenderInfo_Platform>::value ||
153     ::std::is_integral<T>::value,
154     "Incorrect type passed to function CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Name.");
155   return CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Name(static_cast<CastLogsProto_CastConnectionInfo_SenderInfo_Platform>(enum_t_value));
156 }
157 bool CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Parse(
158     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastConnectionInfo_SenderInfo_Platform* value);
159 enum CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType : int {
160   CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_UNKNOWN = 0,
161   CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_LOCAL = 1,
162   CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_RELAY = 2,
163   CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_INTERNAL = 3
164 };
165 bool CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_IsValid(int value);
166 constexpr CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_MIN = CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_UNKNOWN;
167 constexpr CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_MAX = CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_INTERNAL;
168 constexpr int CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_ARRAYSIZE = CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_MAX + 1;
169 
170 const std::string& CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Name(CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value);
171 template<typename T>
CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Name(T enum_t_value)172 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Name(T enum_t_value) {
173   static_assert(::std::is_same<T, CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType>::value ||
174     ::std::is_integral<T>::value,
175     "Incorrect type passed to function CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Name.");
176   return CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Name(static_cast<CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType>(enum_t_value));
177 }
178 bool CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Parse(
179     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType* value);
180 enum CastLogsProto_CastEventProto_LaunchFrom : int {
181   CastLogsProto_CastEventProto_LaunchFrom_FROM_UNKNOWN = 0,
182   CastLogsProto_CastEventProto_LaunchFrom_FROM_LOCAL = 1,
183   CastLogsProto_CastEventProto_LaunchFrom_FROM_DIAL = 2,
184   CastLogsProto_CastEventProto_LaunchFrom_FROM_CAST_V2 = 3,
185   CastLogsProto_CastEventProto_LaunchFrom_FROM_CCS = 4
186 };
187 bool CastLogsProto_CastEventProto_LaunchFrom_IsValid(int value);
188 constexpr CastLogsProto_CastEventProto_LaunchFrom CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_MIN = CastLogsProto_CastEventProto_LaunchFrom_FROM_UNKNOWN;
189 constexpr CastLogsProto_CastEventProto_LaunchFrom CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_MAX = CastLogsProto_CastEventProto_LaunchFrom_FROM_CCS;
190 constexpr int CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_ARRAYSIZE = CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_MAX + 1;
191 
192 const std::string& CastLogsProto_CastEventProto_LaunchFrom_Name(CastLogsProto_CastEventProto_LaunchFrom value);
193 template<typename T>
CastLogsProto_CastEventProto_LaunchFrom_Name(T enum_t_value)194 inline const std::string& CastLogsProto_CastEventProto_LaunchFrom_Name(T enum_t_value) {
195   static_assert(::std::is_same<T, CastLogsProto_CastEventProto_LaunchFrom>::value ||
196     ::std::is_integral<T>::value,
197     "Incorrect type passed to function CastLogsProto_CastEventProto_LaunchFrom_Name.");
198   return CastLogsProto_CastEventProto_LaunchFrom_Name(static_cast<CastLogsProto_CastEventProto_LaunchFrom>(enum_t_value));
199 }
200 bool CastLogsProto_CastEventProto_LaunchFrom_Parse(
201     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastEventProto_LaunchFrom* value);
202 enum CastLogsProto_CastEventProto_RuntimeType : int {
203   CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_UNKNOWN = 0,
204   CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_CAST_WEB = 1,
205   CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_CAST_LITE = 2,
206   CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_NATIVE = 3
207 };
208 bool CastLogsProto_CastEventProto_RuntimeType_IsValid(int value);
209 constexpr CastLogsProto_CastEventProto_RuntimeType CastLogsProto_CastEventProto_RuntimeType_RuntimeType_MIN = CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_UNKNOWN;
210 constexpr CastLogsProto_CastEventProto_RuntimeType CastLogsProto_CastEventProto_RuntimeType_RuntimeType_MAX = CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_NATIVE;
211 constexpr int CastLogsProto_CastEventProto_RuntimeType_RuntimeType_ARRAYSIZE = CastLogsProto_CastEventProto_RuntimeType_RuntimeType_MAX + 1;
212 
213 const std::string& CastLogsProto_CastEventProto_RuntimeType_Name(CastLogsProto_CastEventProto_RuntimeType value);
214 template<typename T>
CastLogsProto_CastEventProto_RuntimeType_Name(T enum_t_value)215 inline const std::string& CastLogsProto_CastEventProto_RuntimeType_Name(T enum_t_value) {
216   static_assert(::std::is_same<T, CastLogsProto_CastEventProto_RuntimeType>::value ||
217     ::std::is_integral<T>::value,
218     "Incorrect type passed to function CastLogsProto_CastEventProto_RuntimeType_Name.");
219   return CastLogsProto_CastEventProto_RuntimeType_Name(static_cast<CastLogsProto_CastEventProto_RuntimeType>(enum_t_value));
220 }
221 bool CastLogsProto_CastEventProto_RuntimeType_Parse(
222     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastEventProto_RuntimeType* value);
223 enum CastLogsProto_CastDeviceMutableInfo_RebootType : int {
224   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UNKNOWN = 0,
225   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_FORCED = 1,
226   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_API = 2,
227   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_NIGHTLY = 3,
228   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_OTA = 4,
229   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_WATCHDOG = 5,
230   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_PROCESS_MANAGER = 6,
231   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_CRASH_UPLOADER = 7,
232   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_FDR = 8,
233   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_HW_WATCHDOG = 9,
234   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_SW_OTHER = 10,
235   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_OVERHEAT = 11,
236   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_REGENERATE_CLOUD_ID = 12,
237   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_REPEATED_OOM = 13,
238   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UTILITY_PROCESS_CRASH = 14,
239   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_GRACEFUL_RESTART = 15,
240   CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UNGRACEFUL_RESTART = 16,
241   CastLogsProto_CastDeviceMutableInfo_RebootType_MULTI_SERVICE_BUG = 17,
242   CastLogsProto_CastDeviceMutableInfo_RebootType_POWER_MANAGER = 18,
243   CastLogsProto_CastDeviceMutableInfo_RebootType_EXPERIMENT_CHANGE = 19,
244   CastLogsProto_CastDeviceMutableInfo_RebootType_ANOMALY_DETECTION = 20,
245   CastLogsProto_CastDeviceMutableInfo_RebootType_KERNEL_PANIC = 21
246 };
247 bool CastLogsProto_CastDeviceMutableInfo_RebootType_IsValid(int value);
248 constexpr CastLogsProto_CastDeviceMutableInfo_RebootType CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_MIN = CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UNKNOWN;
249 constexpr CastLogsProto_CastDeviceMutableInfo_RebootType CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_MAX = CastLogsProto_CastDeviceMutableInfo_RebootType_KERNEL_PANIC;
250 constexpr int CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_ARRAYSIZE = CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_MAX + 1;
251 
252 const std::string& CastLogsProto_CastDeviceMutableInfo_RebootType_Name(CastLogsProto_CastDeviceMutableInfo_RebootType value);
253 template<typename T>
CastLogsProto_CastDeviceMutableInfo_RebootType_Name(T enum_t_value)254 inline const std::string& CastLogsProto_CastDeviceMutableInfo_RebootType_Name(T enum_t_value) {
255   static_assert(::std::is_same<T, CastLogsProto_CastDeviceMutableInfo_RebootType>::value ||
256     ::std::is_integral<T>::value,
257     "Incorrect type passed to function CastLogsProto_CastDeviceMutableInfo_RebootType_Name.");
258   return CastLogsProto_CastDeviceMutableInfo_RebootType_Name(static_cast<CastLogsProto_CastDeviceMutableInfo_RebootType>(enum_t_value));
259 }
260 bool CastLogsProto_CastDeviceMutableInfo_RebootType_Parse(
261     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastDeviceMutableInfo_RebootType* value);
262 enum CastLogsProto_CastDeviceMutableInfo_NetifIPVersion : int {
263   CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_UNKNOWN = 0,
264   CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_V4 = 1,
265   CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_V6 = 2,
266   CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_DUAL_STACK = 3
267 };
268 bool CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IsValid(int value);
269 constexpr CastLogsProto_CastDeviceMutableInfo_NetifIPVersion CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_MIN = CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_UNKNOWN;
270 constexpr CastLogsProto_CastDeviceMutableInfo_NetifIPVersion CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_MAX = CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_DUAL_STACK;
271 constexpr int CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_ARRAYSIZE = CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_MAX + 1;
272 
273 const std::string& CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Name(CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value);
274 template<typename T>
CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Name(T enum_t_value)275 inline const std::string& CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Name(T enum_t_value) {
276   static_assert(::std::is_same<T, CastLogsProto_CastDeviceMutableInfo_NetifIPVersion>::value ||
277     ::std::is_integral<T>::value,
278     "Incorrect type passed to function CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Name.");
279   return CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Name(static_cast<CastLogsProto_CastDeviceMutableInfo_NetifIPVersion>(enum_t_value));
280 }
281 bool CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Parse(
282     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastLogsProto_CastDeviceMutableInfo_NetifIPVersion* value);
283 // ===================================================================
284 
285 class CastLogsProto_CastDeviceInfo_HardwareInfo final :
286     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo) */ {
287  public:
CastLogsProto_CastDeviceInfo_HardwareInfo()288   inline CastLogsProto_CastDeviceInfo_HardwareInfo() : CastLogsProto_CastDeviceInfo_HardwareInfo(nullptr) {}
289   ~CastLogsProto_CastDeviceInfo_HardwareInfo() override;
290   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastDeviceInfo_HardwareInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
291 
292   CastLogsProto_CastDeviceInfo_HardwareInfo(const CastLogsProto_CastDeviceInfo_HardwareInfo& from);
CastLogsProto_CastDeviceInfo_HardwareInfo(CastLogsProto_CastDeviceInfo_HardwareInfo && from)293   CastLogsProto_CastDeviceInfo_HardwareInfo(CastLogsProto_CastDeviceInfo_HardwareInfo&& from) noexcept
294     : CastLogsProto_CastDeviceInfo_HardwareInfo() {
295     *this = ::std::move(from);
296   }
297 
298   inline CastLogsProto_CastDeviceInfo_HardwareInfo& operator=(const CastLogsProto_CastDeviceInfo_HardwareInfo& from) {
299     CopyFrom(from);
300     return *this;
301   }
302   inline CastLogsProto_CastDeviceInfo_HardwareInfo& operator=(CastLogsProto_CastDeviceInfo_HardwareInfo&& from) noexcept {
303     if (this == &from) return *this;
304     if (GetOwningArena() == from.GetOwningArena()
305   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
306         && GetOwningArena() != nullptr
307   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
308     ) {
309       InternalSwap(&from);
310     } else {
311       CopyFrom(from);
312     }
313     return *this;
314   }
315 
unknown_fields()316   inline const std::string& unknown_fields() const {
317     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
318   }
mutable_unknown_fields()319   inline std::string* mutable_unknown_fields() {
320     return _internal_metadata_.mutable_unknown_fields<std::string>();
321   }
322 
default_instance()323   static const CastLogsProto_CastDeviceInfo_HardwareInfo& default_instance() {
324     return *internal_default_instance();
325   }
internal_default_instance()326   static inline const CastLogsProto_CastDeviceInfo_HardwareInfo* internal_default_instance() {
327     return reinterpret_cast<const CastLogsProto_CastDeviceInfo_HardwareInfo*>(
328                &_CastLogsProto_CastDeviceInfo_HardwareInfo_default_instance_);
329   }
330   static constexpr int kIndexInFileMessages =
331     0;
332 
swap(CastLogsProto_CastDeviceInfo_HardwareInfo & a,CastLogsProto_CastDeviceInfo_HardwareInfo & b)333   friend void swap(CastLogsProto_CastDeviceInfo_HardwareInfo& a, CastLogsProto_CastDeviceInfo_HardwareInfo& b) {
334     a.Swap(&b);
335   }
Swap(CastLogsProto_CastDeviceInfo_HardwareInfo * other)336   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastDeviceInfo_HardwareInfo* other) {
337     if (other == this) return;
338   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
339     if (GetOwningArena() != nullptr &&
340         GetOwningArena() == other->GetOwningArena()) {
341    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
342     if (GetOwningArena() == other->GetOwningArena()) {
343   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
344       InternalSwap(other);
345     } else {
346       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
347     }
348   }
349   void UnsafeArenaSwap(CastLogsProto_CastDeviceInfo_HardwareInfo* other) {
350     if (other == this) return;
351     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
352     InternalSwap(other);
353   }
354 
355   // implements Message ----------------------------------------------
356 
357   CastLogsProto_CastDeviceInfo_HardwareInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
358     return CreateMaybeMessage<CastLogsProto_CastDeviceInfo_HardwareInfo>(arena);
359   }
360   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
361   void CopyFrom(const CastLogsProto_CastDeviceInfo_HardwareInfo& from);
362   void MergeFrom(const CastLogsProto_CastDeviceInfo_HardwareInfo& from);
363   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
364   bool IsInitialized() const final;
365 
366   size_t ByteSizeLong() const final;
367   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
368   uint8_t* _InternalSerialize(
369       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
370   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
371 
372   private:
373   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
374   void SharedDtor();
375   void SetCachedSize(int size) const;
376   void InternalSwap(CastLogsProto_CastDeviceInfo_HardwareInfo* other);
377 
378   private:
379   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
380   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
381     return "metrics.CastLogsProto.CastDeviceInfo.HardwareInfo";
382   }
383   protected:
384   explicit CastLogsProto_CastDeviceInfo_HardwareInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
385                        bool is_message_owned = false);
386   public:
387 
388   std::string GetTypeName() const final;
389 
390   // nested types ----------------------------------------------------
391 
392   // accessors -------------------------------------------------------
393 
394   enum : int {
395     kColorFieldNumber = 1,
396     kMicFieldNumber = 2,
397     kMemoryFieldNumber = 3,
398     kNandFieldNumber = 4,
399     kMfgDateFieldNumber = 5,
400     kBuildNameFieldNumber = 6,
401     kConfigFieldNumber = 7,
402     kEmmcFieldNumber = 8,
403     kDisplayFieldNumber = 9,
404     kAmpFieldNumber = 10,
405     kBoardNameFieldNumber = 11,
406   };
407   // optional string color = 1;
408   bool has_color() const;
409   private:
410   bool _internal_has_color() const;
411   public:
412   void clear_color();
413   const std::string& color() const;
414   template <typename ArgT0 = const std::string&, typename... ArgT>
415   void set_color(ArgT0&& arg0, ArgT... args);
416   std::string* mutable_color();
417   PROTOBUF_NODISCARD std::string* release_color();
418   void set_allocated_color(std::string* color);
419   private:
420   const std::string& _internal_color() const;
421   inline PROTOBUF_ALWAYS_INLINE void _internal_set_color(const std::string& value);
422   std::string* _internal_mutable_color();
423   public:
424 
425   // optional string mic = 2;
426   bool has_mic() const;
427   private:
428   bool _internal_has_mic() const;
429   public:
430   void clear_mic();
431   const std::string& mic() const;
432   template <typename ArgT0 = const std::string&, typename... ArgT>
433   void set_mic(ArgT0&& arg0, ArgT... args);
434   std::string* mutable_mic();
435   PROTOBUF_NODISCARD std::string* release_mic();
436   void set_allocated_mic(std::string* mic);
437   private:
438   const std::string& _internal_mic() const;
439   inline PROTOBUF_ALWAYS_INLINE void _internal_set_mic(const std::string& value);
440   std::string* _internal_mutable_mic();
441   public:
442 
443   // optional string memory = 3;
444   bool has_memory() const;
445   private:
446   bool _internal_has_memory() const;
447   public:
448   void clear_memory();
449   const std::string& memory() const;
450   template <typename ArgT0 = const std::string&, typename... ArgT>
451   void set_memory(ArgT0&& arg0, ArgT... args);
452   std::string* mutable_memory();
453   PROTOBUF_NODISCARD std::string* release_memory();
454   void set_allocated_memory(std::string* memory);
455   private:
456   const std::string& _internal_memory() const;
457   inline PROTOBUF_ALWAYS_INLINE void _internal_set_memory(const std::string& value);
458   std::string* _internal_mutable_memory();
459   public:
460 
461   // optional string nand = 4;
462   bool has_nand() const;
463   private:
464   bool _internal_has_nand() const;
465   public:
466   void clear_nand();
467   const std::string& nand() const;
468   template <typename ArgT0 = const std::string&, typename... ArgT>
469   void set_nand(ArgT0&& arg0, ArgT... args);
470   std::string* mutable_nand();
471   PROTOBUF_NODISCARD std::string* release_nand();
472   void set_allocated_nand(std::string* nand);
473   private:
474   const std::string& _internal_nand() const;
475   inline PROTOBUF_ALWAYS_INLINE void _internal_set_nand(const std::string& value);
476   std::string* _internal_mutable_nand();
477   public:
478 
479   // optional string mfg_date = 5;
480   bool has_mfg_date() const;
481   private:
482   bool _internal_has_mfg_date() const;
483   public:
484   void clear_mfg_date();
485   const std::string& mfg_date() const;
486   template <typename ArgT0 = const std::string&, typename... ArgT>
487   void set_mfg_date(ArgT0&& arg0, ArgT... args);
488   std::string* mutable_mfg_date();
489   PROTOBUF_NODISCARD std::string* release_mfg_date();
490   void set_allocated_mfg_date(std::string* mfg_date);
491   private:
492   const std::string& _internal_mfg_date() const;
493   inline PROTOBUF_ALWAYS_INLINE void _internal_set_mfg_date(const std::string& value);
494   std::string* _internal_mutable_mfg_date();
495   public:
496 
497   // optional string build_name = 6;
498   bool has_build_name() const;
499   private:
500   bool _internal_has_build_name() const;
501   public:
502   void clear_build_name();
503   const std::string& build_name() const;
504   template <typename ArgT0 = const std::string&, typename... ArgT>
505   void set_build_name(ArgT0&& arg0, ArgT... args);
506   std::string* mutable_build_name();
507   PROTOBUF_NODISCARD std::string* release_build_name();
508   void set_allocated_build_name(std::string* build_name);
509   private:
510   const std::string& _internal_build_name() const;
511   inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_name(const std::string& value);
512   std::string* _internal_mutable_build_name();
513   public:
514 
515   // optional string config = 7;
516   bool has_config() const;
517   private:
518   bool _internal_has_config() const;
519   public:
520   void clear_config();
521   const std::string& config() const;
522   template <typename ArgT0 = const std::string&, typename... ArgT>
523   void set_config(ArgT0&& arg0, ArgT... args);
524   std::string* mutable_config();
525   PROTOBUF_NODISCARD std::string* release_config();
526   void set_allocated_config(std::string* config);
527   private:
528   const std::string& _internal_config() const;
529   inline PROTOBUF_ALWAYS_INLINE void _internal_set_config(const std::string& value);
530   std::string* _internal_mutable_config();
531   public:
532 
533   // optional string emmc = 8;
534   bool has_emmc() const;
535   private:
536   bool _internal_has_emmc() const;
537   public:
538   void clear_emmc();
539   const std::string& emmc() const;
540   template <typename ArgT0 = const std::string&, typename... ArgT>
541   void set_emmc(ArgT0&& arg0, ArgT... args);
542   std::string* mutable_emmc();
543   PROTOBUF_NODISCARD std::string* release_emmc();
544   void set_allocated_emmc(std::string* emmc);
545   private:
546   const std::string& _internal_emmc() const;
547   inline PROTOBUF_ALWAYS_INLINE void _internal_set_emmc(const std::string& value);
548   std::string* _internal_mutable_emmc();
549   public:
550 
551   // optional string display = 9;
552   bool has_display() const;
553   private:
554   bool _internal_has_display() const;
555   public:
556   void clear_display();
557   const std::string& display() const;
558   template <typename ArgT0 = const std::string&, typename... ArgT>
559   void set_display(ArgT0&& arg0, ArgT... args);
560   std::string* mutable_display();
561   PROTOBUF_NODISCARD std::string* release_display();
562   void set_allocated_display(std::string* display);
563   private:
564   const std::string& _internal_display() const;
565   inline PROTOBUF_ALWAYS_INLINE void _internal_set_display(const std::string& value);
566   std::string* _internal_mutable_display();
567   public:
568 
569   // optional string amp = 10;
570   bool has_amp() const;
571   private:
572   bool _internal_has_amp() const;
573   public:
574   void clear_amp();
575   const std::string& amp() const;
576   template <typename ArgT0 = const std::string&, typename... ArgT>
577   void set_amp(ArgT0&& arg0, ArgT... args);
578   std::string* mutable_amp();
579   PROTOBUF_NODISCARD std::string* release_amp();
580   void set_allocated_amp(std::string* amp);
581   private:
582   const std::string& _internal_amp() const;
583   inline PROTOBUF_ALWAYS_INLINE void _internal_set_amp(const std::string& value);
584   std::string* _internal_mutable_amp();
585   public:
586 
587   // optional string board_name = 11;
588   bool has_board_name() const;
589   private:
590   bool _internal_has_board_name() const;
591   public:
592   void clear_board_name();
593   const std::string& board_name() const;
594   template <typename ArgT0 = const std::string&, typename... ArgT>
595   void set_board_name(ArgT0&& arg0, ArgT... args);
596   std::string* mutable_board_name();
597   PROTOBUF_NODISCARD std::string* release_board_name();
598   void set_allocated_board_name(std::string* board_name);
599   private:
600   const std::string& _internal_board_name() const;
601   inline PROTOBUF_ALWAYS_INLINE void _internal_set_board_name(const std::string& value);
602   std::string* _internal_mutable_board_name();
603   public:
604 
605   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo)
606  private:
607   class _Internal;
608 
609   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
610   typedef void InternalArenaConstructable_;
611   typedef void DestructorSkippable_;
612   struct Impl_ {
613     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
614     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
615     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr color_;
616     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mic_;
617     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr memory_;
618     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nand_;
619     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mfg_date_;
620     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_name_;
621     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr config_;
622     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr emmc_;
623     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr display_;
624     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amp_;
625     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr board_name_;
626   };
627   union { Impl_ _impl_; };
628   friend struct ::TableStruct_cast_5flogs_2eproto;
629 };
630 // -------------------------------------------------------------------
631 
632 class CastLogsProto_CastDeviceInfo final :
633     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastDeviceInfo) */ {
634  public:
CastLogsProto_CastDeviceInfo()635   inline CastLogsProto_CastDeviceInfo() : CastLogsProto_CastDeviceInfo(nullptr) {}
636   ~CastLogsProto_CastDeviceInfo() override;
637   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
638 
639   CastLogsProto_CastDeviceInfo(const CastLogsProto_CastDeviceInfo& from);
CastLogsProto_CastDeviceInfo(CastLogsProto_CastDeviceInfo && from)640   CastLogsProto_CastDeviceInfo(CastLogsProto_CastDeviceInfo&& from) noexcept
641     : CastLogsProto_CastDeviceInfo() {
642     *this = ::std::move(from);
643   }
644 
645   inline CastLogsProto_CastDeviceInfo& operator=(const CastLogsProto_CastDeviceInfo& from) {
646     CopyFrom(from);
647     return *this;
648   }
649   inline CastLogsProto_CastDeviceInfo& operator=(CastLogsProto_CastDeviceInfo&& from) noexcept {
650     if (this == &from) return *this;
651     if (GetOwningArena() == from.GetOwningArena()
652   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
653         && GetOwningArena() != nullptr
654   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
655     ) {
656       InternalSwap(&from);
657     } else {
658       CopyFrom(from);
659     }
660     return *this;
661   }
662 
unknown_fields()663   inline const std::string& unknown_fields() const {
664     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
665   }
mutable_unknown_fields()666   inline std::string* mutable_unknown_fields() {
667     return _internal_metadata_.mutable_unknown_fields<std::string>();
668   }
669 
default_instance()670   static const CastLogsProto_CastDeviceInfo& default_instance() {
671     return *internal_default_instance();
672   }
internal_default_instance()673   static inline const CastLogsProto_CastDeviceInfo* internal_default_instance() {
674     return reinterpret_cast<const CastLogsProto_CastDeviceInfo*>(
675                &_CastLogsProto_CastDeviceInfo_default_instance_);
676   }
677   static constexpr int kIndexInFileMessages =
678     1;
679 
swap(CastLogsProto_CastDeviceInfo & a,CastLogsProto_CastDeviceInfo & b)680   friend void swap(CastLogsProto_CastDeviceInfo& a, CastLogsProto_CastDeviceInfo& b) {
681     a.Swap(&b);
682   }
Swap(CastLogsProto_CastDeviceInfo * other)683   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastDeviceInfo* other) {
684     if (other == this) return;
685   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
686     if (GetOwningArena() != nullptr &&
687         GetOwningArena() == other->GetOwningArena()) {
688    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
689     if (GetOwningArena() == other->GetOwningArena()) {
690   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
691       InternalSwap(other);
692     } else {
693       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
694     }
695   }
696   void UnsafeArenaSwap(CastLogsProto_CastDeviceInfo* other) {
697     if (other == this) return;
698     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
699     InternalSwap(other);
700   }
701 
702   // implements Message ----------------------------------------------
703 
704   CastLogsProto_CastDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
705     return CreateMaybeMessage<CastLogsProto_CastDeviceInfo>(arena);
706   }
707   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
708   void CopyFrom(const CastLogsProto_CastDeviceInfo& from);
709   void MergeFrom(const CastLogsProto_CastDeviceInfo& from);
710   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
711   bool IsInitialized() const final;
712 
713   size_t ByteSizeLong() const final;
714   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
715   uint8_t* _InternalSerialize(
716       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
717   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
718 
719   private:
720   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
721   void SharedDtor();
722   void SetCachedSize(int size) const;
723   void InternalSwap(CastLogsProto_CastDeviceInfo* other);
724 
725   private:
726   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
727   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
728     return "metrics.CastLogsProto.CastDeviceInfo";
729   }
730   protected:
731   explicit CastLogsProto_CastDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
732                        bool is_message_owned = false);
733   public:
734 
735   std::string GetTypeName() const final;
736 
737   // nested types ----------------------------------------------------
738 
739   typedef CastLogsProto_CastDeviceInfo_HardwareInfo HardwareInfo;
740 
741   typedef CastLogsProto_CastDeviceInfo_CastProductType CastProductType;
742   static constexpr CastProductType CAST_PRODUCT_TYPE_UNKNOWN =
743     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_UNKNOWN;
744   static constexpr CastProductType CAST_PRODUCT_TYPE_CHROMECAST =
745     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_CHROMECAST;
746   static constexpr CastProductType CAST_PRODUCT_TYPE_TV =
747     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_TV;
748   static constexpr CastProductType CAST_PRODUCT_TYPE_AUDIO =
749     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_AUDIO;
750   static constexpr CastProductType CAST_PRODUCT_TYPE_ANDROID_TV =
751     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID_TV;
752   static constexpr CastProductType CAST_PRODUCT_TYPE_ASSISTANT =
753     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ASSISTANT;
754   static constexpr CastProductType CAST_PRODUCT_TYPE_ANDROID_THINGS =
755     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID_THINGS;
756   static constexpr CastProductType CAST_PRODUCT_TYPE_CHROME_OS =
757     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_CHROME_OS;
758   static constexpr CastProductType CAST_PRODUCT_TYPE_FUCHSIA_OS =
759     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_FUCHSIA_OS;
760   static constexpr CastProductType CAST_PRODUCT_TYPE_LITE =
761     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_LITE;
762   static constexpr CastProductType CAST_PRODUCT_TYPE_CORE =
763     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_CORE;
764   static constexpr CastProductType CAST_PRODUCT_TYPE_11 =
765     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_11;
766   static constexpr CastProductType CAST_PRODUCT_TYPE_ANDROID_AUTOMOTIVE =
767     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID_AUTOMOTIVE;
768   static constexpr CastProductType CAST_PRODUCT_TYPE_ANDROID =
769     CastLogsProto_CastDeviceInfo_CastProductType_CAST_PRODUCT_TYPE_ANDROID;
770   static inline bool CastProductType_IsValid(int value) {
771     return CastLogsProto_CastDeviceInfo_CastProductType_IsValid(value);
772   }
773   static constexpr CastProductType CastProductType_MIN =
774     CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_MIN;
775   static constexpr CastProductType CastProductType_MAX =
776     CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_MAX;
777   static constexpr int CastProductType_ARRAYSIZE =
778     CastLogsProto_CastDeviceInfo_CastProductType_CastProductType_ARRAYSIZE;
779   template<typename T>
780   static inline const std::string& CastProductType_Name(T enum_t_value) {
781     static_assert(::std::is_same<T, CastProductType>::value ||
782       ::std::is_integral<T>::value,
783       "Incorrect type passed to function CastProductType_Name.");
784     return CastLogsProto_CastDeviceInfo_CastProductType_Name(enum_t_value);
785   }
786   static inline bool CastProductType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
787       CastProductType* value) {
788     return CastLogsProto_CastDeviceInfo_CastProductType_Parse(name, value);
789   }
790 
791   // accessors -------------------------------------------------------
792 
793   enum : int {
794     kHardwareRevisionFieldNumber = 2,
795     kManufacturerFieldNumber = 3,
796     kModelFieldNumber = 4,
797     kSerialNumberFieldNumber = 5,
798     kHardwareInfoFieldNumber = 6,
799     kTypeFieldNumber = 1,
800   };
801   // optional string hardware_revision = 2;
802   bool has_hardware_revision() const;
803   private:
804   bool _internal_has_hardware_revision() const;
805   public:
806   void clear_hardware_revision();
807   const std::string& hardware_revision() const;
808   template <typename ArgT0 = const std::string&, typename... ArgT>
809   void set_hardware_revision(ArgT0&& arg0, ArgT... args);
810   std::string* mutable_hardware_revision();
811   PROTOBUF_NODISCARD std::string* release_hardware_revision();
812   void set_allocated_hardware_revision(std::string* hardware_revision);
813   private:
814   const std::string& _internal_hardware_revision() const;
815   inline PROTOBUF_ALWAYS_INLINE void _internal_set_hardware_revision(const std::string& value);
816   std::string* _internal_mutable_hardware_revision();
817   public:
818 
819   // optional string manufacturer = 3;
820   bool has_manufacturer() const;
821   private:
822   bool _internal_has_manufacturer() const;
823   public:
824   void clear_manufacturer();
825   const std::string& manufacturer() const;
826   template <typename ArgT0 = const std::string&, typename... ArgT>
827   void set_manufacturer(ArgT0&& arg0, ArgT... args);
828   std::string* mutable_manufacturer();
829   PROTOBUF_NODISCARD std::string* release_manufacturer();
830   void set_allocated_manufacturer(std::string* manufacturer);
831   private:
832   const std::string& _internal_manufacturer() const;
833   inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
834   std::string* _internal_mutable_manufacturer();
835   public:
836 
837   // optional string model = 4;
838   bool has_model() const;
839   private:
840   bool _internal_has_model() const;
841   public:
842   void clear_model();
843   const std::string& model() const;
844   template <typename ArgT0 = const std::string&, typename... ArgT>
845   void set_model(ArgT0&& arg0, ArgT... args);
846   std::string* mutable_model();
847   PROTOBUF_NODISCARD std::string* release_model();
848   void set_allocated_model(std::string* model);
849   private:
850   const std::string& _internal_model() const;
851   inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
852   std::string* _internal_mutable_model();
853   public:
854 
855   // optional string serial_number = 5;
856   bool has_serial_number() const;
857   private:
858   bool _internal_has_serial_number() const;
859   public:
860   void clear_serial_number();
861   const std::string& serial_number() const;
862   template <typename ArgT0 = const std::string&, typename... ArgT>
863   void set_serial_number(ArgT0&& arg0, ArgT... args);
864   std::string* mutable_serial_number();
865   PROTOBUF_NODISCARD std::string* release_serial_number();
866   void set_allocated_serial_number(std::string* serial_number);
867   private:
868   const std::string& _internal_serial_number() const;
869   inline PROTOBUF_ALWAYS_INLINE void _internal_set_serial_number(const std::string& value);
870   std::string* _internal_mutable_serial_number();
871   public:
872 
873   // optional .metrics.CastLogsProto.CastDeviceInfo.HardwareInfo hardware_info = 6;
874   bool has_hardware_info() const;
875   private:
876   bool _internal_has_hardware_info() const;
877   public:
878   void clear_hardware_info();
879   const ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo& hardware_info() const;
880   PROTOBUF_NODISCARD ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* release_hardware_info();
881   ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* mutable_hardware_info();
882   void set_allocated_hardware_info(::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* hardware_info);
883   private:
884   const ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo& _internal_hardware_info() const;
885   ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* _internal_mutable_hardware_info();
886   public:
887   void unsafe_arena_set_allocated_hardware_info(
888       ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* hardware_info);
889   ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* unsafe_arena_release_hardware_info();
890 
891   // optional .metrics.CastLogsProto.CastDeviceInfo.CastProductType type = 1;
892   bool has_type() const;
893   private:
894   bool _internal_has_type() const;
895   public:
896   void clear_type();
897   ::metrics::CastLogsProto_CastDeviceInfo_CastProductType type() const;
898   void set_type(::metrics::CastLogsProto_CastDeviceInfo_CastProductType value);
899   private:
900   ::metrics::CastLogsProto_CastDeviceInfo_CastProductType _internal_type() const;
901   void _internal_set_type(::metrics::CastLogsProto_CastDeviceInfo_CastProductType value);
902   public:
903 
904   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastDeviceInfo)
905  private:
906   class _Internal;
907 
908   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
909   typedef void InternalArenaConstructable_;
910   typedef void DestructorSkippable_;
911   struct Impl_ {
912     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
913     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
914     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hardware_revision_;
915     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
916     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
917     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serial_number_;
918     ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* hardware_info_;
919     int type_;
920   };
921   union { Impl_ _impl_; };
922   friend struct ::TableStruct_cast_5flogs_2eproto;
923 };
924 // -------------------------------------------------------------------
925 
926 class CastLogsProto_CastConnectionInfo_SenderInfo final :
927     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastConnectionInfo.SenderInfo) */ {
928  public:
CastLogsProto_CastConnectionInfo_SenderInfo()929   inline CastLogsProto_CastConnectionInfo_SenderInfo() : CastLogsProto_CastConnectionInfo_SenderInfo(nullptr) {}
930   ~CastLogsProto_CastConnectionInfo_SenderInfo() override;
931   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastConnectionInfo_SenderInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
932 
933   CastLogsProto_CastConnectionInfo_SenderInfo(const CastLogsProto_CastConnectionInfo_SenderInfo& from);
CastLogsProto_CastConnectionInfo_SenderInfo(CastLogsProto_CastConnectionInfo_SenderInfo && from)934   CastLogsProto_CastConnectionInfo_SenderInfo(CastLogsProto_CastConnectionInfo_SenderInfo&& from) noexcept
935     : CastLogsProto_CastConnectionInfo_SenderInfo() {
936     *this = ::std::move(from);
937   }
938 
939   inline CastLogsProto_CastConnectionInfo_SenderInfo& operator=(const CastLogsProto_CastConnectionInfo_SenderInfo& from) {
940     CopyFrom(from);
941     return *this;
942   }
943   inline CastLogsProto_CastConnectionInfo_SenderInfo& operator=(CastLogsProto_CastConnectionInfo_SenderInfo&& from) noexcept {
944     if (this == &from) return *this;
945     if (GetOwningArena() == from.GetOwningArena()
946   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
947         && GetOwningArena() != nullptr
948   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
949     ) {
950       InternalSwap(&from);
951     } else {
952       CopyFrom(from);
953     }
954     return *this;
955   }
956 
unknown_fields()957   inline const std::string& unknown_fields() const {
958     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
959   }
mutable_unknown_fields()960   inline std::string* mutable_unknown_fields() {
961     return _internal_metadata_.mutable_unknown_fields<std::string>();
962   }
963 
default_instance()964   static const CastLogsProto_CastConnectionInfo_SenderInfo& default_instance() {
965     return *internal_default_instance();
966   }
internal_default_instance()967   static inline const CastLogsProto_CastConnectionInfo_SenderInfo* internal_default_instance() {
968     return reinterpret_cast<const CastLogsProto_CastConnectionInfo_SenderInfo*>(
969                &_CastLogsProto_CastConnectionInfo_SenderInfo_default_instance_);
970   }
971   static constexpr int kIndexInFileMessages =
972     2;
973 
swap(CastLogsProto_CastConnectionInfo_SenderInfo & a,CastLogsProto_CastConnectionInfo_SenderInfo & b)974   friend void swap(CastLogsProto_CastConnectionInfo_SenderInfo& a, CastLogsProto_CastConnectionInfo_SenderInfo& b) {
975     a.Swap(&b);
976   }
Swap(CastLogsProto_CastConnectionInfo_SenderInfo * other)977   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastConnectionInfo_SenderInfo* other) {
978     if (other == this) return;
979   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
980     if (GetOwningArena() != nullptr &&
981         GetOwningArena() == other->GetOwningArena()) {
982    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
983     if (GetOwningArena() == other->GetOwningArena()) {
984   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
985       InternalSwap(other);
986     } else {
987       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
988     }
989   }
990   void UnsafeArenaSwap(CastLogsProto_CastConnectionInfo_SenderInfo* other) {
991     if (other == this) return;
992     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
993     InternalSwap(other);
994   }
995 
996   // implements Message ----------------------------------------------
997 
998   CastLogsProto_CastConnectionInfo_SenderInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
999     return CreateMaybeMessage<CastLogsProto_CastConnectionInfo_SenderInfo>(arena);
1000   }
1001   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1002   void CopyFrom(const CastLogsProto_CastConnectionInfo_SenderInfo& from);
1003   void MergeFrom(const CastLogsProto_CastConnectionInfo_SenderInfo& from);
1004   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1005   bool IsInitialized() const final;
1006 
1007   size_t ByteSizeLong() const final;
1008   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1009   uint8_t* _InternalSerialize(
1010       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1011   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1012 
1013   private:
1014   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1015   void SharedDtor();
1016   void SetCachedSize(int size) const;
1017   void InternalSwap(CastLogsProto_CastConnectionInfo_SenderInfo* other);
1018 
1019   private:
1020   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1021   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1022     return "metrics.CastLogsProto.CastConnectionInfo.SenderInfo";
1023   }
1024   protected:
1025   explicit CastLogsProto_CastConnectionInfo_SenderInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1026                        bool is_message_owned = false);
1027   public:
1028 
1029   std::string GetTypeName() const final;
1030 
1031   // nested types ----------------------------------------------------
1032 
1033   typedef CastLogsProto_CastConnectionInfo_SenderInfo_SDKType SDKType;
1034   static constexpr SDKType SDK_UNKNOWN =
1035     CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_UNKNOWN;
1036   static constexpr SDKType SDK_NATIVE =
1037     CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_NATIVE;
1038   static constexpr SDKType SDK_CHROME_EXTENSION =
1039     CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDK_CHROME_EXTENSION;
1040   static inline bool SDKType_IsValid(int value) {
1041     return CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_IsValid(value);
1042   }
1043   static constexpr SDKType SDKType_MIN =
1044     CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_MIN;
1045   static constexpr SDKType SDKType_MAX =
1046     CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_MAX;
1047   static constexpr int SDKType_ARRAYSIZE =
1048     CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_SDKType_ARRAYSIZE;
1049   template<typename T>
1050   static inline const std::string& SDKType_Name(T enum_t_value) {
1051     static_assert(::std::is_same<T, SDKType>::value ||
1052       ::std::is_integral<T>::value,
1053       "Incorrect type passed to function SDKType_Name.");
1054     return CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Name(enum_t_value);
1055   }
1056   static inline bool SDKType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1057       SDKType* value) {
1058     return CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_Parse(name, value);
1059   }
1060 
1061   typedef CastLogsProto_CastConnectionInfo_SenderInfo_Platform Platform;
1062   static constexpr Platform PLATFORM_OTHER =
1063     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_OTHER;
1064   static constexpr Platform PLATFORM_ANDROID =
1065     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_ANDROID;
1066   static constexpr Platform PLATFORM_IOS =
1067     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_IOS;
1068   static constexpr Platform PLATFORM_WINDOWS =
1069     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_WINDOWS;
1070   static constexpr Platform PLATFORM_OSX =
1071     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_OSX;
1072   static constexpr Platform PLATFORM_CHROMEOS =
1073     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_CHROMEOS;
1074   static constexpr Platform PLATFORM_LINUX =
1075     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_LINUX;
1076   static constexpr Platform PLATFORM_CAST =
1077     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_PLATFORM_CAST;
1078   static inline bool Platform_IsValid(int value) {
1079     return CastLogsProto_CastConnectionInfo_SenderInfo_Platform_IsValid(value);
1080   }
1081   static constexpr Platform Platform_MIN =
1082     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_MIN;
1083   static constexpr Platform Platform_MAX =
1084     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_MAX;
1085   static constexpr int Platform_ARRAYSIZE =
1086     CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Platform_ARRAYSIZE;
1087   template<typename T>
1088   static inline const std::string& Platform_Name(T enum_t_value) {
1089     static_assert(::std::is_same<T, Platform>::value ||
1090       ::std::is_integral<T>::value,
1091       "Incorrect type passed to function Platform_Name.");
1092     return CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Name(enum_t_value);
1093   }
1094   static inline bool Platform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1095       Platform* value) {
1096     return CastLogsProto_CastConnectionInfo_SenderInfo_Platform_Parse(name, value);
1097   }
1098 
1099   typedef CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType ConnectionType;
1100   static constexpr ConnectionType CONNECTION_TYPE_UNKNOWN =
1101     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_UNKNOWN;
1102   static constexpr ConnectionType CONNECTION_TYPE_LOCAL =
1103     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_LOCAL;
1104   static constexpr ConnectionType CONNECTION_TYPE_RELAY =
1105     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_RELAY;
1106   static constexpr ConnectionType CONNECTION_TYPE_INTERNAL =
1107     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_CONNECTION_TYPE_INTERNAL;
1108   static inline bool ConnectionType_IsValid(int value) {
1109     return CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_IsValid(value);
1110   }
1111   static constexpr ConnectionType ConnectionType_MIN =
1112     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_MIN;
1113   static constexpr ConnectionType ConnectionType_MAX =
1114     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_MAX;
1115   static constexpr int ConnectionType_ARRAYSIZE =
1116     CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_ConnectionType_ARRAYSIZE;
1117   template<typename T>
1118   static inline const std::string& ConnectionType_Name(T enum_t_value) {
1119     static_assert(::std::is_same<T, ConnectionType>::value ||
1120       ::std::is_integral<T>::value,
1121       "Incorrect type passed to function ConnectionType_Name.");
1122     return CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Name(enum_t_value);
1123   }
1124   static inline bool ConnectionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1125       ConnectionType* value) {
1126     return CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_Parse(name, value);
1127   }
1128 
1129   // accessors -------------------------------------------------------
1130 
1131   enum : int {
1132     kVersionFieldNumber = 3,
1133     kChromeBrowserVersionFieldNumber = 4,
1134     kSystemVersionFieldNumber = 6,
1135     kModelFieldNumber = 8,
1136     kSenderDeviceIdFieldNumber = 1,
1137     kSdkTypeFieldNumber = 2,
1138     kPlatformFieldNumber = 5,
1139     kTransportConnectionTypeFieldNumber = 7,
1140     kSenderLocalIpFragmentFieldNumber = 9,
1141   };
1142   // optional string version = 3;
1143   bool has_version() const;
1144   private:
1145   bool _internal_has_version() const;
1146   public:
1147   void clear_version();
1148   const std::string& version() const;
1149   template <typename ArgT0 = const std::string&, typename... ArgT>
1150   void set_version(ArgT0&& arg0, ArgT... args);
1151   std::string* mutable_version();
1152   PROTOBUF_NODISCARD std::string* release_version();
1153   void set_allocated_version(std::string* version);
1154   private:
1155   const std::string& _internal_version() const;
1156   inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
1157   std::string* _internal_mutable_version();
1158   public:
1159 
1160   // optional string chrome_browser_version = 4;
1161   bool has_chrome_browser_version() const;
1162   private:
1163   bool _internal_has_chrome_browser_version() const;
1164   public:
1165   void clear_chrome_browser_version();
1166   const std::string& chrome_browser_version() const;
1167   template <typename ArgT0 = const std::string&, typename... ArgT>
1168   void set_chrome_browser_version(ArgT0&& arg0, ArgT... args);
1169   std::string* mutable_chrome_browser_version();
1170   PROTOBUF_NODISCARD std::string* release_chrome_browser_version();
1171   void set_allocated_chrome_browser_version(std::string* chrome_browser_version);
1172   private:
1173   const std::string& _internal_chrome_browser_version() const;
1174   inline PROTOBUF_ALWAYS_INLINE void _internal_set_chrome_browser_version(const std::string& value);
1175   std::string* _internal_mutable_chrome_browser_version();
1176   public:
1177 
1178   // optional string system_version = 6;
1179   bool has_system_version() const;
1180   private:
1181   bool _internal_has_system_version() const;
1182   public:
1183   void clear_system_version();
1184   const std::string& system_version() const;
1185   template <typename ArgT0 = const std::string&, typename... ArgT>
1186   void set_system_version(ArgT0&& arg0, ArgT... args);
1187   std::string* mutable_system_version();
1188   PROTOBUF_NODISCARD std::string* release_system_version();
1189   void set_allocated_system_version(std::string* system_version);
1190   private:
1191   const std::string& _internal_system_version() const;
1192   inline PROTOBUF_ALWAYS_INLINE void _internal_set_system_version(const std::string& value);
1193   std::string* _internal_mutable_system_version();
1194   public:
1195 
1196   // optional string model = 8;
1197   bool has_model() const;
1198   private:
1199   bool _internal_has_model() const;
1200   public:
1201   void clear_model();
1202   const std::string& model() const;
1203   template <typename ArgT0 = const std::string&, typename... ArgT>
1204   void set_model(ArgT0&& arg0, ArgT... args);
1205   std::string* mutable_model();
1206   PROTOBUF_NODISCARD std::string* release_model();
1207   void set_allocated_model(std::string* model);
1208   private:
1209   const std::string& _internal_model() const;
1210   inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
1211   std::string* _internal_mutable_model();
1212   public:
1213 
1214   // optional fixed64 sender_device_id = 1;
1215   bool has_sender_device_id() const;
1216   private:
1217   bool _internal_has_sender_device_id() const;
1218   public:
1219   void clear_sender_device_id();
1220   uint64_t sender_device_id() const;
1221   void set_sender_device_id(uint64_t value);
1222   private:
1223   uint64_t _internal_sender_device_id() const;
1224   void _internal_set_sender_device_id(uint64_t value);
1225   public:
1226 
1227   // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo.SDKType sdk_type = 2;
1228   bool has_sdk_type() const;
1229   private:
1230   bool _internal_has_sdk_type() const;
1231   public:
1232   void clear_sdk_type();
1233   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType sdk_type() const;
1234   void set_sdk_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value);
1235   private:
1236   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType _internal_sdk_type() const;
1237   void _internal_set_sdk_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value);
1238   public:
1239 
1240   // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo.Platform platform = 5;
1241   bool has_platform() const;
1242   private:
1243   bool _internal_has_platform() const;
1244   public:
1245   void clear_platform();
1246   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform platform() const;
1247   void set_platform(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform value);
1248   private:
1249   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform _internal_platform() const;
1250   void _internal_set_platform(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform value);
1251   public:
1252 
1253   // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo.ConnectionType transport_connection_type = 7;
1254   bool has_transport_connection_type() const;
1255   private:
1256   bool _internal_has_transport_connection_type() const;
1257   public:
1258   void clear_transport_connection_type();
1259   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType transport_connection_type() const;
1260   void set_transport_connection_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value);
1261   private:
1262   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType _internal_transport_connection_type() const;
1263   void _internal_set_transport_connection_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value);
1264   public:
1265 
1266   // optional int32 sender_local_ip_fragment = 9;
1267   bool has_sender_local_ip_fragment() const;
1268   private:
1269   bool _internal_has_sender_local_ip_fragment() const;
1270   public:
1271   void clear_sender_local_ip_fragment();
1272   int32_t sender_local_ip_fragment() const;
1273   void set_sender_local_ip_fragment(int32_t value);
1274   private:
1275   int32_t _internal_sender_local_ip_fragment() const;
1276   void _internal_set_sender_local_ip_fragment(int32_t value);
1277   public:
1278 
1279   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastConnectionInfo.SenderInfo)
1280  private:
1281   class _Internal;
1282 
1283   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1284   typedef void InternalArenaConstructable_;
1285   typedef void DestructorSkippable_;
1286   struct Impl_ {
1287     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1288     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1289     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
1290     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr chrome_browser_version_;
1291     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_version_;
1292     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
1293     uint64_t sender_device_id_;
1294     int sdk_type_;
1295     int platform_;
1296     int transport_connection_type_;
1297     int32_t sender_local_ip_fragment_;
1298   };
1299   union { Impl_ _impl_; };
1300   friend struct ::TableStruct_cast_5flogs_2eproto;
1301 };
1302 // -------------------------------------------------------------------
1303 
1304 class CastLogsProto_CastConnectionInfo final :
1305     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastConnectionInfo) */ {
1306  public:
CastLogsProto_CastConnectionInfo()1307   inline CastLogsProto_CastConnectionInfo() : CastLogsProto_CastConnectionInfo(nullptr) {}
1308   ~CastLogsProto_CastConnectionInfo() override;
1309   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastConnectionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1310 
1311   CastLogsProto_CastConnectionInfo(const CastLogsProto_CastConnectionInfo& from);
CastLogsProto_CastConnectionInfo(CastLogsProto_CastConnectionInfo && from)1312   CastLogsProto_CastConnectionInfo(CastLogsProto_CastConnectionInfo&& from) noexcept
1313     : CastLogsProto_CastConnectionInfo() {
1314     *this = ::std::move(from);
1315   }
1316 
1317   inline CastLogsProto_CastConnectionInfo& operator=(const CastLogsProto_CastConnectionInfo& from) {
1318     CopyFrom(from);
1319     return *this;
1320   }
1321   inline CastLogsProto_CastConnectionInfo& operator=(CastLogsProto_CastConnectionInfo&& from) noexcept {
1322     if (this == &from) return *this;
1323     if (GetOwningArena() == from.GetOwningArena()
1324   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1325         && GetOwningArena() != nullptr
1326   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1327     ) {
1328       InternalSwap(&from);
1329     } else {
1330       CopyFrom(from);
1331     }
1332     return *this;
1333   }
1334 
unknown_fields()1335   inline const std::string& unknown_fields() const {
1336     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1337   }
mutable_unknown_fields()1338   inline std::string* mutable_unknown_fields() {
1339     return _internal_metadata_.mutable_unknown_fields<std::string>();
1340   }
1341 
default_instance()1342   static const CastLogsProto_CastConnectionInfo& default_instance() {
1343     return *internal_default_instance();
1344   }
internal_default_instance()1345   static inline const CastLogsProto_CastConnectionInfo* internal_default_instance() {
1346     return reinterpret_cast<const CastLogsProto_CastConnectionInfo*>(
1347                &_CastLogsProto_CastConnectionInfo_default_instance_);
1348   }
1349   static constexpr int kIndexInFileMessages =
1350     3;
1351 
swap(CastLogsProto_CastConnectionInfo & a,CastLogsProto_CastConnectionInfo & b)1352   friend void swap(CastLogsProto_CastConnectionInfo& a, CastLogsProto_CastConnectionInfo& b) {
1353     a.Swap(&b);
1354   }
Swap(CastLogsProto_CastConnectionInfo * other)1355   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastConnectionInfo* other) {
1356     if (other == this) return;
1357   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1358     if (GetOwningArena() != nullptr &&
1359         GetOwningArena() == other->GetOwningArena()) {
1360    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1361     if (GetOwningArena() == other->GetOwningArena()) {
1362   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1363       InternalSwap(other);
1364     } else {
1365       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1366     }
1367   }
1368   void UnsafeArenaSwap(CastLogsProto_CastConnectionInfo* other) {
1369     if (other == this) return;
1370     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1371     InternalSwap(other);
1372   }
1373 
1374   // implements Message ----------------------------------------------
1375 
1376   CastLogsProto_CastConnectionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1377     return CreateMaybeMessage<CastLogsProto_CastConnectionInfo>(arena);
1378   }
1379   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1380   void CopyFrom(const CastLogsProto_CastConnectionInfo& from);
1381   void MergeFrom(const CastLogsProto_CastConnectionInfo& from);
1382   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1383   bool IsInitialized() const final;
1384 
1385   size_t ByteSizeLong() const final;
1386   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1387   uint8_t* _InternalSerialize(
1388       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1389   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1390 
1391   private:
1392   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1393   void SharedDtor();
1394   void SetCachedSize(int size) const;
1395   void InternalSwap(CastLogsProto_CastConnectionInfo* other);
1396 
1397   private:
1398   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1399   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1400     return "metrics.CastLogsProto.CastConnectionInfo";
1401   }
1402   protected:
1403   explicit CastLogsProto_CastConnectionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1404                        bool is_message_owned = false);
1405   public:
1406 
1407   std::string GetTypeName() const final;
1408 
1409   // nested types ----------------------------------------------------
1410 
1411   typedef CastLogsProto_CastConnectionInfo_SenderInfo SenderInfo;
1412 
1413   // accessors -------------------------------------------------------
1414 
1415   enum : int {
1416     kSenderInfoFieldNumber = 3,
1417     kTransportConnectionIdFieldNumber = 1,
1418     kVirtualConnectionIdFieldNumber = 2,
1419   };
1420   // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo sender_info = 3;
1421   bool has_sender_info() const;
1422   private:
1423   bool _internal_has_sender_info() const;
1424   public:
1425   void clear_sender_info();
1426   const ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo& sender_info() const;
1427   PROTOBUF_NODISCARD ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* release_sender_info();
1428   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* mutable_sender_info();
1429   void set_allocated_sender_info(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* sender_info);
1430   private:
1431   const ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo& _internal_sender_info() const;
1432   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* _internal_mutable_sender_info();
1433   public:
1434   void unsafe_arena_set_allocated_sender_info(
1435       ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* sender_info);
1436   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* unsafe_arena_release_sender_info();
1437 
1438   // optional fixed32 transport_connection_id = 1;
1439   bool has_transport_connection_id() const;
1440   private:
1441   bool _internal_has_transport_connection_id() const;
1442   public:
1443   void clear_transport_connection_id();
1444   uint32_t transport_connection_id() const;
1445   void set_transport_connection_id(uint32_t value);
1446   private:
1447   uint32_t _internal_transport_connection_id() const;
1448   void _internal_set_transport_connection_id(uint32_t value);
1449   public:
1450 
1451   // optional fixed32 virtual_connection_id = 2;
1452   bool has_virtual_connection_id() const;
1453   private:
1454   bool _internal_has_virtual_connection_id() const;
1455   public:
1456   void clear_virtual_connection_id();
1457   uint32_t virtual_connection_id() const;
1458   void set_virtual_connection_id(uint32_t value);
1459   private:
1460   uint32_t _internal_virtual_connection_id() const;
1461   void _internal_set_virtual_connection_id(uint32_t value);
1462   public:
1463 
1464   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastConnectionInfo)
1465  private:
1466   class _Internal;
1467 
1468   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1469   typedef void InternalArenaConstructable_;
1470   typedef void DestructorSkippable_;
1471   struct Impl_ {
1472     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1473     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1474     ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* sender_info_;
1475     uint32_t transport_connection_id_;
1476     uint32_t virtual_connection_id_;
1477   };
1478   union { Impl_ _impl_; };
1479   friend struct ::TableStruct_cast_5flogs_2eproto;
1480 };
1481 // -------------------------------------------------------------------
1482 
1483 class CastLogsProto_CastEventProto_Metadata final :
1484     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastEventProto.Metadata) */ {
1485  public:
CastLogsProto_CastEventProto_Metadata()1486   inline CastLogsProto_CastEventProto_Metadata() : CastLogsProto_CastEventProto_Metadata(nullptr) {}
1487   ~CastLogsProto_CastEventProto_Metadata() override;
1488   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastEventProto_Metadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1489 
1490   CastLogsProto_CastEventProto_Metadata(const CastLogsProto_CastEventProto_Metadata& from);
CastLogsProto_CastEventProto_Metadata(CastLogsProto_CastEventProto_Metadata && from)1491   CastLogsProto_CastEventProto_Metadata(CastLogsProto_CastEventProto_Metadata&& from) noexcept
1492     : CastLogsProto_CastEventProto_Metadata() {
1493     *this = ::std::move(from);
1494   }
1495 
1496   inline CastLogsProto_CastEventProto_Metadata& operator=(const CastLogsProto_CastEventProto_Metadata& from) {
1497     CopyFrom(from);
1498     return *this;
1499   }
1500   inline CastLogsProto_CastEventProto_Metadata& operator=(CastLogsProto_CastEventProto_Metadata&& from) noexcept {
1501     if (this == &from) return *this;
1502     if (GetOwningArena() == from.GetOwningArena()
1503   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1504         && GetOwningArena() != nullptr
1505   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1506     ) {
1507       InternalSwap(&from);
1508     } else {
1509       CopyFrom(from);
1510     }
1511     return *this;
1512   }
1513 
unknown_fields()1514   inline const std::string& unknown_fields() const {
1515     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1516   }
mutable_unknown_fields()1517   inline std::string* mutable_unknown_fields() {
1518     return _internal_metadata_.mutable_unknown_fields<std::string>();
1519   }
1520 
default_instance()1521   static const CastLogsProto_CastEventProto_Metadata& default_instance() {
1522     return *internal_default_instance();
1523   }
internal_default_instance()1524   static inline const CastLogsProto_CastEventProto_Metadata* internal_default_instance() {
1525     return reinterpret_cast<const CastLogsProto_CastEventProto_Metadata*>(
1526                &_CastLogsProto_CastEventProto_Metadata_default_instance_);
1527   }
1528   static constexpr int kIndexInFileMessages =
1529     4;
1530 
swap(CastLogsProto_CastEventProto_Metadata & a,CastLogsProto_CastEventProto_Metadata & b)1531   friend void swap(CastLogsProto_CastEventProto_Metadata& a, CastLogsProto_CastEventProto_Metadata& b) {
1532     a.Swap(&b);
1533   }
Swap(CastLogsProto_CastEventProto_Metadata * other)1534   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastEventProto_Metadata* other) {
1535     if (other == this) return;
1536   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1537     if (GetOwningArena() != nullptr &&
1538         GetOwningArena() == other->GetOwningArena()) {
1539    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1540     if (GetOwningArena() == other->GetOwningArena()) {
1541   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1542       InternalSwap(other);
1543     } else {
1544       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1545     }
1546   }
1547   void UnsafeArenaSwap(CastLogsProto_CastEventProto_Metadata* other) {
1548     if (other == this) return;
1549     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1550     InternalSwap(other);
1551   }
1552 
1553   // implements Message ----------------------------------------------
1554 
1555   CastLogsProto_CastEventProto_Metadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1556     return CreateMaybeMessage<CastLogsProto_CastEventProto_Metadata>(arena);
1557   }
1558   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1559   void CopyFrom(const CastLogsProto_CastEventProto_Metadata& from);
1560   void MergeFrom(const CastLogsProto_CastEventProto_Metadata& from);
1561   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1562   bool IsInitialized() const final;
1563 
1564   size_t ByteSizeLong() const final;
1565   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1566   uint8_t* _InternalSerialize(
1567       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1568   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1569 
1570   private:
1571   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1572   void SharedDtor();
1573   void SetCachedSize(int size) const;
1574   void InternalSwap(CastLogsProto_CastEventProto_Metadata* other);
1575 
1576   private:
1577   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1578   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1579     return "metrics.CastLogsProto.CastEventProto.Metadata";
1580   }
1581   protected:
1582   explicit CastLogsProto_CastEventProto_Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1583                        bool is_message_owned = false);
1584   public:
1585 
1586   std::string GetTypeName() const final;
1587 
1588   // nested types ----------------------------------------------------
1589 
1590   // accessors -------------------------------------------------------
1591 
1592   enum : int {
1593     kNameHashFieldNumber = 1,
1594     kValueFieldNumber = 2,
1595   };
1596   // optional fixed64 name_hash = 1;
1597   bool has_name_hash() const;
1598   private:
1599   bool _internal_has_name_hash() const;
1600   public:
1601   void clear_name_hash();
1602   uint64_t name_hash() const;
1603   void set_name_hash(uint64_t value);
1604   private:
1605   uint64_t _internal_name_hash() const;
1606   void _internal_set_name_hash(uint64_t value);
1607   public:
1608 
1609   // optional int64 value = 2;
1610   bool has_value() const;
1611   private:
1612   bool _internal_has_value() const;
1613   public:
1614   void clear_value();
1615   int64_t value() const;
1616   void set_value(int64_t value);
1617   private:
1618   int64_t _internal_value() const;
1619   void _internal_set_value(int64_t value);
1620   public:
1621 
1622   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastEventProto.Metadata)
1623  private:
1624   class _Internal;
1625 
1626   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1627   typedef void InternalArenaConstructable_;
1628   typedef void DestructorSkippable_;
1629   struct Impl_ {
1630     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1631     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1632     uint64_t name_hash_;
1633     int64_t value_;
1634   };
1635   union { Impl_ _impl_; };
1636   friend struct ::TableStruct_cast_5flogs_2eproto;
1637 };
1638 // -------------------------------------------------------------------
1639 
1640 class CastLogsProto_CastEventProto final :
1641     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastEventProto) */ {
1642  public:
CastLogsProto_CastEventProto()1643   inline CastLogsProto_CastEventProto() : CastLogsProto_CastEventProto(nullptr) {}
1644   ~CastLogsProto_CastEventProto() override;
1645   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastEventProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1646 
1647   CastLogsProto_CastEventProto(const CastLogsProto_CastEventProto& from);
CastLogsProto_CastEventProto(CastLogsProto_CastEventProto && from)1648   CastLogsProto_CastEventProto(CastLogsProto_CastEventProto&& from) noexcept
1649     : CastLogsProto_CastEventProto() {
1650     *this = ::std::move(from);
1651   }
1652 
1653   inline CastLogsProto_CastEventProto& operator=(const CastLogsProto_CastEventProto& from) {
1654     CopyFrom(from);
1655     return *this;
1656   }
1657   inline CastLogsProto_CastEventProto& operator=(CastLogsProto_CastEventProto&& from) noexcept {
1658     if (this == &from) return *this;
1659     if (GetOwningArena() == from.GetOwningArena()
1660   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1661         && GetOwningArena() != nullptr
1662   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1663     ) {
1664       InternalSwap(&from);
1665     } else {
1666       CopyFrom(from);
1667     }
1668     return *this;
1669   }
1670 
unknown_fields()1671   inline const std::string& unknown_fields() const {
1672     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1673   }
mutable_unknown_fields()1674   inline std::string* mutable_unknown_fields() {
1675     return _internal_metadata_.mutable_unknown_fields<std::string>();
1676   }
1677 
default_instance()1678   static const CastLogsProto_CastEventProto& default_instance() {
1679     return *internal_default_instance();
1680   }
internal_default_instance()1681   static inline const CastLogsProto_CastEventProto* internal_default_instance() {
1682     return reinterpret_cast<const CastLogsProto_CastEventProto*>(
1683                &_CastLogsProto_CastEventProto_default_instance_);
1684   }
1685   static constexpr int kIndexInFileMessages =
1686     5;
1687 
swap(CastLogsProto_CastEventProto & a,CastLogsProto_CastEventProto & b)1688   friend void swap(CastLogsProto_CastEventProto& a, CastLogsProto_CastEventProto& b) {
1689     a.Swap(&b);
1690   }
Swap(CastLogsProto_CastEventProto * other)1691   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastEventProto* other) {
1692     if (other == this) return;
1693   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1694     if (GetOwningArena() != nullptr &&
1695         GetOwningArena() == other->GetOwningArena()) {
1696    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1697     if (GetOwningArena() == other->GetOwningArena()) {
1698   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1699       InternalSwap(other);
1700     } else {
1701       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1702     }
1703   }
1704   void UnsafeArenaSwap(CastLogsProto_CastEventProto* other) {
1705     if (other == this) return;
1706     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1707     InternalSwap(other);
1708   }
1709 
1710   // implements Message ----------------------------------------------
1711 
1712   CastLogsProto_CastEventProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1713     return CreateMaybeMessage<CastLogsProto_CastEventProto>(arena);
1714   }
1715   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1716   void CopyFrom(const CastLogsProto_CastEventProto& from);
1717   void MergeFrom(const CastLogsProto_CastEventProto& from);
1718   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1719   bool IsInitialized() const final;
1720 
1721   size_t ByteSizeLong() const final;
1722   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1723   uint8_t* _InternalSerialize(
1724       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1725   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1726 
1727   private:
1728   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1729   void SharedDtor();
1730   void SetCachedSize(int size) const;
1731   void InternalSwap(CastLogsProto_CastEventProto* other);
1732 
1733   private:
1734   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1735   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1736     return "metrics.CastLogsProto.CastEventProto";
1737   }
1738   protected:
1739   explicit CastLogsProto_CastEventProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1740                        bool is_message_owned = false);
1741   public:
1742 
1743   std::string GetTypeName() const final;
1744 
1745   // nested types ----------------------------------------------------
1746 
1747   typedef CastLogsProto_CastEventProto_Metadata Metadata;
1748 
1749   typedef CastLogsProto_CastEventProto_LaunchFrom LaunchFrom;
1750   static constexpr LaunchFrom FROM_UNKNOWN =
1751     CastLogsProto_CastEventProto_LaunchFrom_FROM_UNKNOWN;
1752   static constexpr LaunchFrom FROM_LOCAL =
1753     CastLogsProto_CastEventProto_LaunchFrom_FROM_LOCAL;
1754   static constexpr LaunchFrom FROM_DIAL =
1755     CastLogsProto_CastEventProto_LaunchFrom_FROM_DIAL;
1756   static constexpr LaunchFrom FROM_CAST_V2 =
1757     CastLogsProto_CastEventProto_LaunchFrom_FROM_CAST_V2;
1758   static constexpr LaunchFrom FROM_CCS =
1759     CastLogsProto_CastEventProto_LaunchFrom_FROM_CCS;
1760   static inline bool LaunchFrom_IsValid(int value) {
1761     return CastLogsProto_CastEventProto_LaunchFrom_IsValid(value);
1762   }
1763   static constexpr LaunchFrom LaunchFrom_MIN =
1764     CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_MIN;
1765   static constexpr LaunchFrom LaunchFrom_MAX =
1766     CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_MAX;
1767   static constexpr int LaunchFrom_ARRAYSIZE =
1768     CastLogsProto_CastEventProto_LaunchFrom_LaunchFrom_ARRAYSIZE;
1769   template<typename T>
1770   static inline const std::string& LaunchFrom_Name(T enum_t_value) {
1771     static_assert(::std::is_same<T, LaunchFrom>::value ||
1772       ::std::is_integral<T>::value,
1773       "Incorrect type passed to function LaunchFrom_Name.");
1774     return CastLogsProto_CastEventProto_LaunchFrom_Name(enum_t_value);
1775   }
1776   static inline bool LaunchFrom_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1777       LaunchFrom* value) {
1778     return CastLogsProto_CastEventProto_LaunchFrom_Parse(name, value);
1779   }
1780 
1781   typedef CastLogsProto_CastEventProto_RuntimeType RuntimeType;
1782   static constexpr RuntimeType RUNTIME_TYPE_UNKNOWN =
1783     CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_UNKNOWN;
1784   static constexpr RuntimeType RUNTIME_TYPE_CAST_WEB =
1785     CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_CAST_WEB;
1786   static constexpr RuntimeType RUNTIME_TYPE_CAST_LITE =
1787     CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_CAST_LITE;
1788   static constexpr RuntimeType RUNTIME_TYPE_NATIVE =
1789     CastLogsProto_CastEventProto_RuntimeType_RUNTIME_TYPE_NATIVE;
1790   static inline bool RuntimeType_IsValid(int value) {
1791     return CastLogsProto_CastEventProto_RuntimeType_IsValid(value);
1792   }
1793   static constexpr RuntimeType RuntimeType_MIN =
1794     CastLogsProto_CastEventProto_RuntimeType_RuntimeType_MIN;
1795   static constexpr RuntimeType RuntimeType_MAX =
1796     CastLogsProto_CastEventProto_RuntimeType_RuntimeType_MAX;
1797   static constexpr int RuntimeType_ARRAYSIZE =
1798     CastLogsProto_CastEventProto_RuntimeType_RuntimeType_ARRAYSIZE;
1799   template<typename T>
1800   static inline const std::string& RuntimeType_Name(T enum_t_value) {
1801     static_assert(::std::is_same<T, RuntimeType>::value ||
1802       ::std::is_integral<T>::value,
1803       "Incorrect type passed to function RuntimeType_Name.");
1804     return CastLogsProto_CastEventProto_RuntimeType_Name(enum_t_value);
1805   }
1806   static inline bool RuntimeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1807       RuntimeType* value) {
1808     return CastLogsProto_CastEventProto_RuntimeType_Parse(name, value);
1809   }
1810 
1811   // accessors -------------------------------------------------------
1812 
1813   enum : int {
1814     kMetadataFieldNumber = 14,
1815     kFeatureVectorFieldNumber = 15,
1816     kEventIdListFieldNumber = 23,
1817     kConversationKeyFieldNumber = 11,
1818     kEventIdFieldNumber = 13,
1819     kAoghRequestIdFieldNumber = 16,
1820     kTimezoneIdFieldNumber = 17,
1821     kUiVersionFieldNumber = 20,
1822     kAoghAgentIdFieldNumber = 21,
1823     kSelinuxAuditDetailFieldNumber = 22,
1824     kHotwordModelIdFieldNumber = 25,
1825     kAoghStandardAgentIdFieldNumber = 28,
1826     kNameHashFieldNumber = 1,
1827     kTimeMsecFieldNumber = 2,
1828     kApplicationSessionIdFieldNumber = 4,
1829     kAppIdFieldNumber = 3,
1830     kTransportConnectionIdFieldNumber = 6,
1831     kCastReceiverVersionFieldNumber = 5,
1832     kValueFieldNumber = 8,
1833     kCastMplVersionFieldNumber = 9,
1834     kVirtualConnectionIdFieldNumber = 7,
1835     kRequestIdFieldNumber = 12,
1836     kGroupUuidFieldNumber = 10,
1837     kAoghLocalDeviceIdFieldNumber = 18,
1838     kRemoteAppIdFieldNumber = 19,
1839     kLaunchFromFieldNumber = 26,
1840     kDuoCoreVersionFieldNumber = 24,
1841     kRuntimeTypeFieldNumber = 27,
1842   };
1843   // repeated .metrics.CastLogsProto.CastEventProto.Metadata metadata = 14;
1844   int metadata_size() const;
1845   private:
1846   int _internal_metadata_size() const;
1847   public:
1848   void clear_metadata();
1849   ::metrics::CastLogsProto_CastEventProto_Metadata* mutable_metadata(int index);
1850   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto_Metadata >*
1851       mutable_metadata();
1852   private:
1853   const ::metrics::CastLogsProto_CastEventProto_Metadata& _internal_metadata(int index) const;
1854   ::metrics::CastLogsProto_CastEventProto_Metadata* _internal_add_metadata();
1855   public:
1856   const ::metrics::CastLogsProto_CastEventProto_Metadata& metadata(int index) const;
1857   ::metrics::CastLogsProto_CastEventProto_Metadata* add_metadata();
1858   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto_Metadata >&
1859       metadata() const;
1860 
1861   // repeated float feature_vector = 15;
1862   int feature_vector_size() const;
1863   private:
1864   int _internal_feature_vector_size() const;
1865   public:
1866   void clear_feature_vector();
1867   private:
1868   float _internal_feature_vector(int index) const;
1869   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
1870       _internal_feature_vector() const;
1871   void _internal_add_feature_vector(float value);
1872   ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
1873       _internal_mutable_feature_vector();
1874   public:
1875   float feature_vector(int index) const;
1876   void set_feature_vector(int index, float value);
1877   void add_feature_vector(float value);
1878   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
1879       feature_vector() const;
1880   ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
1881       mutable_feature_vector();
1882 
1883   // repeated string event_id_list = 23;
1884   int event_id_list_size() const;
1885   private:
1886   int _internal_event_id_list_size() const;
1887   public:
1888   void clear_event_id_list();
1889   const std::string& event_id_list(int index) const;
1890   std::string* mutable_event_id_list(int index);
1891   void set_event_id_list(int index, const std::string& value);
1892   void set_event_id_list(int index, std::string&& value);
1893   void set_event_id_list(int index, const char* value);
1894   void set_event_id_list(int index, const char* value, size_t size);
1895   std::string* add_event_id_list();
1896   void add_event_id_list(const std::string& value);
1897   void add_event_id_list(std::string&& value);
1898   void add_event_id_list(const char* value);
1899   void add_event_id_list(const char* value, size_t size);
1900   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& event_id_list() const;
1901   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_event_id_list();
1902   private:
1903   const std::string& _internal_event_id_list(int index) const;
1904   std::string* _internal_add_event_id_list();
1905   public:
1906 
1907   // optional string conversation_key = 11;
1908   bool has_conversation_key() const;
1909   private:
1910   bool _internal_has_conversation_key() const;
1911   public:
1912   void clear_conversation_key();
1913   const std::string& conversation_key() const;
1914   template <typename ArgT0 = const std::string&, typename... ArgT>
1915   void set_conversation_key(ArgT0&& arg0, ArgT... args);
1916   std::string* mutable_conversation_key();
1917   PROTOBUF_NODISCARD std::string* release_conversation_key();
1918   void set_allocated_conversation_key(std::string* conversation_key);
1919   private:
1920   const std::string& _internal_conversation_key() const;
1921   inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversation_key(const std::string& value);
1922   std::string* _internal_mutable_conversation_key();
1923   public:
1924 
1925   // optional string event_id = 13;
1926   bool has_event_id() const;
1927   private:
1928   bool _internal_has_event_id() const;
1929   public:
1930   void clear_event_id();
1931   const std::string& event_id() const;
1932   template <typename ArgT0 = const std::string&, typename... ArgT>
1933   void set_event_id(ArgT0&& arg0, ArgT... args);
1934   std::string* mutable_event_id();
1935   PROTOBUF_NODISCARD std::string* release_event_id();
1936   void set_allocated_event_id(std::string* event_id);
1937   private:
1938   const std::string& _internal_event_id() const;
1939   inline PROTOBUF_ALWAYS_INLINE void _internal_set_event_id(const std::string& value);
1940   std::string* _internal_mutable_event_id();
1941   public:
1942 
1943   // optional string aogh_request_id = 16;
1944   bool has_aogh_request_id() const;
1945   private:
1946   bool _internal_has_aogh_request_id() const;
1947   public:
1948   void clear_aogh_request_id();
1949   const std::string& aogh_request_id() const;
1950   template <typename ArgT0 = const std::string&, typename... ArgT>
1951   void set_aogh_request_id(ArgT0&& arg0, ArgT... args);
1952   std::string* mutable_aogh_request_id();
1953   PROTOBUF_NODISCARD std::string* release_aogh_request_id();
1954   void set_allocated_aogh_request_id(std::string* aogh_request_id);
1955   private:
1956   const std::string& _internal_aogh_request_id() const;
1957   inline PROTOBUF_ALWAYS_INLINE void _internal_set_aogh_request_id(const std::string& value);
1958   std::string* _internal_mutable_aogh_request_id();
1959   public:
1960 
1961   // optional string timezone_id = 17;
1962   bool has_timezone_id() const;
1963   private:
1964   bool _internal_has_timezone_id() const;
1965   public:
1966   void clear_timezone_id();
1967   const std::string& timezone_id() const;
1968   template <typename ArgT0 = const std::string&, typename... ArgT>
1969   void set_timezone_id(ArgT0&& arg0, ArgT... args);
1970   std::string* mutable_timezone_id();
1971   PROTOBUF_NODISCARD std::string* release_timezone_id();
1972   void set_allocated_timezone_id(std::string* timezone_id);
1973   private:
1974   const std::string& _internal_timezone_id() const;
1975   inline PROTOBUF_ALWAYS_INLINE void _internal_set_timezone_id(const std::string& value);
1976   std::string* _internal_mutable_timezone_id();
1977   public:
1978 
1979   // optional string ui_version = 20;
1980   bool has_ui_version() const;
1981   private:
1982   bool _internal_has_ui_version() const;
1983   public:
1984   void clear_ui_version();
1985   const std::string& ui_version() const;
1986   template <typename ArgT0 = const std::string&, typename... ArgT>
1987   void set_ui_version(ArgT0&& arg0, ArgT... args);
1988   std::string* mutable_ui_version();
1989   PROTOBUF_NODISCARD std::string* release_ui_version();
1990   void set_allocated_ui_version(std::string* ui_version);
1991   private:
1992   const std::string& _internal_ui_version() const;
1993   inline PROTOBUF_ALWAYS_INLINE void _internal_set_ui_version(const std::string& value);
1994   std::string* _internal_mutable_ui_version();
1995   public:
1996 
1997   // optional string aogh_agent_id = 21;
1998   bool has_aogh_agent_id() const;
1999   private:
2000   bool _internal_has_aogh_agent_id() const;
2001   public:
2002   void clear_aogh_agent_id();
2003   const std::string& aogh_agent_id() const;
2004   template <typename ArgT0 = const std::string&, typename... ArgT>
2005   void set_aogh_agent_id(ArgT0&& arg0, ArgT... args);
2006   std::string* mutable_aogh_agent_id();
2007   PROTOBUF_NODISCARD std::string* release_aogh_agent_id();
2008   void set_allocated_aogh_agent_id(std::string* aogh_agent_id);
2009   private:
2010   const std::string& _internal_aogh_agent_id() const;
2011   inline PROTOBUF_ALWAYS_INLINE void _internal_set_aogh_agent_id(const std::string& value);
2012   std::string* _internal_mutable_aogh_agent_id();
2013   public:
2014 
2015   // optional string selinux_audit_detail = 22;
2016   bool has_selinux_audit_detail() const;
2017   private:
2018   bool _internal_has_selinux_audit_detail() const;
2019   public:
2020   void clear_selinux_audit_detail();
2021   const std::string& selinux_audit_detail() const;
2022   template <typename ArgT0 = const std::string&, typename... ArgT>
2023   void set_selinux_audit_detail(ArgT0&& arg0, ArgT... args);
2024   std::string* mutable_selinux_audit_detail();
2025   PROTOBUF_NODISCARD std::string* release_selinux_audit_detail();
2026   void set_allocated_selinux_audit_detail(std::string* selinux_audit_detail);
2027   private:
2028   const std::string& _internal_selinux_audit_detail() const;
2029   inline PROTOBUF_ALWAYS_INLINE void _internal_set_selinux_audit_detail(const std::string& value);
2030   std::string* _internal_mutable_selinux_audit_detail();
2031   public:
2032 
2033   // optional string hotword_model_id = 25;
2034   bool has_hotword_model_id() const;
2035   private:
2036   bool _internal_has_hotword_model_id() const;
2037   public:
2038   void clear_hotword_model_id();
2039   const std::string& hotword_model_id() const;
2040   template <typename ArgT0 = const std::string&, typename... ArgT>
2041   void set_hotword_model_id(ArgT0&& arg0, ArgT... args);
2042   std::string* mutable_hotword_model_id();
2043   PROTOBUF_NODISCARD std::string* release_hotword_model_id();
2044   void set_allocated_hotword_model_id(std::string* hotword_model_id);
2045   private:
2046   const std::string& _internal_hotword_model_id() const;
2047   inline PROTOBUF_ALWAYS_INLINE void _internal_set_hotword_model_id(const std::string& value);
2048   std::string* _internal_mutable_hotword_model_id();
2049   public:
2050 
2051   // optional string aogh_standard_agent_id = 28;
2052   bool has_aogh_standard_agent_id() const;
2053   private:
2054   bool _internal_has_aogh_standard_agent_id() const;
2055   public:
2056   void clear_aogh_standard_agent_id();
2057   const std::string& aogh_standard_agent_id() const;
2058   template <typename ArgT0 = const std::string&, typename... ArgT>
2059   void set_aogh_standard_agent_id(ArgT0&& arg0, ArgT... args);
2060   std::string* mutable_aogh_standard_agent_id();
2061   PROTOBUF_NODISCARD std::string* release_aogh_standard_agent_id();
2062   void set_allocated_aogh_standard_agent_id(std::string* aogh_standard_agent_id);
2063   private:
2064   const std::string& _internal_aogh_standard_agent_id() const;
2065   inline PROTOBUF_ALWAYS_INLINE void _internal_set_aogh_standard_agent_id(const std::string& value);
2066   std::string* _internal_mutable_aogh_standard_agent_id();
2067   public:
2068 
2069   // optional fixed64 name_hash = 1;
2070   bool has_name_hash() const;
2071   private:
2072   bool _internal_has_name_hash() const;
2073   public:
2074   void clear_name_hash();
2075   uint64_t name_hash() const;
2076   void set_name_hash(uint64_t value);
2077   private:
2078   uint64_t _internal_name_hash() const;
2079   void _internal_set_name_hash(uint64_t value);
2080   public:
2081 
2082   // optional int64 time_msec = 2;
2083   bool has_time_msec() const;
2084   private:
2085   bool _internal_has_time_msec() const;
2086   public:
2087   void clear_time_msec();
2088   int64_t time_msec() const;
2089   void set_time_msec(int64_t value);
2090   private:
2091   int64_t _internal_time_msec() const;
2092   void _internal_set_time_msec(int64_t value);
2093   public:
2094 
2095   // optional fixed64 application_session_id = 4;
2096   bool has_application_session_id() const;
2097   private:
2098   bool _internal_has_application_session_id() const;
2099   public:
2100   void clear_application_session_id();
2101   uint64_t application_session_id() const;
2102   void set_application_session_id(uint64_t value);
2103   private:
2104   uint64_t _internal_application_session_id() const;
2105   void _internal_set_application_session_id(uint64_t value);
2106   public:
2107 
2108   // optional fixed32 app_id = 3;
2109   bool has_app_id() const;
2110   private:
2111   bool _internal_has_app_id() const;
2112   public:
2113   void clear_app_id();
2114   uint32_t app_id() const;
2115   void set_app_id(uint32_t value);
2116   private:
2117   uint32_t _internal_app_id() const;
2118   void _internal_set_app_id(uint32_t value);
2119   public:
2120 
2121   // optional fixed32 transport_connection_id = 6;
2122   bool has_transport_connection_id() const;
2123   private:
2124   bool _internal_has_transport_connection_id() const;
2125   public:
2126   void clear_transport_connection_id();
2127   uint32_t transport_connection_id() const;
2128   void set_transport_connection_id(uint32_t value);
2129   private:
2130   uint32_t _internal_transport_connection_id() const;
2131   void _internal_set_transport_connection_id(uint32_t value);
2132   public:
2133 
2134   // optional fixed64 cast_receiver_version = 5;
2135   bool has_cast_receiver_version() const;
2136   private:
2137   bool _internal_has_cast_receiver_version() const;
2138   public:
2139   void clear_cast_receiver_version();
2140   uint64_t cast_receiver_version() const;
2141   void set_cast_receiver_version(uint64_t value);
2142   private:
2143   uint64_t _internal_cast_receiver_version() const;
2144   void _internal_set_cast_receiver_version(uint64_t value);
2145   public:
2146 
2147   // optional int64 value = 8;
2148   bool has_value() const;
2149   private:
2150   bool _internal_has_value() const;
2151   public:
2152   void clear_value();
2153   int64_t value() const;
2154   void set_value(int64_t value);
2155   private:
2156   int64_t _internal_value() const;
2157   void _internal_set_value(int64_t value);
2158   public:
2159 
2160   // optional fixed64 cast_mpl_version = 9;
2161   bool has_cast_mpl_version() const;
2162   private:
2163   bool _internal_has_cast_mpl_version() const;
2164   public:
2165   void clear_cast_mpl_version();
2166   uint64_t cast_mpl_version() const;
2167   void set_cast_mpl_version(uint64_t value);
2168   private:
2169   uint64_t _internal_cast_mpl_version() const;
2170   void _internal_set_cast_mpl_version(uint64_t value);
2171   public:
2172 
2173   // optional fixed32 virtual_connection_id = 7;
2174   bool has_virtual_connection_id() const;
2175   private:
2176   bool _internal_has_virtual_connection_id() const;
2177   public:
2178   void clear_virtual_connection_id();
2179   uint32_t virtual_connection_id() const;
2180   void set_virtual_connection_id(uint32_t value);
2181   private:
2182   uint32_t _internal_virtual_connection_id() const;
2183   void _internal_set_virtual_connection_id(uint32_t value);
2184   public:
2185 
2186   // optional fixed32 request_id = 12;
2187   bool has_request_id() const;
2188   private:
2189   bool _internal_has_request_id() const;
2190   public:
2191   void clear_request_id();
2192   uint32_t request_id() const;
2193   void set_request_id(uint32_t value);
2194   private:
2195   uint32_t _internal_request_id() const;
2196   void _internal_set_request_id(uint32_t value);
2197   public:
2198 
2199   // optional fixed64 group_uuid = 10;
2200   bool has_group_uuid() const;
2201   private:
2202   bool _internal_has_group_uuid() const;
2203   public:
2204   void clear_group_uuid();
2205   uint64_t group_uuid() const;
2206   void set_group_uuid(uint64_t value);
2207   private:
2208   uint64_t _internal_group_uuid() const;
2209   void _internal_set_group_uuid(uint64_t value);
2210   public:
2211 
2212   // optional int64 aogh_local_device_id = 18;
2213   bool has_aogh_local_device_id() const;
2214   private:
2215   bool _internal_has_aogh_local_device_id() const;
2216   public:
2217   void clear_aogh_local_device_id();
2218   int64_t aogh_local_device_id() const;
2219   void set_aogh_local_device_id(int64_t value);
2220   private:
2221   int64_t _internal_aogh_local_device_id() const;
2222   void _internal_set_aogh_local_device_id(int64_t value);
2223   public:
2224 
2225   // optional fixed32 remote_app_id = 19;
2226   bool has_remote_app_id() const;
2227   private:
2228   bool _internal_has_remote_app_id() const;
2229   public:
2230   void clear_remote_app_id();
2231   uint32_t remote_app_id() const;
2232   void set_remote_app_id(uint32_t value);
2233   private:
2234   uint32_t _internal_remote_app_id() const;
2235   void _internal_set_remote_app_id(uint32_t value);
2236   public:
2237 
2238   // optional .metrics.CastLogsProto.CastEventProto.LaunchFrom launch_from = 26;
2239   bool has_launch_from() const;
2240   private:
2241   bool _internal_has_launch_from() const;
2242   public:
2243   void clear_launch_from();
2244   ::metrics::CastLogsProto_CastEventProto_LaunchFrom launch_from() const;
2245   void set_launch_from(::metrics::CastLogsProto_CastEventProto_LaunchFrom value);
2246   private:
2247   ::metrics::CastLogsProto_CastEventProto_LaunchFrom _internal_launch_from() const;
2248   void _internal_set_launch_from(::metrics::CastLogsProto_CastEventProto_LaunchFrom value);
2249   public:
2250 
2251   // optional fixed64 duo_core_version = 24;
2252   bool has_duo_core_version() const;
2253   private:
2254   bool _internal_has_duo_core_version() const;
2255   public:
2256   void clear_duo_core_version();
2257   uint64_t duo_core_version() const;
2258   void set_duo_core_version(uint64_t value);
2259   private:
2260   uint64_t _internal_duo_core_version() const;
2261   void _internal_set_duo_core_version(uint64_t value);
2262   public:
2263 
2264   // optional .metrics.CastLogsProto.CastEventProto.RuntimeType runtime_type = 27;
2265   bool has_runtime_type() const;
2266   private:
2267   bool _internal_has_runtime_type() const;
2268   public:
2269   void clear_runtime_type();
2270   ::metrics::CastLogsProto_CastEventProto_RuntimeType runtime_type() const;
2271   void set_runtime_type(::metrics::CastLogsProto_CastEventProto_RuntimeType value);
2272   private:
2273   ::metrics::CastLogsProto_CastEventProto_RuntimeType _internal_runtime_type() const;
2274   void _internal_set_runtime_type(::metrics::CastLogsProto_CastEventProto_RuntimeType value);
2275   public:
2276 
2277   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastEventProto)
2278  private:
2279   class _Internal;
2280 
2281   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2282   typedef void InternalArenaConstructable_;
2283   typedef void DestructorSkippable_;
2284   struct Impl_ {
2285     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2286     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2287     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto_Metadata > metadata_;
2288     ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > feature_vector_;
2289     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> event_id_list_;
2290     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversation_key_;
2291     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr event_id_;
2292     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aogh_request_id_;
2293     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr timezone_id_;
2294     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ui_version_;
2295     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aogh_agent_id_;
2296     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selinux_audit_detail_;
2297     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hotword_model_id_;
2298     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aogh_standard_agent_id_;
2299     uint64_t name_hash_;
2300     int64_t time_msec_;
2301     uint64_t application_session_id_;
2302     uint32_t app_id_;
2303     uint32_t transport_connection_id_;
2304     uint64_t cast_receiver_version_;
2305     int64_t value_;
2306     uint64_t cast_mpl_version_;
2307     uint32_t virtual_connection_id_;
2308     uint32_t request_id_;
2309     uint64_t group_uuid_;
2310     int64_t aogh_local_device_id_;
2311     uint32_t remote_app_id_;
2312     int launch_from_;
2313     uint64_t duo_core_version_;
2314     int runtime_type_;
2315   };
2316   union { Impl_ _impl_; };
2317   friend struct ::TableStruct_cast_5flogs_2eproto;
2318 };
2319 // -------------------------------------------------------------------
2320 
2321 class CastLogsProto_CastDeviceMutableInfo final :
2322     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto.CastDeviceMutableInfo) */ {
2323  public:
CastLogsProto_CastDeviceMutableInfo()2324   inline CastLogsProto_CastDeviceMutableInfo() : CastLogsProto_CastDeviceMutableInfo(nullptr) {}
2325   ~CastLogsProto_CastDeviceMutableInfo() override;
2326   explicit PROTOBUF_CONSTEXPR CastLogsProto_CastDeviceMutableInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2327 
2328   CastLogsProto_CastDeviceMutableInfo(const CastLogsProto_CastDeviceMutableInfo& from);
CastLogsProto_CastDeviceMutableInfo(CastLogsProto_CastDeviceMutableInfo && from)2329   CastLogsProto_CastDeviceMutableInfo(CastLogsProto_CastDeviceMutableInfo&& from) noexcept
2330     : CastLogsProto_CastDeviceMutableInfo() {
2331     *this = ::std::move(from);
2332   }
2333 
2334   inline CastLogsProto_CastDeviceMutableInfo& operator=(const CastLogsProto_CastDeviceMutableInfo& from) {
2335     CopyFrom(from);
2336     return *this;
2337   }
2338   inline CastLogsProto_CastDeviceMutableInfo& operator=(CastLogsProto_CastDeviceMutableInfo&& from) noexcept {
2339     if (this == &from) return *this;
2340     if (GetOwningArena() == from.GetOwningArena()
2341   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2342         && GetOwningArena() != nullptr
2343   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2344     ) {
2345       InternalSwap(&from);
2346     } else {
2347       CopyFrom(from);
2348     }
2349     return *this;
2350   }
2351 
unknown_fields()2352   inline const std::string& unknown_fields() const {
2353     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2354   }
mutable_unknown_fields()2355   inline std::string* mutable_unknown_fields() {
2356     return _internal_metadata_.mutable_unknown_fields<std::string>();
2357   }
2358 
default_instance()2359   static const CastLogsProto_CastDeviceMutableInfo& default_instance() {
2360     return *internal_default_instance();
2361   }
internal_default_instance()2362   static inline const CastLogsProto_CastDeviceMutableInfo* internal_default_instance() {
2363     return reinterpret_cast<const CastLogsProto_CastDeviceMutableInfo*>(
2364                &_CastLogsProto_CastDeviceMutableInfo_default_instance_);
2365   }
2366   static constexpr int kIndexInFileMessages =
2367     6;
2368 
swap(CastLogsProto_CastDeviceMutableInfo & a,CastLogsProto_CastDeviceMutableInfo & b)2369   friend void swap(CastLogsProto_CastDeviceMutableInfo& a, CastLogsProto_CastDeviceMutableInfo& b) {
2370     a.Swap(&b);
2371   }
Swap(CastLogsProto_CastDeviceMutableInfo * other)2372   PROTOBUF_NOINLINE void Swap(CastLogsProto_CastDeviceMutableInfo* other) {
2373     if (other == this) return;
2374   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2375     if (GetOwningArena() != nullptr &&
2376         GetOwningArena() == other->GetOwningArena()) {
2377    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2378     if (GetOwningArena() == other->GetOwningArena()) {
2379   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2380       InternalSwap(other);
2381     } else {
2382       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2383     }
2384   }
2385   void UnsafeArenaSwap(CastLogsProto_CastDeviceMutableInfo* other) {
2386     if (other == this) return;
2387     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2388     InternalSwap(other);
2389   }
2390 
2391   // implements Message ----------------------------------------------
2392 
2393   CastLogsProto_CastDeviceMutableInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2394     return CreateMaybeMessage<CastLogsProto_CastDeviceMutableInfo>(arena);
2395   }
2396   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2397   void CopyFrom(const CastLogsProto_CastDeviceMutableInfo& from);
2398   void MergeFrom(const CastLogsProto_CastDeviceMutableInfo& from);
2399   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2400   bool IsInitialized() const final;
2401 
2402   size_t ByteSizeLong() const final;
2403   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2404   uint8_t* _InternalSerialize(
2405       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2406   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2407 
2408   private:
2409   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2410   void SharedDtor();
2411   void SetCachedSize(int size) const;
2412   void InternalSwap(CastLogsProto_CastDeviceMutableInfo* other);
2413 
2414   private:
2415   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2416   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2417     return "metrics.CastLogsProto.CastDeviceMutableInfo";
2418   }
2419   protected:
2420   explicit CastLogsProto_CastDeviceMutableInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2421                        bool is_message_owned = false);
2422   public:
2423 
2424   std::string GetTypeName() const final;
2425 
2426   // nested types ----------------------------------------------------
2427 
2428   typedef CastLogsProto_CastDeviceMutableInfo_RebootType RebootType;
2429   static constexpr RebootType REBOOT_TYPE_UNKNOWN =
2430     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UNKNOWN;
2431   static constexpr RebootType REBOOT_TYPE_FORCED =
2432     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_FORCED;
2433   static constexpr RebootType REBOOT_TYPE_API =
2434     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_API;
2435   static constexpr RebootType REBOOT_TYPE_NIGHTLY =
2436     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_NIGHTLY;
2437   static constexpr RebootType REBOOT_TYPE_OTA =
2438     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_OTA;
2439   static constexpr RebootType REBOOT_TYPE_WATCHDOG =
2440     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_WATCHDOG;
2441   static constexpr RebootType REBOOT_TYPE_PROCESS_MANAGER =
2442     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_PROCESS_MANAGER;
2443   static constexpr RebootType REBOOT_TYPE_CRASH_UPLOADER =
2444     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_CRASH_UPLOADER;
2445   static constexpr RebootType REBOOT_TYPE_FDR =
2446     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_FDR;
2447   static constexpr RebootType REBOOT_TYPE_HW_WATCHDOG =
2448     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_HW_WATCHDOG;
2449   static constexpr RebootType REBOOT_TYPE_SW_OTHER =
2450     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_SW_OTHER;
2451   static constexpr RebootType REBOOT_TYPE_OVERHEAT =
2452     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_OVERHEAT;
2453   static constexpr RebootType REBOOT_TYPE_REGENERATE_CLOUD_ID =
2454     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_REGENERATE_CLOUD_ID;
2455   static constexpr RebootType REBOOT_TYPE_REPEATED_OOM =
2456     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_REPEATED_OOM;
2457   static constexpr RebootType REBOOT_TYPE_UTILITY_PROCESS_CRASH =
2458     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UTILITY_PROCESS_CRASH;
2459   static constexpr RebootType REBOOT_TYPE_GRACEFUL_RESTART =
2460     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_GRACEFUL_RESTART;
2461   static constexpr RebootType REBOOT_TYPE_UNGRACEFUL_RESTART =
2462     CastLogsProto_CastDeviceMutableInfo_RebootType_REBOOT_TYPE_UNGRACEFUL_RESTART;
2463   static constexpr RebootType MULTI_SERVICE_BUG =
2464     CastLogsProto_CastDeviceMutableInfo_RebootType_MULTI_SERVICE_BUG;
2465   static constexpr RebootType POWER_MANAGER =
2466     CastLogsProto_CastDeviceMutableInfo_RebootType_POWER_MANAGER;
2467   static constexpr RebootType EXPERIMENT_CHANGE =
2468     CastLogsProto_CastDeviceMutableInfo_RebootType_EXPERIMENT_CHANGE;
2469   static constexpr RebootType ANOMALY_DETECTION =
2470     CastLogsProto_CastDeviceMutableInfo_RebootType_ANOMALY_DETECTION;
2471   static constexpr RebootType KERNEL_PANIC =
2472     CastLogsProto_CastDeviceMutableInfo_RebootType_KERNEL_PANIC;
2473   static inline bool RebootType_IsValid(int value) {
2474     return CastLogsProto_CastDeviceMutableInfo_RebootType_IsValid(value);
2475   }
2476   static constexpr RebootType RebootType_MIN =
2477     CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_MIN;
2478   static constexpr RebootType RebootType_MAX =
2479     CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_MAX;
2480   static constexpr int RebootType_ARRAYSIZE =
2481     CastLogsProto_CastDeviceMutableInfo_RebootType_RebootType_ARRAYSIZE;
2482   template<typename T>
2483   static inline const std::string& RebootType_Name(T enum_t_value) {
2484     static_assert(::std::is_same<T, RebootType>::value ||
2485       ::std::is_integral<T>::value,
2486       "Incorrect type passed to function RebootType_Name.");
2487     return CastLogsProto_CastDeviceMutableInfo_RebootType_Name(enum_t_value);
2488   }
2489   static inline bool RebootType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2490       RebootType* value) {
2491     return CastLogsProto_CastDeviceMutableInfo_RebootType_Parse(name, value);
2492   }
2493 
2494   typedef CastLogsProto_CastDeviceMutableInfo_NetifIPVersion NetifIPVersion;
2495   static constexpr NetifIPVersion IP_UNKNOWN =
2496     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_UNKNOWN;
2497   static constexpr NetifIPVersion IP_V4 =
2498     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_V4;
2499   static constexpr NetifIPVersion IP_V6 =
2500     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_V6;
2501   static constexpr NetifIPVersion IP_DUAL_STACK =
2502     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IP_DUAL_STACK;
2503   static inline bool NetifIPVersion_IsValid(int value) {
2504     return CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IsValid(value);
2505   }
2506   static constexpr NetifIPVersion NetifIPVersion_MIN =
2507     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_MIN;
2508   static constexpr NetifIPVersion NetifIPVersion_MAX =
2509     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_MAX;
2510   static constexpr int NetifIPVersion_ARRAYSIZE =
2511     CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_NetifIPVersion_ARRAYSIZE;
2512   template<typename T>
2513   static inline const std::string& NetifIPVersion_Name(T enum_t_value) {
2514     static_assert(::std::is_same<T, NetifIPVersion>::value ||
2515       ::std::is_integral<T>::value,
2516       "Incorrect type passed to function NetifIPVersion_Name.");
2517     return CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Name(enum_t_value);
2518   }
2519   static inline bool NetifIPVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2520       NetifIPVersion* value) {
2521     return CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_Parse(name, value);
2522   }
2523 
2524   // accessors -------------------------------------------------------
2525 
2526   enum : int {
2527     kBackdropAppDeviceIdFieldNumber = 3,
2528     kTimezoneIdFieldNumber = 7,
2529     kLatestUiVersionFieldNumber = 8,
2530     kGoogleWifiStationShmacFieldNumber = 9,
2531     kInstalledManifestPlatformVersionFieldNumber = 10,
2532     kSystemBundleVersionFieldNumber = 12,
2533     kSystemBuildNumberFieldNumber = 2,
2534     kLastRebootTypeFieldNumber = 1,
2535     kReleaseVersionFieldNumber = 4,
2536     kNetifIpVersionFieldNumber = 5,
2537     kIpDualStackSupportedFieldNumber = 6,
2538     kInstalledManifestVersionFieldNumber = 11,
2539   };
2540   // optional string backdrop_app_device_id = 3;
2541   bool has_backdrop_app_device_id() const;
2542   private:
2543   bool _internal_has_backdrop_app_device_id() const;
2544   public:
2545   void clear_backdrop_app_device_id();
2546   const std::string& backdrop_app_device_id() const;
2547   template <typename ArgT0 = const std::string&, typename... ArgT>
2548   void set_backdrop_app_device_id(ArgT0&& arg0, ArgT... args);
2549   std::string* mutable_backdrop_app_device_id();
2550   PROTOBUF_NODISCARD std::string* release_backdrop_app_device_id();
2551   void set_allocated_backdrop_app_device_id(std::string* backdrop_app_device_id);
2552   private:
2553   const std::string& _internal_backdrop_app_device_id() const;
2554   inline PROTOBUF_ALWAYS_INLINE void _internal_set_backdrop_app_device_id(const std::string& value);
2555   std::string* _internal_mutable_backdrop_app_device_id();
2556   public:
2557 
2558   // optional string timezone_id = 7;
2559   bool has_timezone_id() const;
2560   private:
2561   bool _internal_has_timezone_id() const;
2562   public:
2563   void clear_timezone_id();
2564   const std::string& timezone_id() const;
2565   template <typename ArgT0 = const std::string&, typename... ArgT>
2566   void set_timezone_id(ArgT0&& arg0, ArgT... args);
2567   std::string* mutable_timezone_id();
2568   PROTOBUF_NODISCARD std::string* release_timezone_id();
2569   void set_allocated_timezone_id(std::string* timezone_id);
2570   private:
2571   const std::string& _internal_timezone_id() const;
2572   inline PROTOBUF_ALWAYS_INLINE void _internal_set_timezone_id(const std::string& value);
2573   std::string* _internal_mutable_timezone_id();
2574   public:
2575 
2576   // optional string latest_ui_version = 8;
2577   bool has_latest_ui_version() const;
2578   private:
2579   bool _internal_has_latest_ui_version() const;
2580   public:
2581   void clear_latest_ui_version();
2582   const std::string& latest_ui_version() const;
2583   template <typename ArgT0 = const std::string&, typename... ArgT>
2584   void set_latest_ui_version(ArgT0&& arg0, ArgT... args);
2585   std::string* mutable_latest_ui_version();
2586   PROTOBUF_NODISCARD std::string* release_latest_ui_version();
2587   void set_allocated_latest_ui_version(std::string* latest_ui_version);
2588   private:
2589   const std::string& _internal_latest_ui_version() const;
2590   inline PROTOBUF_ALWAYS_INLINE void _internal_set_latest_ui_version(const std::string& value);
2591   std::string* _internal_mutable_latest_ui_version();
2592   public:
2593 
2594   // optional string google_wifi_station_shmac = 9;
2595   bool has_google_wifi_station_shmac() const;
2596   private:
2597   bool _internal_has_google_wifi_station_shmac() const;
2598   public:
2599   void clear_google_wifi_station_shmac();
2600   const std::string& google_wifi_station_shmac() const;
2601   template <typename ArgT0 = const std::string&, typename... ArgT>
2602   void set_google_wifi_station_shmac(ArgT0&& arg0, ArgT... args);
2603   std::string* mutable_google_wifi_station_shmac();
2604   PROTOBUF_NODISCARD std::string* release_google_wifi_station_shmac();
2605   void set_allocated_google_wifi_station_shmac(std::string* google_wifi_station_shmac);
2606   private:
2607   const std::string& _internal_google_wifi_station_shmac() const;
2608   inline PROTOBUF_ALWAYS_INLINE void _internal_set_google_wifi_station_shmac(const std::string& value);
2609   std::string* _internal_mutable_google_wifi_station_shmac();
2610   public:
2611 
2612   // optional string installed_manifest_platform_version = 10;
2613   bool has_installed_manifest_platform_version() const;
2614   private:
2615   bool _internal_has_installed_manifest_platform_version() const;
2616   public:
2617   void clear_installed_manifest_platform_version();
2618   const std::string& installed_manifest_platform_version() const;
2619   template <typename ArgT0 = const std::string&, typename... ArgT>
2620   void set_installed_manifest_platform_version(ArgT0&& arg0, ArgT... args);
2621   std::string* mutable_installed_manifest_platform_version();
2622   PROTOBUF_NODISCARD std::string* release_installed_manifest_platform_version();
2623   void set_allocated_installed_manifest_platform_version(std::string* installed_manifest_platform_version);
2624   private:
2625   const std::string& _internal_installed_manifest_platform_version() const;
2626   inline PROTOBUF_ALWAYS_INLINE void _internal_set_installed_manifest_platform_version(const std::string& value);
2627   std::string* _internal_mutable_installed_manifest_platform_version();
2628   public:
2629 
2630   // optional string system_bundle_version = 12;
2631   bool has_system_bundle_version() const;
2632   private:
2633   bool _internal_has_system_bundle_version() const;
2634   public:
2635   void clear_system_bundle_version();
2636   const std::string& system_bundle_version() const;
2637   template <typename ArgT0 = const std::string&, typename... ArgT>
2638   void set_system_bundle_version(ArgT0&& arg0, ArgT... args);
2639   std::string* mutable_system_bundle_version();
2640   PROTOBUF_NODISCARD std::string* release_system_bundle_version();
2641   void set_allocated_system_bundle_version(std::string* system_bundle_version);
2642   private:
2643   const std::string& _internal_system_bundle_version() const;
2644   inline PROTOBUF_ALWAYS_INLINE void _internal_set_system_bundle_version(const std::string& value);
2645   std::string* _internal_mutable_system_bundle_version();
2646   public:
2647 
2648   // optional fixed64 system_build_number = 2;
2649   bool has_system_build_number() const;
2650   private:
2651   bool _internal_has_system_build_number() const;
2652   public:
2653   void clear_system_build_number();
2654   uint64_t system_build_number() const;
2655   void set_system_build_number(uint64_t value);
2656   private:
2657   uint64_t _internal_system_build_number() const;
2658   void _internal_set_system_build_number(uint64_t value);
2659   public:
2660 
2661   // optional .metrics.CastLogsProto.CastDeviceMutableInfo.RebootType last_reboot_type = 1;
2662   bool has_last_reboot_type() const;
2663   private:
2664   bool _internal_has_last_reboot_type() const;
2665   public:
2666   void clear_last_reboot_type();
2667   ::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType last_reboot_type() const;
2668   void set_last_reboot_type(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType value);
2669   private:
2670   ::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType _internal_last_reboot_type() const;
2671   void _internal_set_last_reboot_type(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType value);
2672   public:
2673 
2674   // optional fixed32 release_version = 4;
2675   bool has_release_version() const;
2676   private:
2677   bool _internal_has_release_version() const;
2678   public:
2679   void clear_release_version();
2680   uint32_t release_version() const;
2681   void set_release_version(uint32_t value);
2682   private:
2683   uint32_t _internal_release_version() const;
2684   void _internal_set_release_version(uint32_t value);
2685   public:
2686 
2687   // optional .metrics.CastLogsProto.CastDeviceMutableInfo.NetifIPVersion netif_ip_version = 5;
2688   bool has_netif_ip_version() const;
2689   private:
2690   bool _internal_has_netif_ip_version() const;
2691   public:
2692   void clear_netif_ip_version();
2693   ::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion netif_ip_version() const;
2694   void set_netif_ip_version(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value);
2695   private:
2696   ::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion _internal_netif_ip_version() const;
2697   void _internal_set_netif_ip_version(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value);
2698   public:
2699 
2700   // optional bool ip_dual_stack_supported = 6;
2701   bool has_ip_dual_stack_supported() const;
2702   private:
2703   bool _internal_has_ip_dual_stack_supported() const;
2704   public:
2705   void clear_ip_dual_stack_supported();
2706   bool ip_dual_stack_supported() const;
2707   void set_ip_dual_stack_supported(bool value);
2708   private:
2709   bool _internal_ip_dual_stack_supported() const;
2710   void _internal_set_ip_dual_stack_supported(bool value);
2711   public:
2712 
2713   // optional uint32 installed_manifest_version = 11;
2714   bool has_installed_manifest_version() const;
2715   private:
2716   bool _internal_has_installed_manifest_version() const;
2717   public:
2718   void clear_installed_manifest_version();
2719   uint32_t installed_manifest_version() const;
2720   void set_installed_manifest_version(uint32_t value);
2721   private:
2722   uint32_t _internal_installed_manifest_version() const;
2723   void _internal_set_installed_manifest_version(uint32_t value);
2724   public:
2725 
2726   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto.CastDeviceMutableInfo)
2727  private:
2728   class _Internal;
2729 
2730   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2731   typedef void InternalArenaConstructable_;
2732   typedef void DestructorSkippable_;
2733   struct Impl_ {
2734     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2735     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2736     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backdrop_app_device_id_;
2737     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr timezone_id_;
2738     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr latest_ui_version_;
2739     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr google_wifi_station_shmac_;
2740     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr installed_manifest_platform_version_;
2741     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_bundle_version_;
2742     uint64_t system_build_number_;
2743     int last_reboot_type_;
2744     uint32_t release_version_;
2745     int netif_ip_version_;
2746     bool ip_dual_stack_supported_;
2747     uint32_t installed_manifest_version_;
2748   };
2749   union { Impl_ _impl_; };
2750   friend struct ::TableStruct_cast_5flogs_2eproto;
2751 };
2752 // -------------------------------------------------------------------
2753 
2754 class CastLogsProto final :
2755     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.CastLogsProto) */ {
2756  public:
CastLogsProto()2757   inline CastLogsProto() : CastLogsProto(nullptr) {}
2758   ~CastLogsProto() override;
2759   explicit PROTOBUF_CONSTEXPR CastLogsProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2760 
2761   CastLogsProto(const CastLogsProto& from);
CastLogsProto(CastLogsProto && from)2762   CastLogsProto(CastLogsProto&& from) noexcept
2763     : CastLogsProto() {
2764     *this = ::std::move(from);
2765   }
2766 
2767   inline CastLogsProto& operator=(const CastLogsProto& from) {
2768     CopyFrom(from);
2769     return *this;
2770   }
2771   inline CastLogsProto& operator=(CastLogsProto&& from) noexcept {
2772     if (this == &from) return *this;
2773     if (GetOwningArena() == from.GetOwningArena()
2774   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2775         && GetOwningArena() != nullptr
2776   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2777     ) {
2778       InternalSwap(&from);
2779     } else {
2780       CopyFrom(from);
2781     }
2782     return *this;
2783   }
2784 
unknown_fields()2785   inline const std::string& unknown_fields() const {
2786     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2787   }
mutable_unknown_fields()2788   inline std::string* mutable_unknown_fields() {
2789     return _internal_metadata_.mutable_unknown_fields<std::string>();
2790   }
2791 
default_instance()2792   static const CastLogsProto& default_instance() {
2793     return *internal_default_instance();
2794   }
internal_default_instance()2795   static inline const CastLogsProto* internal_default_instance() {
2796     return reinterpret_cast<const CastLogsProto*>(
2797                &_CastLogsProto_default_instance_);
2798   }
2799   static constexpr int kIndexInFileMessages =
2800     7;
2801 
swap(CastLogsProto & a,CastLogsProto & b)2802   friend void swap(CastLogsProto& a, CastLogsProto& b) {
2803     a.Swap(&b);
2804   }
Swap(CastLogsProto * other)2805   PROTOBUF_NOINLINE void Swap(CastLogsProto* other) {
2806     if (other == this) return;
2807   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2808     if (GetOwningArena() != nullptr &&
2809         GetOwningArena() == other->GetOwningArena()) {
2810    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2811     if (GetOwningArena() == other->GetOwningArena()) {
2812   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2813       InternalSwap(other);
2814     } else {
2815       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2816     }
2817   }
2818   void UnsafeArenaSwap(CastLogsProto* other) {
2819     if (other == this) return;
2820     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2821     InternalSwap(other);
2822   }
2823 
2824   // implements Message ----------------------------------------------
2825 
2826   CastLogsProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2827     return CreateMaybeMessage<CastLogsProto>(arena);
2828   }
2829   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2830   void CopyFrom(const CastLogsProto& from);
2831   void MergeFrom(const CastLogsProto& from);
2832   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2833   bool IsInitialized() const final;
2834 
2835   size_t ByteSizeLong() const final;
2836   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2837   uint8_t* _InternalSerialize(
2838       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2839   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2840 
2841   private:
2842   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2843   void SharedDtor();
2844   void SetCachedSize(int size) const;
2845   void InternalSwap(CastLogsProto* other);
2846 
2847   private:
2848   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2849   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2850     return "metrics.CastLogsProto";
2851   }
2852   protected:
2853   explicit CastLogsProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2854                        bool is_message_owned = false);
2855   public:
2856 
2857   std::string GetTypeName() const final;
2858 
2859   // nested types ----------------------------------------------------
2860 
2861   typedef CastLogsProto_CastDeviceInfo CastDeviceInfo;
2862   typedef CastLogsProto_CastConnectionInfo CastConnectionInfo;
2863   typedef CastLogsProto_CastEventProto CastEventProto;
2864   typedef CastLogsProto_CastDeviceMutableInfo CastDeviceMutableInfo;
2865 
2866   // accessors -------------------------------------------------------
2867 
2868   enum : int {
2869     kCastConnectionInfoFieldNumber = 2,
2870     kCastEventFieldNumber = 3,
2871     kCastDeviceInfoFieldNumber = 1,
2872     kCastDeviceMutableInfoFieldNumber = 5,
2873     kReceiverMetricsIdFieldNumber = 6,
2874     kVirtualReleaseTrackFieldNumber = 4,
2875     kSourceVirtualReleaseTrackFieldNumber = 8,
2876     kEphemeralIdFieldNumber = 7,
2877   };
2878   // repeated .metrics.CastLogsProto.CastConnectionInfo cast_connection_info = 2;
2879   int cast_connection_info_size() const;
2880   private:
2881   int _internal_cast_connection_info_size() const;
2882   public:
2883   void clear_cast_connection_info();
2884   ::metrics::CastLogsProto_CastConnectionInfo* mutable_cast_connection_info(int index);
2885   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastConnectionInfo >*
2886       mutable_cast_connection_info();
2887   private:
2888   const ::metrics::CastLogsProto_CastConnectionInfo& _internal_cast_connection_info(int index) const;
2889   ::metrics::CastLogsProto_CastConnectionInfo* _internal_add_cast_connection_info();
2890   public:
2891   const ::metrics::CastLogsProto_CastConnectionInfo& cast_connection_info(int index) const;
2892   ::metrics::CastLogsProto_CastConnectionInfo* add_cast_connection_info();
2893   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastConnectionInfo >&
2894       cast_connection_info() const;
2895 
2896   // repeated .metrics.CastLogsProto.CastEventProto cast_event = 3;
2897   int cast_event_size() const;
2898   private:
2899   int _internal_cast_event_size() const;
2900   public:
2901   void clear_cast_event();
2902   ::metrics::CastLogsProto_CastEventProto* mutable_cast_event(int index);
2903   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto >*
2904       mutable_cast_event();
2905   private:
2906   const ::metrics::CastLogsProto_CastEventProto& _internal_cast_event(int index) const;
2907   ::metrics::CastLogsProto_CastEventProto* _internal_add_cast_event();
2908   public:
2909   const ::metrics::CastLogsProto_CastEventProto& cast_event(int index) const;
2910   ::metrics::CastLogsProto_CastEventProto* add_cast_event();
2911   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto >&
2912       cast_event() const;
2913 
2914   // optional .metrics.CastLogsProto.CastDeviceInfo cast_device_info = 1;
2915   bool has_cast_device_info() const;
2916   private:
2917   bool _internal_has_cast_device_info() const;
2918   public:
2919   void clear_cast_device_info();
2920   const ::metrics::CastLogsProto_CastDeviceInfo& cast_device_info() const;
2921   PROTOBUF_NODISCARD ::metrics::CastLogsProto_CastDeviceInfo* release_cast_device_info();
2922   ::metrics::CastLogsProto_CastDeviceInfo* mutable_cast_device_info();
2923   void set_allocated_cast_device_info(::metrics::CastLogsProto_CastDeviceInfo* cast_device_info);
2924   private:
2925   const ::metrics::CastLogsProto_CastDeviceInfo& _internal_cast_device_info() const;
2926   ::metrics::CastLogsProto_CastDeviceInfo* _internal_mutable_cast_device_info();
2927   public:
2928   void unsafe_arena_set_allocated_cast_device_info(
2929       ::metrics::CastLogsProto_CastDeviceInfo* cast_device_info);
2930   ::metrics::CastLogsProto_CastDeviceInfo* unsafe_arena_release_cast_device_info();
2931 
2932   // optional .metrics.CastLogsProto.CastDeviceMutableInfo cast_device_mutable_info = 5;
2933   bool has_cast_device_mutable_info() const;
2934   private:
2935   bool _internal_has_cast_device_mutable_info() const;
2936   public:
2937   void clear_cast_device_mutable_info();
2938   const ::metrics::CastLogsProto_CastDeviceMutableInfo& cast_device_mutable_info() const;
2939   PROTOBUF_NODISCARD ::metrics::CastLogsProto_CastDeviceMutableInfo* release_cast_device_mutable_info();
2940   ::metrics::CastLogsProto_CastDeviceMutableInfo* mutable_cast_device_mutable_info();
2941   void set_allocated_cast_device_mutable_info(::metrics::CastLogsProto_CastDeviceMutableInfo* cast_device_mutable_info);
2942   private:
2943   const ::metrics::CastLogsProto_CastDeviceMutableInfo& _internal_cast_device_mutable_info() const;
2944   ::metrics::CastLogsProto_CastDeviceMutableInfo* _internal_mutable_cast_device_mutable_info();
2945   public:
2946   void unsafe_arena_set_allocated_cast_device_mutable_info(
2947       ::metrics::CastLogsProto_CastDeviceMutableInfo* cast_device_mutable_info);
2948   ::metrics::CastLogsProto_CastDeviceMutableInfo* unsafe_arena_release_cast_device_mutable_info();
2949 
2950   // optional fixed64 receiver_metrics_id = 6;
2951   bool has_receiver_metrics_id() const;
2952   private:
2953   bool _internal_has_receiver_metrics_id() const;
2954   public:
2955   void clear_receiver_metrics_id();
2956   uint64_t receiver_metrics_id() const;
2957   void set_receiver_metrics_id(uint64_t value);
2958   private:
2959   uint64_t _internal_receiver_metrics_id() const;
2960   void _internal_set_receiver_metrics_id(uint64_t value);
2961   public:
2962 
2963   // optional fixed32 virtual_release_track = 4;
2964   bool has_virtual_release_track() const;
2965   private:
2966   bool _internal_has_virtual_release_track() const;
2967   public:
2968   void clear_virtual_release_track();
2969   uint32_t virtual_release_track() const;
2970   void set_virtual_release_track(uint32_t value);
2971   private:
2972   uint32_t _internal_virtual_release_track() const;
2973   void _internal_set_virtual_release_track(uint32_t value);
2974   public:
2975 
2976   // optional fixed32 source_virtual_release_track = 8;
2977   bool has_source_virtual_release_track() const;
2978   private:
2979   bool _internal_has_source_virtual_release_track() const;
2980   public:
2981   void clear_source_virtual_release_track();
2982   uint32_t source_virtual_release_track() const;
2983   void set_source_virtual_release_track(uint32_t value);
2984   private:
2985   uint32_t _internal_source_virtual_release_track() const;
2986   void _internal_set_source_virtual_release_track(uint32_t value);
2987   public:
2988 
2989   // optional uint64 ephemeral_id = 7;
2990   bool has_ephemeral_id() const;
2991   private:
2992   bool _internal_has_ephemeral_id() const;
2993   public:
2994   void clear_ephemeral_id();
2995   uint64_t ephemeral_id() const;
2996   void set_ephemeral_id(uint64_t value);
2997   private:
2998   uint64_t _internal_ephemeral_id() const;
2999   void _internal_set_ephemeral_id(uint64_t value);
3000   public:
3001 
3002   // @@protoc_insertion_point(class_scope:metrics.CastLogsProto)
3003  private:
3004   class _Internal;
3005 
3006   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3007   typedef void InternalArenaConstructable_;
3008   typedef void DestructorSkippable_;
3009   struct Impl_ {
3010     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3011     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3012     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastConnectionInfo > cast_connection_info_;
3013     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto > cast_event_;
3014     ::metrics::CastLogsProto_CastDeviceInfo* cast_device_info_;
3015     ::metrics::CastLogsProto_CastDeviceMutableInfo* cast_device_mutable_info_;
3016     uint64_t receiver_metrics_id_;
3017     uint32_t virtual_release_track_;
3018     uint32_t source_virtual_release_track_;
3019     uint64_t ephemeral_id_;
3020   };
3021   union { Impl_ _impl_; };
3022   friend struct ::TableStruct_cast_5flogs_2eproto;
3023 };
3024 // ===================================================================
3025 
3026 
3027 // ===================================================================
3028 
3029 #ifdef __GNUC__
3030   #pragma GCC diagnostic push
3031   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3032 #endif  // __GNUC__
3033 // CastLogsProto_CastDeviceInfo_HardwareInfo
3034 
3035 // optional string color = 1;
_internal_has_color()3036 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_color() const {
3037   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3038   return value;
3039 }
has_color()3040 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_color() const {
3041   return _internal_has_color();
3042 }
clear_color()3043 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_color() {
3044   _impl_.color_.ClearToEmpty();
3045   _impl_._has_bits_[0] &= ~0x00000001u;
3046 }
color()3047 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::color() const {
3048   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.color)
3049   return _internal_color();
3050 }
3051 template <typename ArgT0, typename... ArgT>
3052 inline PROTOBUF_ALWAYS_INLINE
set_color(ArgT0 && arg0,ArgT...args)3053 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_color(ArgT0&& arg0, ArgT... args) {
3054  _impl_._has_bits_[0] |= 0x00000001u;
3055  _impl_.color_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3056   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.color)
3057 }
mutable_color()3058 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_color() {
3059   std::string* _s = _internal_mutable_color();
3060   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.color)
3061   return _s;
3062 }
_internal_color()3063 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_color() const {
3064   return _impl_.color_.Get();
3065 }
_internal_set_color(const std::string & value)3066 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_color(const std::string& value) {
3067   _impl_._has_bits_[0] |= 0x00000001u;
3068   _impl_.color_.Set(value, GetArenaForAllocation());
3069 }
_internal_mutable_color()3070 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_color() {
3071   _impl_._has_bits_[0] |= 0x00000001u;
3072   return _impl_.color_.Mutable(GetArenaForAllocation());
3073 }
release_color()3074 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_color() {
3075   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.color)
3076   if (!_internal_has_color()) {
3077     return nullptr;
3078   }
3079   _impl_._has_bits_[0] &= ~0x00000001u;
3080   auto* p = _impl_.color_.Release();
3081 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3082   if (_impl_.color_.IsDefault()) {
3083     _impl_.color_.Set("", GetArenaForAllocation());
3084   }
3085 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3086   return p;
3087 }
set_allocated_color(std::string * color)3088 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_color(std::string* color) {
3089   if (color != nullptr) {
3090     _impl_._has_bits_[0] |= 0x00000001u;
3091   } else {
3092     _impl_._has_bits_[0] &= ~0x00000001u;
3093   }
3094   _impl_.color_.SetAllocated(color, GetArenaForAllocation());
3095 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3096   if (_impl_.color_.IsDefault()) {
3097     _impl_.color_.Set("", GetArenaForAllocation());
3098   }
3099 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3100   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.color)
3101 }
3102 
3103 // optional string mic = 2;
_internal_has_mic()3104 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_mic() const {
3105   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3106   return value;
3107 }
has_mic()3108 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_mic() const {
3109   return _internal_has_mic();
3110 }
clear_mic()3111 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_mic() {
3112   _impl_.mic_.ClearToEmpty();
3113   _impl_._has_bits_[0] &= ~0x00000002u;
3114 }
mic()3115 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::mic() const {
3116   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mic)
3117   return _internal_mic();
3118 }
3119 template <typename ArgT0, typename... ArgT>
3120 inline PROTOBUF_ALWAYS_INLINE
set_mic(ArgT0 && arg0,ArgT...args)3121 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_mic(ArgT0&& arg0, ArgT... args) {
3122  _impl_._has_bits_[0] |= 0x00000002u;
3123  _impl_.mic_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3124   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mic)
3125 }
mutable_mic()3126 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_mic() {
3127   std::string* _s = _internal_mutable_mic();
3128   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mic)
3129   return _s;
3130 }
_internal_mic()3131 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mic() const {
3132   return _impl_.mic_.Get();
3133 }
_internal_set_mic(const std::string & value)3134 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_mic(const std::string& value) {
3135   _impl_._has_bits_[0] |= 0x00000002u;
3136   _impl_.mic_.Set(value, GetArenaForAllocation());
3137 }
_internal_mutable_mic()3138 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_mic() {
3139   _impl_._has_bits_[0] |= 0x00000002u;
3140   return _impl_.mic_.Mutable(GetArenaForAllocation());
3141 }
release_mic()3142 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_mic() {
3143   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mic)
3144   if (!_internal_has_mic()) {
3145     return nullptr;
3146   }
3147   _impl_._has_bits_[0] &= ~0x00000002u;
3148   auto* p = _impl_.mic_.Release();
3149 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3150   if (_impl_.mic_.IsDefault()) {
3151     _impl_.mic_.Set("", GetArenaForAllocation());
3152   }
3153 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3154   return p;
3155 }
set_allocated_mic(std::string * mic)3156 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_mic(std::string* mic) {
3157   if (mic != nullptr) {
3158     _impl_._has_bits_[0] |= 0x00000002u;
3159   } else {
3160     _impl_._has_bits_[0] &= ~0x00000002u;
3161   }
3162   _impl_.mic_.SetAllocated(mic, GetArenaForAllocation());
3163 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3164   if (_impl_.mic_.IsDefault()) {
3165     _impl_.mic_.Set("", GetArenaForAllocation());
3166   }
3167 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3168   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mic)
3169 }
3170 
3171 // optional string memory = 3;
_internal_has_memory()3172 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_memory() const {
3173   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3174   return value;
3175 }
has_memory()3176 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_memory() const {
3177   return _internal_has_memory();
3178 }
clear_memory()3179 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_memory() {
3180   _impl_.memory_.ClearToEmpty();
3181   _impl_._has_bits_[0] &= ~0x00000004u;
3182 }
memory()3183 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::memory() const {
3184   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.memory)
3185   return _internal_memory();
3186 }
3187 template <typename ArgT0, typename... ArgT>
3188 inline PROTOBUF_ALWAYS_INLINE
set_memory(ArgT0 && arg0,ArgT...args)3189 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_memory(ArgT0&& arg0, ArgT... args) {
3190  _impl_._has_bits_[0] |= 0x00000004u;
3191  _impl_.memory_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3192   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.memory)
3193 }
mutable_memory()3194 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_memory() {
3195   std::string* _s = _internal_mutable_memory();
3196   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.memory)
3197   return _s;
3198 }
_internal_memory()3199 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_memory() const {
3200   return _impl_.memory_.Get();
3201 }
_internal_set_memory(const std::string & value)3202 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_memory(const std::string& value) {
3203   _impl_._has_bits_[0] |= 0x00000004u;
3204   _impl_.memory_.Set(value, GetArenaForAllocation());
3205 }
_internal_mutable_memory()3206 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_memory() {
3207   _impl_._has_bits_[0] |= 0x00000004u;
3208   return _impl_.memory_.Mutable(GetArenaForAllocation());
3209 }
release_memory()3210 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_memory() {
3211   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.memory)
3212   if (!_internal_has_memory()) {
3213     return nullptr;
3214   }
3215   _impl_._has_bits_[0] &= ~0x00000004u;
3216   auto* p = _impl_.memory_.Release();
3217 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3218   if (_impl_.memory_.IsDefault()) {
3219     _impl_.memory_.Set("", GetArenaForAllocation());
3220   }
3221 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3222   return p;
3223 }
set_allocated_memory(std::string * memory)3224 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_memory(std::string* memory) {
3225   if (memory != nullptr) {
3226     _impl_._has_bits_[0] |= 0x00000004u;
3227   } else {
3228     _impl_._has_bits_[0] &= ~0x00000004u;
3229   }
3230   _impl_.memory_.SetAllocated(memory, GetArenaForAllocation());
3231 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3232   if (_impl_.memory_.IsDefault()) {
3233     _impl_.memory_.Set("", GetArenaForAllocation());
3234   }
3235 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3236   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.memory)
3237 }
3238 
3239 // optional string nand = 4;
_internal_has_nand()3240 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_nand() const {
3241   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3242   return value;
3243 }
has_nand()3244 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_nand() const {
3245   return _internal_has_nand();
3246 }
clear_nand()3247 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_nand() {
3248   _impl_.nand_.ClearToEmpty();
3249   _impl_._has_bits_[0] &= ~0x00000008u;
3250 }
nand()3251 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::nand() const {
3252   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.nand)
3253   return _internal_nand();
3254 }
3255 template <typename ArgT0, typename... ArgT>
3256 inline PROTOBUF_ALWAYS_INLINE
set_nand(ArgT0 && arg0,ArgT...args)3257 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_nand(ArgT0&& arg0, ArgT... args) {
3258  _impl_._has_bits_[0] |= 0x00000008u;
3259  _impl_.nand_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3260   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.nand)
3261 }
mutable_nand()3262 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_nand() {
3263   std::string* _s = _internal_mutable_nand();
3264   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.nand)
3265   return _s;
3266 }
_internal_nand()3267 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_nand() const {
3268   return _impl_.nand_.Get();
3269 }
_internal_set_nand(const std::string & value)3270 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_nand(const std::string& value) {
3271   _impl_._has_bits_[0] |= 0x00000008u;
3272   _impl_.nand_.Set(value, GetArenaForAllocation());
3273 }
_internal_mutable_nand()3274 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_nand() {
3275   _impl_._has_bits_[0] |= 0x00000008u;
3276   return _impl_.nand_.Mutable(GetArenaForAllocation());
3277 }
release_nand()3278 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_nand() {
3279   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.nand)
3280   if (!_internal_has_nand()) {
3281     return nullptr;
3282   }
3283   _impl_._has_bits_[0] &= ~0x00000008u;
3284   auto* p = _impl_.nand_.Release();
3285 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3286   if (_impl_.nand_.IsDefault()) {
3287     _impl_.nand_.Set("", GetArenaForAllocation());
3288   }
3289 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3290   return p;
3291 }
set_allocated_nand(std::string * nand)3292 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_nand(std::string* nand) {
3293   if (nand != nullptr) {
3294     _impl_._has_bits_[0] |= 0x00000008u;
3295   } else {
3296     _impl_._has_bits_[0] &= ~0x00000008u;
3297   }
3298   _impl_.nand_.SetAllocated(nand, GetArenaForAllocation());
3299 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3300   if (_impl_.nand_.IsDefault()) {
3301     _impl_.nand_.Set("", GetArenaForAllocation());
3302   }
3303 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3304   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.nand)
3305 }
3306 
3307 // optional string mfg_date = 5;
_internal_has_mfg_date()3308 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_mfg_date() const {
3309   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
3310   return value;
3311 }
has_mfg_date()3312 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_mfg_date() const {
3313   return _internal_has_mfg_date();
3314 }
clear_mfg_date()3315 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_mfg_date() {
3316   _impl_.mfg_date_.ClearToEmpty();
3317   _impl_._has_bits_[0] &= ~0x00000010u;
3318 }
mfg_date()3319 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::mfg_date() const {
3320   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mfg_date)
3321   return _internal_mfg_date();
3322 }
3323 template <typename ArgT0, typename... ArgT>
3324 inline PROTOBUF_ALWAYS_INLINE
set_mfg_date(ArgT0 && arg0,ArgT...args)3325 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_mfg_date(ArgT0&& arg0, ArgT... args) {
3326  _impl_._has_bits_[0] |= 0x00000010u;
3327  _impl_.mfg_date_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3328   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mfg_date)
3329 }
mutable_mfg_date()3330 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_mfg_date() {
3331   std::string* _s = _internal_mutable_mfg_date();
3332   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mfg_date)
3333   return _s;
3334 }
_internal_mfg_date()3335 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mfg_date() const {
3336   return _impl_.mfg_date_.Get();
3337 }
_internal_set_mfg_date(const std::string & value)3338 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_mfg_date(const std::string& value) {
3339   _impl_._has_bits_[0] |= 0x00000010u;
3340   _impl_.mfg_date_.Set(value, GetArenaForAllocation());
3341 }
_internal_mutable_mfg_date()3342 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_mfg_date() {
3343   _impl_._has_bits_[0] |= 0x00000010u;
3344   return _impl_.mfg_date_.Mutable(GetArenaForAllocation());
3345 }
release_mfg_date()3346 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_mfg_date() {
3347   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mfg_date)
3348   if (!_internal_has_mfg_date()) {
3349     return nullptr;
3350   }
3351   _impl_._has_bits_[0] &= ~0x00000010u;
3352   auto* p = _impl_.mfg_date_.Release();
3353 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3354   if (_impl_.mfg_date_.IsDefault()) {
3355     _impl_.mfg_date_.Set("", GetArenaForAllocation());
3356   }
3357 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3358   return p;
3359 }
set_allocated_mfg_date(std::string * mfg_date)3360 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_mfg_date(std::string* mfg_date) {
3361   if (mfg_date != nullptr) {
3362     _impl_._has_bits_[0] |= 0x00000010u;
3363   } else {
3364     _impl_._has_bits_[0] &= ~0x00000010u;
3365   }
3366   _impl_.mfg_date_.SetAllocated(mfg_date, GetArenaForAllocation());
3367 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3368   if (_impl_.mfg_date_.IsDefault()) {
3369     _impl_.mfg_date_.Set("", GetArenaForAllocation());
3370   }
3371 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3372   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.mfg_date)
3373 }
3374 
3375 // optional string build_name = 6;
_internal_has_build_name()3376 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_build_name() const {
3377   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
3378   return value;
3379 }
has_build_name()3380 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_build_name() const {
3381   return _internal_has_build_name();
3382 }
clear_build_name()3383 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_build_name() {
3384   _impl_.build_name_.ClearToEmpty();
3385   _impl_._has_bits_[0] &= ~0x00000020u;
3386 }
build_name()3387 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::build_name() const {
3388   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.build_name)
3389   return _internal_build_name();
3390 }
3391 template <typename ArgT0, typename... ArgT>
3392 inline PROTOBUF_ALWAYS_INLINE
set_build_name(ArgT0 && arg0,ArgT...args)3393 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_build_name(ArgT0&& arg0, ArgT... args) {
3394  _impl_._has_bits_[0] |= 0x00000020u;
3395  _impl_.build_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3396   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.build_name)
3397 }
mutable_build_name()3398 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_build_name() {
3399   std::string* _s = _internal_mutable_build_name();
3400   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.build_name)
3401   return _s;
3402 }
_internal_build_name()3403 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_build_name() const {
3404   return _impl_.build_name_.Get();
3405 }
_internal_set_build_name(const std::string & value)3406 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_build_name(const std::string& value) {
3407   _impl_._has_bits_[0] |= 0x00000020u;
3408   _impl_.build_name_.Set(value, GetArenaForAllocation());
3409 }
_internal_mutable_build_name()3410 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_build_name() {
3411   _impl_._has_bits_[0] |= 0x00000020u;
3412   return _impl_.build_name_.Mutable(GetArenaForAllocation());
3413 }
release_build_name()3414 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_build_name() {
3415   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.build_name)
3416   if (!_internal_has_build_name()) {
3417     return nullptr;
3418   }
3419   _impl_._has_bits_[0] &= ~0x00000020u;
3420   auto* p = _impl_.build_name_.Release();
3421 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3422   if (_impl_.build_name_.IsDefault()) {
3423     _impl_.build_name_.Set("", GetArenaForAllocation());
3424   }
3425 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3426   return p;
3427 }
set_allocated_build_name(std::string * build_name)3428 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_build_name(std::string* build_name) {
3429   if (build_name != nullptr) {
3430     _impl_._has_bits_[0] |= 0x00000020u;
3431   } else {
3432     _impl_._has_bits_[0] &= ~0x00000020u;
3433   }
3434   _impl_.build_name_.SetAllocated(build_name, GetArenaForAllocation());
3435 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3436   if (_impl_.build_name_.IsDefault()) {
3437     _impl_.build_name_.Set("", GetArenaForAllocation());
3438   }
3439 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3440   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.build_name)
3441 }
3442 
3443 // optional string config = 7;
_internal_has_config()3444 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_config() const {
3445   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
3446   return value;
3447 }
has_config()3448 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_config() const {
3449   return _internal_has_config();
3450 }
clear_config()3451 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_config() {
3452   _impl_.config_.ClearToEmpty();
3453   _impl_._has_bits_[0] &= ~0x00000040u;
3454 }
config()3455 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::config() const {
3456   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.config)
3457   return _internal_config();
3458 }
3459 template <typename ArgT0, typename... ArgT>
3460 inline PROTOBUF_ALWAYS_INLINE
set_config(ArgT0 && arg0,ArgT...args)3461 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_config(ArgT0&& arg0, ArgT... args) {
3462  _impl_._has_bits_[0] |= 0x00000040u;
3463  _impl_.config_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3464   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.config)
3465 }
mutable_config()3466 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_config() {
3467   std::string* _s = _internal_mutable_config();
3468   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.config)
3469   return _s;
3470 }
_internal_config()3471 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_config() const {
3472   return _impl_.config_.Get();
3473 }
_internal_set_config(const std::string & value)3474 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_config(const std::string& value) {
3475   _impl_._has_bits_[0] |= 0x00000040u;
3476   _impl_.config_.Set(value, GetArenaForAllocation());
3477 }
_internal_mutable_config()3478 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_config() {
3479   _impl_._has_bits_[0] |= 0x00000040u;
3480   return _impl_.config_.Mutable(GetArenaForAllocation());
3481 }
release_config()3482 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_config() {
3483   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.config)
3484   if (!_internal_has_config()) {
3485     return nullptr;
3486   }
3487   _impl_._has_bits_[0] &= ~0x00000040u;
3488   auto* p = _impl_.config_.Release();
3489 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3490   if (_impl_.config_.IsDefault()) {
3491     _impl_.config_.Set("", GetArenaForAllocation());
3492   }
3493 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3494   return p;
3495 }
set_allocated_config(std::string * config)3496 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_config(std::string* config) {
3497   if (config != nullptr) {
3498     _impl_._has_bits_[0] |= 0x00000040u;
3499   } else {
3500     _impl_._has_bits_[0] &= ~0x00000040u;
3501   }
3502   _impl_.config_.SetAllocated(config, GetArenaForAllocation());
3503 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3504   if (_impl_.config_.IsDefault()) {
3505     _impl_.config_.Set("", GetArenaForAllocation());
3506   }
3507 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3508   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.config)
3509 }
3510 
3511 // optional string emmc = 8;
_internal_has_emmc()3512 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_emmc() const {
3513   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
3514   return value;
3515 }
has_emmc()3516 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_emmc() const {
3517   return _internal_has_emmc();
3518 }
clear_emmc()3519 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_emmc() {
3520   _impl_.emmc_.ClearToEmpty();
3521   _impl_._has_bits_[0] &= ~0x00000080u;
3522 }
emmc()3523 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::emmc() const {
3524   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.emmc)
3525   return _internal_emmc();
3526 }
3527 template <typename ArgT0, typename... ArgT>
3528 inline PROTOBUF_ALWAYS_INLINE
set_emmc(ArgT0 && arg0,ArgT...args)3529 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_emmc(ArgT0&& arg0, ArgT... args) {
3530  _impl_._has_bits_[0] |= 0x00000080u;
3531  _impl_.emmc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3532   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.emmc)
3533 }
mutable_emmc()3534 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_emmc() {
3535   std::string* _s = _internal_mutable_emmc();
3536   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.emmc)
3537   return _s;
3538 }
_internal_emmc()3539 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_emmc() const {
3540   return _impl_.emmc_.Get();
3541 }
_internal_set_emmc(const std::string & value)3542 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_emmc(const std::string& value) {
3543   _impl_._has_bits_[0] |= 0x00000080u;
3544   _impl_.emmc_.Set(value, GetArenaForAllocation());
3545 }
_internal_mutable_emmc()3546 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_emmc() {
3547   _impl_._has_bits_[0] |= 0x00000080u;
3548   return _impl_.emmc_.Mutable(GetArenaForAllocation());
3549 }
release_emmc()3550 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_emmc() {
3551   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.emmc)
3552   if (!_internal_has_emmc()) {
3553     return nullptr;
3554   }
3555   _impl_._has_bits_[0] &= ~0x00000080u;
3556   auto* p = _impl_.emmc_.Release();
3557 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3558   if (_impl_.emmc_.IsDefault()) {
3559     _impl_.emmc_.Set("", GetArenaForAllocation());
3560   }
3561 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3562   return p;
3563 }
set_allocated_emmc(std::string * emmc)3564 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_emmc(std::string* emmc) {
3565   if (emmc != nullptr) {
3566     _impl_._has_bits_[0] |= 0x00000080u;
3567   } else {
3568     _impl_._has_bits_[0] &= ~0x00000080u;
3569   }
3570   _impl_.emmc_.SetAllocated(emmc, GetArenaForAllocation());
3571 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3572   if (_impl_.emmc_.IsDefault()) {
3573     _impl_.emmc_.Set("", GetArenaForAllocation());
3574   }
3575 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3576   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.emmc)
3577 }
3578 
3579 // optional string display = 9;
_internal_has_display()3580 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_display() const {
3581   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
3582   return value;
3583 }
has_display()3584 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_display() const {
3585   return _internal_has_display();
3586 }
clear_display()3587 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_display() {
3588   _impl_.display_.ClearToEmpty();
3589   _impl_._has_bits_[0] &= ~0x00000100u;
3590 }
display()3591 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::display() const {
3592   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.display)
3593   return _internal_display();
3594 }
3595 template <typename ArgT0, typename... ArgT>
3596 inline PROTOBUF_ALWAYS_INLINE
set_display(ArgT0 && arg0,ArgT...args)3597 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_display(ArgT0&& arg0, ArgT... args) {
3598  _impl_._has_bits_[0] |= 0x00000100u;
3599  _impl_.display_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3600   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.display)
3601 }
mutable_display()3602 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_display() {
3603   std::string* _s = _internal_mutable_display();
3604   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.display)
3605   return _s;
3606 }
_internal_display()3607 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_display() const {
3608   return _impl_.display_.Get();
3609 }
_internal_set_display(const std::string & value)3610 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_display(const std::string& value) {
3611   _impl_._has_bits_[0] |= 0x00000100u;
3612   _impl_.display_.Set(value, GetArenaForAllocation());
3613 }
_internal_mutable_display()3614 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_display() {
3615   _impl_._has_bits_[0] |= 0x00000100u;
3616   return _impl_.display_.Mutable(GetArenaForAllocation());
3617 }
release_display()3618 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_display() {
3619   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.display)
3620   if (!_internal_has_display()) {
3621     return nullptr;
3622   }
3623   _impl_._has_bits_[0] &= ~0x00000100u;
3624   auto* p = _impl_.display_.Release();
3625 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3626   if (_impl_.display_.IsDefault()) {
3627     _impl_.display_.Set("", GetArenaForAllocation());
3628   }
3629 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3630   return p;
3631 }
set_allocated_display(std::string * display)3632 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_display(std::string* display) {
3633   if (display != nullptr) {
3634     _impl_._has_bits_[0] |= 0x00000100u;
3635   } else {
3636     _impl_._has_bits_[0] &= ~0x00000100u;
3637   }
3638   _impl_.display_.SetAllocated(display, GetArenaForAllocation());
3639 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3640   if (_impl_.display_.IsDefault()) {
3641     _impl_.display_.Set("", GetArenaForAllocation());
3642   }
3643 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3644   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.display)
3645 }
3646 
3647 // optional string amp = 10;
_internal_has_amp()3648 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_amp() const {
3649   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
3650   return value;
3651 }
has_amp()3652 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_amp() const {
3653   return _internal_has_amp();
3654 }
clear_amp()3655 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_amp() {
3656   _impl_.amp_.ClearToEmpty();
3657   _impl_._has_bits_[0] &= ~0x00000200u;
3658 }
amp()3659 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::amp() const {
3660   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.amp)
3661   return _internal_amp();
3662 }
3663 template <typename ArgT0, typename... ArgT>
3664 inline PROTOBUF_ALWAYS_INLINE
set_amp(ArgT0 && arg0,ArgT...args)3665 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_amp(ArgT0&& arg0, ArgT... args) {
3666  _impl_._has_bits_[0] |= 0x00000200u;
3667  _impl_.amp_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3668   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.amp)
3669 }
mutable_amp()3670 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_amp() {
3671   std::string* _s = _internal_mutable_amp();
3672   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.amp)
3673   return _s;
3674 }
_internal_amp()3675 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_amp() const {
3676   return _impl_.amp_.Get();
3677 }
_internal_set_amp(const std::string & value)3678 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_amp(const std::string& value) {
3679   _impl_._has_bits_[0] |= 0x00000200u;
3680   _impl_.amp_.Set(value, GetArenaForAllocation());
3681 }
_internal_mutable_amp()3682 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_amp() {
3683   _impl_._has_bits_[0] |= 0x00000200u;
3684   return _impl_.amp_.Mutable(GetArenaForAllocation());
3685 }
release_amp()3686 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_amp() {
3687   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.amp)
3688   if (!_internal_has_amp()) {
3689     return nullptr;
3690   }
3691   _impl_._has_bits_[0] &= ~0x00000200u;
3692   auto* p = _impl_.amp_.Release();
3693 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3694   if (_impl_.amp_.IsDefault()) {
3695     _impl_.amp_.Set("", GetArenaForAllocation());
3696   }
3697 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3698   return p;
3699 }
set_allocated_amp(std::string * amp)3700 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_amp(std::string* amp) {
3701   if (amp != nullptr) {
3702     _impl_._has_bits_[0] |= 0x00000200u;
3703   } else {
3704     _impl_._has_bits_[0] &= ~0x00000200u;
3705   }
3706   _impl_.amp_.SetAllocated(amp, GetArenaForAllocation());
3707 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3708   if (_impl_.amp_.IsDefault()) {
3709     _impl_.amp_.Set("", GetArenaForAllocation());
3710   }
3711 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3712   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.amp)
3713 }
3714 
3715 // optional string board_name = 11;
_internal_has_board_name()3716 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_has_board_name() const {
3717   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
3718   return value;
3719 }
has_board_name()3720 inline bool CastLogsProto_CastDeviceInfo_HardwareInfo::has_board_name() const {
3721   return _internal_has_board_name();
3722 }
clear_board_name()3723 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::clear_board_name() {
3724   _impl_.board_name_.ClearToEmpty();
3725   _impl_._has_bits_[0] &= ~0x00000400u;
3726 }
board_name()3727 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::board_name() const {
3728   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.board_name)
3729   return _internal_board_name();
3730 }
3731 template <typename ArgT0, typename... ArgT>
3732 inline PROTOBUF_ALWAYS_INLINE
set_board_name(ArgT0 && arg0,ArgT...args)3733 void CastLogsProto_CastDeviceInfo_HardwareInfo::set_board_name(ArgT0&& arg0, ArgT... args) {
3734  _impl_._has_bits_[0] |= 0x00000400u;
3735  _impl_.board_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3736   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.board_name)
3737 }
mutable_board_name()3738 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::mutable_board_name() {
3739   std::string* _s = _internal_mutable_board_name();
3740   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.board_name)
3741   return _s;
3742 }
_internal_board_name()3743 inline const std::string& CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_board_name() const {
3744   return _impl_.board_name_.Get();
3745 }
_internal_set_board_name(const std::string & value)3746 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_set_board_name(const std::string& value) {
3747   _impl_._has_bits_[0] |= 0x00000400u;
3748   _impl_.board_name_.Set(value, GetArenaForAllocation());
3749 }
_internal_mutable_board_name()3750 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::_internal_mutable_board_name() {
3751   _impl_._has_bits_[0] |= 0x00000400u;
3752   return _impl_.board_name_.Mutable(GetArenaForAllocation());
3753 }
release_board_name()3754 inline std::string* CastLogsProto_CastDeviceInfo_HardwareInfo::release_board_name() {
3755   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.board_name)
3756   if (!_internal_has_board_name()) {
3757     return nullptr;
3758   }
3759   _impl_._has_bits_[0] &= ~0x00000400u;
3760   auto* p = _impl_.board_name_.Release();
3761 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3762   if (_impl_.board_name_.IsDefault()) {
3763     _impl_.board_name_.Set("", GetArenaForAllocation());
3764   }
3765 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3766   return p;
3767 }
set_allocated_board_name(std::string * board_name)3768 inline void CastLogsProto_CastDeviceInfo_HardwareInfo::set_allocated_board_name(std::string* board_name) {
3769   if (board_name != nullptr) {
3770     _impl_._has_bits_[0] |= 0x00000400u;
3771   } else {
3772     _impl_._has_bits_[0] &= ~0x00000400u;
3773   }
3774   _impl_.board_name_.SetAllocated(board_name, GetArenaForAllocation());
3775 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3776   if (_impl_.board_name_.IsDefault()) {
3777     _impl_.board_name_.Set("", GetArenaForAllocation());
3778   }
3779 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3780   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.HardwareInfo.board_name)
3781 }
3782 
3783 // -------------------------------------------------------------------
3784 
3785 // CastLogsProto_CastDeviceInfo
3786 
3787 // optional .metrics.CastLogsProto.CastDeviceInfo.CastProductType type = 1;
_internal_has_type()3788 inline bool CastLogsProto_CastDeviceInfo::_internal_has_type() const {
3789   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
3790   return value;
3791 }
has_type()3792 inline bool CastLogsProto_CastDeviceInfo::has_type() const {
3793   return _internal_has_type();
3794 }
clear_type()3795 inline void CastLogsProto_CastDeviceInfo::clear_type() {
3796   _impl_.type_ = 0;
3797   _impl_._has_bits_[0] &= ~0x00000020u;
3798 }
_internal_type()3799 inline ::metrics::CastLogsProto_CastDeviceInfo_CastProductType CastLogsProto_CastDeviceInfo::_internal_type() const {
3800   return static_cast< ::metrics::CastLogsProto_CastDeviceInfo_CastProductType >(_impl_.type_);
3801 }
type()3802 inline ::metrics::CastLogsProto_CastDeviceInfo_CastProductType CastLogsProto_CastDeviceInfo::type() const {
3803   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.type)
3804   return _internal_type();
3805 }
_internal_set_type(::metrics::CastLogsProto_CastDeviceInfo_CastProductType value)3806 inline void CastLogsProto_CastDeviceInfo::_internal_set_type(::metrics::CastLogsProto_CastDeviceInfo_CastProductType value) {
3807   assert(::metrics::CastLogsProto_CastDeviceInfo_CastProductType_IsValid(value));
3808   _impl_._has_bits_[0] |= 0x00000020u;
3809   _impl_.type_ = value;
3810 }
set_type(::metrics::CastLogsProto_CastDeviceInfo_CastProductType value)3811 inline void CastLogsProto_CastDeviceInfo::set_type(::metrics::CastLogsProto_CastDeviceInfo_CastProductType value) {
3812   _internal_set_type(value);
3813   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.type)
3814 }
3815 
3816 // optional string hardware_revision = 2;
_internal_has_hardware_revision()3817 inline bool CastLogsProto_CastDeviceInfo::_internal_has_hardware_revision() const {
3818   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3819   return value;
3820 }
has_hardware_revision()3821 inline bool CastLogsProto_CastDeviceInfo::has_hardware_revision() const {
3822   return _internal_has_hardware_revision();
3823 }
clear_hardware_revision()3824 inline void CastLogsProto_CastDeviceInfo::clear_hardware_revision() {
3825   _impl_.hardware_revision_.ClearToEmpty();
3826   _impl_._has_bits_[0] &= ~0x00000001u;
3827 }
hardware_revision()3828 inline const std::string& CastLogsProto_CastDeviceInfo::hardware_revision() const {
3829   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.hardware_revision)
3830   return _internal_hardware_revision();
3831 }
3832 template <typename ArgT0, typename... ArgT>
3833 inline PROTOBUF_ALWAYS_INLINE
set_hardware_revision(ArgT0 && arg0,ArgT...args)3834 void CastLogsProto_CastDeviceInfo::set_hardware_revision(ArgT0&& arg0, ArgT... args) {
3835  _impl_._has_bits_[0] |= 0x00000001u;
3836  _impl_.hardware_revision_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3837   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.hardware_revision)
3838 }
mutable_hardware_revision()3839 inline std::string* CastLogsProto_CastDeviceInfo::mutable_hardware_revision() {
3840   std::string* _s = _internal_mutable_hardware_revision();
3841   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.hardware_revision)
3842   return _s;
3843 }
_internal_hardware_revision()3844 inline const std::string& CastLogsProto_CastDeviceInfo::_internal_hardware_revision() const {
3845   return _impl_.hardware_revision_.Get();
3846 }
_internal_set_hardware_revision(const std::string & value)3847 inline void CastLogsProto_CastDeviceInfo::_internal_set_hardware_revision(const std::string& value) {
3848   _impl_._has_bits_[0] |= 0x00000001u;
3849   _impl_.hardware_revision_.Set(value, GetArenaForAllocation());
3850 }
_internal_mutable_hardware_revision()3851 inline std::string* CastLogsProto_CastDeviceInfo::_internal_mutable_hardware_revision() {
3852   _impl_._has_bits_[0] |= 0x00000001u;
3853   return _impl_.hardware_revision_.Mutable(GetArenaForAllocation());
3854 }
release_hardware_revision()3855 inline std::string* CastLogsProto_CastDeviceInfo::release_hardware_revision() {
3856   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.hardware_revision)
3857   if (!_internal_has_hardware_revision()) {
3858     return nullptr;
3859   }
3860   _impl_._has_bits_[0] &= ~0x00000001u;
3861   auto* p = _impl_.hardware_revision_.Release();
3862 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3863   if (_impl_.hardware_revision_.IsDefault()) {
3864     _impl_.hardware_revision_.Set("", GetArenaForAllocation());
3865   }
3866 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3867   return p;
3868 }
set_allocated_hardware_revision(std::string * hardware_revision)3869 inline void CastLogsProto_CastDeviceInfo::set_allocated_hardware_revision(std::string* hardware_revision) {
3870   if (hardware_revision != nullptr) {
3871     _impl_._has_bits_[0] |= 0x00000001u;
3872   } else {
3873     _impl_._has_bits_[0] &= ~0x00000001u;
3874   }
3875   _impl_.hardware_revision_.SetAllocated(hardware_revision, GetArenaForAllocation());
3876 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3877   if (_impl_.hardware_revision_.IsDefault()) {
3878     _impl_.hardware_revision_.Set("", GetArenaForAllocation());
3879   }
3880 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3881   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.hardware_revision)
3882 }
3883 
3884 // optional string manufacturer = 3;
_internal_has_manufacturer()3885 inline bool CastLogsProto_CastDeviceInfo::_internal_has_manufacturer() const {
3886   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3887   return value;
3888 }
has_manufacturer()3889 inline bool CastLogsProto_CastDeviceInfo::has_manufacturer() const {
3890   return _internal_has_manufacturer();
3891 }
clear_manufacturer()3892 inline void CastLogsProto_CastDeviceInfo::clear_manufacturer() {
3893   _impl_.manufacturer_.ClearToEmpty();
3894   _impl_._has_bits_[0] &= ~0x00000002u;
3895 }
manufacturer()3896 inline const std::string& CastLogsProto_CastDeviceInfo::manufacturer() const {
3897   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.manufacturer)
3898   return _internal_manufacturer();
3899 }
3900 template <typename ArgT0, typename... ArgT>
3901 inline PROTOBUF_ALWAYS_INLINE
set_manufacturer(ArgT0 && arg0,ArgT...args)3902 void CastLogsProto_CastDeviceInfo::set_manufacturer(ArgT0&& arg0, ArgT... args) {
3903  _impl_._has_bits_[0] |= 0x00000002u;
3904  _impl_.manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3905   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.manufacturer)
3906 }
mutable_manufacturer()3907 inline std::string* CastLogsProto_CastDeviceInfo::mutable_manufacturer() {
3908   std::string* _s = _internal_mutable_manufacturer();
3909   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.manufacturer)
3910   return _s;
3911 }
_internal_manufacturer()3912 inline const std::string& CastLogsProto_CastDeviceInfo::_internal_manufacturer() const {
3913   return _impl_.manufacturer_.Get();
3914 }
_internal_set_manufacturer(const std::string & value)3915 inline void CastLogsProto_CastDeviceInfo::_internal_set_manufacturer(const std::string& value) {
3916   _impl_._has_bits_[0] |= 0x00000002u;
3917   _impl_.manufacturer_.Set(value, GetArenaForAllocation());
3918 }
_internal_mutable_manufacturer()3919 inline std::string* CastLogsProto_CastDeviceInfo::_internal_mutable_manufacturer() {
3920   _impl_._has_bits_[0] |= 0x00000002u;
3921   return _impl_.manufacturer_.Mutable(GetArenaForAllocation());
3922 }
release_manufacturer()3923 inline std::string* CastLogsProto_CastDeviceInfo::release_manufacturer() {
3924   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.manufacturer)
3925   if (!_internal_has_manufacturer()) {
3926     return nullptr;
3927   }
3928   _impl_._has_bits_[0] &= ~0x00000002u;
3929   auto* p = _impl_.manufacturer_.Release();
3930 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3931   if (_impl_.manufacturer_.IsDefault()) {
3932     _impl_.manufacturer_.Set("", GetArenaForAllocation());
3933   }
3934 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3935   return p;
3936 }
set_allocated_manufacturer(std::string * manufacturer)3937 inline void CastLogsProto_CastDeviceInfo::set_allocated_manufacturer(std::string* manufacturer) {
3938   if (manufacturer != nullptr) {
3939     _impl_._has_bits_[0] |= 0x00000002u;
3940   } else {
3941     _impl_._has_bits_[0] &= ~0x00000002u;
3942   }
3943   _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation());
3944 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3945   if (_impl_.manufacturer_.IsDefault()) {
3946     _impl_.manufacturer_.Set("", GetArenaForAllocation());
3947   }
3948 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3949   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.manufacturer)
3950 }
3951 
3952 // optional string model = 4;
_internal_has_model()3953 inline bool CastLogsProto_CastDeviceInfo::_internal_has_model() const {
3954   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3955   return value;
3956 }
has_model()3957 inline bool CastLogsProto_CastDeviceInfo::has_model() const {
3958   return _internal_has_model();
3959 }
clear_model()3960 inline void CastLogsProto_CastDeviceInfo::clear_model() {
3961   _impl_.model_.ClearToEmpty();
3962   _impl_._has_bits_[0] &= ~0x00000004u;
3963 }
model()3964 inline const std::string& CastLogsProto_CastDeviceInfo::model() const {
3965   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.model)
3966   return _internal_model();
3967 }
3968 template <typename ArgT0, typename... ArgT>
3969 inline PROTOBUF_ALWAYS_INLINE
set_model(ArgT0 && arg0,ArgT...args)3970 void CastLogsProto_CastDeviceInfo::set_model(ArgT0&& arg0, ArgT... args) {
3971  _impl_._has_bits_[0] |= 0x00000004u;
3972  _impl_.model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3973   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.model)
3974 }
mutable_model()3975 inline std::string* CastLogsProto_CastDeviceInfo::mutable_model() {
3976   std::string* _s = _internal_mutable_model();
3977   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.model)
3978   return _s;
3979 }
_internal_model()3980 inline const std::string& CastLogsProto_CastDeviceInfo::_internal_model() const {
3981   return _impl_.model_.Get();
3982 }
_internal_set_model(const std::string & value)3983 inline void CastLogsProto_CastDeviceInfo::_internal_set_model(const std::string& value) {
3984   _impl_._has_bits_[0] |= 0x00000004u;
3985   _impl_.model_.Set(value, GetArenaForAllocation());
3986 }
_internal_mutable_model()3987 inline std::string* CastLogsProto_CastDeviceInfo::_internal_mutable_model() {
3988   _impl_._has_bits_[0] |= 0x00000004u;
3989   return _impl_.model_.Mutable(GetArenaForAllocation());
3990 }
release_model()3991 inline std::string* CastLogsProto_CastDeviceInfo::release_model() {
3992   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.model)
3993   if (!_internal_has_model()) {
3994     return nullptr;
3995   }
3996   _impl_._has_bits_[0] &= ~0x00000004u;
3997   auto* p = _impl_.model_.Release();
3998 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3999   if (_impl_.model_.IsDefault()) {
4000     _impl_.model_.Set("", GetArenaForAllocation());
4001   }
4002 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4003   return p;
4004 }
set_allocated_model(std::string * model)4005 inline void CastLogsProto_CastDeviceInfo::set_allocated_model(std::string* model) {
4006   if (model != nullptr) {
4007     _impl_._has_bits_[0] |= 0x00000004u;
4008   } else {
4009     _impl_._has_bits_[0] &= ~0x00000004u;
4010   }
4011   _impl_.model_.SetAllocated(model, GetArenaForAllocation());
4012 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4013   if (_impl_.model_.IsDefault()) {
4014     _impl_.model_.Set("", GetArenaForAllocation());
4015   }
4016 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4017   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.model)
4018 }
4019 
4020 // optional string serial_number = 5;
_internal_has_serial_number()4021 inline bool CastLogsProto_CastDeviceInfo::_internal_has_serial_number() const {
4022   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4023   return value;
4024 }
has_serial_number()4025 inline bool CastLogsProto_CastDeviceInfo::has_serial_number() const {
4026   return _internal_has_serial_number();
4027 }
clear_serial_number()4028 inline void CastLogsProto_CastDeviceInfo::clear_serial_number() {
4029   _impl_.serial_number_.ClearToEmpty();
4030   _impl_._has_bits_[0] &= ~0x00000008u;
4031 }
serial_number()4032 inline const std::string& CastLogsProto_CastDeviceInfo::serial_number() const {
4033   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.serial_number)
4034   return _internal_serial_number();
4035 }
4036 template <typename ArgT0, typename... ArgT>
4037 inline PROTOBUF_ALWAYS_INLINE
set_serial_number(ArgT0 && arg0,ArgT...args)4038 void CastLogsProto_CastDeviceInfo::set_serial_number(ArgT0&& arg0, ArgT... args) {
4039  _impl_._has_bits_[0] |= 0x00000008u;
4040  _impl_.serial_number_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4041   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceInfo.serial_number)
4042 }
mutable_serial_number()4043 inline std::string* CastLogsProto_CastDeviceInfo::mutable_serial_number() {
4044   std::string* _s = _internal_mutable_serial_number();
4045   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.serial_number)
4046   return _s;
4047 }
_internal_serial_number()4048 inline const std::string& CastLogsProto_CastDeviceInfo::_internal_serial_number() const {
4049   return _impl_.serial_number_.Get();
4050 }
_internal_set_serial_number(const std::string & value)4051 inline void CastLogsProto_CastDeviceInfo::_internal_set_serial_number(const std::string& value) {
4052   _impl_._has_bits_[0] |= 0x00000008u;
4053   _impl_.serial_number_.Set(value, GetArenaForAllocation());
4054 }
_internal_mutable_serial_number()4055 inline std::string* CastLogsProto_CastDeviceInfo::_internal_mutable_serial_number() {
4056   _impl_._has_bits_[0] |= 0x00000008u;
4057   return _impl_.serial_number_.Mutable(GetArenaForAllocation());
4058 }
release_serial_number()4059 inline std::string* CastLogsProto_CastDeviceInfo::release_serial_number() {
4060   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.serial_number)
4061   if (!_internal_has_serial_number()) {
4062     return nullptr;
4063   }
4064   _impl_._has_bits_[0] &= ~0x00000008u;
4065   auto* p = _impl_.serial_number_.Release();
4066 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4067   if (_impl_.serial_number_.IsDefault()) {
4068     _impl_.serial_number_.Set("", GetArenaForAllocation());
4069   }
4070 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4071   return p;
4072 }
set_allocated_serial_number(std::string * serial_number)4073 inline void CastLogsProto_CastDeviceInfo::set_allocated_serial_number(std::string* serial_number) {
4074   if (serial_number != nullptr) {
4075     _impl_._has_bits_[0] |= 0x00000008u;
4076   } else {
4077     _impl_._has_bits_[0] &= ~0x00000008u;
4078   }
4079   _impl_.serial_number_.SetAllocated(serial_number, GetArenaForAllocation());
4080 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4081   if (_impl_.serial_number_.IsDefault()) {
4082     _impl_.serial_number_.Set("", GetArenaForAllocation());
4083   }
4084 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4085   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.serial_number)
4086 }
4087 
4088 // optional .metrics.CastLogsProto.CastDeviceInfo.HardwareInfo hardware_info = 6;
_internal_has_hardware_info()4089 inline bool CastLogsProto_CastDeviceInfo::_internal_has_hardware_info() const {
4090   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
4091   PROTOBUF_ASSUME(!value || _impl_.hardware_info_ != nullptr);
4092   return value;
4093 }
has_hardware_info()4094 inline bool CastLogsProto_CastDeviceInfo::has_hardware_info() const {
4095   return _internal_has_hardware_info();
4096 }
clear_hardware_info()4097 inline void CastLogsProto_CastDeviceInfo::clear_hardware_info() {
4098   if (_impl_.hardware_info_ != nullptr) _impl_.hardware_info_->Clear();
4099   _impl_._has_bits_[0] &= ~0x00000010u;
4100 }
_internal_hardware_info()4101 inline const ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo& CastLogsProto_CastDeviceInfo::_internal_hardware_info() const {
4102   const ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* p = _impl_.hardware_info_;
4103   return p != nullptr ? *p : reinterpret_cast<const ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo&>(
4104       ::metrics::_CastLogsProto_CastDeviceInfo_HardwareInfo_default_instance_);
4105 }
hardware_info()4106 inline const ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo& CastLogsProto_CastDeviceInfo::hardware_info() const {
4107   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceInfo.hardware_info)
4108   return _internal_hardware_info();
4109 }
unsafe_arena_set_allocated_hardware_info(::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo * hardware_info)4110 inline void CastLogsProto_CastDeviceInfo::unsafe_arena_set_allocated_hardware_info(
4111     ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* hardware_info) {
4112   if (GetArenaForAllocation() == nullptr) {
4113     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hardware_info_);
4114   }
4115   _impl_.hardware_info_ = hardware_info;
4116   if (hardware_info) {
4117     _impl_._has_bits_[0] |= 0x00000010u;
4118   } else {
4119     _impl_._has_bits_[0] &= ~0x00000010u;
4120   }
4121   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.CastLogsProto.CastDeviceInfo.hardware_info)
4122 }
release_hardware_info()4123 inline ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* CastLogsProto_CastDeviceInfo::release_hardware_info() {
4124   _impl_._has_bits_[0] &= ~0x00000010u;
4125   ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* temp = _impl_.hardware_info_;
4126   _impl_.hardware_info_ = nullptr;
4127 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4128   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4129   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4130   if (GetArenaForAllocation() == nullptr) { delete old; }
4131 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
4132   if (GetArenaForAllocation() != nullptr) {
4133     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4134   }
4135 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
4136   return temp;
4137 }
unsafe_arena_release_hardware_info()4138 inline ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* CastLogsProto_CastDeviceInfo::unsafe_arena_release_hardware_info() {
4139   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceInfo.hardware_info)
4140   _impl_._has_bits_[0] &= ~0x00000010u;
4141   ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* temp = _impl_.hardware_info_;
4142   _impl_.hardware_info_ = nullptr;
4143   return temp;
4144 }
_internal_mutable_hardware_info()4145 inline ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* CastLogsProto_CastDeviceInfo::_internal_mutable_hardware_info() {
4146   _impl_._has_bits_[0] |= 0x00000010u;
4147   if (_impl_.hardware_info_ == nullptr) {
4148     auto* p = CreateMaybeMessage<::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo>(GetArenaForAllocation());
4149     _impl_.hardware_info_ = p;
4150   }
4151   return _impl_.hardware_info_;
4152 }
mutable_hardware_info()4153 inline ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* CastLogsProto_CastDeviceInfo::mutable_hardware_info() {
4154   ::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* _msg = _internal_mutable_hardware_info();
4155   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceInfo.hardware_info)
4156   return _msg;
4157 }
set_allocated_hardware_info(::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo * hardware_info)4158 inline void CastLogsProto_CastDeviceInfo::set_allocated_hardware_info(::metrics::CastLogsProto_CastDeviceInfo_HardwareInfo* hardware_info) {
4159   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4160   if (message_arena == nullptr) {
4161     delete _impl_.hardware_info_;
4162   }
4163   if (hardware_info) {
4164     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4165         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hardware_info);
4166     if (message_arena != submessage_arena) {
4167       hardware_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4168           message_arena, hardware_info, submessage_arena);
4169     }
4170     _impl_._has_bits_[0] |= 0x00000010u;
4171   } else {
4172     _impl_._has_bits_[0] &= ~0x00000010u;
4173   }
4174   _impl_.hardware_info_ = hardware_info;
4175   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceInfo.hardware_info)
4176 }
4177 
4178 // -------------------------------------------------------------------
4179 
4180 // CastLogsProto_CastConnectionInfo_SenderInfo
4181 
4182 // optional fixed64 sender_device_id = 1;
_internal_has_sender_device_id()4183 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_sender_device_id() const {
4184   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
4185   return value;
4186 }
has_sender_device_id()4187 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_sender_device_id() const {
4188   return _internal_has_sender_device_id();
4189 }
clear_sender_device_id()4190 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_sender_device_id() {
4191   _impl_.sender_device_id_ = uint64_t{0u};
4192   _impl_._has_bits_[0] &= ~0x00000010u;
4193 }
_internal_sender_device_id()4194 inline uint64_t CastLogsProto_CastConnectionInfo_SenderInfo::_internal_sender_device_id() const {
4195   return _impl_.sender_device_id_;
4196 }
sender_device_id()4197 inline uint64_t CastLogsProto_CastConnectionInfo_SenderInfo::sender_device_id() const {
4198   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.sender_device_id)
4199   return _internal_sender_device_id();
4200 }
_internal_set_sender_device_id(uint64_t value)4201 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_sender_device_id(uint64_t value) {
4202   _impl_._has_bits_[0] |= 0x00000010u;
4203   _impl_.sender_device_id_ = value;
4204 }
set_sender_device_id(uint64_t value)4205 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_sender_device_id(uint64_t value) {
4206   _internal_set_sender_device_id(value);
4207   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.sender_device_id)
4208 }
4209 
4210 // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo.SDKType sdk_type = 2;
_internal_has_sdk_type()4211 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_sdk_type() const {
4212   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
4213   return value;
4214 }
has_sdk_type()4215 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_sdk_type() const {
4216   return _internal_has_sdk_type();
4217 }
clear_sdk_type()4218 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_sdk_type() {
4219   _impl_.sdk_type_ = 0;
4220   _impl_._has_bits_[0] &= ~0x00000020u;
4221 }
_internal_sdk_type()4222 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType CastLogsProto_CastConnectionInfo_SenderInfo::_internal_sdk_type() const {
4223   return static_cast< ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType >(_impl_.sdk_type_);
4224 }
sdk_type()4225 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType CastLogsProto_CastConnectionInfo_SenderInfo::sdk_type() const {
4226   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.sdk_type)
4227   return _internal_sdk_type();
4228 }
_internal_set_sdk_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value)4229 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_sdk_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value) {
4230   assert(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType_IsValid(value));
4231   _impl_._has_bits_[0] |= 0x00000020u;
4232   _impl_.sdk_type_ = value;
4233 }
set_sdk_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value)4234 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_sdk_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType value) {
4235   _internal_set_sdk_type(value);
4236   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.sdk_type)
4237 }
4238 
4239 // optional string version = 3;
_internal_has_version()4240 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_version() const {
4241   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4242   return value;
4243 }
has_version()4244 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_version() const {
4245   return _internal_has_version();
4246 }
clear_version()4247 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_version() {
4248   _impl_.version_.ClearToEmpty();
4249   _impl_._has_bits_[0] &= ~0x00000001u;
4250 }
version()4251 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::version() const {
4252   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.version)
4253   return _internal_version();
4254 }
4255 template <typename ArgT0, typename... ArgT>
4256 inline PROTOBUF_ALWAYS_INLINE
set_version(ArgT0 && arg0,ArgT...args)4257 void CastLogsProto_CastConnectionInfo_SenderInfo::set_version(ArgT0&& arg0, ArgT... args) {
4258  _impl_._has_bits_[0] |= 0x00000001u;
4259  _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4260   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.version)
4261 }
mutable_version()4262 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::mutable_version() {
4263   std::string* _s = _internal_mutable_version();
4264   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.version)
4265   return _s;
4266 }
_internal_version()4267 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::_internal_version() const {
4268   return _impl_.version_.Get();
4269 }
_internal_set_version(const std::string & value)4270 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_version(const std::string& value) {
4271   _impl_._has_bits_[0] |= 0x00000001u;
4272   _impl_.version_.Set(value, GetArenaForAllocation());
4273 }
_internal_mutable_version()4274 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::_internal_mutable_version() {
4275   _impl_._has_bits_[0] |= 0x00000001u;
4276   return _impl_.version_.Mutable(GetArenaForAllocation());
4277 }
release_version()4278 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::release_version() {
4279   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.version)
4280   if (!_internal_has_version()) {
4281     return nullptr;
4282   }
4283   _impl_._has_bits_[0] &= ~0x00000001u;
4284   auto* p = _impl_.version_.Release();
4285 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4286   if (_impl_.version_.IsDefault()) {
4287     _impl_.version_.Set("", GetArenaForAllocation());
4288   }
4289 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4290   return p;
4291 }
set_allocated_version(std::string * version)4292 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_allocated_version(std::string* version) {
4293   if (version != nullptr) {
4294     _impl_._has_bits_[0] |= 0x00000001u;
4295   } else {
4296     _impl_._has_bits_[0] &= ~0x00000001u;
4297   }
4298   _impl_.version_.SetAllocated(version, GetArenaForAllocation());
4299 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4300   if (_impl_.version_.IsDefault()) {
4301     _impl_.version_.Set("", GetArenaForAllocation());
4302   }
4303 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4304   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.version)
4305 }
4306 
4307 // optional string chrome_browser_version = 4;
_internal_has_chrome_browser_version()4308 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_chrome_browser_version() const {
4309   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4310   return value;
4311 }
has_chrome_browser_version()4312 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_chrome_browser_version() const {
4313   return _internal_has_chrome_browser_version();
4314 }
clear_chrome_browser_version()4315 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_chrome_browser_version() {
4316   _impl_.chrome_browser_version_.ClearToEmpty();
4317   _impl_._has_bits_[0] &= ~0x00000002u;
4318 }
chrome_browser_version()4319 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::chrome_browser_version() const {
4320   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.chrome_browser_version)
4321   return _internal_chrome_browser_version();
4322 }
4323 template <typename ArgT0, typename... ArgT>
4324 inline PROTOBUF_ALWAYS_INLINE
set_chrome_browser_version(ArgT0 && arg0,ArgT...args)4325 void CastLogsProto_CastConnectionInfo_SenderInfo::set_chrome_browser_version(ArgT0&& arg0, ArgT... args) {
4326  _impl_._has_bits_[0] |= 0x00000002u;
4327  _impl_.chrome_browser_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4328   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.chrome_browser_version)
4329 }
mutable_chrome_browser_version()4330 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::mutable_chrome_browser_version() {
4331   std::string* _s = _internal_mutable_chrome_browser_version();
4332   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.chrome_browser_version)
4333   return _s;
4334 }
_internal_chrome_browser_version()4335 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::_internal_chrome_browser_version() const {
4336   return _impl_.chrome_browser_version_.Get();
4337 }
_internal_set_chrome_browser_version(const std::string & value)4338 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_chrome_browser_version(const std::string& value) {
4339   _impl_._has_bits_[0] |= 0x00000002u;
4340   _impl_.chrome_browser_version_.Set(value, GetArenaForAllocation());
4341 }
_internal_mutable_chrome_browser_version()4342 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::_internal_mutable_chrome_browser_version() {
4343   _impl_._has_bits_[0] |= 0x00000002u;
4344   return _impl_.chrome_browser_version_.Mutable(GetArenaForAllocation());
4345 }
release_chrome_browser_version()4346 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::release_chrome_browser_version() {
4347   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.chrome_browser_version)
4348   if (!_internal_has_chrome_browser_version()) {
4349     return nullptr;
4350   }
4351   _impl_._has_bits_[0] &= ~0x00000002u;
4352   auto* p = _impl_.chrome_browser_version_.Release();
4353 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4354   if (_impl_.chrome_browser_version_.IsDefault()) {
4355     _impl_.chrome_browser_version_.Set("", GetArenaForAllocation());
4356   }
4357 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4358   return p;
4359 }
set_allocated_chrome_browser_version(std::string * chrome_browser_version)4360 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_allocated_chrome_browser_version(std::string* chrome_browser_version) {
4361   if (chrome_browser_version != nullptr) {
4362     _impl_._has_bits_[0] |= 0x00000002u;
4363   } else {
4364     _impl_._has_bits_[0] &= ~0x00000002u;
4365   }
4366   _impl_.chrome_browser_version_.SetAllocated(chrome_browser_version, GetArenaForAllocation());
4367 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4368   if (_impl_.chrome_browser_version_.IsDefault()) {
4369     _impl_.chrome_browser_version_.Set("", GetArenaForAllocation());
4370   }
4371 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4372   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.chrome_browser_version)
4373 }
4374 
4375 // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo.Platform platform = 5;
_internal_has_platform()4376 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_platform() const {
4377   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
4378   return value;
4379 }
has_platform()4380 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_platform() const {
4381   return _internal_has_platform();
4382 }
clear_platform()4383 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_platform() {
4384   _impl_.platform_ = 0;
4385   _impl_._has_bits_[0] &= ~0x00000040u;
4386 }
_internal_platform()4387 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform CastLogsProto_CastConnectionInfo_SenderInfo::_internal_platform() const {
4388   return static_cast< ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform >(_impl_.platform_);
4389 }
platform()4390 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform CastLogsProto_CastConnectionInfo_SenderInfo::platform() const {
4391   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.platform)
4392   return _internal_platform();
4393 }
_internal_set_platform(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform value)4394 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_platform(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform value) {
4395   assert(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform_IsValid(value));
4396   _impl_._has_bits_[0] |= 0x00000040u;
4397   _impl_.platform_ = value;
4398 }
set_platform(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform value)4399 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_platform(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform value) {
4400   _internal_set_platform(value);
4401   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.platform)
4402 }
4403 
4404 // optional string system_version = 6;
_internal_has_system_version()4405 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_system_version() const {
4406   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4407   return value;
4408 }
has_system_version()4409 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_system_version() const {
4410   return _internal_has_system_version();
4411 }
clear_system_version()4412 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_system_version() {
4413   _impl_.system_version_.ClearToEmpty();
4414   _impl_._has_bits_[0] &= ~0x00000004u;
4415 }
system_version()4416 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::system_version() const {
4417   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.system_version)
4418   return _internal_system_version();
4419 }
4420 template <typename ArgT0, typename... ArgT>
4421 inline PROTOBUF_ALWAYS_INLINE
set_system_version(ArgT0 && arg0,ArgT...args)4422 void CastLogsProto_CastConnectionInfo_SenderInfo::set_system_version(ArgT0&& arg0, ArgT... args) {
4423  _impl_._has_bits_[0] |= 0x00000004u;
4424  _impl_.system_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4425   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.system_version)
4426 }
mutable_system_version()4427 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::mutable_system_version() {
4428   std::string* _s = _internal_mutable_system_version();
4429   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.system_version)
4430   return _s;
4431 }
_internal_system_version()4432 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::_internal_system_version() const {
4433   return _impl_.system_version_.Get();
4434 }
_internal_set_system_version(const std::string & value)4435 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_system_version(const std::string& value) {
4436   _impl_._has_bits_[0] |= 0x00000004u;
4437   _impl_.system_version_.Set(value, GetArenaForAllocation());
4438 }
_internal_mutable_system_version()4439 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::_internal_mutable_system_version() {
4440   _impl_._has_bits_[0] |= 0x00000004u;
4441   return _impl_.system_version_.Mutable(GetArenaForAllocation());
4442 }
release_system_version()4443 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::release_system_version() {
4444   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.system_version)
4445   if (!_internal_has_system_version()) {
4446     return nullptr;
4447   }
4448   _impl_._has_bits_[0] &= ~0x00000004u;
4449   auto* p = _impl_.system_version_.Release();
4450 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4451   if (_impl_.system_version_.IsDefault()) {
4452     _impl_.system_version_.Set("", GetArenaForAllocation());
4453   }
4454 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4455   return p;
4456 }
set_allocated_system_version(std::string * system_version)4457 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_allocated_system_version(std::string* system_version) {
4458   if (system_version != nullptr) {
4459     _impl_._has_bits_[0] |= 0x00000004u;
4460   } else {
4461     _impl_._has_bits_[0] &= ~0x00000004u;
4462   }
4463   _impl_.system_version_.SetAllocated(system_version, GetArenaForAllocation());
4464 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4465   if (_impl_.system_version_.IsDefault()) {
4466     _impl_.system_version_.Set("", GetArenaForAllocation());
4467   }
4468 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4469   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.system_version)
4470 }
4471 
4472 // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo.ConnectionType transport_connection_type = 7;
_internal_has_transport_connection_type()4473 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_transport_connection_type() const {
4474   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
4475   return value;
4476 }
has_transport_connection_type()4477 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_transport_connection_type() const {
4478   return _internal_has_transport_connection_type();
4479 }
clear_transport_connection_type()4480 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_transport_connection_type() {
4481   _impl_.transport_connection_type_ = 0;
4482   _impl_._has_bits_[0] &= ~0x00000080u;
4483 }
_internal_transport_connection_type()4484 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType CastLogsProto_CastConnectionInfo_SenderInfo::_internal_transport_connection_type() const {
4485   return static_cast< ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType >(_impl_.transport_connection_type_);
4486 }
transport_connection_type()4487 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType CastLogsProto_CastConnectionInfo_SenderInfo::transport_connection_type() const {
4488   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.transport_connection_type)
4489   return _internal_transport_connection_type();
4490 }
_internal_set_transport_connection_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value)4491 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_transport_connection_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value) {
4492   assert(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType_IsValid(value));
4493   _impl_._has_bits_[0] |= 0x00000080u;
4494   _impl_.transport_connection_type_ = value;
4495 }
set_transport_connection_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value)4496 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_transport_connection_type(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType value) {
4497   _internal_set_transport_connection_type(value);
4498   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.transport_connection_type)
4499 }
4500 
4501 // optional string model = 8;
_internal_has_model()4502 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_model() const {
4503   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4504   return value;
4505 }
has_model()4506 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_model() const {
4507   return _internal_has_model();
4508 }
clear_model()4509 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_model() {
4510   _impl_.model_.ClearToEmpty();
4511   _impl_._has_bits_[0] &= ~0x00000008u;
4512 }
model()4513 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::model() const {
4514   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.model)
4515   return _internal_model();
4516 }
4517 template <typename ArgT0, typename... ArgT>
4518 inline PROTOBUF_ALWAYS_INLINE
set_model(ArgT0 && arg0,ArgT...args)4519 void CastLogsProto_CastConnectionInfo_SenderInfo::set_model(ArgT0&& arg0, ArgT... args) {
4520  _impl_._has_bits_[0] |= 0x00000008u;
4521  _impl_.model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4522   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.model)
4523 }
mutable_model()4524 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::mutable_model() {
4525   std::string* _s = _internal_mutable_model();
4526   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.model)
4527   return _s;
4528 }
_internal_model()4529 inline const std::string& CastLogsProto_CastConnectionInfo_SenderInfo::_internal_model() const {
4530   return _impl_.model_.Get();
4531 }
_internal_set_model(const std::string & value)4532 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_model(const std::string& value) {
4533   _impl_._has_bits_[0] |= 0x00000008u;
4534   _impl_.model_.Set(value, GetArenaForAllocation());
4535 }
_internal_mutable_model()4536 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::_internal_mutable_model() {
4537   _impl_._has_bits_[0] |= 0x00000008u;
4538   return _impl_.model_.Mutable(GetArenaForAllocation());
4539 }
release_model()4540 inline std::string* CastLogsProto_CastConnectionInfo_SenderInfo::release_model() {
4541   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.model)
4542   if (!_internal_has_model()) {
4543     return nullptr;
4544   }
4545   _impl_._has_bits_[0] &= ~0x00000008u;
4546   auto* p = _impl_.model_.Release();
4547 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4548   if (_impl_.model_.IsDefault()) {
4549     _impl_.model_.Set("", GetArenaForAllocation());
4550   }
4551 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4552   return p;
4553 }
set_allocated_model(std::string * model)4554 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_allocated_model(std::string* model) {
4555   if (model != nullptr) {
4556     _impl_._has_bits_[0] |= 0x00000008u;
4557   } else {
4558     _impl_._has_bits_[0] &= ~0x00000008u;
4559   }
4560   _impl_.model_.SetAllocated(model, GetArenaForAllocation());
4561 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4562   if (_impl_.model_.IsDefault()) {
4563     _impl_.model_.Set("", GetArenaForAllocation());
4564   }
4565 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4566   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.model)
4567 }
4568 
4569 // optional int32 sender_local_ip_fragment = 9;
_internal_has_sender_local_ip_fragment()4570 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::_internal_has_sender_local_ip_fragment() const {
4571   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
4572   return value;
4573 }
has_sender_local_ip_fragment()4574 inline bool CastLogsProto_CastConnectionInfo_SenderInfo::has_sender_local_ip_fragment() const {
4575   return _internal_has_sender_local_ip_fragment();
4576 }
clear_sender_local_ip_fragment()4577 inline void CastLogsProto_CastConnectionInfo_SenderInfo::clear_sender_local_ip_fragment() {
4578   _impl_.sender_local_ip_fragment_ = 0;
4579   _impl_._has_bits_[0] &= ~0x00000100u;
4580 }
_internal_sender_local_ip_fragment()4581 inline int32_t CastLogsProto_CastConnectionInfo_SenderInfo::_internal_sender_local_ip_fragment() const {
4582   return _impl_.sender_local_ip_fragment_;
4583 }
sender_local_ip_fragment()4584 inline int32_t CastLogsProto_CastConnectionInfo_SenderInfo::sender_local_ip_fragment() const {
4585   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.sender_local_ip_fragment)
4586   return _internal_sender_local_ip_fragment();
4587 }
_internal_set_sender_local_ip_fragment(int32_t value)4588 inline void CastLogsProto_CastConnectionInfo_SenderInfo::_internal_set_sender_local_ip_fragment(int32_t value) {
4589   _impl_._has_bits_[0] |= 0x00000100u;
4590   _impl_.sender_local_ip_fragment_ = value;
4591 }
set_sender_local_ip_fragment(int32_t value)4592 inline void CastLogsProto_CastConnectionInfo_SenderInfo::set_sender_local_ip_fragment(int32_t value) {
4593   _internal_set_sender_local_ip_fragment(value);
4594   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.SenderInfo.sender_local_ip_fragment)
4595 }
4596 
4597 // -------------------------------------------------------------------
4598 
4599 // CastLogsProto_CastConnectionInfo
4600 
4601 // optional fixed32 transport_connection_id = 1;
_internal_has_transport_connection_id()4602 inline bool CastLogsProto_CastConnectionInfo::_internal_has_transport_connection_id() const {
4603   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4604   return value;
4605 }
has_transport_connection_id()4606 inline bool CastLogsProto_CastConnectionInfo::has_transport_connection_id() const {
4607   return _internal_has_transport_connection_id();
4608 }
clear_transport_connection_id()4609 inline void CastLogsProto_CastConnectionInfo::clear_transport_connection_id() {
4610   _impl_.transport_connection_id_ = 0u;
4611   _impl_._has_bits_[0] &= ~0x00000002u;
4612 }
_internal_transport_connection_id()4613 inline uint32_t CastLogsProto_CastConnectionInfo::_internal_transport_connection_id() const {
4614   return _impl_.transport_connection_id_;
4615 }
transport_connection_id()4616 inline uint32_t CastLogsProto_CastConnectionInfo::transport_connection_id() const {
4617   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.transport_connection_id)
4618   return _internal_transport_connection_id();
4619 }
_internal_set_transport_connection_id(uint32_t value)4620 inline void CastLogsProto_CastConnectionInfo::_internal_set_transport_connection_id(uint32_t value) {
4621   _impl_._has_bits_[0] |= 0x00000002u;
4622   _impl_.transport_connection_id_ = value;
4623 }
set_transport_connection_id(uint32_t value)4624 inline void CastLogsProto_CastConnectionInfo::set_transport_connection_id(uint32_t value) {
4625   _internal_set_transport_connection_id(value);
4626   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.transport_connection_id)
4627 }
4628 
4629 // optional fixed32 virtual_connection_id = 2;
_internal_has_virtual_connection_id()4630 inline bool CastLogsProto_CastConnectionInfo::_internal_has_virtual_connection_id() const {
4631   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4632   return value;
4633 }
has_virtual_connection_id()4634 inline bool CastLogsProto_CastConnectionInfo::has_virtual_connection_id() const {
4635   return _internal_has_virtual_connection_id();
4636 }
clear_virtual_connection_id()4637 inline void CastLogsProto_CastConnectionInfo::clear_virtual_connection_id() {
4638   _impl_.virtual_connection_id_ = 0u;
4639   _impl_._has_bits_[0] &= ~0x00000004u;
4640 }
_internal_virtual_connection_id()4641 inline uint32_t CastLogsProto_CastConnectionInfo::_internal_virtual_connection_id() const {
4642   return _impl_.virtual_connection_id_;
4643 }
virtual_connection_id()4644 inline uint32_t CastLogsProto_CastConnectionInfo::virtual_connection_id() const {
4645   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.virtual_connection_id)
4646   return _internal_virtual_connection_id();
4647 }
_internal_set_virtual_connection_id(uint32_t value)4648 inline void CastLogsProto_CastConnectionInfo::_internal_set_virtual_connection_id(uint32_t value) {
4649   _impl_._has_bits_[0] |= 0x00000004u;
4650   _impl_.virtual_connection_id_ = value;
4651 }
set_virtual_connection_id(uint32_t value)4652 inline void CastLogsProto_CastConnectionInfo::set_virtual_connection_id(uint32_t value) {
4653   _internal_set_virtual_connection_id(value);
4654   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastConnectionInfo.virtual_connection_id)
4655 }
4656 
4657 // optional .metrics.CastLogsProto.CastConnectionInfo.SenderInfo sender_info = 3;
_internal_has_sender_info()4658 inline bool CastLogsProto_CastConnectionInfo::_internal_has_sender_info() const {
4659   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4660   PROTOBUF_ASSUME(!value || _impl_.sender_info_ != nullptr);
4661   return value;
4662 }
has_sender_info()4663 inline bool CastLogsProto_CastConnectionInfo::has_sender_info() const {
4664   return _internal_has_sender_info();
4665 }
clear_sender_info()4666 inline void CastLogsProto_CastConnectionInfo::clear_sender_info() {
4667   if (_impl_.sender_info_ != nullptr) _impl_.sender_info_->Clear();
4668   _impl_._has_bits_[0] &= ~0x00000001u;
4669 }
_internal_sender_info()4670 inline const ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo& CastLogsProto_CastConnectionInfo::_internal_sender_info() const {
4671   const ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* p = _impl_.sender_info_;
4672   return p != nullptr ? *p : reinterpret_cast<const ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo&>(
4673       ::metrics::_CastLogsProto_CastConnectionInfo_SenderInfo_default_instance_);
4674 }
sender_info()4675 inline const ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo& CastLogsProto_CastConnectionInfo::sender_info() const {
4676   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastConnectionInfo.sender_info)
4677   return _internal_sender_info();
4678 }
unsafe_arena_set_allocated_sender_info(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo * sender_info)4679 inline void CastLogsProto_CastConnectionInfo::unsafe_arena_set_allocated_sender_info(
4680     ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* sender_info) {
4681   if (GetArenaForAllocation() == nullptr) {
4682     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sender_info_);
4683   }
4684   _impl_.sender_info_ = sender_info;
4685   if (sender_info) {
4686     _impl_._has_bits_[0] |= 0x00000001u;
4687   } else {
4688     _impl_._has_bits_[0] &= ~0x00000001u;
4689   }
4690   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.CastLogsProto.CastConnectionInfo.sender_info)
4691 }
release_sender_info()4692 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* CastLogsProto_CastConnectionInfo::release_sender_info() {
4693   _impl_._has_bits_[0] &= ~0x00000001u;
4694   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* temp = _impl_.sender_info_;
4695   _impl_.sender_info_ = nullptr;
4696 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4697   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4698   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4699   if (GetArenaForAllocation() == nullptr) { delete old; }
4700 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
4701   if (GetArenaForAllocation() != nullptr) {
4702     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4703   }
4704 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
4705   return temp;
4706 }
unsafe_arena_release_sender_info()4707 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* CastLogsProto_CastConnectionInfo::unsafe_arena_release_sender_info() {
4708   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastConnectionInfo.sender_info)
4709   _impl_._has_bits_[0] &= ~0x00000001u;
4710   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* temp = _impl_.sender_info_;
4711   _impl_.sender_info_ = nullptr;
4712   return temp;
4713 }
_internal_mutable_sender_info()4714 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* CastLogsProto_CastConnectionInfo::_internal_mutable_sender_info() {
4715   _impl_._has_bits_[0] |= 0x00000001u;
4716   if (_impl_.sender_info_ == nullptr) {
4717     auto* p = CreateMaybeMessage<::metrics::CastLogsProto_CastConnectionInfo_SenderInfo>(GetArenaForAllocation());
4718     _impl_.sender_info_ = p;
4719   }
4720   return _impl_.sender_info_;
4721 }
mutable_sender_info()4722 inline ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* CastLogsProto_CastConnectionInfo::mutable_sender_info() {
4723   ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* _msg = _internal_mutable_sender_info();
4724   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastConnectionInfo.sender_info)
4725   return _msg;
4726 }
set_allocated_sender_info(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo * sender_info)4727 inline void CastLogsProto_CastConnectionInfo::set_allocated_sender_info(::metrics::CastLogsProto_CastConnectionInfo_SenderInfo* sender_info) {
4728   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4729   if (message_arena == nullptr) {
4730     delete _impl_.sender_info_;
4731   }
4732   if (sender_info) {
4733     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4734         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sender_info);
4735     if (message_arena != submessage_arena) {
4736       sender_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4737           message_arena, sender_info, submessage_arena);
4738     }
4739     _impl_._has_bits_[0] |= 0x00000001u;
4740   } else {
4741     _impl_._has_bits_[0] &= ~0x00000001u;
4742   }
4743   _impl_.sender_info_ = sender_info;
4744   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastConnectionInfo.sender_info)
4745 }
4746 
4747 // -------------------------------------------------------------------
4748 
4749 // CastLogsProto_CastEventProto_Metadata
4750 
4751 // optional fixed64 name_hash = 1;
_internal_has_name_hash()4752 inline bool CastLogsProto_CastEventProto_Metadata::_internal_has_name_hash() const {
4753   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4754   return value;
4755 }
has_name_hash()4756 inline bool CastLogsProto_CastEventProto_Metadata::has_name_hash() const {
4757   return _internal_has_name_hash();
4758 }
clear_name_hash()4759 inline void CastLogsProto_CastEventProto_Metadata::clear_name_hash() {
4760   _impl_.name_hash_ = uint64_t{0u};
4761   _impl_._has_bits_[0] &= ~0x00000001u;
4762 }
_internal_name_hash()4763 inline uint64_t CastLogsProto_CastEventProto_Metadata::_internal_name_hash() const {
4764   return _impl_.name_hash_;
4765 }
name_hash()4766 inline uint64_t CastLogsProto_CastEventProto_Metadata::name_hash() const {
4767   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.Metadata.name_hash)
4768   return _internal_name_hash();
4769 }
_internal_set_name_hash(uint64_t value)4770 inline void CastLogsProto_CastEventProto_Metadata::_internal_set_name_hash(uint64_t value) {
4771   _impl_._has_bits_[0] |= 0x00000001u;
4772   _impl_.name_hash_ = value;
4773 }
set_name_hash(uint64_t value)4774 inline void CastLogsProto_CastEventProto_Metadata::set_name_hash(uint64_t value) {
4775   _internal_set_name_hash(value);
4776   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.Metadata.name_hash)
4777 }
4778 
4779 // optional int64 value = 2;
_internal_has_value()4780 inline bool CastLogsProto_CastEventProto_Metadata::_internal_has_value() const {
4781   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4782   return value;
4783 }
has_value()4784 inline bool CastLogsProto_CastEventProto_Metadata::has_value() const {
4785   return _internal_has_value();
4786 }
clear_value()4787 inline void CastLogsProto_CastEventProto_Metadata::clear_value() {
4788   _impl_.value_ = int64_t{0};
4789   _impl_._has_bits_[0] &= ~0x00000002u;
4790 }
_internal_value()4791 inline int64_t CastLogsProto_CastEventProto_Metadata::_internal_value() const {
4792   return _impl_.value_;
4793 }
value()4794 inline int64_t CastLogsProto_CastEventProto_Metadata::value() const {
4795   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.Metadata.value)
4796   return _internal_value();
4797 }
_internal_set_value(int64_t value)4798 inline void CastLogsProto_CastEventProto_Metadata::_internal_set_value(int64_t value) {
4799   _impl_._has_bits_[0] |= 0x00000002u;
4800   _impl_.value_ = value;
4801 }
set_value(int64_t value)4802 inline void CastLogsProto_CastEventProto_Metadata::set_value(int64_t value) {
4803   _internal_set_value(value);
4804   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.Metadata.value)
4805 }
4806 
4807 // -------------------------------------------------------------------
4808 
4809 // CastLogsProto_CastEventProto
4810 
4811 // optional fixed64 name_hash = 1;
_internal_has_name_hash()4812 inline bool CastLogsProto_CastEventProto::_internal_has_name_hash() const {
4813   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
4814   return value;
4815 }
has_name_hash()4816 inline bool CastLogsProto_CastEventProto::has_name_hash() const {
4817   return _internal_has_name_hash();
4818 }
clear_name_hash()4819 inline void CastLogsProto_CastEventProto::clear_name_hash() {
4820   _impl_.name_hash_ = uint64_t{0u};
4821   _impl_._has_bits_[0] &= ~0x00000200u;
4822 }
_internal_name_hash()4823 inline uint64_t CastLogsProto_CastEventProto::_internal_name_hash() const {
4824   return _impl_.name_hash_;
4825 }
name_hash()4826 inline uint64_t CastLogsProto_CastEventProto::name_hash() const {
4827   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.name_hash)
4828   return _internal_name_hash();
4829 }
_internal_set_name_hash(uint64_t value)4830 inline void CastLogsProto_CastEventProto::_internal_set_name_hash(uint64_t value) {
4831   _impl_._has_bits_[0] |= 0x00000200u;
4832   _impl_.name_hash_ = value;
4833 }
set_name_hash(uint64_t value)4834 inline void CastLogsProto_CastEventProto::set_name_hash(uint64_t value) {
4835   _internal_set_name_hash(value);
4836   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.name_hash)
4837 }
4838 
4839 // optional int64 time_msec = 2;
_internal_has_time_msec()4840 inline bool CastLogsProto_CastEventProto::_internal_has_time_msec() const {
4841   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
4842   return value;
4843 }
has_time_msec()4844 inline bool CastLogsProto_CastEventProto::has_time_msec() const {
4845   return _internal_has_time_msec();
4846 }
clear_time_msec()4847 inline void CastLogsProto_CastEventProto::clear_time_msec() {
4848   _impl_.time_msec_ = int64_t{0};
4849   _impl_._has_bits_[0] &= ~0x00000400u;
4850 }
_internal_time_msec()4851 inline int64_t CastLogsProto_CastEventProto::_internal_time_msec() const {
4852   return _impl_.time_msec_;
4853 }
time_msec()4854 inline int64_t CastLogsProto_CastEventProto::time_msec() const {
4855   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.time_msec)
4856   return _internal_time_msec();
4857 }
_internal_set_time_msec(int64_t value)4858 inline void CastLogsProto_CastEventProto::_internal_set_time_msec(int64_t value) {
4859   _impl_._has_bits_[0] |= 0x00000400u;
4860   _impl_.time_msec_ = value;
4861 }
set_time_msec(int64_t value)4862 inline void CastLogsProto_CastEventProto::set_time_msec(int64_t value) {
4863   _internal_set_time_msec(value);
4864   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.time_msec)
4865 }
4866 
4867 // optional fixed32 app_id = 3;
_internal_has_app_id()4868 inline bool CastLogsProto_CastEventProto::_internal_has_app_id() const {
4869   bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
4870   return value;
4871 }
has_app_id()4872 inline bool CastLogsProto_CastEventProto::has_app_id() const {
4873   return _internal_has_app_id();
4874 }
clear_app_id()4875 inline void CastLogsProto_CastEventProto::clear_app_id() {
4876   _impl_.app_id_ = 0u;
4877   _impl_._has_bits_[0] &= ~0x00001000u;
4878 }
_internal_app_id()4879 inline uint32_t CastLogsProto_CastEventProto::_internal_app_id() const {
4880   return _impl_.app_id_;
4881 }
app_id()4882 inline uint32_t CastLogsProto_CastEventProto::app_id() const {
4883   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.app_id)
4884   return _internal_app_id();
4885 }
_internal_set_app_id(uint32_t value)4886 inline void CastLogsProto_CastEventProto::_internal_set_app_id(uint32_t value) {
4887   _impl_._has_bits_[0] |= 0x00001000u;
4888   _impl_.app_id_ = value;
4889 }
set_app_id(uint32_t value)4890 inline void CastLogsProto_CastEventProto::set_app_id(uint32_t value) {
4891   _internal_set_app_id(value);
4892   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.app_id)
4893 }
4894 
4895 // optional fixed32 remote_app_id = 19;
_internal_has_remote_app_id()4896 inline bool CastLogsProto_CastEventProto::_internal_has_remote_app_id() const {
4897   bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
4898   return value;
4899 }
has_remote_app_id()4900 inline bool CastLogsProto_CastEventProto::has_remote_app_id() const {
4901   return _internal_has_remote_app_id();
4902 }
clear_remote_app_id()4903 inline void CastLogsProto_CastEventProto::clear_remote_app_id() {
4904   _impl_.remote_app_id_ = 0u;
4905   _impl_._has_bits_[0] &= ~0x00200000u;
4906 }
_internal_remote_app_id()4907 inline uint32_t CastLogsProto_CastEventProto::_internal_remote_app_id() const {
4908   return _impl_.remote_app_id_;
4909 }
remote_app_id()4910 inline uint32_t CastLogsProto_CastEventProto::remote_app_id() const {
4911   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.remote_app_id)
4912   return _internal_remote_app_id();
4913 }
_internal_set_remote_app_id(uint32_t value)4914 inline void CastLogsProto_CastEventProto::_internal_set_remote_app_id(uint32_t value) {
4915   _impl_._has_bits_[0] |= 0x00200000u;
4916   _impl_.remote_app_id_ = value;
4917 }
set_remote_app_id(uint32_t value)4918 inline void CastLogsProto_CastEventProto::set_remote_app_id(uint32_t value) {
4919   _internal_set_remote_app_id(value);
4920   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.remote_app_id)
4921 }
4922 
4923 // optional fixed64 application_session_id = 4;
_internal_has_application_session_id()4924 inline bool CastLogsProto_CastEventProto::_internal_has_application_session_id() const {
4925   bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
4926   return value;
4927 }
has_application_session_id()4928 inline bool CastLogsProto_CastEventProto::has_application_session_id() const {
4929   return _internal_has_application_session_id();
4930 }
clear_application_session_id()4931 inline void CastLogsProto_CastEventProto::clear_application_session_id() {
4932   _impl_.application_session_id_ = uint64_t{0u};
4933   _impl_._has_bits_[0] &= ~0x00000800u;
4934 }
_internal_application_session_id()4935 inline uint64_t CastLogsProto_CastEventProto::_internal_application_session_id() const {
4936   return _impl_.application_session_id_;
4937 }
application_session_id()4938 inline uint64_t CastLogsProto_CastEventProto::application_session_id() const {
4939   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.application_session_id)
4940   return _internal_application_session_id();
4941 }
_internal_set_application_session_id(uint64_t value)4942 inline void CastLogsProto_CastEventProto::_internal_set_application_session_id(uint64_t value) {
4943   _impl_._has_bits_[0] |= 0x00000800u;
4944   _impl_.application_session_id_ = value;
4945 }
set_application_session_id(uint64_t value)4946 inline void CastLogsProto_CastEventProto::set_application_session_id(uint64_t value) {
4947   _internal_set_application_session_id(value);
4948   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.application_session_id)
4949 }
4950 
4951 // optional fixed64 cast_receiver_version = 5;
_internal_has_cast_receiver_version()4952 inline bool CastLogsProto_CastEventProto::_internal_has_cast_receiver_version() const {
4953   bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
4954   return value;
4955 }
has_cast_receiver_version()4956 inline bool CastLogsProto_CastEventProto::has_cast_receiver_version() const {
4957   return _internal_has_cast_receiver_version();
4958 }
clear_cast_receiver_version()4959 inline void CastLogsProto_CastEventProto::clear_cast_receiver_version() {
4960   _impl_.cast_receiver_version_ = uint64_t{0u};
4961   _impl_._has_bits_[0] &= ~0x00004000u;
4962 }
_internal_cast_receiver_version()4963 inline uint64_t CastLogsProto_CastEventProto::_internal_cast_receiver_version() const {
4964   return _impl_.cast_receiver_version_;
4965 }
cast_receiver_version()4966 inline uint64_t CastLogsProto_CastEventProto::cast_receiver_version() const {
4967   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.cast_receiver_version)
4968   return _internal_cast_receiver_version();
4969 }
_internal_set_cast_receiver_version(uint64_t value)4970 inline void CastLogsProto_CastEventProto::_internal_set_cast_receiver_version(uint64_t value) {
4971   _impl_._has_bits_[0] |= 0x00004000u;
4972   _impl_.cast_receiver_version_ = value;
4973 }
set_cast_receiver_version(uint64_t value)4974 inline void CastLogsProto_CastEventProto::set_cast_receiver_version(uint64_t value) {
4975   _internal_set_cast_receiver_version(value);
4976   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.cast_receiver_version)
4977 }
4978 
4979 // optional fixed64 cast_mpl_version = 9;
_internal_has_cast_mpl_version()4980 inline bool CastLogsProto_CastEventProto::_internal_has_cast_mpl_version() const {
4981   bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
4982   return value;
4983 }
has_cast_mpl_version()4984 inline bool CastLogsProto_CastEventProto::has_cast_mpl_version() const {
4985   return _internal_has_cast_mpl_version();
4986 }
clear_cast_mpl_version()4987 inline void CastLogsProto_CastEventProto::clear_cast_mpl_version() {
4988   _impl_.cast_mpl_version_ = uint64_t{0u};
4989   _impl_._has_bits_[0] &= ~0x00010000u;
4990 }
_internal_cast_mpl_version()4991 inline uint64_t CastLogsProto_CastEventProto::_internal_cast_mpl_version() const {
4992   return _impl_.cast_mpl_version_;
4993 }
cast_mpl_version()4994 inline uint64_t CastLogsProto_CastEventProto::cast_mpl_version() const {
4995   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.cast_mpl_version)
4996   return _internal_cast_mpl_version();
4997 }
_internal_set_cast_mpl_version(uint64_t value)4998 inline void CastLogsProto_CastEventProto::_internal_set_cast_mpl_version(uint64_t value) {
4999   _impl_._has_bits_[0] |= 0x00010000u;
5000   _impl_.cast_mpl_version_ = value;
5001 }
set_cast_mpl_version(uint64_t value)5002 inline void CastLogsProto_CastEventProto::set_cast_mpl_version(uint64_t value) {
5003   _internal_set_cast_mpl_version(value);
5004   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.cast_mpl_version)
5005 }
5006 
5007 // optional fixed32 transport_connection_id = 6;
_internal_has_transport_connection_id()5008 inline bool CastLogsProto_CastEventProto::_internal_has_transport_connection_id() const {
5009   bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
5010   return value;
5011 }
has_transport_connection_id()5012 inline bool CastLogsProto_CastEventProto::has_transport_connection_id() const {
5013   return _internal_has_transport_connection_id();
5014 }
clear_transport_connection_id()5015 inline void CastLogsProto_CastEventProto::clear_transport_connection_id() {
5016   _impl_.transport_connection_id_ = 0u;
5017   _impl_._has_bits_[0] &= ~0x00002000u;
5018 }
_internal_transport_connection_id()5019 inline uint32_t CastLogsProto_CastEventProto::_internal_transport_connection_id() const {
5020   return _impl_.transport_connection_id_;
5021 }
transport_connection_id()5022 inline uint32_t CastLogsProto_CastEventProto::transport_connection_id() const {
5023   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.transport_connection_id)
5024   return _internal_transport_connection_id();
5025 }
_internal_set_transport_connection_id(uint32_t value)5026 inline void CastLogsProto_CastEventProto::_internal_set_transport_connection_id(uint32_t value) {
5027   _impl_._has_bits_[0] |= 0x00002000u;
5028   _impl_.transport_connection_id_ = value;
5029 }
set_transport_connection_id(uint32_t value)5030 inline void CastLogsProto_CastEventProto::set_transport_connection_id(uint32_t value) {
5031   _internal_set_transport_connection_id(value);
5032   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.transport_connection_id)
5033 }
5034 
5035 // optional fixed32 virtual_connection_id = 7;
_internal_has_virtual_connection_id()5036 inline bool CastLogsProto_CastEventProto::_internal_has_virtual_connection_id() const {
5037   bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
5038   return value;
5039 }
has_virtual_connection_id()5040 inline bool CastLogsProto_CastEventProto::has_virtual_connection_id() const {
5041   return _internal_has_virtual_connection_id();
5042 }
clear_virtual_connection_id()5043 inline void CastLogsProto_CastEventProto::clear_virtual_connection_id() {
5044   _impl_.virtual_connection_id_ = 0u;
5045   _impl_._has_bits_[0] &= ~0x00020000u;
5046 }
_internal_virtual_connection_id()5047 inline uint32_t CastLogsProto_CastEventProto::_internal_virtual_connection_id() const {
5048   return _impl_.virtual_connection_id_;
5049 }
virtual_connection_id()5050 inline uint32_t CastLogsProto_CastEventProto::virtual_connection_id() const {
5051   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.virtual_connection_id)
5052   return _internal_virtual_connection_id();
5053 }
_internal_set_virtual_connection_id(uint32_t value)5054 inline void CastLogsProto_CastEventProto::_internal_set_virtual_connection_id(uint32_t value) {
5055   _impl_._has_bits_[0] |= 0x00020000u;
5056   _impl_.virtual_connection_id_ = value;
5057 }
set_virtual_connection_id(uint32_t value)5058 inline void CastLogsProto_CastEventProto::set_virtual_connection_id(uint32_t value) {
5059   _internal_set_virtual_connection_id(value);
5060   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.virtual_connection_id)
5061 }
5062 
5063 // optional int64 value = 8;
_internal_has_value()5064 inline bool CastLogsProto_CastEventProto::_internal_has_value() const {
5065   bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
5066   return value;
5067 }
has_value()5068 inline bool CastLogsProto_CastEventProto::has_value() const {
5069   return _internal_has_value();
5070 }
clear_value()5071 inline void CastLogsProto_CastEventProto::clear_value() {
5072   _impl_.value_ = int64_t{0};
5073   _impl_._has_bits_[0] &= ~0x00008000u;
5074 }
_internal_value()5075 inline int64_t CastLogsProto_CastEventProto::_internal_value() const {
5076   return _impl_.value_;
5077 }
value()5078 inline int64_t CastLogsProto_CastEventProto::value() const {
5079   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.value)
5080   return _internal_value();
5081 }
_internal_set_value(int64_t value)5082 inline void CastLogsProto_CastEventProto::_internal_set_value(int64_t value) {
5083   _impl_._has_bits_[0] |= 0x00008000u;
5084   _impl_.value_ = value;
5085 }
set_value(int64_t value)5086 inline void CastLogsProto_CastEventProto::set_value(int64_t value) {
5087   _internal_set_value(value);
5088   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.value)
5089 }
5090 
5091 // optional fixed64 group_uuid = 10;
_internal_has_group_uuid()5092 inline bool CastLogsProto_CastEventProto::_internal_has_group_uuid() const {
5093   bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
5094   return value;
5095 }
has_group_uuid()5096 inline bool CastLogsProto_CastEventProto::has_group_uuid() const {
5097   return _internal_has_group_uuid();
5098 }
clear_group_uuid()5099 inline void CastLogsProto_CastEventProto::clear_group_uuid() {
5100   _impl_.group_uuid_ = uint64_t{0u};
5101   _impl_._has_bits_[0] &= ~0x00080000u;
5102 }
_internal_group_uuid()5103 inline uint64_t CastLogsProto_CastEventProto::_internal_group_uuid() const {
5104   return _impl_.group_uuid_;
5105 }
group_uuid()5106 inline uint64_t CastLogsProto_CastEventProto::group_uuid() const {
5107   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.group_uuid)
5108   return _internal_group_uuid();
5109 }
_internal_set_group_uuid(uint64_t value)5110 inline void CastLogsProto_CastEventProto::_internal_set_group_uuid(uint64_t value) {
5111   _impl_._has_bits_[0] |= 0x00080000u;
5112   _impl_.group_uuid_ = value;
5113 }
set_group_uuid(uint64_t value)5114 inline void CastLogsProto_CastEventProto::set_group_uuid(uint64_t value) {
5115   _internal_set_group_uuid(value);
5116   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.group_uuid)
5117 }
5118 
5119 // optional string conversation_key = 11;
_internal_has_conversation_key()5120 inline bool CastLogsProto_CastEventProto::_internal_has_conversation_key() const {
5121   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5122   return value;
5123 }
has_conversation_key()5124 inline bool CastLogsProto_CastEventProto::has_conversation_key() const {
5125   return _internal_has_conversation_key();
5126 }
clear_conversation_key()5127 inline void CastLogsProto_CastEventProto::clear_conversation_key() {
5128   _impl_.conversation_key_.ClearToEmpty();
5129   _impl_._has_bits_[0] &= ~0x00000001u;
5130 }
conversation_key()5131 inline const std::string& CastLogsProto_CastEventProto::conversation_key() const {
5132   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.conversation_key)
5133   return _internal_conversation_key();
5134 }
5135 template <typename ArgT0, typename... ArgT>
5136 inline PROTOBUF_ALWAYS_INLINE
set_conversation_key(ArgT0 && arg0,ArgT...args)5137 void CastLogsProto_CastEventProto::set_conversation_key(ArgT0&& arg0, ArgT... args) {
5138  _impl_._has_bits_[0] |= 0x00000001u;
5139  _impl_.conversation_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5140   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.conversation_key)
5141 }
mutable_conversation_key()5142 inline std::string* CastLogsProto_CastEventProto::mutable_conversation_key() {
5143   std::string* _s = _internal_mutable_conversation_key();
5144   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.conversation_key)
5145   return _s;
5146 }
_internal_conversation_key()5147 inline const std::string& CastLogsProto_CastEventProto::_internal_conversation_key() const {
5148   return _impl_.conversation_key_.Get();
5149 }
_internal_set_conversation_key(const std::string & value)5150 inline void CastLogsProto_CastEventProto::_internal_set_conversation_key(const std::string& value) {
5151   _impl_._has_bits_[0] |= 0x00000001u;
5152   _impl_.conversation_key_.Set(value, GetArenaForAllocation());
5153 }
_internal_mutable_conversation_key()5154 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_conversation_key() {
5155   _impl_._has_bits_[0] |= 0x00000001u;
5156   return _impl_.conversation_key_.Mutable(GetArenaForAllocation());
5157 }
release_conversation_key()5158 inline std::string* CastLogsProto_CastEventProto::release_conversation_key() {
5159   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.conversation_key)
5160   if (!_internal_has_conversation_key()) {
5161     return nullptr;
5162   }
5163   _impl_._has_bits_[0] &= ~0x00000001u;
5164   auto* p = _impl_.conversation_key_.Release();
5165 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5166   if (_impl_.conversation_key_.IsDefault()) {
5167     _impl_.conversation_key_.Set("", GetArenaForAllocation());
5168   }
5169 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5170   return p;
5171 }
set_allocated_conversation_key(std::string * conversation_key)5172 inline void CastLogsProto_CastEventProto::set_allocated_conversation_key(std::string* conversation_key) {
5173   if (conversation_key != nullptr) {
5174     _impl_._has_bits_[0] |= 0x00000001u;
5175   } else {
5176     _impl_._has_bits_[0] &= ~0x00000001u;
5177   }
5178   _impl_.conversation_key_.SetAllocated(conversation_key, GetArenaForAllocation());
5179 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5180   if (_impl_.conversation_key_.IsDefault()) {
5181     _impl_.conversation_key_.Set("", GetArenaForAllocation());
5182   }
5183 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5184   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.conversation_key)
5185 }
5186 
5187 // optional fixed32 request_id = 12;
_internal_has_request_id()5188 inline bool CastLogsProto_CastEventProto::_internal_has_request_id() const {
5189   bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
5190   return value;
5191 }
has_request_id()5192 inline bool CastLogsProto_CastEventProto::has_request_id() const {
5193   return _internal_has_request_id();
5194 }
clear_request_id()5195 inline void CastLogsProto_CastEventProto::clear_request_id() {
5196   _impl_.request_id_ = 0u;
5197   _impl_._has_bits_[0] &= ~0x00040000u;
5198 }
_internal_request_id()5199 inline uint32_t CastLogsProto_CastEventProto::_internal_request_id() const {
5200   return _impl_.request_id_;
5201 }
request_id()5202 inline uint32_t CastLogsProto_CastEventProto::request_id() const {
5203   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.request_id)
5204   return _internal_request_id();
5205 }
_internal_set_request_id(uint32_t value)5206 inline void CastLogsProto_CastEventProto::_internal_set_request_id(uint32_t value) {
5207   _impl_._has_bits_[0] |= 0x00040000u;
5208   _impl_.request_id_ = value;
5209 }
set_request_id(uint32_t value)5210 inline void CastLogsProto_CastEventProto::set_request_id(uint32_t value) {
5211   _internal_set_request_id(value);
5212   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.request_id)
5213 }
5214 
5215 // optional string event_id = 13;
_internal_has_event_id()5216 inline bool CastLogsProto_CastEventProto::_internal_has_event_id() const {
5217   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5218   return value;
5219 }
has_event_id()5220 inline bool CastLogsProto_CastEventProto::has_event_id() const {
5221   return _internal_has_event_id();
5222 }
clear_event_id()5223 inline void CastLogsProto_CastEventProto::clear_event_id() {
5224   _impl_.event_id_.ClearToEmpty();
5225   _impl_._has_bits_[0] &= ~0x00000002u;
5226 }
event_id()5227 inline const std::string& CastLogsProto_CastEventProto::event_id() const {
5228   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.event_id)
5229   return _internal_event_id();
5230 }
5231 template <typename ArgT0, typename... ArgT>
5232 inline PROTOBUF_ALWAYS_INLINE
set_event_id(ArgT0 && arg0,ArgT...args)5233 void CastLogsProto_CastEventProto::set_event_id(ArgT0&& arg0, ArgT... args) {
5234  _impl_._has_bits_[0] |= 0x00000002u;
5235  _impl_.event_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5236   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.event_id)
5237 }
mutable_event_id()5238 inline std::string* CastLogsProto_CastEventProto::mutable_event_id() {
5239   std::string* _s = _internal_mutable_event_id();
5240   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.event_id)
5241   return _s;
5242 }
_internal_event_id()5243 inline const std::string& CastLogsProto_CastEventProto::_internal_event_id() const {
5244   return _impl_.event_id_.Get();
5245 }
_internal_set_event_id(const std::string & value)5246 inline void CastLogsProto_CastEventProto::_internal_set_event_id(const std::string& value) {
5247   _impl_._has_bits_[0] |= 0x00000002u;
5248   _impl_.event_id_.Set(value, GetArenaForAllocation());
5249 }
_internal_mutable_event_id()5250 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_event_id() {
5251   _impl_._has_bits_[0] |= 0x00000002u;
5252   return _impl_.event_id_.Mutable(GetArenaForAllocation());
5253 }
release_event_id()5254 inline std::string* CastLogsProto_CastEventProto::release_event_id() {
5255   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.event_id)
5256   if (!_internal_has_event_id()) {
5257     return nullptr;
5258   }
5259   _impl_._has_bits_[0] &= ~0x00000002u;
5260   auto* p = _impl_.event_id_.Release();
5261 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5262   if (_impl_.event_id_.IsDefault()) {
5263     _impl_.event_id_.Set("", GetArenaForAllocation());
5264   }
5265 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5266   return p;
5267 }
set_allocated_event_id(std::string * event_id)5268 inline void CastLogsProto_CastEventProto::set_allocated_event_id(std::string* event_id) {
5269   if (event_id != nullptr) {
5270     _impl_._has_bits_[0] |= 0x00000002u;
5271   } else {
5272     _impl_._has_bits_[0] &= ~0x00000002u;
5273   }
5274   _impl_.event_id_.SetAllocated(event_id, GetArenaForAllocation());
5275 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5276   if (_impl_.event_id_.IsDefault()) {
5277     _impl_.event_id_.Set("", GetArenaForAllocation());
5278   }
5279 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5280   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.event_id)
5281 }
5282 
5283 // optional string aogh_request_id = 16;
_internal_has_aogh_request_id()5284 inline bool CastLogsProto_CastEventProto::_internal_has_aogh_request_id() const {
5285   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5286   return value;
5287 }
has_aogh_request_id()5288 inline bool CastLogsProto_CastEventProto::has_aogh_request_id() const {
5289   return _internal_has_aogh_request_id();
5290 }
clear_aogh_request_id()5291 inline void CastLogsProto_CastEventProto::clear_aogh_request_id() {
5292   _impl_.aogh_request_id_.ClearToEmpty();
5293   _impl_._has_bits_[0] &= ~0x00000004u;
5294 }
aogh_request_id()5295 inline const std::string& CastLogsProto_CastEventProto::aogh_request_id() const {
5296   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.aogh_request_id)
5297   return _internal_aogh_request_id();
5298 }
5299 template <typename ArgT0, typename... ArgT>
5300 inline PROTOBUF_ALWAYS_INLINE
set_aogh_request_id(ArgT0 && arg0,ArgT...args)5301 void CastLogsProto_CastEventProto::set_aogh_request_id(ArgT0&& arg0, ArgT... args) {
5302  _impl_._has_bits_[0] |= 0x00000004u;
5303  _impl_.aogh_request_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5304   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.aogh_request_id)
5305 }
mutable_aogh_request_id()5306 inline std::string* CastLogsProto_CastEventProto::mutable_aogh_request_id() {
5307   std::string* _s = _internal_mutable_aogh_request_id();
5308   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.aogh_request_id)
5309   return _s;
5310 }
_internal_aogh_request_id()5311 inline const std::string& CastLogsProto_CastEventProto::_internal_aogh_request_id() const {
5312   return _impl_.aogh_request_id_.Get();
5313 }
_internal_set_aogh_request_id(const std::string & value)5314 inline void CastLogsProto_CastEventProto::_internal_set_aogh_request_id(const std::string& value) {
5315   _impl_._has_bits_[0] |= 0x00000004u;
5316   _impl_.aogh_request_id_.Set(value, GetArenaForAllocation());
5317 }
_internal_mutable_aogh_request_id()5318 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_aogh_request_id() {
5319   _impl_._has_bits_[0] |= 0x00000004u;
5320   return _impl_.aogh_request_id_.Mutable(GetArenaForAllocation());
5321 }
release_aogh_request_id()5322 inline std::string* CastLogsProto_CastEventProto::release_aogh_request_id() {
5323   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.aogh_request_id)
5324   if (!_internal_has_aogh_request_id()) {
5325     return nullptr;
5326   }
5327   _impl_._has_bits_[0] &= ~0x00000004u;
5328   auto* p = _impl_.aogh_request_id_.Release();
5329 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5330   if (_impl_.aogh_request_id_.IsDefault()) {
5331     _impl_.aogh_request_id_.Set("", GetArenaForAllocation());
5332   }
5333 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5334   return p;
5335 }
set_allocated_aogh_request_id(std::string * aogh_request_id)5336 inline void CastLogsProto_CastEventProto::set_allocated_aogh_request_id(std::string* aogh_request_id) {
5337   if (aogh_request_id != nullptr) {
5338     _impl_._has_bits_[0] |= 0x00000004u;
5339   } else {
5340     _impl_._has_bits_[0] &= ~0x00000004u;
5341   }
5342   _impl_.aogh_request_id_.SetAllocated(aogh_request_id, GetArenaForAllocation());
5343 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5344   if (_impl_.aogh_request_id_.IsDefault()) {
5345     _impl_.aogh_request_id_.Set("", GetArenaForAllocation());
5346   }
5347 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5348   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.aogh_request_id)
5349 }
5350 
5351 // optional int64 aogh_local_device_id = 18;
_internal_has_aogh_local_device_id()5352 inline bool CastLogsProto_CastEventProto::_internal_has_aogh_local_device_id() const {
5353   bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
5354   return value;
5355 }
has_aogh_local_device_id()5356 inline bool CastLogsProto_CastEventProto::has_aogh_local_device_id() const {
5357   return _internal_has_aogh_local_device_id();
5358 }
clear_aogh_local_device_id()5359 inline void CastLogsProto_CastEventProto::clear_aogh_local_device_id() {
5360   _impl_.aogh_local_device_id_ = int64_t{0};
5361   _impl_._has_bits_[0] &= ~0x00100000u;
5362 }
_internal_aogh_local_device_id()5363 inline int64_t CastLogsProto_CastEventProto::_internal_aogh_local_device_id() const {
5364   return _impl_.aogh_local_device_id_;
5365 }
aogh_local_device_id()5366 inline int64_t CastLogsProto_CastEventProto::aogh_local_device_id() const {
5367   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.aogh_local_device_id)
5368   return _internal_aogh_local_device_id();
5369 }
_internal_set_aogh_local_device_id(int64_t value)5370 inline void CastLogsProto_CastEventProto::_internal_set_aogh_local_device_id(int64_t value) {
5371   _impl_._has_bits_[0] |= 0x00100000u;
5372   _impl_.aogh_local_device_id_ = value;
5373 }
set_aogh_local_device_id(int64_t value)5374 inline void CastLogsProto_CastEventProto::set_aogh_local_device_id(int64_t value) {
5375   _internal_set_aogh_local_device_id(value);
5376   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.aogh_local_device_id)
5377 }
5378 
5379 // optional string aogh_agent_id = 21;
_internal_has_aogh_agent_id()5380 inline bool CastLogsProto_CastEventProto::_internal_has_aogh_agent_id() const {
5381   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
5382   return value;
5383 }
has_aogh_agent_id()5384 inline bool CastLogsProto_CastEventProto::has_aogh_agent_id() const {
5385   return _internal_has_aogh_agent_id();
5386 }
clear_aogh_agent_id()5387 inline void CastLogsProto_CastEventProto::clear_aogh_agent_id() {
5388   _impl_.aogh_agent_id_.ClearToEmpty();
5389   _impl_._has_bits_[0] &= ~0x00000020u;
5390 }
aogh_agent_id()5391 inline const std::string& CastLogsProto_CastEventProto::aogh_agent_id() const {
5392   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.aogh_agent_id)
5393   return _internal_aogh_agent_id();
5394 }
5395 template <typename ArgT0, typename... ArgT>
5396 inline PROTOBUF_ALWAYS_INLINE
set_aogh_agent_id(ArgT0 && arg0,ArgT...args)5397 void CastLogsProto_CastEventProto::set_aogh_agent_id(ArgT0&& arg0, ArgT... args) {
5398  _impl_._has_bits_[0] |= 0x00000020u;
5399  _impl_.aogh_agent_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5400   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.aogh_agent_id)
5401 }
mutable_aogh_agent_id()5402 inline std::string* CastLogsProto_CastEventProto::mutable_aogh_agent_id() {
5403   std::string* _s = _internal_mutable_aogh_agent_id();
5404   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.aogh_agent_id)
5405   return _s;
5406 }
_internal_aogh_agent_id()5407 inline const std::string& CastLogsProto_CastEventProto::_internal_aogh_agent_id() const {
5408   return _impl_.aogh_agent_id_.Get();
5409 }
_internal_set_aogh_agent_id(const std::string & value)5410 inline void CastLogsProto_CastEventProto::_internal_set_aogh_agent_id(const std::string& value) {
5411   _impl_._has_bits_[0] |= 0x00000020u;
5412   _impl_.aogh_agent_id_.Set(value, GetArenaForAllocation());
5413 }
_internal_mutable_aogh_agent_id()5414 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_aogh_agent_id() {
5415   _impl_._has_bits_[0] |= 0x00000020u;
5416   return _impl_.aogh_agent_id_.Mutable(GetArenaForAllocation());
5417 }
release_aogh_agent_id()5418 inline std::string* CastLogsProto_CastEventProto::release_aogh_agent_id() {
5419   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.aogh_agent_id)
5420   if (!_internal_has_aogh_agent_id()) {
5421     return nullptr;
5422   }
5423   _impl_._has_bits_[0] &= ~0x00000020u;
5424   auto* p = _impl_.aogh_agent_id_.Release();
5425 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5426   if (_impl_.aogh_agent_id_.IsDefault()) {
5427     _impl_.aogh_agent_id_.Set("", GetArenaForAllocation());
5428   }
5429 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5430   return p;
5431 }
set_allocated_aogh_agent_id(std::string * aogh_agent_id)5432 inline void CastLogsProto_CastEventProto::set_allocated_aogh_agent_id(std::string* aogh_agent_id) {
5433   if (aogh_agent_id != nullptr) {
5434     _impl_._has_bits_[0] |= 0x00000020u;
5435   } else {
5436     _impl_._has_bits_[0] &= ~0x00000020u;
5437   }
5438   _impl_.aogh_agent_id_.SetAllocated(aogh_agent_id, GetArenaForAllocation());
5439 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5440   if (_impl_.aogh_agent_id_.IsDefault()) {
5441     _impl_.aogh_agent_id_.Set("", GetArenaForAllocation());
5442   }
5443 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5444   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.aogh_agent_id)
5445 }
5446 
5447 // optional string aogh_standard_agent_id = 28;
_internal_has_aogh_standard_agent_id()5448 inline bool CastLogsProto_CastEventProto::_internal_has_aogh_standard_agent_id() const {
5449   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
5450   return value;
5451 }
has_aogh_standard_agent_id()5452 inline bool CastLogsProto_CastEventProto::has_aogh_standard_agent_id() const {
5453   return _internal_has_aogh_standard_agent_id();
5454 }
clear_aogh_standard_agent_id()5455 inline void CastLogsProto_CastEventProto::clear_aogh_standard_agent_id() {
5456   _impl_.aogh_standard_agent_id_.ClearToEmpty();
5457   _impl_._has_bits_[0] &= ~0x00000100u;
5458 }
aogh_standard_agent_id()5459 inline const std::string& CastLogsProto_CastEventProto::aogh_standard_agent_id() const {
5460   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.aogh_standard_agent_id)
5461   return _internal_aogh_standard_agent_id();
5462 }
5463 template <typename ArgT0, typename... ArgT>
5464 inline PROTOBUF_ALWAYS_INLINE
set_aogh_standard_agent_id(ArgT0 && arg0,ArgT...args)5465 void CastLogsProto_CastEventProto::set_aogh_standard_agent_id(ArgT0&& arg0, ArgT... args) {
5466  _impl_._has_bits_[0] |= 0x00000100u;
5467  _impl_.aogh_standard_agent_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5468   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.aogh_standard_agent_id)
5469 }
mutable_aogh_standard_agent_id()5470 inline std::string* CastLogsProto_CastEventProto::mutable_aogh_standard_agent_id() {
5471   std::string* _s = _internal_mutable_aogh_standard_agent_id();
5472   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.aogh_standard_agent_id)
5473   return _s;
5474 }
_internal_aogh_standard_agent_id()5475 inline const std::string& CastLogsProto_CastEventProto::_internal_aogh_standard_agent_id() const {
5476   return _impl_.aogh_standard_agent_id_.Get();
5477 }
_internal_set_aogh_standard_agent_id(const std::string & value)5478 inline void CastLogsProto_CastEventProto::_internal_set_aogh_standard_agent_id(const std::string& value) {
5479   _impl_._has_bits_[0] |= 0x00000100u;
5480   _impl_.aogh_standard_agent_id_.Set(value, GetArenaForAllocation());
5481 }
_internal_mutable_aogh_standard_agent_id()5482 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_aogh_standard_agent_id() {
5483   _impl_._has_bits_[0] |= 0x00000100u;
5484   return _impl_.aogh_standard_agent_id_.Mutable(GetArenaForAllocation());
5485 }
release_aogh_standard_agent_id()5486 inline std::string* CastLogsProto_CastEventProto::release_aogh_standard_agent_id() {
5487   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.aogh_standard_agent_id)
5488   if (!_internal_has_aogh_standard_agent_id()) {
5489     return nullptr;
5490   }
5491   _impl_._has_bits_[0] &= ~0x00000100u;
5492   auto* p = _impl_.aogh_standard_agent_id_.Release();
5493 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5494   if (_impl_.aogh_standard_agent_id_.IsDefault()) {
5495     _impl_.aogh_standard_agent_id_.Set("", GetArenaForAllocation());
5496   }
5497 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5498   return p;
5499 }
set_allocated_aogh_standard_agent_id(std::string * aogh_standard_agent_id)5500 inline void CastLogsProto_CastEventProto::set_allocated_aogh_standard_agent_id(std::string* aogh_standard_agent_id) {
5501   if (aogh_standard_agent_id != nullptr) {
5502     _impl_._has_bits_[0] |= 0x00000100u;
5503   } else {
5504     _impl_._has_bits_[0] &= ~0x00000100u;
5505   }
5506   _impl_.aogh_standard_agent_id_.SetAllocated(aogh_standard_agent_id, GetArenaForAllocation());
5507 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5508   if (_impl_.aogh_standard_agent_id_.IsDefault()) {
5509     _impl_.aogh_standard_agent_id_.Set("", GetArenaForAllocation());
5510   }
5511 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5512   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.aogh_standard_agent_id)
5513 }
5514 
5515 // repeated .metrics.CastLogsProto.CastEventProto.Metadata metadata = 14;
_internal_metadata_size()5516 inline int CastLogsProto_CastEventProto::_internal_metadata_size() const {
5517   return _impl_.metadata_.size();
5518 }
metadata_size()5519 inline int CastLogsProto_CastEventProto::metadata_size() const {
5520   return _internal_metadata_size();
5521 }
clear_metadata()5522 inline void CastLogsProto_CastEventProto::clear_metadata() {
5523   _impl_.metadata_.Clear();
5524 }
mutable_metadata(int index)5525 inline ::metrics::CastLogsProto_CastEventProto_Metadata* CastLogsProto_CastEventProto::mutable_metadata(int index) {
5526   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.metadata)
5527   return _impl_.metadata_.Mutable(index);
5528 }
5529 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto_Metadata >*
mutable_metadata()5530 CastLogsProto_CastEventProto::mutable_metadata() {
5531   // @@protoc_insertion_point(field_mutable_list:metrics.CastLogsProto.CastEventProto.metadata)
5532   return &_impl_.metadata_;
5533 }
_internal_metadata(int index)5534 inline const ::metrics::CastLogsProto_CastEventProto_Metadata& CastLogsProto_CastEventProto::_internal_metadata(int index) const {
5535   return _impl_.metadata_.Get(index);
5536 }
metadata(int index)5537 inline const ::metrics::CastLogsProto_CastEventProto_Metadata& CastLogsProto_CastEventProto::metadata(int index) const {
5538   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.metadata)
5539   return _internal_metadata(index);
5540 }
_internal_add_metadata()5541 inline ::metrics::CastLogsProto_CastEventProto_Metadata* CastLogsProto_CastEventProto::_internal_add_metadata() {
5542   return _impl_.metadata_.Add();
5543 }
add_metadata()5544 inline ::metrics::CastLogsProto_CastEventProto_Metadata* CastLogsProto_CastEventProto::add_metadata() {
5545   ::metrics::CastLogsProto_CastEventProto_Metadata* _add = _internal_add_metadata();
5546   // @@protoc_insertion_point(field_add:metrics.CastLogsProto.CastEventProto.metadata)
5547   return _add;
5548 }
5549 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto_Metadata >&
metadata()5550 CastLogsProto_CastEventProto::metadata() const {
5551   // @@protoc_insertion_point(field_list:metrics.CastLogsProto.CastEventProto.metadata)
5552   return _impl_.metadata_;
5553 }
5554 
5555 // repeated float feature_vector = 15;
_internal_feature_vector_size()5556 inline int CastLogsProto_CastEventProto::_internal_feature_vector_size() const {
5557   return _impl_.feature_vector_.size();
5558 }
feature_vector_size()5559 inline int CastLogsProto_CastEventProto::feature_vector_size() const {
5560   return _internal_feature_vector_size();
5561 }
clear_feature_vector()5562 inline void CastLogsProto_CastEventProto::clear_feature_vector() {
5563   _impl_.feature_vector_.Clear();
5564 }
_internal_feature_vector(int index)5565 inline float CastLogsProto_CastEventProto::_internal_feature_vector(int index) const {
5566   return _impl_.feature_vector_.Get(index);
5567 }
feature_vector(int index)5568 inline float CastLogsProto_CastEventProto::feature_vector(int index) const {
5569   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.feature_vector)
5570   return _internal_feature_vector(index);
5571 }
set_feature_vector(int index,float value)5572 inline void CastLogsProto_CastEventProto::set_feature_vector(int index, float value) {
5573   _impl_.feature_vector_.Set(index, value);
5574   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.feature_vector)
5575 }
_internal_add_feature_vector(float value)5576 inline void CastLogsProto_CastEventProto::_internal_add_feature_vector(float value) {
5577   _impl_.feature_vector_.Add(value);
5578 }
add_feature_vector(float value)5579 inline void CastLogsProto_CastEventProto::add_feature_vector(float value) {
5580   _internal_add_feature_vector(value);
5581   // @@protoc_insertion_point(field_add:metrics.CastLogsProto.CastEventProto.feature_vector)
5582 }
5583 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_feature_vector()5584 CastLogsProto_CastEventProto::_internal_feature_vector() const {
5585   return _impl_.feature_vector_;
5586 }
5587 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
feature_vector()5588 CastLogsProto_CastEventProto::feature_vector() const {
5589   // @@protoc_insertion_point(field_list:metrics.CastLogsProto.CastEventProto.feature_vector)
5590   return _internal_feature_vector();
5591 }
5592 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_feature_vector()5593 CastLogsProto_CastEventProto::_internal_mutable_feature_vector() {
5594   return &_impl_.feature_vector_;
5595 }
5596 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_feature_vector()5597 CastLogsProto_CastEventProto::mutable_feature_vector() {
5598   // @@protoc_insertion_point(field_mutable_list:metrics.CastLogsProto.CastEventProto.feature_vector)
5599   return _internal_mutable_feature_vector();
5600 }
5601 
5602 // optional string timezone_id = 17;
_internal_has_timezone_id()5603 inline bool CastLogsProto_CastEventProto::_internal_has_timezone_id() const {
5604   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
5605   return value;
5606 }
has_timezone_id()5607 inline bool CastLogsProto_CastEventProto::has_timezone_id() const {
5608   return _internal_has_timezone_id();
5609 }
clear_timezone_id()5610 inline void CastLogsProto_CastEventProto::clear_timezone_id() {
5611   _impl_.timezone_id_.ClearToEmpty();
5612   _impl_._has_bits_[0] &= ~0x00000008u;
5613 }
timezone_id()5614 inline const std::string& CastLogsProto_CastEventProto::timezone_id() const {
5615   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.timezone_id)
5616   return _internal_timezone_id();
5617 }
5618 template <typename ArgT0, typename... ArgT>
5619 inline PROTOBUF_ALWAYS_INLINE
set_timezone_id(ArgT0 && arg0,ArgT...args)5620 void CastLogsProto_CastEventProto::set_timezone_id(ArgT0&& arg0, ArgT... args) {
5621  _impl_._has_bits_[0] |= 0x00000008u;
5622  _impl_.timezone_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5623   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.timezone_id)
5624 }
mutable_timezone_id()5625 inline std::string* CastLogsProto_CastEventProto::mutable_timezone_id() {
5626   std::string* _s = _internal_mutable_timezone_id();
5627   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.timezone_id)
5628   return _s;
5629 }
_internal_timezone_id()5630 inline const std::string& CastLogsProto_CastEventProto::_internal_timezone_id() const {
5631   return _impl_.timezone_id_.Get();
5632 }
_internal_set_timezone_id(const std::string & value)5633 inline void CastLogsProto_CastEventProto::_internal_set_timezone_id(const std::string& value) {
5634   _impl_._has_bits_[0] |= 0x00000008u;
5635   _impl_.timezone_id_.Set(value, GetArenaForAllocation());
5636 }
_internal_mutable_timezone_id()5637 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_timezone_id() {
5638   _impl_._has_bits_[0] |= 0x00000008u;
5639   return _impl_.timezone_id_.Mutable(GetArenaForAllocation());
5640 }
release_timezone_id()5641 inline std::string* CastLogsProto_CastEventProto::release_timezone_id() {
5642   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.timezone_id)
5643   if (!_internal_has_timezone_id()) {
5644     return nullptr;
5645   }
5646   _impl_._has_bits_[0] &= ~0x00000008u;
5647   auto* p = _impl_.timezone_id_.Release();
5648 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5649   if (_impl_.timezone_id_.IsDefault()) {
5650     _impl_.timezone_id_.Set("", GetArenaForAllocation());
5651   }
5652 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5653   return p;
5654 }
set_allocated_timezone_id(std::string * timezone_id)5655 inline void CastLogsProto_CastEventProto::set_allocated_timezone_id(std::string* timezone_id) {
5656   if (timezone_id != nullptr) {
5657     _impl_._has_bits_[0] |= 0x00000008u;
5658   } else {
5659     _impl_._has_bits_[0] &= ~0x00000008u;
5660   }
5661   _impl_.timezone_id_.SetAllocated(timezone_id, GetArenaForAllocation());
5662 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5663   if (_impl_.timezone_id_.IsDefault()) {
5664     _impl_.timezone_id_.Set("", GetArenaForAllocation());
5665   }
5666 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5667   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.timezone_id)
5668 }
5669 
5670 // optional string ui_version = 20;
_internal_has_ui_version()5671 inline bool CastLogsProto_CastEventProto::_internal_has_ui_version() const {
5672   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
5673   return value;
5674 }
has_ui_version()5675 inline bool CastLogsProto_CastEventProto::has_ui_version() const {
5676   return _internal_has_ui_version();
5677 }
clear_ui_version()5678 inline void CastLogsProto_CastEventProto::clear_ui_version() {
5679   _impl_.ui_version_.ClearToEmpty();
5680   _impl_._has_bits_[0] &= ~0x00000010u;
5681 }
ui_version()5682 inline const std::string& CastLogsProto_CastEventProto::ui_version() const {
5683   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.ui_version)
5684   return _internal_ui_version();
5685 }
5686 template <typename ArgT0, typename... ArgT>
5687 inline PROTOBUF_ALWAYS_INLINE
set_ui_version(ArgT0 && arg0,ArgT...args)5688 void CastLogsProto_CastEventProto::set_ui_version(ArgT0&& arg0, ArgT... args) {
5689  _impl_._has_bits_[0] |= 0x00000010u;
5690  _impl_.ui_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5691   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.ui_version)
5692 }
mutable_ui_version()5693 inline std::string* CastLogsProto_CastEventProto::mutable_ui_version() {
5694   std::string* _s = _internal_mutable_ui_version();
5695   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.ui_version)
5696   return _s;
5697 }
_internal_ui_version()5698 inline const std::string& CastLogsProto_CastEventProto::_internal_ui_version() const {
5699   return _impl_.ui_version_.Get();
5700 }
_internal_set_ui_version(const std::string & value)5701 inline void CastLogsProto_CastEventProto::_internal_set_ui_version(const std::string& value) {
5702   _impl_._has_bits_[0] |= 0x00000010u;
5703   _impl_.ui_version_.Set(value, GetArenaForAllocation());
5704 }
_internal_mutable_ui_version()5705 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_ui_version() {
5706   _impl_._has_bits_[0] |= 0x00000010u;
5707   return _impl_.ui_version_.Mutable(GetArenaForAllocation());
5708 }
release_ui_version()5709 inline std::string* CastLogsProto_CastEventProto::release_ui_version() {
5710   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.ui_version)
5711   if (!_internal_has_ui_version()) {
5712     return nullptr;
5713   }
5714   _impl_._has_bits_[0] &= ~0x00000010u;
5715   auto* p = _impl_.ui_version_.Release();
5716 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5717   if (_impl_.ui_version_.IsDefault()) {
5718     _impl_.ui_version_.Set("", GetArenaForAllocation());
5719   }
5720 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5721   return p;
5722 }
set_allocated_ui_version(std::string * ui_version)5723 inline void CastLogsProto_CastEventProto::set_allocated_ui_version(std::string* ui_version) {
5724   if (ui_version != nullptr) {
5725     _impl_._has_bits_[0] |= 0x00000010u;
5726   } else {
5727     _impl_._has_bits_[0] &= ~0x00000010u;
5728   }
5729   _impl_.ui_version_.SetAllocated(ui_version, GetArenaForAllocation());
5730 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5731   if (_impl_.ui_version_.IsDefault()) {
5732     _impl_.ui_version_.Set("", GetArenaForAllocation());
5733   }
5734 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5735   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.ui_version)
5736 }
5737 
5738 // optional string selinux_audit_detail = 22;
_internal_has_selinux_audit_detail()5739 inline bool CastLogsProto_CastEventProto::_internal_has_selinux_audit_detail() const {
5740   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
5741   return value;
5742 }
has_selinux_audit_detail()5743 inline bool CastLogsProto_CastEventProto::has_selinux_audit_detail() const {
5744   return _internal_has_selinux_audit_detail();
5745 }
clear_selinux_audit_detail()5746 inline void CastLogsProto_CastEventProto::clear_selinux_audit_detail() {
5747   _impl_.selinux_audit_detail_.ClearToEmpty();
5748   _impl_._has_bits_[0] &= ~0x00000040u;
5749 }
selinux_audit_detail()5750 inline const std::string& CastLogsProto_CastEventProto::selinux_audit_detail() const {
5751   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.selinux_audit_detail)
5752   return _internal_selinux_audit_detail();
5753 }
5754 template <typename ArgT0, typename... ArgT>
5755 inline PROTOBUF_ALWAYS_INLINE
set_selinux_audit_detail(ArgT0 && arg0,ArgT...args)5756 void CastLogsProto_CastEventProto::set_selinux_audit_detail(ArgT0&& arg0, ArgT... args) {
5757  _impl_._has_bits_[0] |= 0x00000040u;
5758  _impl_.selinux_audit_detail_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5759   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.selinux_audit_detail)
5760 }
mutable_selinux_audit_detail()5761 inline std::string* CastLogsProto_CastEventProto::mutable_selinux_audit_detail() {
5762   std::string* _s = _internal_mutable_selinux_audit_detail();
5763   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.selinux_audit_detail)
5764   return _s;
5765 }
_internal_selinux_audit_detail()5766 inline const std::string& CastLogsProto_CastEventProto::_internal_selinux_audit_detail() const {
5767   return _impl_.selinux_audit_detail_.Get();
5768 }
_internal_set_selinux_audit_detail(const std::string & value)5769 inline void CastLogsProto_CastEventProto::_internal_set_selinux_audit_detail(const std::string& value) {
5770   _impl_._has_bits_[0] |= 0x00000040u;
5771   _impl_.selinux_audit_detail_.Set(value, GetArenaForAllocation());
5772 }
_internal_mutable_selinux_audit_detail()5773 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_selinux_audit_detail() {
5774   _impl_._has_bits_[0] |= 0x00000040u;
5775   return _impl_.selinux_audit_detail_.Mutable(GetArenaForAllocation());
5776 }
release_selinux_audit_detail()5777 inline std::string* CastLogsProto_CastEventProto::release_selinux_audit_detail() {
5778   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.selinux_audit_detail)
5779   if (!_internal_has_selinux_audit_detail()) {
5780     return nullptr;
5781   }
5782   _impl_._has_bits_[0] &= ~0x00000040u;
5783   auto* p = _impl_.selinux_audit_detail_.Release();
5784 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5785   if (_impl_.selinux_audit_detail_.IsDefault()) {
5786     _impl_.selinux_audit_detail_.Set("", GetArenaForAllocation());
5787   }
5788 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5789   return p;
5790 }
set_allocated_selinux_audit_detail(std::string * selinux_audit_detail)5791 inline void CastLogsProto_CastEventProto::set_allocated_selinux_audit_detail(std::string* selinux_audit_detail) {
5792   if (selinux_audit_detail != nullptr) {
5793     _impl_._has_bits_[0] |= 0x00000040u;
5794   } else {
5795     _impl_._has_bits_[0] &= ~0x00000040u;
5796   }
5797   _impl_.selinux_audit_detail_.SetAllocated(selinux_audit_detail, GetArenaForAllocation());
5798 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5799   if (_impl_.selinux_audit_detail_.IsDefault()) {
5800     _impl_.selinux_audit_detail_.Set("", GetArenaForAllocation());
5801   }
5802 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5803   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.selinux_audit_detail)
5804 }
5805 
5806 // repeated string event_id_list = 23;
_internal_event_id_list_size()5807 inline int CastLogsProto_CastEventProto::_internal_event_id_list_size() const {
5808   return _impl_.event_id_list_.size();
5809 }
event_id_list_size()5810 inline int CastLogsProto_CastEventProto::event_id_list_size() const {
5811   return _internal_event_id_list_size();
5812 }
clear_event_id_list()5813 inline void CastLogsProto_CastEventProto::clear_event_id_list() {
5814   _impl_.event_id_list_.Clear();
5815 }
add_event_id_list()5816 inline std::string* CastLogsProto_CastEventProto::add_event_id_list() {
5817   std::string* _s = _internal_add_event_id_list();
5818   // @@protoc_insertion_point(field_add_mutable:metrics.CastLogsProto.CastEventProto.event_id_list)
5819   return _s;
5820 }
_internal_event_id_list(int index)5821 inline const std::string& CastLogsProto_CastEventProto::_internal_event_id_list(int index) const {
5822   return _impl_.event_id_list_.Get(index);
5823 }
event_id_list(int index)5824 inline const std::string& CastLogsProto_CastEventProto::event_id_list(int index) const {
5825   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.event_id_list)
5826   return _internal_event_id_list(index);
5827 }
mutable_event_id_list(int index)5828 inline std::string* CastLogsProto_CastEventProto::mutable_event_id_list(int index) {
5829   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.event_id_list)
5830   return _impl_.event_id_list_.Mutable(index);
5831 }
set_event_id_list(int index,const std::string & value)5832 inline void CastLogsProto_CastEventProto::set_event_id_list(int index, const std::string& value) {
5833   _impl_.event_id_list_.Mutable(index)->assign(value);
5834   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.event_id_list)
5835 }
set_event_id_list(int index,std::string && value)5836 inline void CastLogsProto_CastEventProto::set_event_id_list(int index, std::string&& value) {
5837   _impl_.event_id_list_.Mutable(index)->assign(std::move(value));
5838   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.event_id_list)
5839 }
set_event_id_list(int index,const char * value)5840 inline void CastLogsProto_CastEventProto::set_event_id_list(int index, const char* value) {
5841   GOOGLE_DCHECK(value != nullptr);
5842   _impl_.event_id_list_.Mutable(index)->assign(value);
5843   // @@protoc_insertion_point(field_set_char:metrics.CastLogsProto.CastEventProto.event_id_list)
5844 }
set_event_id_list(int index,const char * value,size_t size)5845 inline void CastLogsProto_CastEventProto::set_event_id_list(int index, const char* value, size_t size) {
5846   _impl_.event_id_list_.Mutable(index)->assign(
5847     reinterpret_cast<const char*>(value), size);
5848   // @@protoc_insertion_point(field_set_pointer:metrics.CastLogsProto.CastEventProto.event_id_list)
5849 }
_internal_add_event_id_list()5850 inline std::string* CastLogsProto_CastEventProto::_internal_add_event_id_list() {
5851   return _impl_.event_id_list_.Add();
5852 }
add_event_id_list(const std::string & value)5853 inline void CastLogsProto_CastEventProto::add_event_id_list(const std::string& value) {
5854   _impl_.event_id_list_.Add()->assign(value);
5855   // @@protoc_insertion_point(field_add:metrics.CastLogsProto.CastEventProto.event_id_list)
5856 }
add_event_id_list(std::string && value)5857 inline void CastLogsProto_CastEventProto::add_event_id_list(std::string&& value) {
5858   _impl_.event_id_list_.Add(std::move(value));
5859   // @@protoc_insertion_point(field_add:metrics.CastLogsProto.CastEventProto.event_id_list)
5860 }
add_event_id_list(const char * value)5861 inline void CastLogsProto_CastEventProto::add_event_id_list(const char* value) {
5862   GOOGLE_DCHECK(value != nullptr);
5863   _impl_.event_id_list_.Add()->assign(value);
5864   // @@protoc_insertion_point(field_add_char:metrics.CastLogsProto.CastEventProto.event_id_list)
5865 }
add_event_id_list(const char * value,size_t size)5866 inline void CastLogsProto_CastEventProto::add_event_id_list(const char* value, size_t size) {
5867   _impl_.event_id_list_.Add()->assign(reinterpret_cast<const char*>(value), size);
5868   // @@protoc_insertion_point(field_add_pointer:metrics.CastLogsProto.CastEventProto.event_id_list)
5869 }
5870 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
event_id_list()5871 CastLogsProto_CastEventProto::event_id_list() const {
5872   // @@protoc_insertion_point(field_list:metrics.CastLogsProto.CastEventProto.event_id_list)
5873   return _impl_.event_id_list_;
5874 }
5875 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_event_id_list()5876 CastLogsProto_CastEventProto::mutable_event_id_list() {
5877   // @@protoc_insertion_point(field_mutable_list:metrics.CastLogsProto.CastEventProto.event_id_list)
5878   return &_impl_.event_id_list_;
5879 }
5880 
5881 // optional fixed64 duo_core_version = 24;
_internal_has_duo_core_version()5882 inline bool CastLogsProto_CastEventProto::_internal_has_duo_core_version() const {
5883   bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
5884   return value;
5885 }
has_duo_core_version()5886 inline bool CastLogsProto_CastEventProto::has_duo_core_version() const {
5887   return _internal_has_duo_core_version();
5888 }
clear_duo_core_version()5889 inline void CastLogsProto_CastEventProto::clear_duo_core_version() {
5890   _impl_.duo_core_version_ = uint64_t{0u};
5891   _impl_._has_bits_[0] &= ~0x00800000u;
5892 }
_internal_duo_core_version()5893 inline uint64_t CastLogsProto_CastEventProto::_internal_duo_core_version() const {
5894   return _impl_.duo_core_version_;
5895 }
duo_core_version()5896 inline uint64_t CastLogsProto_CastEventProto::duo_core_version() const {
5897   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.duo_core_version)
5898   return _internal_duo_core_version();
5899 }
_internal_set_duo_core_version(uint64_t value)5900 inline void CastLogsProto_CastEventProto::_internal_set_duo_core_version(uint64_t value) {
5901   _impl_._has_bits_[0] |= 0x00800000u;
5902   _impl_.duo_core_version_ = value;
5903 }
set_duo_core_version(uint64_t value)5904 inline void CastLogsProto_CastEventProto::set_duo_core_version(uint64_t value) {
5905   _internal_set_duo_core_version(value);
5906   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.duo_core_version)
5907 }
5908 
5909 // optional string hotword_model_id = 25;
_internal_has_hotword_model_id()5910 inline bool CastLogsProto_CastEventProto::_internal_has_hotword_model_id() const {
5911   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
5912   return value;
5913 }
has_hotword_model_id()5914 inline bool CastLogsProto_CastEventProto::has_hotword_model_id() const {
5915   return _internal_has_hotword_model_id();
5916 }
clear_hotword_model_id()5917 inline void CastLogsProto_CastEventProto::clear_hotword_model_id() {
5918   _impl_.hotword_model_id_.ClearToEmpty();
5919   _impl_._has_bits_[0] &= ~0x00000080u;
5920 }
hotword_model_id()5921 inline const std::string& CastLogsProto_CastEventProto::hotword_model_id() const {
5922   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.hotword_model_id)
5923   return _internal_hotword_model_id();
5924 }
5925 template <typename ArgT0, typename... ArgT>
5926 inline PROTOBUF_ALWAYS_INLINE
set_hotword_model_id(ArgT0 && arg0,ArgT...args)5927 void CastLogsProto_CastEventProto::set_hotword_model_id(ArgT0&& arg0, ArgT... args) {
5928  _impl_._has_bits_[0] |= 0x00000080u;
5929  _impl_.hotword_model_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5930   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.hotword_model_id)
5931 }
mutable_hotword_model_id()5932 inline std::string* CastLogsProto_CastEventProto::mutable_hotword_model_id() {
5933   std::string* _s = _internal_mutable_hotword_model_id();
5934   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastEventProto.hotword_model_id)
5935   return _s;
5936 }
_internal_hotword_model_id()5937 inline const std::string& CastLogsProto_CastEventProto::_internal_hotword_model_id() const {
5938   return _impl_.hotword_model_id_.Get();
5939 }
_internal_set_hotword_model_id(const std::string & value)5940 inline void CastLogsProto_CastEventProto::_internal_set_hotword_model_id(const std::string& value) {
5941   _impl_._has_bits_[0] |= 0x00000080u;
5942   _impl_.hotword_model_id_.Set(value, GetArenaForAllocation());
5943 }
_internal_mutable_hotword_model_id()5944 inline std::string* CastLogsProto_CastEventProto::_internal_mutable_hotword_model_id() {
5945   _impl_._has_bits_[0] |= 0x00000080u;
5946   return _impl_.hotword_model_id_.Mutable(GetArenaForAllocation());
5947 }
release_hotword_model_id()5948 inline std::string* CastLogsProto_CastEventProto::release_hotword_model_id() {
5949   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastEventProto.hotword_model_id)
5950   if (!_internal_has_hotword_model_id()) {
5951     return nullptr;
5952   }
5953   _impl_._has_bits_[0] &= ~0x00000080u;
5954   auto* p = _impl_.hotword_model_id_.Release();
5955 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5956   if (_impl_.hotword_model_id_.IsDefault()) {
5957     _impl_.hotword_model_id_.Set("", GetArenaForAllocation());
5958   }
5959 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5960   return p;
5961 }
set_allocated_hotword_model_id(std::string * hotword_model_id)5962 inline void CastLogsProto_CastEventProto::set_allocated_hotword_model_id(std::string* hotword_model_id) {
5963   if (hotword_model_id != nullptr) {
5964     _impl_._has_bits_[0] |= 0x00000080u;
5965   } else {
5966     _impl_._has_bits_[0] &= ~0x00000080u;
5967   }
5968   _impl_.hotword_model_id_.SetAllocated(hotword_model_id, GetArenaForAllocation());
5969 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5970   if (_impl_.hotword_model_id_.IsDefault()) {
5971     _impl_.hotword_model_id_.Set("", GetArenaForAllocation());
5972   }
5973 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5974   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastEventProto.hotword_model_id)
5975 }
5976 
5977 // optional .metrics.CastLogsProto.CastEventProto.LaunchFrom launch_from = 26;
_internal_has_launch_from()5978 inline bool CastLogsProto_CastEventProto::_internal_has_launch_from() const {
5979   bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
5980   return value;
5981 }
has_launch_from()5982 inline bool CastLogsProto_CastEventProto::has_launch_from() const {
5983   return _internal_has_launch_from();
5984 }
clear_launch_from()5985 inline void CastLogsProto_CastEventProto::clear_launch_from() {
5986   _impl_.launch_from_ = 0;
5987   _impl_._has_bits_[0] &= ~0x00400000u;
5988 }
_internal_launch_from()5989 inline ::metrics::CastLogsProto_CastEventProto_LaunchFrom CastLogsProto_CastEventProto::_internal_launch_from() const {
5990   return static_cast< ::metrics::CastLogsProto_CastEventProto_LaunchFrom >(_impl_.launch_from_);
5991 }
launch_from()5992 inline ::metrics::CastLogsProto_CastEventProto_LaunchFrom CastLogsProto_CastEventProto::launch_from() const {
5993   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.launch_from)
5994   return _internal_launch_from();
5995 }
_internal_set_launch_from(::metrics::CastLogsProto_CastEventProto_LaunchFrom value)5996 inline void CastLogsProto_CastEventProto::_internal_set_launch_from(::metrics::CastLogsProto_CastEventProto_LaunchFrom value) {
5997   assert(::metrics::CastLogsProto_CastEventProto_LaunchFrom_IsValid(value));
5998   _impl_._has_bits_[0] |= 0x00400000u;
5999   _impl_.launch_from_ = value;
6000 }
set_launch_from(::metrics::CastLogsProto_CastEventProto_LaunchFrom value)6001 inline void CastLogsProto_CastEventProto::set_launch_from(::metrics::CastLogsProto_CastEventProto_LaunchFrom value) {
6002   _internal_set_launch_from(value);
6003   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.launch_from)
6004 }
6005 
6006 // optional .metrics.CastLogsProto.CastEventProto.RuntimeType runtime_type = 27;
_internal_has_runtime_type()6007 inline bool CastLogsProto_CastEventProto::_internal_has_runtime_type() const {
6008   bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
6009   return value;
6010 }
has_runtime_type()6011 inline bool CastLogsProto_CastEventProto::has_runtime_type() const {
6012   return _internal_has_runtime_type();
6013 }
clear_runtime_type()6014 inline void CastLogsProto_CastEventProto::clear_runtime_type() {
6015   _impl_.runtime_type_ = 0;
6016   _impl_._has_bits_[0] &= ~0x01000000u;
6017 }
_internal_runtime_type()6018 inline ::metrics::CastLogsProto_CastEventProto_RuntimeType CastLogsProto_CastEventProto::_internal_runtime_type() const {
6019   return static_cast< ::metrics::CastLogsProto_CastEventProto_RuntimeType >(_impl_.runtime_type_);
6020 }
runtime_type()6021 inline ::metrics::CastLogsProto_CastEventProto_RuntimeType CastLogsProto_CastEventProto::runtime_type() const {
6022   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastEventProto.runtime_type)
6023   return _internal_runtime_type();
6024 }
_internal_set_runtime_type(::metrics::CastLogsProto_CastEventProto_RuntimeType value)6025 inline void CastLogsProto_CastEventProto::_internal_set_runtime_type(::metrics::CastLogsProto_CastEventProto_RuntimeType value) {
6026   assert(::metrics::CastLogsProto_CastEventProto_RuntimeType_IsValid(value));
6027   _impl_._has_bits_[0] |= 0x01000000u;
6028   _impl_.runtime_type_ = value;
6029 }
set_runtime_type(::metrics::CastLogsProto_CastEventProto_RuntimeType value)6030 inline void CastLogsProto_CastEventProto::set_runtime_type(::metrics::CastLogsProto_CastEventProto_RuntimeType value) {
6031   _internal_set_runtime_type(value);
6032   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastEventProto.runtime_type)
6033 }
6034 
6035 // -------------------------------------------------------------------
6036 
6037 // CastLogsProto_CastDeviceMutableInfo
6038 
6039 // optional .metrics.CastLogsProto.CastDeviceMutableInfo.RebootType last_reboot_type = 1;
_internal_has_last_reboot_type()6040 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_last_reboot_type() const {
6041   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
6042   return value;
6043 }
has_last_reboot_type()6044 inline bool CastLogsProto_CastDeviceMutableInfo::has_last_reboot_type() const {
6045   return _internal_has_last_reboot_type();
6046 }
clear_last_reboot_type()6047 inline void CastLogsProto_CastDeviceMutableInfo::clear_last_reboot_type() {
6048   _impl_.last_reboot_type_ = 0;
6049   _impl_._has_bits_[0] &= ~0x00000080u;
6050 }
_internal_last_reboot_type()6051 inline ::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType CastLogsProto_CastDeviceMutableInfo::_internal_last_reboot_type() const {
6052   return static_cast< ::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType >(_impl_.last_reboot_type_);
6053 }
last_reboot_type()6054 inline ::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType CastLogsProto_CastDeviceMutableInfo::last_reboot_type() const {
6055   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.last_reboot_type)
6056   return _internal_last_reboot_type();
6057 }
_internal_set_last_reboot_type(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType value)6058 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_last_reboot_type(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType value) {
6059   assert(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType_IsValid(value));
6060   _impl_._has_bits_[0] |= 0x00000080u;
6061   _impl_.last_reboot_type_ = value;
6062 }
set_last_reboot_type(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType value)6063 inline void CastLogsProto_CastDeviceMutableInfo::set_last_reboot_type(::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType value) {
6064   _internal_set_last_reboot_type(value);
6065   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.last_reboot_type)
6066 }
6067 
6068 // optional fixed64 system_build_number = 2;
_internal_has_system_build_number()6069 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_system_build_number() const {
6070   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
6071   return value;
6072 }
has_system_build_number()6073 inline bool CastLogsProto_CastDeviceMutableInfo::has_system_build_number() const {
6074   return _internal_has_system_build_number();
6075 }
clear_system_build_number()6076 inline void CastLogsProto_CastDeviceMutableInfo::clear_system_build_number() {
6077   _impl_.system_build_number_ = uint64_t{0u};
6078   _impl_._has_bits_[0] &= ~0x00000040u;
6079 }
_internal_system_build_number()6080 inline uint64_t CastLogsProto_CastDeviceMutableInfo::_internal_system_build_number() const {
6081   return _impl_.system_build_number_;
6082 }
system_build_number()6083 inline uint64_t CastLogsProto_CastDeviceMutableInfo::system_build_number() const {
6084   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.system_build_number)
6085   return _internal_system_build_number();
6086 }
_internal_set_system_build_number(uint64_t value)6087 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_system_build_number(uint64_t value) {
6088   _impl_._has_bits_[0] |= 0x00000040u;
6089   _impl_.system_build_number_ = value;
6090 }
set_system_build_number(uint64_t value)6091 inline void CastLogsProto_CastDeviceMutableInfo::set_system_build_number(uint64_t value) {
6092   _internal_set_system_build_number(value);
6093   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.system_build_number)
6094 }
6095 
6096 // optional string backdrop_app_device_id = 3;
_internal_has_backdrop_app_device_id()6097 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_backdrop_app_device_id() const {
6098   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6099   return value;
6100 }
has_backdrop_app_device_id()6101 inline bool CastLogsProto_CastDeviceMutableInfo::has_backdrop_app_device_id() const {
6102   return _internal_has_backdrop_app_device_id();
6103 }
clear_backdrop_app_device_id()6104 inline void CastLogsProto_CastDeviceMutableInfo::clear_backdrop_app_device_id() {
6105   _impl_.backdrop_app_device_id_.ClearToEmpty();
6106   _impl_._has_bits_[0] &= ~0x00000001u;
6107 }
backdrop_app_device_id()6108 inline const std::string& CastLogsProto_CastDeviceMutableInfo::backdrop_app_device_id() const {
6109   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.backdrop_app_device_id)
6110   return _internal_backdrop_app_device_id();
6111 }
6112 template <typename ArgT0, typename... ArgT>
6113 inline PROTOBUF_ALWAYS_INLINE
set_backdrop_app_device_id(ArgT0 && arg0,ArgT...args)6114 void CastLogsProto_CastDeviceMutableInfo::set_backdrop_app_device_id(ArgT0&& arg0, ArgT... args) {
6115  _impl_._has_bits_[0] |= 0x00000001u;
6116  _impl_.backdrop_app_device_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6117   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.backdrop_app_device_id)
6118 }
mutable_backdrop_app_device_id()6119 inline std::string* CastLogsProto_CastDeviceMutableInfo::mutable_backdrop_app_device_id() {
6120   std::string* _s = _internal_mutable_backdrop_app_device_id();
6121   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceMutableInfo.backdrop_app_device_id)
6122   return _s;
6123 }
_internal_backdrop_app_device_id()6124 inline const std::string& CastLogsProto_CastDeviceMutableInfo::_internal_backdrop_app_device_id() const {
6125   return _impl_.backdrop_app_device_id_.Get();
6126 }
_internal_set_backdrop_app_device_id(const std::string & value)6127 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_backdrop_app_device_id(const std::string& value) {
6128   _impl_._has_bits_[0] |= 0x00000001u;
6129   _impl_.backdrop_app_device_id_.Set(value, GetArenaForAllocation());
6130 }
_internal_mutable_backdrop_app_device_id()6131 inline std::string* CastLogsProto_CastDeviceMutableInfo::_internal_mutable_backdrop_app_device_id() {
6132   _impl_._has_bits_[0] |= 0x00000001u;
6133   return _impl_.backdrop_app_device_id_.Mutable(GetArenaForAllocation());
6134 }
release_backdrop_app_device_id()6135 inline std::string* CastLogsProto_CastDeviceMutableInfo::release_backdrop_app_device_id() {
6136   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceMutableInfo.backdrop_app_device_id)
6137   if (!_internal_has_backdrop_app_device_id()) {
6138     return nullptr;
6139   }
6140   _impl_._has_bits_[0] &= ~0x00000001u;
6141   auto* p = _impl_.backdrop_app_device_id_.Release();
6142 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6143   if (_impl_.backdrop_app_device_id_.IsDefault()) {
6144     _impl_.backdrop_app_device_id_.Set("", GetArenaForAllocation());
6145   }
6146 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6147   return p;
6148 }
set_allocated_backdrop_app_device_id(std::string * backdrop_app_device_id)6149 inline void CastLogsProto_CastDeviceMutableInfo::set_allocated_backdrop_app_device_id(std::string* backdrop_app_device_id) {
6150   if (backdrop_app_device_id != nullptr) {
6151     _impl_._has_bits_[0] |= 0x00000001u;
6152   } else {
6153     _impl_._has_bits_[0] &= ~0x00000001u;
6154   }
6155   _impl_.backdrop_app_device_id_.SetAllocated(backdrop_app_device_id, GetArenaForAllocation());
6156 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6157   if (_impl_.backdrop_app_device_id_.IsDefault()) {
6158     _impl_.backdrop_app_device_id_.Set("", GetArenaForAllocation());
6159   }
6160 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6161   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceMutableInfo.backdrop_app_device_id)
6162 }
6163 
6164 // optional fixed32 release_version = 4;
_internal_has_release_version()6165 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_release_version() const {
6166   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
6167   return value;
6168 }
has_release_version()6169 inline bool CastLogsProto_CastDeviceMutableInfo::has_release_version() const {
6170   return _internal_has_release_version();
6171 }
clear_release_version()6172 inline void CastLogsProto_CastDeviceMutableInfo::clear_release_version() {
6173   _impl_.release_version_ = 0u;
6174   _impl_._has_bits_[0] &= ~0x00000100u;
6175 }
_internal_release_version()6176 inline uint32_t CastLogsProto_CastDeviceMutableInfo::_internal_release_version() const {
6177   return _impl_.release_version_;
6178 }
release_version()6179 inline uint32_t CastLogsProto_CastDeviceMutableInfo::release_version() const {
6180   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.release_version)
6181   return _internal_release_version();
6182 }
_internal_set_release_version(uint32_t value)6183 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_release_version(uint32_t value) {
6184   _impl_._has_bits_[0] |= 0x00000100u;
6185   _impl_.release_version_ = value;
6186 }
set_release_version(uint32_t value)6187 inline void CastLogsProto_CastDeviceMutableInfo::set_release_version(uint32_t value) {
6188   _internal_set_release_version(value);
6189   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.release_version)
6190 }
6191 
6192 // optional .metrics.CastLogsProto.CastDeviceMutableInfo.NetifIPVersion netif_ip_version = 5;
_internal_has_netif_ip_version()6193 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_netif_ip_version() const {
6194   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
6195   return value;
6196 }
has_netif_ip_version()6197 inline bool CastLogsProto_CastDeviceMutableInfo::has_netif_ip_version() const {
6198   return _internal_has_netif_ip_version();
6199 }
clear_netif_ip_version()6200 inline void CastLogsProto_CastDeviceMutableInfo::clear_netif_ip_version() {
6201   _impl_.netif_ip_version_ = 0;
6202   _impl_._has_bits_[0] &= ~0x00000200u;
6203 }
_internal_netif_ip_version()6204 inline ::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion CastLogsProto_CastDeviceMutableInfo::_internal_netif_ip_version() const {
6205   return static_cast< ::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion >(_impl_.netif_ip_version_);
6206 }
netif_ip_version()6207 inline ::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion CastLogsProto_CastDeviceMutableInfo::netif_ip_version() const {
6208   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.netif_ip_version)
6209   return _internal_netif_ip_version();
6210 }
_internal_set_netif_ip_version(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value)6211 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_netif_ip_version(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value) {
6212   assert(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion_IsValid(value));
6213   _impl_._has_bits_[0] |= 0x00000200u;
6214   _impl_.netif_ip_version_ = value;
6215 }
set_netif_ip_version(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value)6216 inline void CastLogsProto_CastDeviceMutableInfo::set_netif_ip_version(::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion value) {
6217   _internal_set_netif_ip_version(value);
6218   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.netif_ip_version)
6219 }
6220 
6221 // optional bool ip_dual_stack_supported = 6;
_internal_has_ip_dual_stack_supported()6222 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_ip_dual_stack_supported() const {
6223   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
6224   return value;
6225 }
has_ip_dual_stack_supported()6226 inline bool CastLogsProto_CastDeviceMutableInfo::has_ip_dual_stack_supported() const {
6227   return _internal_has_ip_dual_stack_supported();
6228 }
clear_ip_dual_stack_supported()6229 inline void CastLogsProto_CastDeviceMutableInfo::clear_ip_dual_stack_supported() {
6230   _impl_.ip_dual_stack_supported_ = false;
6231   _impl_._has_bits_[0] &= ~0x00000400u;
6232 }
_internal_ip_dual_stack_supported()6233 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_ip_dual_stack_supported() const {
6234   return _impl_.ip_dual_stack_supported_;
6235 }
ip_dual_stack_supported()6236 inline bool CastLogsProto_CastDeviceMutableInfo::ip_dual_stack_supported() const {
6237   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.ip_dual_stack_supported)
6238   return _internal_ip_dual_stack_supported();
6239 }
_internal_set_ip_dual_stack_supported(bool value)6240 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_ip_dual_stack_supported(bool value) {
6241   _impl_._has_bits_[0] |= 0x00000400u;
6242   _impl_.ip_dual_stack_supported_ = value;
6243 }
set_ip_dual_stack_supported(bool value)6244 inline void CastLogsProto_CastDeviceMutableInfo::set_ip_dual_stack_supported(bool value) {
6245   _internal_set_ip_dual_stack_supported(value);
6246   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.ip_dual_stack_supported)
6247 }
6248 
6249 // optional string timezone_id = 7;
_internal_has_timezone_id()6250 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_timezone_id() const {
6251   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6252   return value;
6253 }
has_timezone_id()6254 inline bool CastLogsProto_CastDeviceMutableInfo::has_timezone_id() const {
6255   return _internal_has_timezone_id();
6256 }
clear_timezone_id()6257 inline void CastLogsProto_CastDeviceMutableInfo::clear_timezone_id() {
6258   _impl_.timezone_id_.ClearToEmpty();
6259   _impl_._has_bits_[0] &= ~0x00000002u;
6260 }
timezone_id()6261 inline const std::string& CastLogsProto_CastDeviceMutableInfo::timezone_id() const {
6262   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.timezone_id)
6263   return _internal_timezone_id();
6264 }
6265 template <typename ArgT0, typename... ArgT>
6266 inline PROTOBUF_ALWAYS_INLINE
set_timezone_id(ArgT0 && arg0,ArgT...args)6267 void CastLogsProto_CastDeviceMutableInfo::set_timezone_id(ArgT0&& arg0, ArgT... args) {
6268  _impl_._has_bits_[0] |= 0x00000002u;
6269  _impl_.timezone_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6270   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.timezone_id)
6271 }
mutable_timezone_id()6272 inline std::string* CastLogsProto_CastDeviceMutableInfo::mutable_timezone_id() {
6273   std::string* _s = _internal_mutable_timezone_id();
6274   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceMutableInfo.timezone_id)
6275   return _s;
6276 }
_internal_timezone_id()6277 inline const std::string& CastLogsProto_CastDeviceMutableInfo::_internal_timezone_id() const {
6278   return _impl_.timezone_id_.Get();
6279 }
_internal_set_timezone_id(const std::string & value)6280 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_timezone_id(const std::string& value) {
6281   _impl_._has_bits_[0] |= 0x00000002u;
6282   _impl_.timezone_id_.Set(value, GetArenaForAllocation());
6283 }
_internal_mutable_timezone_id()6284 inline std::string* CastLogsProto_CastDeviceMutableInfo::_internal_mutable_timezone_id() {
6285   _impl_._has_bits_[0] |= 0x00000002u;
6286   return _impl_.timezone_id_.Mutable(GetArenaForAllocation());
6287 }
release_timezone_id()6288 inline std::string* CastLogsProto_CastDeviceMutableInfo::release_timezone_id() {
6289   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceMutableInfo.timezone_id)
6290   if (!_internal_has_timezone_id()) {
6291     return nullptr;
6292   }
6293   _impl_._has_bits_[0] &= ~0x00000002u;
6294   auto* p = _impl_.timezone_id_.Release();
6295 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6296   if (_impl_.timezone_id_.IsDefault()) {
6297     _impl_.timezone_id_.Set("", GetArenaForAllocation());
6298   }
6299 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6300   return p;
6301 }
set_allocated_timezone_id(std::string * timezone_id)6302 inline void CastLogsProto_CastDeviceMutableInfo::set_allocated_timezone_id(std::string* timezone_id) {
6303   if (timezone_id != nullptr) {
6304     _impl_._has_bits_[0] |= 0x00000002u;
6305   } else {
6306     _impl_._has_bits_[0] &= ~0x00000002u;
6307   }
6308   _impl_.timezone_id_.SetAllocated(timezone_id, GetArenaForAllocation());
6309 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6310   if (_impl_.timezone_id_.IsDefault()) {
6311     _impl_.timezone_id_.Set("", GetArenaForAllocation());
6312   }
6313 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6314   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceMutableInfo.timezone_id)
6315 }
6316 
6317 // optional string latest_ui_version = 8;
_internal_has_latest_ui_version()6318 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_latest_ui_version() const {
6319   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
6320   return value;
6321 }
has_latest_ui_version()6322 inline bool CastLogsProto_CastDeviceMutableInfo::has_latest_ui_version() const {
6323   return _internal_has_latest_ui_version();
6324 }
clear_latest_ui_version()6325 inline void CastLogsProto_CastDeviceMutableInfo::clear_latest_ui_version() {
6326   _impl_.latest_ui_version_.ClearToEmpty();
6327   _impl_._has_bits_[0] &= ~0x00000004u;
6328 }
latest_ui_version()6329 inline const std::string& CastLogsProto_CastDeviceMutableInfo::latest_ui_version() const {
6330   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.latest_ui_version)
6331   return _internal_latest_ui_version();
6332 }
6333 template <typename ArgT0, typename... ArgT>
6334 inline PROTOBUF_ALWAYS_INLINE
set_latest_ui_version(ArgT0 && arg0,ArgT...args)6335 void CastLogsProto_CastDeviceMutableInfo::set_latest_ui_version(ArgT0&& arg0, ArgT... args) {
6336  _impl_._has_bits_[0] |= 0x00000004u;
6337  _impl_.latest_ui_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6338   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.latest_ui_version)
6339 }
mutable_latest_ui_version()6340 inline std::string* CastLogsProto_CastDeviceMutableInfo::mutable_latest_ui_version() {
6341   std::string* _s = _internal_mutable_latest_ui_version();
6342   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceMutableInfo.latest_ui_version)
6343   return _s;
6344 }
_internal_latest_ui_version()6345 inline const std::string& CastLogsProto_CastDeviceMutableInfo::_internal_latest_ui_version() const {
6346   return _impl_.latest_ui_version_.Get();
6347 }
_internal_set_latest_ui_version(const std::string & value)6348 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_latest_ui_version(const std::string& value) {
6349   _impl_._has_bits_[0] |= 0x00000004u;
6350   _impl_.latest_ui_version_.Set(value, GetArenaForAllocation());
6351 }
_internal_mutable_latest_ui_version()6352 inline std::string* CastLogsProto_CastDeviceMutableInfo::_internal_mutable_latest_ui_version() {
6353   _impl_._has_bits_[0] |= 0x00000004u;
6354   return _impl_.latest_ui_version_.Mutable(GetArenaForAllocation());
6355 }
release_latest_ui_version()6356 inline std::string* CastLogsProto_CastDeviceMutableInfo::release_latest_ui_version() {
6357   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceMutableInfo.latest_ui_version)
6358   if (!_internal_has_latest_ui_version()) {
6359     return nullptr;
6360   }
6361   _impl_._has_bits_[0] &= ~0x00000004u;
6362   auto* p = _impl_.latest_ui_version_.Release();
6363 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6364   if (_impl_.latest_ui_version_.IsDefault()) {
6365     _impl_.latest_ui_version_.Set("", GetArenaForAllocation());
6366   }
6367 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6368   return p;
6369 }
set_allocated_latest_ui_version(std::string * latest_ui_version)6370 inline void CastLogsProto_CastDeviceMutableInfo::set_allocated_latest_ui_version(std::string* latest_ui_version) {
6371   if (latest_ui_version != nullptr) {
6372     _impl_._has_bits_[0] |= 0x00000004u;
6373   } else {
6374     _impl_._has_bits_[0] &= ~0x00000004u;
6375   }
6376   _impl_.latest_ui_version_.SetAllocated(latest_ui_version, GetArenaForAllocation());
6377 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6378   if (_impl_.latest_ui_version_.IsDefault()) {
6379     _impl_.latest_ui_version_.Set("", GetArenaForAllocation());
6380   }
6381 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6382   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceMutableInfo.latest_ui_version)
6383 }
6384 
6385 // optional string google_wifi_station_shmac = 9;
_internal_has_google_wifi_station_shmac()6386 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_google_wifi_station_shmac() const {
6387   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
6388   return value;
6389 }
has_google_wifi_station_shmac()6390 inline bool CastLogsProto_CastDeviceMutableInfo::has_google_wifi_station_shmac() const {
6391   return _internal_has_google_wifi_station_shmac();
6392 }
clear_google_wifi_station_shmac()6393 inline void CastLogsProto_CastDeviceMutableInfo::clear_google_wifi_station_shmac() {
6394   _impl_.google_wifi_station_shmac_.ClearToEmpty();
6395   _impl_._has_bits_[0] &= ~0x00000008u;
6396 }
google_wifi_station_shmac()6397 inline const std::string& CastLogsProto_CastDeviceMutableInfo::google_wifi_station_shmac() const {
6398   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.google_wifi_station_shmac)
6399   return _internal_google_wifi_station_shmac();
6400 }
6401 template <typename ArgT0, typename... ArgT>
6402 inline PROTOBUF_ALWAYS_INLINE
set_google_wifi_station_shmac(ArgT0 && arg0,ArgT...args)6403 void CastLogsProto_CastDeviceMutableInfo::set_google_wifi_station_shmac(ArgT0&& arg0, ArgT... args) {
6404  _impl_._has_bits_[0] |= 0x00000008u;
6405  _impl_.google_wifi_station_shmac_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6406   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.google_wifi_station_shmac)
6407 }
mutable_google_wifi_station_shmac()6408 inline std::string* CastLogsProto_CastDeviceMutableInfo::mutable_google_wifi_station_shmac() {
6409   std::string* _s = _internal_mutable_google_wifi_station_shmac();
6410   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceMutableInfo.google_wifi_station_shmac)
6411   return _s;
6412 }
_internal_google_wifi_station_shmac()6413 inline const std::string& CastLogsProto_CastDeviceMutableInfo::_internal_google_wifi_station_shmac() const {
6414   return _impl_.google_wifi_station_shmac_.Get();
6415 }
_internal_set_google_wifi_station_shmac(const std::string & value)6416 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_google_wifi_station_shmac(const std::string& value) {
6417   _impl_._has_bits_[0] |= 0x00000008u;
6418   _impl_.google_wifi_station_shmac_.Set(value, GetArenaForAllocation());
6419 }
_internal_mutable_google_wifi_station_shmac()6420 inline std::string* CastLogsProto_CastDeviceMutableInfo::_internal_mutable_google_wifi_station_shmac() {
6421   _impl_._has_bits_[0] |= 0x00000008u;
6422   return _impl_.google_wifi_station_shmac_.Mutable(GetArenaForAllocation());
6423 }
release_google_wifi_station_shmac()6424 inline std::string* CastLogsProto_CastDeviceMutableInfo::release_google_wifi_station_shmac() {
6425   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceMutableInfo.google_wifi_station_shmac)
6426   if (!_internal_has_google_wifi_station_shmac()) {
6427     return nullptr;
6428   }
6429   _impl_._has_bits_[0] &= ~0x00000008u;
6430   auto* p = _impl_.google_wifi_station_shmac_.Release();
6431 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6432   if (_impl_.google_wifi_station_shmac_.IsDefault()) {
6433     _impl_.google_wifi_station_shmac_.Set("", GetArenaForAllocation());
6434   }
6435 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6436   return p;
6437 }
set_allocated_google_wifi_station_shmac(std::string * google_wifi_station_shmac)6438 inline void CastLogsProto_CastDeviceMutableInfo::set_allocated_google_wifi_station_shmac(std::string* google_wifi_station_shmac) {
6439   if (google_wifi_station_shmac != nullptr) {
6440     _impl_._has_bits_[0] |= 0x00000008u;
6441   } else {
6442     _impl_._has_bits_[0] &= ~0x00000008u;
6443   }
6444   _impl_.google_wifi_station_shmac_.SetAllocated(google_wifi_station_shmac, GetArenaForAllocation());
6445 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6446   if (_impl_.google_wifi_station_shmac_.IsDefault()) {
6447     _impl_.google_wifi_station_shmac_.Set("", GetArenaForAllocation());
6448   }
6449 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6450   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceMutableInfo.google_wifi_station_shmac)
6451 }
6452 
6453 // optional string installed_manifest_platform_version = 10;
_internal_has_installed_manifest_platform_version()6454 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_installed_manifest_platform_version() const {
6455   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
6456   return value;
6457 }
has_installed_manifest_platform_version()6458 inline bool CastLogsProto_CastDeviceMutableInfo::has_installed_manifest_platform_version() const {
6459   return _internal_has_installed_manifest_platform_version();
6460 }
clear_installed_manifest_platform_version()6461 inline void CastLogsProto_CastDeviceMutableInfo::clear_installed_manifest_platform_version() {
6462   _impl_.installed_manifest_platform_version_.ClearToEmpty();
6463   _impl_._has_bits_[0] &= ~0x00000010u;
6464 }
installed_manifest_platform_version()6465 inline const std::string& CastLogsProto_CastDeviceMutableInfo::installed_manifest_platform_version() const {
6466   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_platform_version)
6467   return _internal_installed_manifest_platform_version();
6468 }
6469 template <typename ArgT0, typename... ArgT>
6470 inline PROTOBUF_ALWAYS_INLINE
set_installed_manifest_platform_version(ArgT0 && arg0,ArgT...args)6471 void CastLogsProto_CastDeviceMutableInfo::set_installed_manifest_platform_version(ArgT0&& arg0, ArgT... args) {
6472  _impl_._has_bits_[0] |= 0x00000010u;
6473  _impl_.installed_manifest_platform_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6474   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_platform_version)
6475 }
mutable_installed_manifest_platform_version()6476 inline std::string* CastLogsProto_CastDeviceMutableInfo::mutable_installed_manifest_platform_version() {
6477   std::string* _s = _internal_mutable_installed_manifest_platform_version();
6478   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_platform_version)
6479   return _s;
6480 }
_internal_installed_manifest_platform_version()6481 inline const std::string& CastLogsProto_CastDeviceMutableInfo::_internal_installed_manifest_platform_version() const {
6482   return _impl_.installed_manifest_platform_version_.Get();
6483 }
_internal_set_installed_manifest_platform_version(const std::string & value)6484 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_installed_manifest_platform_version(const std::string& value) {
6485   _impl_._has_bits_[0] |= 0x00000010u;
6486   _impl_.installed_manifest_platform_version_.Set(value, GetArenaForAllocation());
6487 }
_internal_mutable_installed_manifest_platform_version()6488 inline std::string* CastLogsProto_CastDeviceMutableInfo::_internal_mutable_installed_manifest_platform_version() {
6489   _impl_._has_bits_[0] |= 0x00000010u;
6490   return _impl_.installed_manifest_platform_version_.Mutable(GetArenaForAllocation());
6491 }
release_installed_manifest_platform_version()6492 inline std::string* CastLogsProto_CastDeviceMutableInfo::release_installed_manifest_platform_version() {
6493   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_platform_version)
6494   if (!_internal_has_installed_manifest_platform_version()) {
6495     return nullptr;
6496   }
6497   _impl_._has_bits_[0] &= ~0x00000010u;
6498   auto* p = _impl_.installed_manifest_platform_version_.Release();
6499 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6500   if (_impl_.installed_manifest_platform_version_.IsDefault()) {
6501     _impl_.installed_manifest_platform_version_.Set("", GetArenaForAllocation());
6502   }
6503 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6504   return p;
6505 }
set_allocated_installed_manifest_platform_version(std::string * installed_manifest_platform_version)6506 inline void CastLogsProto_CastDeviceMutableInfo::set_allocated_installed_manifest_platform_version(std::string* installed_manifest_platform_version) {
6507   if (installed_manifest_platform_version != nullptr) {
6508     _impl_._has_bits_[0] |= 0x00000010u;
6509   } else {
6510     _impl_._has_bits_[0] &= ~0x00000010u;
6511   }
6512   _impl_.installed_manifest_platform_version_.SetAllocated(installed_manifest_platform_version, GetArenaForAllocation());
6513 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6514   if (_impl_.installed_manifest_platform_version_.IsDefault()) {
6515     _impl_.installed_manifest_platform_version_.Set("", GetArenaForAllocation());
6516   }
6517 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6518   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_platform_version)
6519 }
6520 
6521 // optional uint32 installed_manifest_version = 11;
_internal_has_installed_manifest_version()6522 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_installed_manifest_version() const {
6523   bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
6524   return value;
6525 }
has_installed_manifest_version()6526 inline bool CastLogsProto_CastDeviceMutableInfo::has_installed_manifest_version() const {
6527   return _internal_has_installed_manifest_version();
6528 }
clear_installed_manifest_version()6529 inline void CastLogsProto_CastDeviceMutableInfo::clear_installed_manifest_version() {
6530   _impl_.installed_manifest_version_ = 0u;
6531   _impl_._has_bits_[0] &= ~0x00000800u;
6532 }
_internal_installed_manifest_version()6533 inline uint32_t CastLogsProto_CastDeviceMutableInfo::_internal_installed_manifest_version() const {
6534   return _impl_.installed_manifest_version_;
6535 }
installed_manifest_version()6536 inline uint32_t CastLogsProto_CastDeviceMutableInfo::installed_manifest_version() const {
6537   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_version)
6538   return _internal_installed_manifest_version();
6539 }
_internal_set_installed_manifest_version(uint32_t value)6540 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_installed_manifest_version(uint32_t value) {
6541   _impl_._has_bits_[0] |= 0x00000800u;
6542   _impl_.installed_manifest_version_ = value;
6543 }
set_installed_manifest_version(uint32_t value)6544 inline void CastLogsProto_CastDeviceMutableInfo::set_installed_manifest_version(uint32_t value) {
6545   _internal_set_installed_manifest_version(value);
6546   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.installed_manifest_version)
6547 }
6548 
6549 // optional string system_bundle_version = 12;
_internal_has_system_bundle_version()6550 inline bool CastLogsProto_CastDeviceMutableInfo::_internal_has_system_bundle_version() const {
6551   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
6552   return value;
6553 }
has_system_bundle_version()6554 inline bool CastLogsProto_CastDeviceMutableInfo::has_system_bundle_version() const {
6555   return _internal_has_system_bundle_version();
6556 }
clear_system_bundle_version()6557 inline void CastLogsProto_CastDeviceMutableInfo::clear_system_bundle_version() {
6558   _impl_.system_bundle_version_.ClearToEmpty();
6559   _impl_._has_bits_[0] &= ~0x00000020u;
6560 }
system_bundle_version()6561 inline const std::string& CastLogsProto_CastDeviceMutableInfo::system_bundle_version() const {
6562   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.CastDeviceMutableInfo.system_bundle_version)
6563   return _internal_system_bundle_version();
6564 }
6565 template <typename ArgT0, typename... ArgT>
6566 inline PROTOBUF_ALWAYS_INLINE
set_system_bundle_version(ArgT0 && arg0,ArgT...args)6567 void CastLogsProto_CastDeviceMutableInfo::set_system_bundle_version(ArgT0&& arg0, ArgT... args) {
6568  _impl_._has_bits_[0] |= 0x00000020u;
6569  _impl_.system_bundle_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6570   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.CastDeviceMutableInfo.system_bundle_version)
6571 }
mutable_system_bundle_version()6572 inline std::string* CastLogsProto_CastDeviceMutableInfo::mutable_system_bundle_version() {
6573   std::string* _s = _internal_mutable_system_bundle_version();
6574   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.CastDeviceMutableInfo.system_bundle_version)
6575   return _s;
6576 }
_internal_system_bundle_version()6577 inline const std::string& CastLogsProto_CastDeviceMutableInfo::_internal_system_bundle_version() const {
6578   return _impl_.system_bundle_version_.Get();
6579 }
_internal_set_system_bundle_version(const std::string & value)6580 inline void CastLogsProto_CastDeviceMutableInfo::_internal_set_system_bundle_version(const std::string& value) {
6581   _impl_._has_bits_[0] |= 0x00000020u;
6582   _impl_.system_bundle_version_.Set(value, GetArenaForAllocation());
6583 }
_internal_mutable_system_bundle_version()6584 inline std::string* CastLogsProto_CastDeviceMutableInfo::_internal_mutable_system_bundle_version() {
6585   _impl_._has_bits_[0] |= 0x00000020u;
6586   return _impl_.system_bundle_version_.Mutable(GetArenaForAllocation());
6587 }
release_system_bundle_version()6588 inline std::string* CastLogsProto_CastDeviceMutableInfo::release_system_bundle_version() {
6589   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.CastDeviceMutableInfo.system_bundle_version)
6590   if (!_internal_has_system_bundle_version()) {
6591     return nullptr;
6592   }
6593   _impl_._has_bits_[0] &= ~0x00000020u;
6594   auto* p = _impl_.system_bundle_version_.Release();
6595 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6596   if (_impl_.system_bundle_version_.IsDefault()) {
6597     _impl_.system_bundle_version_.Set("", GetArenaForAllocation());
6598   }
6599 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6600   return p;
6601 }
set_allocated_system_bundle_version(std::string * system_bundle_version)6602 inline void CastLogsProto_CastDeviceMutableInfo::set_allocated_system_bundle_version(std::string* system_bundle_version) {
6603   if (system_bundle_version != nullptr) {
6604     _impl_._has_bits_[0] |= 0x00000020u;
6605   } else {
6606     _impl_._has_bits_[0] &= ~0x00000020u;
6607   }
6608   _impl_.system_bundle_version_.SetAllocated(system_bundle_version, GetArenaForAllocation());
6609 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6610   if (_impl_.system_bundle_version_.IsDefault()) {
6611     _impl_.system_bundle_version_.Set("", GetArenaForAllocation());
6612   }
6613 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6614   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.CastDeviceMutableInfo.system_bundle_version)
6615 }
6616 
6617 // -------------------------------------------------------------------
6618 
6619 // CastLogsProto
6620 
6621 // optional .metrics.CastLogsProto.CastDeviceInfo cast_device_info = 1;
_internal_has_cast_device_info()6622 inline bool CastLogsProto::_internal_has_cast_device_info() const {
6623   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6624   PROTOBUF_ASSUME(!value || _impl_.cast_device_info_ != nullptr);
6625   return value;
6626 }
has_cast_device_info()6627 inline bool CastLogsProto::has_cast_device_info() const {
6628   return _internal_has_cast_device_info();
6629 }
clear_cast_device_info()6630 inline void CastLogsProto::clear_cast_device_info() {
6631   if (_impl_.cast_device_info_ != nullptr) _impl_.cast_device_info_->Clear();
6632   _impl_._has_bits_[0] &= ~0x00000001u;
6633 }
_internal_cast_device_info()6634 inline const ::metrics::CastLogsProto_CastDeviceInfo& CastLogsProto::_internal_cast_device_info() const {
6635   const ::metrics::CastLogsProto_CastDeviceInfo* p = _impl_.cast_device_info_;
6636   return p != nullptr ? *p : reinterpret_cast<const ::metrics::CastLogsProto_CastDeviceInfo&>(
6637       ::metrics::_CastLogsProto_CastDeviceInfo_default_instance_);
6638 }
cast_device_info()6639 inline const ::metrics::CastLogsProto_CastDeviceInfo& CastLogsProto::cast_device_info() const {
6640   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.cast_device_info)
6641   return _internal_cast_device_info();
6642 }
unsafe_arena_set_allocated_cast_device_info(::metrics::CastLogsProto_CastDeviceInfo * cast_device_info)6643 inline void CastLogsProto::unsafe_arena_set_allocated_cast_device_info(
6644     ::metrics::CastLogsProto_CastDeviceInfo* cast_device_info) {
6645   if (GetArenaForAllocation() == nullptr) {
6646     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cast_device_info_);
6647   }
6648   _impl_.cast_device_info_ = cast_device_info;
6649   if (cast_device_info) {
6650     _impl_._has_bits_[0] |= 0x00000001u;
6651   } else {
6652     _impl_._has_bits_[0] &= ~0x00000001u;
6653   }
6654   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.CastLogsProto.cast_device_info)
6655 }
release_cast_device_info()6656 inline ::metrics::CastLogsProto_CastDeviceInfo* CastLogsProto::release_cast_device_info() {
6657   _impl_._has_bits_[0] &= ~0x00000001u;
6658   ::metrics::CastLogsProto_CastDeviceInfo* temp = _impl_.cast_device_info_;
6659   _impl_.cast_device_info_ = nullptr;
6660 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6661   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6662   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6663   if (GetArenaForAllocation() == nullptr) { delete old; }
6664 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6665   if (GetArenaForAllocation() != nullptr) {
6666     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6667   }
6668 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6669   return temp;
6670 }
unsafe_arena_release_cast_device_info()6671 inline ::metrics::CastLogsProto_CastDeviceInfo* CastLogsProto::unsafe_arena_release_cast_device_info() {
6672   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.cast_device_info)
6673   _impl_._has_bits_[0] &= ~0x00000001u;
6674   ::metrics::CastLogsProto_CastDeviceInfo* temp = _impl_.cast_device_info_;
6675   _impl_.cast_device_info_ = nullptr;
6676   return temp;
6677 }
_internal_mutable_cast_device_info()6678 inline ::metrics::CastLogsProto_CastDeviceInfo* CastLogsProto::_internal_mutable_cast_device_info() {
6679   _impl_._has_bits_[0] |= 0x00000001u;
6680   if (_impl_.cast_device_info_ == nullptr) {
6681     auto* p = CreateMaybeMessage<::metrics::CastLogsProto_CastDeviceInfo>(GetArenaForAllocation());
6682     _impl_.cast_device_info_ = p;
6683   }
6684   return _impl_.cast_device_info_;
6685 }
mutable_cast_device_info()6686 inline ::metrics::CastLogsProto_CastDeviceInfo* CastLogsProto::mutable_cast_device_info() {
6687   ::metrics::CastLogsProto_CastDeviceInfo* _msg = _internal_mutable_cast_device_info();
6688   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.cast_device_info)
6689   return _msg;
6690 }
set_allocated_cast_device_info(::metrics::CastLogsProto_CastDeviceInfo * cast_device_info)6691 inline void CastLogsProto::set_allocated_cast_device_info(::metrics::CastLogsProto_CastDeviceInfo* cast_device_info) {
6692   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6693   if (message_arena == nullptr) {
6694     delete _impl_.cast_device_info_;
6695   }
6696   if (cast_device_info) {
6697     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6698         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cast_device_info);
6699     if (message_arena != submessage_arena) {
6700       cast_device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6701           message_arena, cast_device_info, submessage_arena);
6702     }
6703     _impl_._has_bits_[0] |= 0x00000001u;
6704   } else {
6705     _impl_._has_bits_[0] &= ~0x00000001u;
6706   }
6707   _impl_.cast_device_info_ = cast_device_info;
6708   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.cast_device_info)
6709 }
6710 
6711 // repeated .metrics.CastLogsProto.CastConnectionInfo cast_connection_info = 2;
_internal_cast_connection_info_size()6712 inline int CastLogsProto::_internal_cast_connection_info_size() const {
6713   return _impl_.cast_connection_info_.size();
6714 }
cast_connection_info_size()6715 inline int CastLogsProto::cast_connection_info_size() const {
6716   return _internal_cast_connection_info_size();
6717 }
clear_cast_connection_info()6718 inline void CastLogsProto::clear_cast_connection_info() {
6719   _impl_.cast_connection_info_.Clear();
6720 }
mutable_cast_connection_info(int index)6721 inline ::metrics::CastLogsProto_CastConnectionInfo* CastLogsProto::mutable_cast_connection_info(int index) {
6722   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.cast_connection_info)
6723   return _impl_.cast_connection_info_.Mutable(index);
6724 }
6725 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastConnectionInfo >*
mutable_cast_connection_info()6726 CastLogsProto::mutable_cast_connection_info() {
6727   // @@protoc_insertion_point(field_mutable_list:metrics.CastLogsProto.cast_connection_info)
6728   return &_impl_.cast_connection_info_;
6729 }
_internal_cast_connection_info(int index)6730 inline const ::metrics::CastLogsProto_CastConnectionInfo& CastLogsProto::_internal_cast_connection_info(int index) const {
6731   return _impl_.cast_connection_info_.Get(index);
6732 }
cast_connection_info(int index)6733 inline const ::metrics::CastLogsProto_CastConnectionInfo& CastLogsProto::cast_connection_info(int index) const {
6734   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.cast_connection_info)
6735   return _internal_cast_connection_info(index);
6736 }
_internal_add_cast_connection_info()6737 inline ::metrics::CastLogsProto_CastConnectionInfo* CastLogsProto::_internal_add_cast_connection_info() {
6738   return _impl_.cast_connection_info_.Add();
6739 }
add_cast_connection_info()6740 inline ::metrics::CastLogsProto_CastConnectionInfo* CastLogsProto::add_cast_connection_info() {
6741   ::metrics::CastLogsProto_CastConnectionInfo* _add = _internal_add_cast_connection_info();
6742   // @@protoc_insertion_point(field_add:metrics.CastLogsProto.cast_connection_info)
6743   return _add;
6744 }
6745 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastConnectionInfo >&
cast_connection_info()6746 CastLogsProto::cast_connection_info() const {
6747   // @@protoc_insertion_point(field_list:metrics.CastLogsProto.cast_connection_info)
6748   return _impl_.cast_connection_info_;
6749 }
6750 
6751 // repeated .metrics.CastLogsProto.CastEventProto cast_event = 3;
_internal_cast_event_size()6752 inline int CastLogsProto::_internal_cast_event_size() const {
6753   return _impl_.cast_event_.size();
6754 }
cast_event_size()6755 inline int CastLogsProto::cast_event_size() const {
6756   return _internal_cast_event_size();
6757 }
clear_cast_event()6758 inline void CastLogsProto::clear_cast_event() {
6759   _impl_.cast_event_.Clear();
6760 }
mutable_cast_event(int index)6761 inline ::metrics::CastLogsProto_CastEventProto* CastLogsProto::mutable_cast_event(int index) {
6762   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.cast_event)
6763   return _impl_.cast_event_.Mutable(index);
6764 }
6765 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto >*
mutable_cast_event()6766 CastLogsProto::mutable_cast_event() {
6767   // @@protoc_insertion_point(field_mutable_list:metrics.CastLogsProto.cast_event)
6768   return &_impl_.cast_event_;
6769 }
_internal_cast_event(int index)6770 inline const ::metrics::CastLogsProto_CastEventProto& CastLogsProto::_internal_cast_event(int index) const {
6771   return _impl_.cast_event_.Get(index);
6772 }
cast_event(int index)6773 inline const ::metrics::CastLogsProto_CastEventProto& CastLogsProto::cast_event(int index) const {
6774   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.cast_event)
6775   return _internal_cast_event(index);
6776 }
_internal_add_cast_event()6777 inline ::metrics::CastLogsProto_CastEventProto* CastLogsProto::_internal_add_cast_event() {
6778   return _impl_.cast_event_.Add();
6779 }
add_cast_event()6780 inline ::metrics::CastLogsProto_CastEventProto* CastLogsProto::add_cast_event() {
6781   ::metrics::CastLogsProto_CastEventProto* _add = _internal_add_cast_event();
6782   // @@protoc_insertion_point(field_add:metrics.CastLogsProto.cast_event)
6783   return _add;
6784 }
6785 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::CastLogsProto_CastEventProto >&
cast_event()6786 CastLogsProto::cast_event() const {
6787   // @@protoc_insertion_point(field_list:metrics.CastLogsProto.cast_event)
6788   return _impl_.cast_event_;
6789 }
6790 
6791 // optional fixed32 virtual_release_track = 4;
_internal_has_virtual_release_track()6792 inline bool CastLogsProto::_internal_has_virtual_release_track() const {
6793   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
6794   return value;
6795 }
has_virtual_release_track()6796 inline bool CastLogsProto::has_virtual_release_track() const {
6797   return _internal_has_virtual_release_track();
6798 }
clear_virtual_release_track()6799 inline void CastLogsProto::clear_virtual_release_track() {
6800   _impl_.virtual_release_track_ = 0u;
6801   _impl_._has_bits_[0] &= ~0x00000008u;
6802 }
_internal_virtual_release_track()6803 inline uint32_t CastLogsProto::_internal_virtual_release_track() const {
6804   return _impl_.virtual_release_track_;
6805 }
virtual_release_track()6806 inline uint32_t CastLogsProto::virtual_release_track() const {
6807   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.virtual_release_track)
6808   return _internal_virtual_release_track();
6809 }
_internal_set_virtual_release_track(uint32_t value)6810 inline void CastLogsProto::_internal_set_virtual_release_track(uint32_t value) {
6811   _impl_._has_bits_[0] |= 0x00000008u;
6812   _impl_.virtual_release_track_ = value;
6813 }
set_virtual_release_track(uint32_t value)6814 inline void CastLogsProto::set_virtual_release_track(uint32_t value) {
6815   _internal_set_virtual_release_track(value);
6816   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.virtual_release_track)
6817 }
6818 
6819 // optional .metrics.CastLogsProto.CastDeviceMutableInfo cast_device_mutable_info = 5;
_internal_has_cast_device_mutable_info()6820 inline bool CastLogsProto::_internal_has_cast_device_mutable_info() const {
6821   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6822   PROTOBUF_ASSUME(!value || _impl_.cast_device_mutable_info_ != nullptr);
6823   return value;
6824 }
has_cast_device_mutable_info()6825 inline bool CastLogsProto::has_cast_device_mutable_info() const {
6826   return _internal_has_cast_device_mutable_info();
6827 }
clear_cast_device_mutable_info()6828 inline void CastLogsProto::clear_cast_device_mutable_info() {
6829   if (_impl_.cast_device_mutable_info_ != nullptr) _impl_.cast_device_mutable_info_->Clear();
6830   _impl_._has_bits_[0] &= ~0x00000002u;
6831 }
_internal_cast_device_mutable_info()6832 inline const ::metrics::CastLogsProto_CastDeviceMutableInfo& CastLogsProto::_internal_cast_device_mutable_info() const {
6833   const ::metrics::CastLogsProto_CastDeviceMutableInfo* p = _impl_.cast_device_mutable_info_;
6834   return p != nullptr ? *p : reinterpret_cast<const ::metrics::CastLogsProto_CastDeviceMutableInfo&>(
6835       ::metrics::_CastLogsProto_CastDeviceMutableInfo_default_instance_);
6836 }
cast_device_mutable_info()6837 inline const ::metrics::CastLogsProto_CastDeviceMutableInfo& CastLogsProto::cast_device_mutable_info() const {
6838   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.cast_device_mutable_info)
6839   return _internal_cast_device_mutable_info();
6840 }
unsafe_arena_set_allocated_cast_device_mutable_info(::metrics::CastLogsProto_CastDeviceMutableInfo * cast_device_mutable_info)6841 inline void CastLogsProto::unsafe_arena_set_allocated_cast_device_mutable_info(
6842     ::metrics::CastLogsProto_CastDeviceMutableInfo* cast_device_mutable_info) {
6843   if (GetArenaForAllocation() == nullptr) {
6844     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cast_device_mutable_info_);
6845   }
6846   _impl_.cast_device_mutable_info_ = cast_device_mutable_info;
6847   if (cast_device_mutable_info) {
6848     _impl_._has_bits_[0] |= 0x00000002u;
6849   } else {
6850     _impl_._has_bits_[0] &= ~0x00000002u;
6851   }
6852   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.CastLogsProto.cast_device_mutable_info)
6853 }
release_cast_device_mutable_info()6854 inline ::metrics::CastLogsProto_CastDeviceMutableInfo* CastLogsProto::release_cast_device_mutable_info() {
6855   _impl_._has_bits_[0] &= ~0x00000002u;
6856   ::metrics::CastLogsProto_CastDeviceMutableInfo* temp = _impl_.cast_device_mutable_info_;
6857   _impl_.cast_device_mutable_info_ = nullptr;
6858 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6859   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6860   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6861   if (GetArenaForAllocation() == nullptr) { delete old; }
6862 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6863   if (GetArenaForAllocation() != nullptr) {
6864     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6865   }
6866 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6867   return temp;
6868 }
unsafe_arena_release_cast_device_mutable_info()6869 inline ::metrics::CastLogsProto_CastDeviceMutableInfo* CastLogsProto::unsafe_arena_release_cast_device_mutable_info() {
6870   // @@protoc_insertion_point(field_release:metrics.CastLogsProto.cast_device_mutable_info)
6871   _impl_._has_bits_[0] &= ~0x00000002u;
6872   ::metrics::CastLogsProto_CastDeviceMutableInfo* temp = _impl_.cast_device_mutable_info_;
6873   _impl_.cast_device_mutable_info_ = nullptr;
6874   return temp;
6875 }
_internal_mutable_cast_device_mutable_info()6876 inline ::metrics::CastLogsProto_CastDeviceMutableInfo* CastLogsProto::_internal_mutable_cast_device_mutable_info() {
6877   _impl_._has_bits_[0] |= 0x00000002u;
6878   if (_impl_.cast_device_mutable_info_ == nullptr) {
6879     auto* p = CreateMaybeMessage<::metrics::CastLogsProto_CastDeviceMutableInfo>(GetArenaForAllocation());
6880     _impl_.cast_device_mutable_info_ = p;
6881   }
6882   return _impl_.cast_device_mutable_info_;
6883 }
mutable_cast_device_mutable_info()6884 inline ::metrics::CastLogsProto_CastDeviceMutableInfo* CastLogsProto::mutable_cast_device_mutable_info() {
6885   ::metrics::CastLogsProto_CastDeviceMutableInfo* _msg = _internal_mutable_cast_device_mutable_info();
6886   // @@protoc_insertion_point(field_mutable:metrics.CastLogsProto.cast_device_mutable_info)
6887   return _msg;
6888 }
set_allocated_cast_device_mutable_info(::metrics::CastLogsProto_CastDeviceMutableInfo * cast_device_mutable_info)6889 inline void CastLogsProto::set_allocated_cast_device_mutable_info(::metrics::CastLogsProto_CastDeviceMutableInfo* cast_device_mutable_info) {
6890   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6891   if (message_arena == nullptr) {
6892     delete _impl_.cast_device_mutable_info_;
6893   }
6894   if (cast_device_mutable_info) {
6895     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6896         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cast_device_mutable_info);
6897     if (message_arena != submessage_arena) {
6898       cast_device_mutable_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6899           message_arena, cast_device_mutable_info, submessage_arena);
6900     }
6901     _impl_._has_bits_[0] |= 0x00000002u;
6902   } else {
6903     _impl_._has_bits_[0] &= ~0x00000002u;
6904   }
6905   _impl_.cast_device_mutable_info_ = cast_device_mutable_info;
6906   // @@protoc_insertion_point(field_set_allocated:metrics.CastLogsProto.cast_device_mutable_info)
6907 }
6908 
6909 // optional fixed64 receiver_metrics_id = 6;
_internal_has_receiver_metrics_id()6910 inline bool CastLogsProto::_internal_has_receiver_metrics_id() const {
6911   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
6912   return value;
6913 }
has_receiver_metrics_id()6914 inline bool CastLogsProto::has_receiver_metrics_id() const {
6915   return _internal_has_receiver_metrics_id();
6916 }
clear_receiver_metrics_id()6917 inline void CastLogsProto::clear_receiver_metrics_id() {
6918   _impl_.receiver_metrics_id_ = uint64_t{0u};
6919   _impl_._has_bits_[0] &= ~0x00000004u;
6920 }
_internal_receiver_metrics_id()6921 inline uint64_t CastLogsProto::_internal_receiver_metrics_id() const {
6922   return _impl_.receiver_metrics_id_;
6923 }
receiver_metrics_id()6924 inline uint64_t CastLogsProto::receiver_metrics_id() const {
6925   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.receiver_metrics_id)
6926   return _internal_receiver_metrics_id();
6927 }
_internal_set_receiver_metrics_id(uint64_t value)6928 inline void CastLogsProto::_internal_set_receiver_metrics_id(uint64_t value) {
6929   _impl_._has_bits_[0] |= 0x00000004u;
6930   _impl_.receiver_metrics_id_ = value;
6931 }
set_receiver_metrics_id(uint64_t value)6932 inline void CastLogsProto::set_receiver_metrics_id(uint64_t value) {
6933   _internal_set_receiver_metrics_id(value);
6934   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.receiver_metrics_id)
6935 }
6936 
6937 // optional uint64 ephemeral_id = 7;
_internal_has_ephemeral_id()6938 inline bool CastLogsProto::_internal_has_ephemeral_id() const {
6939   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
6940   return value;
6941 }
has_ephemeral_id()6942 inline bool CastLogsProto::has_ephemeral_id() const {
6943   return _internal_has_ephemeral_id();
6944 }
clear_ephemeral_id()6945 inline void CastLogsProto::clear_ephemeral_id() {
6946   _impl_.ephemeral_id_ = uint64_t{0u};
6947   _impl_._has_bits_[0] &= ~0x00000020u;
6948 }
_internal_ephemeral_id()6949 inline uint64_t CastLogsProto::_internal_ephemeral_id() const {
6950   return _impl_.ephemeral_id_;
6951 }
ephemeral_id()6952 inline uint64_t CastLogsProto::ephemeral_id() const {
6953   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.ephemeral_id)
6954   return _internal_ephemeral_id();
6955 }
_internal_set_ephemeral_id(uint64_t value)6956 inline void CastLogsProto::_internal_set_ephemeral_id(uint64_t value) {
6957   _impl_._has_bits_[0] |= 0x00000020u;
6958   _impl_.ephemeral_id_ = value;
6959 }
set_ephemeral_id(uint64_t value)6960 inline void CastLogsProto::set_ephemeral_id(uint64_t value) {
6961   _internal_set_ephemeral_id(value);
6962   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.ephemeral_id)
6963 }
6964 
6965 // optional fixed32 source_virtual_release_track = 8;
_internal_has_source_virtual_release_track()6966 inline bool CastLogsProto::_internal_has_source_virtual_release_track() const {
6967   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
6968   return value;
6969 }
has_source_virtual_release_track()6970 inline bool CastLogsProto::has_source_virtual_release_track() const {
6971   return _internal_has_source_virtual_release_track();
6972 }
clear_source_virtual_release_track()6973 inline void CastLogsProto::clear_source_virtual_release_track() {
6974   _impl_.source_virtual_release_track_ = 0u;
6975   _impl_._has_bits_[0] &= ~0x00000010u;
6976 }
_internal_source_virtual_release_track()6977 inline uint32_t CastLogsProto::_internal_source_virtual_release_track() const {
6978   return _impl_.source_virtual_release_track_;
6979 }
source_virtual_release_track()6980 inline uint32_t CastLogsProto::source_virtual_release_track() const {
6981   // @@protoc_insertion_point(field_get:metrics.CastLogsProto.source_virtual_release_track)
6982   return _internal_source_virtual_release_track();
6983 }
_internal_set_source_virtual_release_track(uint32_t value)6984 inline void CastLogsProto::_internal_set_source_virtual_release_track(uint32_t value) {
6985   _impl_._has_bits_[0] |= 0x00000010u;
6986   _impl_.source_virtual_release_track_ = value;
6987 }
set_source_virtual_release_track(uint32_t value)6988 inline void CastLogsProto::set_source_virtual_release_track(uint32_t value) {
6989   _internal_set_source_virtual_release_track(value);
6990   // @@protoc_insertion_point(field_set:metrics.CastLogsProto.source_virtual_release_track)
6991 }
6992 
6993 #ifdef __GNUC__
6994   #pragma GCC diagnostic pop
6995 #endif  // __GNUC__
6996 // -------------------------------------------------------------------
6997 
6998 // -------------------------------------------------------------------
6999 
7000 // -------------------------------------------------------------------
7001 
7002 // -------------------------------------------------------------------
7003 
7004 // -------------------------------------------------------------------
7005 
7006 // -------------------------------------------------------------------
7007 
7008 // -------------------------------------------------------------------
7009 
7010 
7011 // @@protoc_insertion_point(namespace_scope)
7012 
7013 }  // namespace metrics
7014 
7015 PROTOBUF_NAMESPACE_OPEN
7016 
7017 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastDeviceInfo_CastProductType> : ::std::true_type {};
7018 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_SDKType> : ::std::true_type {};
7019 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_Platform> : ::std::true_type {};
7020 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastConnectionInfo_SenderInfo_ConnectionType> : ::std::true_type {};
7021 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastEventProto_LaunchFrom> : ::std::true_type {};
7022 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastEventProto_RuntimeType> : ::std::true_type {};
7023 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastDeviceMutableInfo_RebootType> : ::std::true_type {};
7024 template <> struct is_proto_enum< ::metrics::CastLogsProto_CastDeviceMutableInfo_NetifIPVersion> : ::std::true_type {};
7025 
7026 PROTOBUF_NAMESPACE_CLOSE
7027 
7028 // @@protoc_insertion_point(global_scope)
7029 
7030 #include <google/protobuf/port_undef.inc>
7031 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_cast_5flogs_2eproto
7032