1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: safebrowsing.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto
6
7 #include <limits>
8 #include <string>
9
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3011000
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 3011004 < 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_table_driven.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/inlined_string_field.h>
29 #include <google/protobuf/metadata_lite.h>
30 #include <google/protobuf/message_lite.h>
31 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
32 #include <google/protobuf/extension_set.h> // IWYU pragma: export
33 #include <google/protobuf/generated_enum_util.h>
34 // @@protoc_insertion_point(includes)
35 #include <google/protobuf/port_def.inc>
36 #define PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto
37 PROTOBUF_NAMESPACE_OPEN
38 namespace internal {
39 class AnyMetadata;
40 } // namespace internal
41 PROTOBUF_NAMESPACE_CLOSE
42
43 // Internal implementation detail -- do not use these members.
44 struct TableStruct_safebrowsing_2eproto {
45 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
46 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
47 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
48 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
49 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[27]
50 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
52 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
53 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
54 };
55 namespace mozilla {
56 namespace safebrowsing {
57 class Checksum;
58 class ChecksumDefaultTypeInternal;
59 extern ChecksumDefaultTypeInternal _Checksum_default_instance_;
60 class ChromeClientInfo;
61 class ChromeClientInfoDefaultTypeInternal;
62 extern ChromeClientInfoDefaultTypeInternal _ChromeClientInfo_default_instance_;
63 class ClientInfo;
64 class ClientInfoDefaultTypeInternal;
65 extern ClientInfoDefaultTypeInternal _ClientInfo_default_instance_;
66 class Duration;
67 class DurationDefaultTypeInternal;
68 extern DurationDefaultTypeInternal _Duration_default_instance_;
69 class FetchThreatListUpdatesRequest;
70 class FetchThreatListUpdatesRequestDefaultTypeInternal;
71 extern FetchThreatListUpdatesRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_default_instance_;
72 class FetchThreatListUpdatesRequest_ListUpdateRequest;
73 class FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal;
74 extern FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_;
75 class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints;
76 class FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal;
77 extern FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_;
78 class FetchThreatListUpdatesResponse;
79 class FetchThreatListUpdatesResponseDefaultTypeInternal;
80 extern FetchThreatListUpdatesResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_default_instance_;
81 class FetchThreatListUpdatesResponse_ListUpdateResponse;
82 class FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal;
83 extern FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_;
84 class FindFullHashesRequest;
85 class FindFullHashesRequestDefaultTypeInternal;
86 extern FindFullHashesRequestDefaultTypeInternal _FindFullHashesRequest_default_instance_;
87 class FindFullHashesResponse;
88 class FindFullHashesResponseDefaultTypeInternal;
89 extern FindFullHashesResponseDefaultTypeInternal _FindFullHashesResponse_default_instance_;
90 class FindThreatMatchesRequest;
91 class FindThreatMatchesRequestDefaultTypeInternal;
92 extern FindThreatMatchesRequestDefaultTypeInternal _FindThreatMatchesRequest_default_instance_;
93 class FindThreatMatchesResponse;
94 class FindThreatMatchesResponseDefaultTypeInternal;
95 extern FindThreatMatchesResponseDefaultTypeInternal _FindThreatMatchesResponse_default_instance_;
96 class ListThreatListsResponse;
97 class ListThreatListsResponseDefaultTypeInternal;
98 extern ListThreatListsResponseDefaultTypeInternal _ListThreatListsResponse_default_instance_;
99 class RawHashes;
100 class RawHashesDefaultTypeInternal;
101 extern RawHashesDefaultTypeInternal _RawHashes_default_instance_;
102 class RawIndices;
103 class RawIndicesDefaultTypeInternal;
104 extern RawIndicesDefaultTypeInternal _RawIndices_default_instance_;
105 class RiceDeltaEncoding;
106 class RiceDeltaEncodingDefaultTypeInternal;
107 extern RiceDeltaEncodingDefaultTypeInternal _RiceDeltaEncoding_default_instance_;
108 class ThreatEntry;
109 class ThreatEntryDefaultTypeInternal;
110 extern ThreatEntryDefaultTypeInternal _ThreatEntry_default_instance_;
111 class ThreatEntryMetadata;
112 class ThreatEntryMetadataDefaultTypeInternal;
113 extern ThreatEntryMetadataDefaultTypeInternal _ThreatEntryMetadata_default_instance_;
114 class ThreatEntryMetadata_MetadataEntry;
115 class ThreatEntryMetadata_MetadataEntryDefaultTypeInternal;
116 extern ThreatEntryMetadata_MetadataEntryDefaultTypeInternal _ThreatEntryMetadata_MetadataEntry_default_instance_;
117 class ThreatEntrySet;
118 class ThreatEntrySetDefaultTypeInternal;
119 extern ThreatEntrySetDefaultTypeInternal _ThreatEntrySet_default_instance_;
120 class ThreatHit;
121 class ThreatHitDefaultTypeInternal;
122 extern ThreatHitDefaultTypeInternal _ThreatHit_default_instance_;
123 class ThreatHit_ThreatSource;
124 class ThreatHit_ThreatSourceDefaultTypeInternal;
125 extern ThreatHit_ThreatSourceDefaultTypeInternal _ThreatHit_ThreatSource_default_instance_;
126 class ThreatHit_UserInfo;
127 class ThreatHit_UserInfoDefaultTypeInternal;
128 extern ThreatHit_UserInfoDefaultTypeInternal _ThreatHit_UserInfo_default_instance_;
129 class ThreatInfo;
130 class ThreatInfoDefaultTypeInternal;
131 extern ThreatInfoDefaultTypeInternal _ThreatInfo_default_instance_;
132 class ThreatListDescriptor;
133 class ThreatListDescriptorDefaultTypeInternal;
134 extern ThreatListDescriptorDefaultTypeInternal _ThreatListDescriptor_default_instance_;
135 class ThreatMatch;
136 class ThreatMatchDefaultTypeInternal;
137 extern ThreatMatchDefaultTypeInternal _ThreatMatch_default_instance_;
138 } // namespace safebrowsing
139 } // namespace mozilla
140 PROTOBUF_NAMESPACE_OPEN
141 template<> ::mozilla::safebrowsing::Checksum* Arena::CreateMaybeMessage<::mozilla::safebrowsing::Checksum>(Arena*);
142 template<> ::mozilla::safebrowsing::ChromeClientInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ChromeClientInfo>(Arena*);
143 template<> ::mozilla::safebrowsing::ClientInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(Arena*);
144 template<> ::mozilla::safebrowsing::Duration* Arena::CreateMaybeMessage<::mozilla::safebrowsing::Duration>(Arena*);
145 template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest>(Arena*);
146 template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest>(Arena*);
147 template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(Arena*);
148 template<> ::mozilla::safebrowsing::FetchThreatListUpdatesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesResponse>(Arena*);
149 template<> ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse>(Arena*);
150 template<> ::mozilla::safebrowsing::FindFullHashesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindFullHashesRequest>(Arena*);
151 template<> ::mozilla::safebrowsing::FindFullHashesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindFullHashesResponse>(Arena*);
152 template<> ::mozilla::safebrowsing::FindThreatMatchesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindThreatMatchesRequest>(Arena*);
153 template<> ::mozilla::safebrowsing::FindThreatMatchesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindThreatMatchesResponse>(Arena*);
154 template<> ::mozilla::safebrowsing::ListThreatListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ListThreatListsResponse>(Arena*);
155 template<> ::mozilla::safebrowsing::RawHashes* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RawHashes>(Arena*);
156 template<> ::mozilla::safebrowsing::RawIndices* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RawIndices>(Arena*);
157 template<> ::mozilla::safebrowsing::RiceDeltaEncoding* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(Arena*);
158 template<> ::mozilla::safebrowsing::ThreatEntry* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(Arena*);
159 template<> ::mozilla::safebrowsing::ThreatEntryMetadata* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata>(Arena*);
160 template<> ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry>(Arena*);
161 template<> ::mozilla::safebrowsing::ThreatEntrySet* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntrySet>(Arena*);
162 template<> ::mozilla::safebrowsing::ThreatHit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit>(Arena*);
163 template<> ::mozilla::safebrowsing::ThreatHit_ThreatSource* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_ThreatSource>(Arena*);
164 template<> ::mozilla::safebrowsing::ThreatHit_UserInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_UserInfo>(Arena*);
165 template<> ::mozilla::safebrowsing::ThreatInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(Arena*);
166 template<> ::mozilla::safebrowsing::ThreatListDescriptor* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatListDescriptor>(Arena*);
167 template<> ::mozilla::safebrowsing::ThreatMatch* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatMatch>(Arena*);
168 PROTOBUF_NAMESPACE_CLOSE
169 namespace mozilla {
170 namespace safebrowsing {
171
172 enum FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType : int {
173 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED = 0,
174 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE = 1,
175 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE = 2
176 };
177 bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value);
178 constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED;
179 constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE;
180 constexpr int FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX + 1;
181
182 const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
183 template<typename T>
FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(T enum_t_value)184 inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(T enum_t_value) {
185 static_assert(::std::is_same<T, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>::value ||
186 ::std::is_integral<T>::value,
187 "Incorrect type passed to function FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name.");
188 return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(static_cast<FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>(enum_t_value));
189 }
190 bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse(
191 const std::string& name, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType* value);
192 enum ThreatHit_ThreatSourceType : int {
193 ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED = 0,
194 ThreatHit_ThreatSourceType_MATCHING_URL = 1,
195 ThreatHit_ThreatSourceType_TAB_URL = 2,
196 ThreatHit_ThreatSourceType_TAB_REDIRECT = 3,
197 ThreatHit_ThreatSourceType_TAB_RESOURCE = 4
198 };
199 bool ThreatHit_ThreatSourceType_IsValid(int value);
200 constexpr ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MIN = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED;
201 constexpr ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MAX = ThreatHit_ThreatSourceType_TAB_RESOURCE;
202 constexpr int ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE = ThreatHit_ThreatSourceType_ThreatSourceType_MAX + 1;
203
204 const std::string& ThreatHit_ThreatSourceType_Name(ThreatHit_ThreatSourceType value);
205 template<typename T>
ThreatHit_ThreatSourceType_Name(T enum_t_value)206 inline const std::string& ThreatHit_ThreatSourceType_Name(T enum_t_value) {
207 static_assert(::std::is_same<T, ThreatHit_ThreatSourceType>::value ||
208 ::std::is_integral<T>::value,
209 "Incorrect type passed to function ThreatHit_ThreatSourceType_Name.");
210 return ThreatHit_ThreatSourceType_Name(static_cast<ThreatHit_ThreatSourceType>(enum_t_value));
211 }
212 bool ThreatHit_ThreatSourceType_Parse(
213 const std::string& name, ThreatHit_ThreatSourceType* value);
214 enum ChromeClientInfo_SafeBrowsingReportingPopulation : int {
215 ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED = 0,
216 ChromeClientInfo_SafeBrowsingReportingPopulation_OPT_OUT = 1,
217 ChromeClientInfo_SafeBrowsingReportingPopulation_EXTENDED = 2,
218 ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT = 3
219 };
220 bool ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(int value);
221 constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MIN = ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED;
222 constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX = ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT;
223 constexpr int ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_ARRAYSIZE = ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX + 1;
224
225 const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name(ChromeClientInfo_SafeBrowsingReportingPopulation value);
226 template<typename T>
ChromeClientInfo_SafeBrowsingReportingPopulation_Name(T enum_t_value)227 inline const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name(T enum_t_value) {
228 static_assert(::std::is_same<T, ChromeClientInfo_SafeBrowsingReportingPopulation>::value ||
229 ::std::is_integral<T>::value,
230 "Incorrect type passed to function ChromeClientInfo_SafeBrowsingReportingPopulation_Name.");
231 return ChromeClientInfo_SafeBrowsingReportingPopulation_Name(static_cast<ChromeClientInfo_SafeBrowsingReportingPopulation>(enum_t_value));
232 }
233 bool ChromeClientInfo_SafeBrowsingReportingPopulation_Parse(
234 const std::string& name, ChromeClientInfo_SafeBrowsingReportingPopulation* value);
235 enum ThreatType : int {
236 THREAT_TYPE_UNSPECIFIED = 0,
237 MALWARE_THREAT = 1,
238 SOCIAL_ENGINEERING_PUBLIC = 2,
239 UNWANTED_SOFTWARE = 3,
240 POTENTIALLY_HARMFUL_APPLICATION = 4,
241 SOCIAL_ENGINEERING = 5,
242 API_ABUSE = 6,
243 MALICIOUS_BINARY = 7,
244 CSD_WHITELIST = 8,
245 CSD_DOWNLOAD_WHITELIST = 9,
246 CLIENT_INCIDENT = 10,
247 SUBRESOURCE_FILTER = 13
248 };
249 bool ThreatType_IsValid(int value);
250 constexpr ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED;
251 constexpr ThreatType ThreatType_MAX = SUBRESOURCE_FILTER;
252 constexpr int ThreatType_ARRAYSIZE = ThreatType_MAX + 1;
253
254 const std::string& ThreatType_Name(ThreatType value);
255 template<typename T>
ThreatType_Name(T enum_t_value)256 inline const std::string& ThreatType_Name(T enum_t_value) {
257 static_assert(::std::is_same<T, ThreatType>::value ||
258 ::std::is_integral<T>::value,
259 "Incorrect type passed to function ThreatType_Name.");
260 return ThreatType_Name(static_cast<ThreatType>(enum_t_value));
261 }
262 bool ThreatType_Parse(
263 const std::string& name, ThreatType* value);
264 enum PlatformType : int {
265 PLATFORM_TYPE_UNSPECIFIED = 0,
266 WINDOWS_PLATFORM = 1,
267 LINUX_PLATFORM = 2,
268 ANDROID_PLATFORM = 3,
269 OSX_PLATFORM = 4,
270 IOS_PLATFORM = 5,
271 ANY_PLATFORM = 6,
272 ALL_PLATFORMS = 7,
273 CHROME_PLATFORM = 8
274 };
275 bool PlatformType_IsValid(int value);
276 constexpr PlatformType PlatformType_MIN = PLATFORM_TYPE_UNSPECIFIED;
277 constexpr PlatformType PlatformType_MAX = CHROME_PLATFORM;
278 constexpr int PlatformType_ARRAYSIZE = PlatformType_MAX + 1;
279
280 const std::string& PlatformType_Name(PlatformType value);
281 template<typename T>
PlatformType_Name(T enum_t_value)282 inline const std::string& PlatformType_Name(T enum_t_value) {
283 static_assert(::std::is_same<T, PlatformType>::value ||
284 ::std::is_integral<T>::value,
285 "Incorrect type passed to function PlatformType_Name.");
286 return PlatformType_Name(static_cast<PlatformType>(enum_t_value));
287 }
288 bool PlatformType_Parse(
289 const std::string& name, PlatformType* value);
290 enum CompressionType : int {
291 COMPRESSION_TYPE_UNSPECIFIED = 0,
292 RAW = 1,
293 RICE = 2
294 };
295 bool CompressionType_IsValid(int value);
296 constexpr CompressionType CompressionType_MIN = COMPRESSION_TYPE_UNSPECIFIED;
297 constexpr CompressionType CompressionType_MAX = RICE;
298 constexpr int CompressionType_ARRAYSIZE = CompressionType_MAX + 1;
299
300 const std::string& CompressionType_Name(CompressionType value);
301 template<typename T>
CompressionType_Name(T enum_t_value)302 inline const std::string& CompressionType_Name(T enum_t_value) {
303 static_assert(::std::is_same<T, CompressionType>::value ||
304 ::std::is_integral<T>::value,
305 "Incorrect type passed to function CompressionType_Name.");
306 return CompressionType_Name(static_cast<CompressionType>(enum_t_value));
307 }
308 bool CompressionType_Parse(
309 const std::string& name, CompressionType* value);
310 enum ThreatEntryType : int {
311 THREAT_ENTRY_TYPE_UNSPECIFIED = 0,
312 URL = 1,
313 EXECUTABLE = 2,
314 IP_RANGE = 3,
315 CHROME_EXTENSION = 4,
316 FILENAME = 5,
317 CERT = 6
318 };
319 bool ThreatEntryType_IsValid(int value);
320 constexpr ThreatEntryType ThreatEntryType_MIN = THREAT_ENTRY_TYPE_UNSPECIFIED;
321 constexpr ThreatEntryType ThreatEntryType_MAX = CERT;
322 constexpr int ThreatEntryType_ARRAYSIZE = ThreatEntryType_MAX + 1;
323
324 const std::string& ThreatEntryType_Name(ThreatEntryType value);
325 template<typename T>
ThreatEntryType_Name(T enum_t_value)326 inline const std::string& ThreatEntryType_Name(T enum_t_value) {
327 static_assert(::std::is_same<T, ThreatEntryType>::value ||
328 ::std::is_integral<T>::value,
329 "Incorrect type passed to function ThreatEntryType_Name.");
330 return ThreatEntryType_Name(static_cast<ThreatEntryType>(enum_t_value));
331 }
332 bool ThreatEntryType_Parse(
333 const std::string& name, ThreatEntryType* value);
334 // ===================================================================
335
336 class ThreatInfo :
337 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatInfo) */ {
338 public:
339 ThreatInfo();
340 virtual ~ThreatInfo();
341
342 ThreatInfo(const ThreatInfo& from);
ThreatInfo(ThreatInfo && from)343 ThreatInfo(ThreatInfo&& from) noexcept
344 : ThreatInfo() {
345 *this = ::std::move(from);
346 }
347
348 inline ThreatInfo& operator=(const ThreatInfo& from) {
349 CopyFrom(from);
350 return *this;
351 }
352 inline ThreatInfo& operator=(ThreatInfo&& from) noexcept {
353 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
354 if (this != &from) InternalSwap(&from);
355 } else {
356 CopyFrom(from);
357 }
358 return *this;
359 }
360
unknown_fields()361 inline const std::string& unknown_fields() const {
362 return _internal_metadata_.unknown_fields();
363 }
mutable_unknown_fields()364 inline std::string* mutable_unknown_fields() {
365 return _internal_metadata_.mutable_unknown_fields();
366 }
367
368 static const ThreatInfo& default_instance();
369
370 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()371 static inline const ThreatInfo* internal_default_instance() {
372 return reinterpret_cast<const ThreatInfo*>(
373 &_ThreatInfo_default_instance_);
374 }
375 static constexpr int kIndexInFileMessages =
376 0;
377
swap(ThreatInfo & a,ThreatInfo & b)378 friend void swap(ThreatInfo& a, ThreatInfo& b) {
379 a.Swap(&b);
380 }
Swap(ThreatInfo * other)381 inline void Swap(ThreatInfo* other) {
382 if (other == this) return;
383 InternalSwap(other);
384 }
385
386 // implements Message ----------------------------------------------
387
New()388 inline ThreatInfo* New() const final {
389 return CreateMaybeMessage<ThreatInfo>(nullptr);
390 }
391
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)392 ThreatInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
393 return CreateMaybeMessage<ThreatInfo>(arena);
394 }
395 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
396 final;
397 void CopyFrom(const ThreatInfo& from);
398 void MergeFrom(const ThreatInfo& from);
399 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
400 bool IsInitialized() const final;
401
402 size_t ByteSizeLong() const final;
403 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
404 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
405 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
406 void DiscardUnknownFields();
GetCachedSize()407 int GetCachedSize() const final { return _cached_size_.Get(); }
408
409 private:
410 inline void SharedCtor();
411 inline void SharedDtor();
412 void SetCachedSize(int size) const;
413 void InternalSwap(ThreatInfo* other);
414 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()415 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
416 return "mozilla.safebrowsing.ThreatInfo";
417 }
418 private:
GetArenaNoVirtual()419 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
420 return nullptr;
421 }
MaybeArenaPtr()422 inline void* MaybeArenaPtr() const {
423 return nullptr;
424 }
425 public:
426
427 std::string GetTypeName() const final;
428
429 // nested types ----------------------------------------------------
430
431 // accessors -------------------------------------------------------
432
433 enum : int {
434 kThreatTypesFieldNumber = 1,
435 kPlatformTypesFieldNumber = 2,
436 kThreatEntriesFieldNumber = 3,
437 kThreatEntryTypesFieldNumber = 4,
438 };
439 // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
440 int threat_types_size() const;
441 private:
442 int _internal_threat_types_size() const;
443 public:
444 void clear_threat_types();
445 private:
446 ::mozilla::safebrowsing::ThreatType _internal_threat_types(int index) const;
447 void _internal_add_threat_types(::mozilla::safebrowsing::ThreatType value);
448 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_types();
449 public:
450 ::mozilla::safebrowsing::ThreatType threat_types(int index) const;
451 void set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value);
452 void add_threat_types(::mozilla::safebrowsing::ThreatType value);
453 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_types() const;
454 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_types();
455
456 // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
457 int platform_types_size() const;
458 private:
459 int _internal_platform_types_size() const;
460 public:
461 void clear_platform_types();
462 private:
463 ::mozilla::safebrowsing::PlatformType _internal_platform_types(int index) const;
464 void _internal_add_platform_types(::mozilla::safebrowsing::PlatformType value);
465 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_platform_types();
466 public:
467 ::mozilla::safebrowsing::PlatformType platform_types(int index) const;
468 void set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value);
469 void add_platform_types(::mozilla::safebrowsing::PlatformType value);
470 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& platform_types() const;
471 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_platform_types();
472
473 // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
474 int threat_entries_size() const;
475 private:
476 int _internal_threat_entries_size() const;
477 public:
478 void clear_threat_entries();
479 ::mozilla::safebrowsing::ThreatEntry* mutable_threat_entries(int index);
480 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >*
481 mutable_threat_entries();
482 private:
483 const ::mozilla::safebrowsing::ThreatEntry& _internal_threat_entries(int index) const;
484 ::mozilla::safebrowsing::ThreatEntry* _internal_add_threat_entries();
485 public:
486 const ::mozilla::safebrowsing::ThreatEntry& threat_entries(int index) const;
487 ::mozilla::safebrowsing::ThreatEntry* add_threat_entries();
488 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >&
489 threat_entries() const;
490
491 // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
492 int threat_entry_types_size() const;
493 private:
494 int _internal_threat_entry_types_size() const;
495 public:
496 void clear_threat_entry_types();
497 private:
498 ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_types(int index) const;
499 void _internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value);
500 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_entry_types();
501 public:
502 ::mozilla::safebrowsing::ThreatEntryType threat_entry_types(int index) const;
503 void set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value);
504 void add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value);
505 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_entry_types() const;
506 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_entry_types();
507
508 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatInfo)
509 private:
510 class _Internal;
511
512 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
513 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
514 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
515 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_types_;
516 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> platform_types_;
517 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry > threat_entries_;
518 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_entry_types_;
519 friend struct ::TableStruct_safebrowsing_2eproto;
520 };
521 // -------------------------------------------------------------------
522
523 class ThreatMatch :
524 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatMatch) */ {
525 public:
526 ThreatMatch();
527 virtual ~ThreatMatch();
528
529 ThreatMatch(const ThreatMatch& from);
ThreatMatch(ThreatMatch && from)530 ThreatMatch(ThreatMatch&& from) noexcept
531 : ThreatMatch() {
532 *this = ::std::move(from);
533 }
534
535 inline ThreatMatch& operator=(const ThreatMatch& from) {
536 CopyFrom(from);
537 return *this;
538 }
539 inline ThreatMatch& operator=(ThreatMatch&& from) noexcept {
540 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
541 if (this != &from) InternalSwap(&from);
542 } else {
543 CopyFrom(from);
544 }
545 return *this;
546 }
547
unknown_fields()548 inline const std::string& unknown_fields() const {
549 return _internal_metadata_.unknown_fields();
550 }
mutable_unknown_fields()551 inline std::string* mutable_unknown_fields() {
552 return _internal_metadata_.mutable_unknown_fields();
553 }
554
555 static const ThreatMatch& default_instance();
556
557 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()558 static inline const ThreatMatch* internal_default_instance() {
559 return reinterpret_cast<const ThreatMatch*>(
560 &_ThreatMatch_default_instance_);
561 }
562 static constexpr int kIndexInFileMessages =
563 1;
564
swap(ThreatMatch & a,ThreatMatch & b)565 friend void swap(ThreatMatch& a, ThreatMatch& b) {
566 a.Swap(&b);
567 }
Swap(ThreatMatch * other)568 inline void Swap(ThreatMatch* other) {
569 if (other == this) return;
570 InternalSwap(other);
571 }
572
573 // implements Message ----------------------------------------------
574
New()575 inline ThreatMatch* New() const final {
576 return CreateMaybeMessage<ThreatMatch>(nullptr);
577 }
578
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)579 ThreatMatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
580 return CreateMaybeMessage<ThreatMatch>(arena);
581 }
582 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
583 final;
584 void CopyFrom(const ThreatMatch& from);
585 void MergeFrom(const ThreatMatch& from);
586 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
587 bool IsInitialized() const final;
588
589 size_t ByteSizeLong() const final;
590 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
591 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
592 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
593 void DiscardUnknownFields();
GetCachedSize()594 int GetCachedSize() const final { return _cached_size_.Get(); }
595
596 private:
597 inline void SharedCtor();
598 inline void SharedDtor();
599 void SetCachedSize(int size) const;
600 void InternalSwap(ThreatMatch* other);
601 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()602 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
603 return "mozilla.safebrowsing.ThreatMatch";
604 }
605 private:
GetArenaNoVirtual()606 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
607 return nullptr;
608 }
MaybeArenaPtr()609 inline void* MaybeArenaPtr() const {
610 return nullptr;
611 }
612 public:
613
614 std::string GetTypeName() const final;
615
616 // nested types ----------------------------------------------------
617
618 // accessors -------------------------------------------------------
619
620 enum : int {
621 kThreatFieldNumber = 3,
622 kThreatEntryMetadataFieldNumber = 4,
623 kCacheDurationFieldNumber = 5,
624 kThreatTypeFieldNumber = 1,
625 kPlatformTypeFieldNumber = 2,
626 kThreatEntryTypeFieldNumber = 6,
627 };
628 // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
629 bool has_threat() const;
630 private:
631 bool _internal_has_threat() const;
632 public:
633 void clear_threat();
634 const ::mozilla::safebrowsing::ThreatEntry& threat() const;
635 ::mozilla::safebrowsing::ThreatEntry* release_threat();
636 ::mozilla::safebrowsing::ThreatEntry* mutable_threat();
637 void set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat);
638 private:
639 const ::mozilla::safebrowsing::ThreatEntry& _internal_threat() const;
640 ::mozilla::safebrowsing::ThreatEntry* _internal_mutable_threat();
641 public:
642
643 // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
644 bool has_threat_entry_metadata() const;
645 private:
646 bool _internal_has_threat_entry_metadata() const;
647 public:
648 void clear_threat_entry_metadata();
649 const ::mozilla::safebrowsing::ThreatEntryMetadata& threat_entry_metadata() const;
650 ::mozilla::safebrowsing::ThreatEntryMetadata* release_threat_entry_metadata();
651 ::mozilla::safebrowsing::ThreatEntryMetadata* mutable_threat_entry_metadata();
652 void set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata);
653 private:
654 const ::mozilla::safebrowsing::ThreatEntryMetadata& _internal_threat_entry_metadata() const;
655 ::mozilla::safebrowsing::ThreatEntryMetadata* _internal_mutable_threat_entry_metadata();
656 public:
657
658 // optional .mozilla.safebrowsing.Duration cache_duration = 5;
659 bool has_cache_duration() const;
660 private:
661 bool _internal_has_cache_duration() const;
662 public:
663 void clear_cache_duration();
664 const ::mozilla::safebrowsing::Duration& cache_duration() const;
665 ::mozilla::safebrowsing::Duration* release_cache_duration();
666 ::mozilla::safebrowsing::Duration* mutable_cache_duration();
667 void set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration);
668 private:
669 const ::mozilla::safebrowsing::Duration& _internal_cache_duration() const;
670 ::mozilla::safebrowsing::Duration* _internal_mutable_cache_duration();
671 public:
672
673 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
674 bool has_threat_type() const;
675 private:
676 bool _internal_has_threat_type() const;
677 public:
678 void clear_threat_type();
679 ::mozilla::safebrowsing::ThreatType threat_type() const;
680 void set_threat_type(::mozilla::safebrowsing::ThreatType value);
681 private:
682 ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
683 void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
684 public:
685
686 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
687 bool has_platform_type() const;
688 private:
689 bool _internal_has_platform_type() const;
690 public:
691 void clear_platform_type();
692 ::mozilla::safebrowsing::PlatformType platform_type() const;
693 void set_platform_type(::mozilla::safebrowsing::PlatformType value);
694 private:
695 ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
696 void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
697 public:
698
699 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
700 bool has_threat_entry_type() const;
701 private:
702 bool _internal_has_threat_entry_type() const;
703 public:
704 void clear_threat_entry_type();
705 ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
706 void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
707 private:
708 ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
709 void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
710 public:
711
712 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatMatch)
713 private:
714 class _Internal;
715
716 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
717 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
718 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
719 ::mozilla::safebrowsing::ThreatEntry* threat_;
720 ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata_;
721 ::mozilla::safebrowsing::Duration* cache_duration_;
722 int threat_type_;
723 int platform_type_;
724 int threat_entry_type_;
725 friend struct ::TableStruct_safebrowsing_2eproto;
726 };
727 // -------------------------------------------------------------------
728
729 class FindThreatMatchesRequest :
730 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindThreatMatchesRequest) */ {
731 public:
732 FindThreatMatchesRequest();
733 virtual ~FindThreatMatchesRequest();
734
735 FindThreatMatchesRequest(const FindThreatMatchesRequest& from);
FindThreatMatchesRequest(FindThreatMatchesRequest && from)736 FindThreatMatchesRequest(FindThreatMatchesRequest&& from) noexcept
737 : FindThreatMatchesRequest() {
738 *this = ::std::move(from);
739 }
740
741 inline FindThreatMatchesRequest& operator=(const FindThreatMatchesRequest& from) {
742 CopyFrom(from);
743 return *this;
744 }
745 inline FindThreatMatchesRequest& operator=(FindThreatMatchesRequest&& from) noexcept {
746 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
747 if (this != &from) InternalSwap(&from);
748 } else {
749 CopyFrom(from);
750 }
751 return *this;
752 }
753
unknown_fields()754 inline const std::string& unknown_fields() const {
755 return _internal_metadata_.unknown_fields();
756 }
mutable_unknown_fields()757 inline std::string* mutable_unknown_fields() {
758 return _internal_metadata_.mutable_unknown_fields();
759 }
760
761 static const FindThreatMatchesRequest& default_instance();
762
763 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()764 static inline const FindThreatMatchesRequest* internal_default_instance() {
765 return reinterpret_cast<const FindThreatMatchesRequest*>(
766 &_FindThreatMatchesRequest_default_instance_);
767 }
768 static constexpr int kIndexInFileMessages =
769 2;
770
swap(FindThreatMatchesRequest & a,FindThreatMatchesRequest & b)771 friend void swap(FindThreatMatchesRequest& a, FindThreatMatchesRequest& b) {
772 a.Swap(&b);
773 }
Swap(FindThreatMatchesRequest * other)774 inline void Swap(FindThreatMatchesRequest* other) {
775 if (other == this) return;
776 InternalSwap(other);
777 }
778
779 // implements Message ----------------------------------------------
780
New()781 inline FindThreatMatchesRequest* New() const final {
782 return CreateMaybeMessage<FindThreatMatchesRequest>(nullptr);
783 }
784
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)785 FindThreatMatchesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
786 return CreateMaybeMessage<FindThreatMatchesRequest>(arena);
787 }
788 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
789 final;
790 void CopyFrom(const FindThreatMatchesRequest& from);
791 void MergeFrom(const FindThreatMatchesRequest& from);
792 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
793 bool IsInitialized() const final;
794
795 size_t ByteSizeLong() const final;
796 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
797 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
798 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
799 void DiscardUnknownFields();
GetCachedSize()800 int GetCachedSize() const final { return _cached_size_.Get(); }
801
802 private:
803 inline void SharedCtor();
804 inline void SharedDtor();
805 void SetCachedSize(int size) const;
806 void InternalSwap(FindThreatMatchesRequest* other);
807 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()808 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
809 return "mozilla.safebrowsing.FindThreatMatchesRequest";
810 }
811 private:
GetArenaNoVirtual()812 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
813 return nullptr;
814 }
MaybeArenaPtr()815 inline void* MaybeArenaPtr() const {
816 return nullptr;
817 }
818 public:
819
820 std::string GetTypeName() const final;
821
822 // nested types ----------------------------------------------------
823
824 // accessors -------------------------------------------------------
825
826 enum : int {
827 kClientFieldNumber = 1,
828 kThreatInfoFieldNumber = 2,
829 };
830 // optional .mozilla.safebrowsing.ClientInfo client = 1;
831 bool has_client() const;
832 private:
833 bool _internal_has_client() const;
834 public:
835 void clear_client();
836 const ::mozilla::safebrowsing::ClientInfo& client() const;
837 ::mozilla::safebrowsing::ClientInfo* release_client();
838 ::mozilla::safebrowsing::ClientInfo* mutable_client();
839 void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
840 private:
841 const ::mozilla::safebrowsing::ClientInfo& _internal_client() const;
842 ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client();
843 public:
844
845 // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
846 bool has_threat_info() const;
847 private:
848 bool _internal_has_threat_info() const;
849 public:
850 void clear_threat_info();
851 const ::mozilla::safebrowsing::ThreatInfo& threat_info() const;
852 ::mozilla::safebrowsing::ThreatInfo* release_threat_info();
853 ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info();
854 void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info);
855 private:
856 const ::mozilla::safebrowsing::ThreatInfo& _internal_threat_info() const;
857 ::mozilla::safebrowsing::ThreatInfo* _internal_mutable_threat_info();
858 public:
859
860 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesRequest)
861 private:
862 class _Internal;
863
864 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
865 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
866 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
867 ::mozilla::safebrowsing::ClientInfo* client_;
868 ::mozilla::safebrowsing::ThreatInfo* threat_info_;
869 friend struct ::TableStruct_safebrowsing_2eproto;
870 };
871 // -------------------------------------------------------------------
872
873 class FindThreatMatchesResponse :
874 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindThreatMatchesResponse) */ {
875 public:
876 FindThreatMatchesResponse();
877 virtual ~FindThreatMatchesResponse();
878
879 FindThreatMatchesResponse(const FindThreatMatchesResponse& from);
FindThreatMatchesResponse(FindThreatMatchesResponse && from)880 FindThreatMatchesResponse(FindThreatMatchesResponse&& from) noexcept
881 : FindThreatMatchesResponse() {
882 *this = ::std::move(from);
883 }
884
885 inline FindThreatMatchesResponse& operator=(const FindThreatMatchesResponse& from) {
886 CopyFrom(from);
887 return *this;
888 }
889 inline FindThreatMatchesResponse& operator=(FindThreatMatchesResponse&& from) noexcept {
890 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
891 if (this != &from) InternalSwap(&from);
892 } else {
893 CopyFrom(from);
894 }
895 return *this;
896 }
897
unknown_fields()898 inline const std::string& unknown_fields() const {
899 return _internal_metadata_.unknown_fields();
900 }
mutable_unknown_fields()901 inline std::string* mutable_unknown_fields() {
902 return _internal_metadata_.mutable_unknown_fields();
903 }
904
905 static const FindThreatMatchesResponse& default_instance();
906
907 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()908 static inline const FindThreatMatchesResponse* internal_default_instance() {
909 return reinterpret_cast<const FindThreatMatchesResponse*>(
910 &_FindThreatMatchesResponse_default_instance_);
911 }
912 static constexpr int kIndexInFileMessages =
913 3;
914
swap(FindThreatMatchesResponse & a,FindThreatMatchesResponse & b)915 friend void swap(FindThreatMatchesResponse& a, FindThreatMatchesResponse& b) {
916 a.Swap(&b);
917 }
Swap(FindThreatMatchesResponse * other)918 inline void Swap(FindThreatMatchesResponse* other) {
919 if (other == this) return;
920 InternalSwap(other);
921 }
922
923 // implements Message ----------------------------------------------
924
New()925 inline FindThreatMatchesResponse* New() const final {
926 return CreateMaybeMessage<FindThreatMatchesResponse>(nullptr);
927 }
928
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)929 FindThreatMatchesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
930 return CreateMaybeMessage<FindThreatMatchesResponse>(arena);
931 }
932 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
933 final;
934 void CopyFrom(const FindThreatMatchesResponse& from);
935 void MergeFrom(const FindThreatMatchesResponse& from);
936 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
937 bool IsInitialized() const final;
938
939 size_t ByteSizeLong() const final;
940 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
941 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
942 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
943 void DiscardUnknownFields();
GetCachedSize()944 int GetCachedSize() const final { return _cached_size_.Get(); }
945
946 private:
947 inline void SharedCtor();
948 inline void SharedDtor();
949 void SetCachedSize(int size) const;
950 void InternalSwap(FindThreatMatchesResponse* other);
951 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()952 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
953 return "mozilla.safebrowsing.FindThreatMatchesResponse";
954 }
955 private:
GetArenaNoVirtual()956 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
957 return nullptr;
958 }
MaybeArenaPtr()959 inline void* MaybeArenaPtr() const {
960 return nullptr;
961 }
962 public:
963
964 std::string GetTypeName() const final;
965
966 // nested types ----------------------------------------------------
967
968 // accessors -------------------------------------------------------
969
970 enum : int {
971 kMatchesFieldNumber = 1,
972 };
973 // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
974 int matches_size() const;
975 private:
976 int _internal_matches_size() const;
977 public:
978 void clear_matches();
979 ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index);
980 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
981 mutable_matches();
982 private:
983 const ::mozilla::safebrowsing::ThreatMatch& _internal_matches(int index) const;
984 ::mozilla::safebrowsing::ThreatMatch* _internal_add_matches();
985 public:
986 const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const;
987 ::mozilla::safebrowsing::ThreatMatch* add_matches();
988 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
989 matches() const;
990
991 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesResponse)
992 private:
993 class _Internal;
994
995 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
996 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
997 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
998 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_;
999 friend struct ::TableStruct_safebrowsing_2eproto;
1000 };
1001 // -------------------------------------------------------------------
1002
1003 class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints :
1004 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) */ {
1005 public:
1006 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints();
1007 virtual ~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints();
1008
1009 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints && from)1010 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&& from) noexcept
1011 : FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() {
1012 *this = ::std::move(from);
1013 }
1014
1015 inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) {
1016 CopyFrom(from);
1017 return *this;
1018 }
1019 inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&& from) noexcept {
1020 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1021 if (this != &from) InternalSwap(&from);
1022 } else {
1023 CopyFrom(from);
1024 }
1025 return *this;
1026 }
1027
unknown_fields()1028 inline const std::string& unknown_fields() const {
1029 return _internal_metadata_.unknown_fields();
1030 }
mutable_unknown_fields()1031 inline std::string* mutable_unknown_fields() {
1032 return _internal_metadata_.mutable_unknown_fields();
1033 }
1034
1035 static const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& default_instance();
1036
1037 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()1038 static inline const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* internal_default_instance() {
1039 return reinterpret_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(
1040 &_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_);
1041 }
1042 static constexpr int kIndexInFileMessages =
1043 4;
1044
swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints & a,FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints & b)1045 friend void swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& a, FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& b) {
1046 a.Swap(&b);
1047 }
Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints * other)1048 inline void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) {
1049 if (other == this) return;
1050 InternalSwap(other);
1051 }
1052
1053 // implements Message ----------------------------------------------
1054
New()1055 inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* New() const final {
1056 return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(nullptr);
1057 }
1058
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)1059 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1060 return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(arena);
1061 }
1062 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
1063 final;
1064 void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
1065 void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
1066 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1067 bool IsInitialized() const final;
1068
1069 size_t ByteSizeLong() const final;
1070 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1071 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1072 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1073 void DiscardUnknownFields();
GetCachedSize()1074 int GetCachedSize() const final { return _cached_size_.Get(); }
1075
1076 private:
1077 inline void SharedCtor();
1078 inline void SharedDtor();
1079 void SetCachedSize(int size) const;
1080 void InternalSwap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other);
1081 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()1082 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1083 return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints";
1084 }
1085 private:
GetArenaNoVirtual()1086 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1087 return nullptr;
1088 }
MaybeArenaPtr()1089 inline void* MaybeArenaPtr() const {
1090 return nullptr;
1091 }
1092 public:
1093
1094 std::string GetTypeName() const final;
1095
1096 // nested types ----------------------------------------------------
1097
1098 // accessors -------------------------------------------------------
1099
1100 enum : int {
1101 kSupportedCompressionsFieldNumber = 4,
1102 kRegionFieldNumber = 3,
1103 kMaxUpdateEntriesFieldNumber = 1,
1104 kMaxDatabaseEntriesFieldNumber = 2,
1105 };
1106 // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
1107 int supported_compressions_size() const;
1108 private:
1109 int _internal_supported_compressions_size() const;
1110 public:
1111 void clear_supported_compressions();
1112 private:
1113 ::mozilla::safebrowsing::CompressionType _internal_supported_compressions(int index) const;
1114 void _internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value);
1115 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_compressions();
1116 public:
1117 ::mozilla::safebrowsing::CompressionType supported_compressions(int index) const;
1118 void set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value);
1119 void add_supported_compressions(::mozilla::safebrowsing::CompressionType value);
1120 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_compressions() const;
1121 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_compressions();
1122
1123 // optional string region = 3;
1124 bool has_region() const;
1125 private:
1126 bool _internal_has_region() const;
1127 public:
1128 void clear_region();
1129 const std::string& region() const;
1130 void set_region(const std::string& value);
1131 void set_region(std::string&& value);
1132 void set_region(const char* value);
1133 void set_region(const char* value, size_t size);
1134 std::string* mutable_region();
1135 std::string* release_region();
1136 void set_allocated_region(std::string* region);
1137 private:
1138 const std::string& _internal_region() const;
1139 void _internal_set_region(const std::string& value);
1140 std::string* _internal_mutable_region();
1141 public:
1142
1143 // optional int32 max_update_entries = 1;
1144 bool has_max_update_entries() const;
1145 private:
1146 bool _internal_has_max_update_entries() const;
1147 public:
1148 void clear_max_update_entries();
1149 ::PROTOBUF_NAMESPACE_ID::int32 max_update_entries() const;
1150 void set_max_update_entries(::PROTOBUF_NAMESPACE_ID::int32 value);
1151 private:
1152 ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_update_entries() const;
1153 void _internal_set_max_update_entries(::PROTOBUF_NAMESPACE_ID::int32 value);
1154 public:
1155
1156 // optional int32 max_database_entries = 2;
1157 bool has_max_database_entries() const;
1158 private:
1159 bool _internal_has_max_database_entries() const;
1160 public:
1161 void clear_max_database_entries();
1162 ::PROTOBUF_NAMESPACE_ID::int32 max_database_entries() const;
1163 void set_max_database_entries(::PROTOBUF_NAMESPACE_ID::int32 value);
1164 private:
1165 ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_database_entries() const;
1166 void _internal_set_max_database_entries(::PROTOBUF_NAMESPACE_ID::int32 value);
1167 public:
1168
1169 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
1170 private:
1171 class _Internal;
1172
1173 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
1174 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1175 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1176 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_compressions_;
1177 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr region_;
1178 ::PROTOBUF_NAMESPACE_ID::int32 max_update_entries_;
1179 ::PROTOBUF_NAMESPACE_ID::int32 max_database_entries_;
1180 friend struct ::TableStruct_safebrowsing_2eproto;
1181 };
1182 // -------------------------------------------------------------------
1183
1184 class FetchThreatListUpdatesRequest_ListUpdateRequest :
1185 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) */ {
1186 public:
1187 FetchThreatListUpdatesRequest_ListUpdateRequest();
1188 virtual ~FetchThreatListUpdatesRequest_ListUpdateRequest();
1189
1190 FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
FetchThreatListUpdatesRequest_ListUpdateRequest(FetchThreatListUpdatesRequest_ListUpdateRequest && from)1191 FetchThreatListUpdatesRequest_ListUpdateRequest(FetchThreatListUpdatesRequest_ListUpdateRequest&& from) noexcept
1192 : FetchThreatListUpdatesRequest_ListUpdateRequest() {
1193 *this = ::std::move(from);
1194 }
1195
1196 inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) {
1197 CopyFrom(from);
1198 return *this;
1199 }
1200 inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(FetchThreatListUpdatesRequest_ListUpdateRequest&& from) noexcept {
1201 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1202 if (this != &from) InternalSwap(&from);
1203 } else {
1204 CopyFrom(from);
1205 }
1206 return *this;
1207 }
1208
unknown_fields()1209 inline const std::string& unknown_fields() const {
1210 return _internal_metadata_.unknown_fields();
1211 }
mutable_unknown_fields()1212 inline std::string* mutable_unknown_fields() {
1213 return _internal_metadata_.mutable_unknown_fields();
1214 }
1215
1216 static const FetchThreatListUpdatesRequest_ListUpdateRequest& default_instance();
1217
1218 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()1219 static inline const FetchThreatListUpdatesRequest_ListUpdateRequest* internal_default_instance() {
1220 return reinterpret_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>(
1221 &_FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_);
1222 }
1223 static constexpr int kIndexInFileMessages =
1224 5;
1225
swap(FetchThreatListUpdatesRequest_ListUpdateRequest & a,FetchThreatListUpdatesRequest_ListUpdateRequest & b)1226 friend void swap(FetchThreatListUpdatesRequest_ListUpdateRequest& a, FetchThreatListUpdatesRequest_ListUpdateRequest& b) {
1227 a.Swap(&b);
1228 }
Swap(FetchThreatListUpdatesRequest_ListUpdateRequest * other)1229 inline void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* other) {
1230 if (other == this) return;
1231 InternalSwap(other);
1232 }
1233
1234 // implements Message ----------------------------------------------
1235
New()1236 inline FetchThreatListUpdatesRequest_ListUpdateRequest* New() const final {
1237 return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest>(nullptr);
1238 }
1239
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)1240 FetchThreatListUpdatesRequest_ListUpdateRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1241 return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest>(arena);
1242 }
1243 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
1244 final;
1245 void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
1246 void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
1247 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1248 bool IsInitialized() const final;
1249
1250 size_t ByteSizeLong() const final;
1251 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1252 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1253 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1254 void DiscardUnknownFields();
GetCachedSize()1255 int GetCachedSize() const final { return _cached_size_.Get(); }
1256
1257 private:
1258 inline void SharedCtor();
1259 inline void SharedDtor();
1260 void SetCachedSize(int size) const;
1261 void InternalSwap(FetchThreatListUpdatesRequest_ListUpdateRequest* other);
1262 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()1263 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1264 return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest";
1265 }
1266 private:
GetArenaNoVirtual()1267 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1268 return nullptr;
1269 }
MaybeArenaPtr()1270 inline void* MaybeArenaPtr() const {
1271 return nullptr;
1272 }
1273 public:
1274
1275 std::string GetTypeName() const final;
1276
1277 // nested types ----------------------------------------------------
1278
1279 typedef FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints Constraints;
1280
1281 // accessors -------------------------------------------------------
1282
1283 enum : int {
1284 kStateFieldNumber = 3,
1285 kConstraintsFieldNumber = 4,
1286 kThreatTypeFieldNumber = 1,
1287 kPlatformTypeFieldNumber = 2,
1288 kThreatEntryTypeFieldNumber = 5,
1289 };
1290 // optional bytes state = 3;
1291 bool has_state() const;
1292 private:
1293 bool _internal_has_state() const;
1294 public:
1295 void clear_state();
1296 const std::string& state() const;
1297 void set_state(const std::string& value);
1298 void set_state(std::string&& value);
1299 void set_state(const char* value);
1300 void set_state(const void* value, size_t size);
1301 std::string* mutable_state();
1302 std::string* release_state();
1303 void set_allocated_state(std::string* state);
1304 private:
1305 const std::string& _internal_state() const;
1306 void _internal_set_state(const std::string& value);
1307 std::string* _internal_mutable_state();
1308 public:
1309
1310 // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
1311 bool has_constraints() const;
1312 private:
1313 bool _internal_has_constraints() const;
1314 public:
1315 void clear_constraints();
1316 const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& constraints() const;
1317 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* release_constraints();
1318 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* mutable_constraints();
1319 void set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints);
1320 private:
1321 const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& _internal_constraints() const;
1322 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* _internal_mutable_constraints();
1323 public:
1324
1325 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
1326 bool has_threat_type() const;
1327 private:
1328 bool _internal_has_threat_type() const;
1329 public:
1330 void clear_threat_type();
1331 ::mozilla::safebrowsing::ThreatType threat_type() const;
1332 void set_threat_type(::mozilla::safebrowsing::ThreatType value);
1333 private:
1334 ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
1335 void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
1336 public:
1337
1338 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
1339 bool has_platform_type() const;
1340 private:
1341 bool _internal_has_platform_type() const;
1342 public:
1343 void clear_platform_type();
1344 ::mozilla::safebrowsing::PlatformType platform_type() const;
1345 void set_platform_type(::mozilla::safebrowsing::PlatformType value);
1346 private:
1347 ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
1348 void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
1349 public:
1350
1351 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
1352 bool has_threat_entry_type() const;
1353 private:
1354 bool _internal_has_threat_entry_type() const;
1355 public:
1356 void clear_threat_entry_type();
1357 ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
1358 void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
1359 private:
1360 ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
1361 void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
1362 public:
1363
1364 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
1365 private:
1366 class _Internal;
1367
1368 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
1369 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1370 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1371 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr state_;
1372 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints_;
1373 int threat_type_;
1374 int platform_type_;
1375 int threat_entry_type_;
1376 friend struct ::TableStruct_safebrowsing_2eproto;
1377 };
1378 // -------------------------------------------------------------------
1379
1380 class FetchThreatListUpdatesRequest :
1381 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest) */ {
1382 public:
1383 FetchThreatListUpdatesRequest();
1384 virtual ~FetchThreatListUpdatesRequest();
1385
1386 FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from);
FetchThreatListUpdatesRequest(FetchThreatListUpdatesRequest && from)1387 FetchThreatListUpdatesRequest(FetchThreatListUpdatesRequest&& from) noexcept
1388 : FetchThreatListUpdatesRequest() {
1389 *this = ::std::move(from);
1390 }
1391
1392 inline FetchThreatListUpdatesRequest& operator=(const FetchThreatListUpdatesRequest& from) {
1393 CopyFrom(from);
1394 return *this;
1395 }
1396 inline FetchThreatListUpdatesRequest& operator=(FetchThreatListUpdatesRequest&& from) noexcept {
1397 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1398 if (this != &from) InternalSwap(&from);
1399 } else {
1400 CopyFrom(from);
1401 }
1402 return *this;
1403 }
1404
unknown_fields()1405 inline const std::string& unknown_fields() const {
1406 return _internal_metadata_.unknown_fields();
1407 }
mutable_unknown_fields()1408 inline std::string* mutable_unknown_fields() {
1409 return _internal_metadata_.mutable_unknown_fields();
1410 }
1411
1412 static const FetchThreatListUpdatesRequest& default_instance();
1413
1414 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()1415 static inline const FetchThreatListUpdatesRequest* internal_default_instance() {
1416 return reinterpret_cast<const FetchThreatListUpdatesRequest*>(
1417 &_FetchThreatListUpdatesRequest_default_instance_);
1418 }
1419 static constexpr int kIndexInFileMessages =
1420 6;
1421
swap(FetchThreatListUpdatesRequest & a,FetchThreatListUpdatesRequest & b)1422 friend void swap(FetchThreatListUpdatesRequest& a, FetchThreatListUpdatesRequest& b) {
1423 a.Swap(&b);
1424 }
Swap(FetchThreatListUpdatesRequest * other)1425 inline void Swap(FetchThreatListUpdatesRequest* other) {
1426 if (other == this) return;
1427 InternalSwap(other);
1428 }
1429
1430 // implements Message ----------------------------------------------
1431
New()1432 inline FetchThreatListUpdatesRequest* New() const final {
1433 return CreateMaybeMessage<FetchThreatListUpdatesRequest>(nullptr);
1434 }
1435
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)1436 FetchThreatListUpdatesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1437 return CreateMaybeMessage<FetchThreatListUpdatesRequest>(arena);
1438 }
1439 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
1440 final;
1441 void CopyFrom(const FetchThreatListUpdatesRequest& from);
1442 void MergeFrom(const FetchThreatListUpdatesRequest& from);
1443 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1444 bool IsInitialized() const final;
1445
1446 size_t ByteSizeLong() const final;
1447 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1448 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1449 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1450 void DiscardUnknownFields();
GetCachedSize()1451 int GetCachedSize() const final { return _cached_size_.Get(); }
1452
1453 private:
1454 inline void SharedCtor();
1455 inline void SharedDtor();
1456 void SetCachedSize(int size) const;
1457 void InternalSwap(FetchThreatListUpdatesRequest* other);
1458 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()1459 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1460 return "mozilla.safebrowsing.FetchThreatListUpdatesRequest";
1461 }
1462 private:
GetArenaNoVirtual()1463 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1464 return nullptr;
1465 }
MaybeArenaPtr()1466 inline void* MaybeArenaPtr() const {
1467 return nullptr;
1468 }
1469 public:
1470
1471 std::string GetTypeName() const final;
1472
1473 // nested types ----------------------------------------------------
1474
1475 typedef FetchThreatListUpdatesRequest_ListUpdateRequest ListUpdateRequest;
1476
1477 // accessors -------------------------------------------------------
1478
1479 enum : int {
1480 kListUpdateRequestsFieldNumber = 3,
1481 kClientFieldNumber = 1,
1482 kChromeClientInfoFieldNumber = 4,
1483 };
1484 // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
1485 int list_update_requests_size() const;
1486 private:
1487 int _internal_list_update_requests_size() const;
1488 public:
1489 void clear_list_update_requests();
1490 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* mutable_list_update_requests(int index);
1491 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >*
1492 mutable_list_update_requests();
1493 private:
1494 const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& _internal_list_update_requests(int index) const;
1495 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* _internal_add_list_update_requests();
1496 public:
1497 const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& list_update_requests(int index) const;
1498 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* add_list_update_requests();
1499 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >&
1500 list_update_requests() const;
1501
1502 // optional .mozilla.safebrowsing.ClientInfo client = 1;
1503 bool has_client() const;
1504 private:
1505 bool _internal_has_client() const;
1506 public:
1507 void clear_client();
1508 const ::mozilla::safebrowsing::ClientInfo& client() const;
1509 ::mozilla::safebrowsing::ClientInfo* release_client();
1510 ::mozilla::safebrowsing::ClientInfo* mutable_client();
1511 void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
1512 private:
1513 const ::mozilla::safebrowsing::ClientInfo& _internal_client() const;
1514 ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client();
1515 public:
1516
1517 // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4;
1518 bool has_chrome_client_info() const;
1519 private:
1520 bool _internal_has_chrome_client_info() const;
1521 public:
1522 void clear_chrome_client_info();
1523 const ::mozilla::safebrowsing::ChromeClientInfo& chrome_client_info() const;
1524 ::mozilla::safebrowsing::ChromeClientInfo* release_chrome_client_info();
1525 ::mozilla::safebrowsing::ChromeClientInfo* mutable_chrome_client_info();
1526 void set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info);
1527 private:
1528 const ::mozilla::safebrowsing::ChromeClientInfo& _internal_chrome_client_info() const;
1529 ::mozilla::safebrowsing::ChromeClientInfo* _internal_mutable_chrome_client_info();
1530 public:
1531
1532 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
1533 private:
1534 class _Internal;
1535
1536 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
1537 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1538 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1539 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest > list_update_requests_;
1540 ::mozilla::safebrowsing::ClientInfo* client_;
1541 ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info_;
1542 friend struct ::TableStruct_safebrowsing_2eproto;
1543 };
1544 // -------------------------------------------------------------------
1545
1546 class FetchThreatListUpdatesResponse_ListUpdateResponse :
1547 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) */ {
1548 public:
1549 FetchThreatListUpdatesResponse_ListUpdateResponse();
1550 virtual ~FetchThreatListUpdatesResponse_ListUpdateResponse();
1551
1552 FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
FetchThreatListUpdatesResponse_ListUpdateResponse(FetchThreatListUpdatesResponse_ListUpdateResponse && from)1553 FetchThreatListUpdatesResponse_ListUpdateResponse(FetchThreatListUpdatesResponse_ListUpdateResponse&& from) noexcept
1554 : FetchThreatListUpdatesResponse_ListUpdateResponse() {
1555 *this = ::std::move(from);
1556 }
1557
1558 inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) {
1559 CopyFrom(from);
1560 return *this;
1561 }
1562 inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(FetchThreatListUpdatesResponse_ListUpdateResponse&& from) noexcept {
1563 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1564 if (this != &from) InternalSwap(&from);
1565 } else {
1566 CopyFrom(from);
1567 }
1568 return *this;
1569 }
1570
unknown_fields()1571 inline const std::string& unknown_fields() const {
1572 return _internal_metadata_.unknown_fields();
1573 }
mutable_unknown_fields()1574 inline std::string* mutable_unknown_fields() {
1575 return _internal_metadata_.mutable_unknown_fields();
1576 }
1577
1578 static const FetchThreatListUpdatesResponse_ListUpdateResponse& default_instance();
1579
1580 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()1581 static inline const FetchThreatListUpdatesResponse_ListUpdateResponse* internal_default_instance() {
1582 return reinterpret_cast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>(
1583 &_FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_);
1584 }
1585 static constexpr int kIndexInFileMessages =
1586 7;
1587
swap(FetchThreatListUpdatesResponse_ListUpdateResponse & a,FetchThreatListUpdatesResponse_ListUpdateResponse & b)1588 friend void swap(FetchThreatListUpdatesResponse_ListUpdateResponse& a, FetchThreatListUpdatesResponse_ListUpdateResponse& b) {
1589 a.Swap(&b);
1590 }
Swap(FetchThreatListUpdatesResponse_ListUpdateResponse * other)1591 inline void Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* other) {
1592 if (other == this) return;
1593 InternalSwap(other);
1594 }
1595
1596 // implements Message ----------------------------------------------
1597
New()1598 inline FetchThreatListUpdatesResponse_ListUpdateResponse* New() const final {
1599 return CreateMaybeMessage<FetchThreatListUpdatesResponse_ListUpdateResponse>(nullptr);
1600 }
1601
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)1602 FetchThreatListUpdatesResponse_ListUpdateResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1603 return CreateMaybeMessage<FetchThreatListUpdatesResponse_ListUpdateResponse>(arena);
1604 }
1605 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
1606 final;
1607 void CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
1608 void MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
1609 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1610 bool IsInitialized() const final;
1611
1612 size_t ByteSizeLong() const final;
1613 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1614 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1615 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1616 void DiscardUnknownFields();
GetCachedSize()1617 int GetCachedSize() const final { return _cached_size_.Get(); }
1618
1619 private:
1620 inline void SharedCtor();
1621 inline void SharedDtor();
1622 void SetCachedSize(int size) const;
1623 void InternalSwap(FetchThreatListUpdatesResponse_ListUpdateResponse* other);
1624 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()1625 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1626 return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse";
1627 }
1628 private:
GetArenaNoVirtual()1629 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1630 return nullptr;
1631 }
MaybeArenaPtr()1632 inline void* MaybeArenaPtr() const {
1633 return nullptr;
1634 }
1635 public:
1636
1637 std::string GetTypeName() const final;
1638
1639 // nested types ----------------------------------------------------
1640
1641 typedef FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType ResponseType;
1642 static constexpr ResponseType RESPONSE_TYPE_UNSPECIFIED =
1643 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED;
1644 static constexpr ResponseType PARTIAL_UPDATE =
1645 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE;
1646 static constexpr ResponseType FULL_UPDATE =
1647 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE;
ResponseType_IsValid(int value)1648 static inline bool ResponseType_IsValid(int value) {
1649 return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value);
1650 }
1651 static constexpr ResponseType ResponseType_MIN =
1652 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN;
1653 static constexpr ResponseType ResponseType_MAX =
1654 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX;
1655 static constexpr int ResponseType_ARRAYSIZE =
1656 FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE;
1657 template<typename T>
ResponseType_Name(T enum_t_value)1658 static inline const std::string& ResponseType_Name(T enum_t_value) {
1659 static_assert(::std::is_same<T, ResponseType>::value ||
1660 ::std::is_integral<T>::value,
1661 "Incorrect type passed to function ResponseType_Name.");
1662 return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(enum_t_value);
1663 }
ResponseType_Parse(const std::string & name,ResponseType * value)1664 static inline bool ResponseType_Parse(const std::string& name,
1665 ResponseType* value) {
1666 return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse(name, value);
1667 }
1668
1669 // accessors -------------------------------------------------------
1670
1671 enum : int {
1672 kAdditionsFieldNumber = 5,
1673 kRemovalsFieldNumber = 6,
1674 kNewClientStateFieldNumber = 7,
1675 kChecksumFieldNumber = 8,
1676 kThreatTypeFieldNumber = 1,
1677 kThreatEntryTypeFieldNumber = 2,
1678 kPlatformTypeFieldNumber = 3,
1679 kResponseTypeFieldNumber = 4,
1680 };
1681 // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
1682 int additions_size() const;
1683 private:
1684 int _internal_additions_size() const;
1685 public:
1686 void clear_additions();
1687 ::mozilla::safebrowsing::ThreatEntrySet* mutable_additions(int index);
1688 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
1689 mutable_additions();
1690 private:
1691 const ::mozilla::safebrowsing::ThreatEntrySet& _internal_additions(int index) const;
1692 ::mozilla::safebrowsing::ThreatEntrySet* _internal_add_additions();
1693 public:
1694 const ::mozilla::safebrowsing::ThreatEntrySet& additions(int index) const;
1695 ::mozilla::safebrowsing::ThreatEntrySet* add_additions();
1696 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
1697 additions() const;
1698
1699 // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
1700 int removals_size() const;
1701 private:
1702 int _internal_removals_size() const;
1703 public:
1704 void clear_removals();
1705 ::mozilla::safebrowsing::ThreatEntrySet* mutable_removals(int index);
1706 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
1707 mutable_removals();
1708 private:
1709 const ::mozilla::safebrowsing::ThreatEntrySet& _internal_removals(int index) const;
1710 ::mozilla::safebrowsing::ThreatEntrySet* _internal_add_removals();
1711 public:
1712 const ::mozilla::safebrowsing::ThreatEntrySet& removals(int index) const;
1713 ::mozilla::safebrowsing::ThreatEntrySet* add_removals();
1714 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
1715 removals() const;
1716
1717 // optional bytes new_client_state = 7;
1718 bool has_new_client_state() const;
1719 private:
1720 bool _internal_has_new_client_state() const;
1721 public:
1722 void clear_new_client_state();
1723 const std::string& new_client_state() const;
1724 void set_new_client_state(const std::string& value);
1725 void set_new_client_state(std::string&& value);
1726 void set_new_client_state(const char* value);
1727 void set_new_client_state(const void* value, size_t size);
1728 std::string* mutable_new_client_state();
1729 std::string* release_new_client_state();
1730 void set_allocated_new_client_state(std::string* new_client_state);
1731 private:
1732 const std::string& _internal_new_client_state() const;
1733 void _internal_set_new_client_state(const std::string& value);
1734 std::string* _internal_mutable_new_client_state();
1735 public:
1736
1737 // optional .mozilla.safebrowsing.Checksum checksum = 8;
1738 bool has_checksum() const;
1739 private:
1740 bool _internal_has_checksum() const;
1741 public:
1742 void clear_checksum();
1743 const ::mozilla::safebrowsing::Checksum& checksum() const;
1744 ::mozilla::safebrowsing::Checksum* release_checksum();
1745 ::mozilla::safebrowsing::Checksum* mutable_checksum();
1746 void set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum);
1747 private:
1748 const ::mozilla::safebrowsing::Checksum& _internal_checksum() const;
1749 ::mozilla::safebrowsing::Checksum* _internal_mutable_checksum();
1750 public:
1751
1752 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
1753 bool has_threat_type() const;
1754 private:
1755 bool _internal_has_threat_type() const;
1756 public:
1757 void clear_threat_type();
1758 ::mozilla::safebrowsing::ThreatType threat_type() const;
1759 void set_threat_type(::mozilla::safebrowsing::ThreatType value);
1760 private:
1761 ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
1762 void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
1763 public:
1764
1765 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
1766 bool has_threat_entry_type() const;
1767 private:
1768 bool _internal_has_threat_entry_type() const;
1769 public:
1770 void clear_threat_entry_type();
1771 ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
1772 void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
1773 private:
1774 ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
1775 void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
1776 public:
1777
1778 // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
1779 bool has_platform_type() const;
1780 private:
1781 bool _internal_has_platform_type() const;
1782 public:
1783 void clear_platform_type();
1784 ::mozilla::safebrowsing::PlatformType platform_type() const;
1785 void set_platform_type(::mozilla::safebrowsing::PlatformType value);
1786 private:
1787 ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
1788 void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
1789 public:
1790
1791 // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
1792 bool has_response_type() const;
1793 private:
1794 bool _internal_has_response_type() const;
1795 public:
1796 void clear_response_type();
1797 ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType response_type() const;
1798 void set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
1799 private:
1800 ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType _internal_response_type() const;
1801 void _internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
1802 public:
1803
1804 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
1805 private:
1806 class _Internal;
1807
1808 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
1809 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1810 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1811 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > additions_;
1812 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > removals_;
1813 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_client_state_;
1814 ::mozilla::safebrowsing::Checksum* checksum_;
1815 int threat_type_;
1816 int threat_entry_type_;
1817 int platform_type_;
1818 int response_type_;
1819 friend struct ::TableStruct_safebrowsing_2eproto;
1820 };
1821 // -------------------------------------------------------------------
1822
1823 class FetchThreatListUpdatesResponse :
1824 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesResponse) */ {
1825 public:
1826 FetchThreatListUpdatesResponse();
1827 virtual ~FetchThreatListUpdatesResponse();
1828
1829 FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from);
FetchThreatListUpdatesResponse(FetchThreatListUpdatesResponse && from)1830 FetchThreatListUpdatesResponse(FetchThreatListUpdatesResponse&& from) noexcept
1831 : FetchThreatListUpdatesResponse() {
1832 *this = ::std::move(from);
1833 }
1834
1835 inline FetchThreatListUpdatesResponse& operator=(const FetchThreatListUpdatesResponse& from) {
1836 CopyFrom(from);
1837 return *this;
1838 }
1839 inline FetchThreatListUpdatesResponse& operator=(FetchThreatListUpdatesResponse&& from) noexcept {
1840 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1841 if (this != &from) InternalSwap(&from);
1842 } else {
1843 CopyFrom(from);
1844 }
1845 return *this;
1846 }
1847
unknown_fields()1848 inline const std::string& unknown_fields() const {
1849 return _internal_metadata_.unknown_fields();
1850 }
mutable_unknown_fields()1851 inline std::string* mutable_unknown_fields() {
1852 return _internal_metadata_.mutable_unknown_fields();
1853 }
1854
1855 static const FetchThreatListUpdatesResponse& default_instance();
1856
1857 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()1858 static inline const FetchThreatListUpdatesResponse* internal_default_instance() {
1859 return reinterpret_cast<const FetchThreatListUpdatesResponse*>(
1860 &_FetchThreatListUpdatesResponse_default_instance_);
1861 }
1862 static constexpr int kIndexInFileMessages =
1863 8;
1864
swap(FetchThreatListUpdatesResponse & a,FetchThreatListUpdatesResponse & b)1865 friend void swap(FetchThreatListUpdatesResponse& a, FetchThreatListUpdatesResponse& b) {
1866 a.Swap(&b);
1867 }
Swap(FetchThreatListUpdatesResponse * other)1868 inline void Swap(FetchThreatListUpdatesResponse* other) {
1869 if (other == this) return;
1870 InternalSwap(other);
1871 }
1872
1873 // implements Message ----------------------------------------------
1874
New()1875 inline FetchThreatListUpdatesResponse* New() const final {
1876 return CreateMaybeMessage<FetchThreatListUpdatesResponse>(nullptr);
1877 }
1878
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)1879 FetchThreatListUpdatesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1880 return CreateMaybeMessage<FetchThreatListUpdatesResponse>(arena);
1881 }
1882 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
1883 final;
1884 void CopyFrom(const FetchThreatListUpdatesResponse& from);
1885 void MergeFrom(const FetchThreatListUpdatesResponse& from);
1886 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1887 bool IsInitialized() const final;
1888
1889 size_t ByteSizeLong() const final;
1890 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1891 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1892 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1893 void DiscardUnknownFields();
GetCachedSize()1894 int GetCachedSize() const final { return _cached_size_.Get(); }
1895
1896 private:
1897 inline void SharedCtor();
1898 inline void SharedDtor();
1899 void SetCachedSize(int size) const;
1900 void InternalSwap(FetchThreatListUpdatesResponse* other);
1901 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()1902 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1903 return "mozilla.safebrowsing.FetchThreatListUpdatesResponse";
1904 }
1905 private:
GetArenaNoVirtual()1906 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1907 return nullptr;
1908 }
MaybeArenaPtr()1909 inline void* MaybeArenaPtr() const {
1910 return nullptr;
1911 }
1912 public:
1913
1914 std::string GetTypeName() const final;
1915
1916 // nested types ----------------------------------------------------
1917
1918 typedef FetchThreatListUpdatesResponse_ListUpdateResponse ListUpdateResponse;
1919
1920 // accessors -------------------------------------------------------
1921
1922 enum : int {
1923 kListUpdateResponsesFieldNumber = 1,
1924 kMinimumWaitDurationFieldNumber = 2,
1925 };
1926 // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
1927 int list_update_responses_size() const;
1928 private:
1929 int _internal_list_update_responses_size() const;
1930 public:
1931 void clear_list_update_responses();
1932 ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* mutable_list_update_responses(int index);
1933 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >*
1934 mutable_list_update_responses();
1935 private:
1936 const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& _internal_list_update_responses(int index) const;
1937 ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* _internal_add_list_update_responses();
1938 public:
1939 const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& list_update_responses(int index) const;
1940 ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* add_list_update_responses();
1941 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >&
1942 list_update_responses() const;
1943
1944 // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
1945 bool has_minimum_wait_duration() const;
1946 private:
1947 bool _internal_has_minimum_wait_duration() const;
1948 public:
1949 void clear_minimum_wait_duration();
1950 const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const;
1951 ::mozilla::safebrowsing::Duration* release_minimum_wait_duration();
1952 ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration();
1953 void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration);
1954 private:
1955 const ::mozilla::safebrowsing::Duration& _internal_minimum_wait_duration() const;
1956 ::mozilla::safebrowsing::Duration* _internal_mutable_minimum_wait_duration();
1957 public:
1958
1959 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
1960 private:
1961 class _Internal;
1962
1963 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
1964 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1965 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1966 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse > list_update_responses_;
1967 ::mozilla::safebrowsing::Duration* minimum_wait_duration_;
1968 friend struct ::TableStruct_safebrowsing_2eproto;
1969 };
1970 // -------------------------------------------------------------------
1971
1972 class FindFullHashesRequest :
1973 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindFullHashesRequest) */ {
1974 public:
1975 FindFullHashesRequest();
1976 virtual ~FindFullHashesRequest();
1977
1978 FindFullHashesRequest(const FindFullHashesRequest& from);
FindFullHashesRequest(FindFullHashesRequest && from)1979 FindFullHashesRequest(FindFullHashesRequest&& from) noexcept
1980 : FindFullHashesRequest() {
1981 *this = ::std::move(from);
1982 }
1983
1984 inline FindFullHashesRequest& operator=(const FindFullHashesRequest& from) {
1985 CopyFrom(from);
1986 return *this;
1987 }
1988 inline FindFullHashesRequest& operator=(FindFullHashesRequest&& from) noexcept {
1989 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1990 if (this != &from) InternalSwap(&from);
1991 } else {
1992 CopyFrom(from);
1993 }
1994 return *this;
1995 }
1996
unknown_fields()1997 inline const std::string& unknown_fields() const {
1998 return _internal_metadata_.unknown_fields();
1999 }
mutable_unknown_fields()2000 inline std::string* mutable_unknown_fields() {
2001 return _internal_metadata_.mutable_unknown_fields();
2002 }
2003
2004 static const FindFullHashesRequest& default_instance();
2005
2006 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()2007 static inline const FindFullHashesRequest* internal_default_instance() {
2008 return reinterpret_cast<const FindFullHashesRequest*>(
2009 &_FindFullHashesRequest_default_instance_);
2010 }
2011 static constexpr int kIndexInFileMessages =
2012 9;
2013
swap(FindFullHashesRequest & a,FindFullHashesRequest & b)2014 friend void swap(FindFullHashesRequest& a, FindFullHashesRequest& b) {
2015 a.Swap(&b);
2016 }
Swap(FindFullHashesRequest * other)2017 inline void Swap(FindFullHashesRequest* other) {
2018 if (other == this) return;
2019 InternalSwap(other);
2020 }
2021
2022 // implements Message ----------------------------------------------
2023
New()2024 inline FindFullHashesRequest* New() const final {
2025 return CreateMaybeMessage<FindFullHashesRequest>(nullptr);
2026 }
2027
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)2028 FindFullHashesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2029 return CreateMaybeMessage<FindFullHashesRequest>(arena);
2030 }
2031 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
2032 final;
2033 void CopyFrom(const FindFullHashesRequest& from);
2034 void MergeFrom(const FindFullHashesRequest& from);
2035 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2036 bool IsInitialized() const final;
2037
2038 size_t ByteSizeLong() const final;
2039 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2040 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2041 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2042 void DiscardUnknownFields();
GetCachedSize()2043 int GetCachedSize() const final { return _cached_size_.Get(); }
2044
2045 private:
2046 inline void SharedCtor();
2047 inline void SharedDtor();
2048 void SetCachedSize(int size) const;
2049 void InternalSwap(FindFullHashesRequest* other);
2050 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()2051 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2052 return "mozilla.safebrowsing.FindFullHashesRequest";
2053 }
2054 private:
GetArenaNoVirtual()2055 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2056 return nullptr;
2057 }
MaybeArenaPtr()2058 inline void* MaybeArenaPtr() const {
2059 return nullptr;
2060 }
2061 public:
2062
2063 std::string GetTypeName() const final;
2064
2065 // nested types ----------------------------------------------------
2066
2067 // accessors -------------------------------------------------------
2068
2069 enum : int {
2070 kClientStatesFieldNumber = 2,
2071 kClientFieldNumber = 1,
2072 kThreatInfoFieldNumber = 3,
2073 };
2074 // repeated bytes client_states = 2;
2075 int client_states_size() const;
2076 private:
2077 int _internal_client_states_size() const;
2078 public:
2079 void clear_client_states();
2080 const std::string& client_states(int index) const;
2081 std::string* mutable_client_states(int index);
2082 void set_client_states(int index, const std::string& value);
2083 void set_client_states(int index, std::string&& value);
2084 void set_client_states(int index, const char* value);
2085 void set_client_states(int index, const void* value, size_t size);
2086 std::string* add_client_states();
2087 void add_client_states(const std::string& value);
2088 void add_client_states(std::string&& value);
2089 void add_client_states(const char* value);
2090 void add_client_states(const void* value, size_t size);
2091 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& client_states() const;
2092 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_client_states();
2093 private:
2094 const std::string& _internal_client_states(int index) const;
2095 std::string* _internal_add_client_states();
2096 public:
2097
2098 // optional .mozilla.safebrowsing.ClientInfo client = 1;
2099 bool has_client() const;
2100 private:
2101 bool _internal_has_client() const;
2102 public:
2103 void clear_client();
2104 const ::mozilla::safebrowsing::ClientInfo& client() const;
2105 ::mozilla::safebrowsing::ClientInfo* release_client();
2106 ::mozilla::safebrowsing::ClientInfo* mutable_client();
2107 void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
2108 private:
2109 const ::mozilla::safebrowsing::ClientInfo& _internal_client() const;
2110 ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client();
2111 public:
2112
2113 // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
2114 bool has_threat_info() const;
2115 private:
2116 bool _internal_has_threat_info() const;
2117 public:
2118 void clear_threat_info();
2119 const ::mozilla::safebrowsing::ThreatInfo& threat_info() const;
2120 ::mozilla::safebrowsing::ThreatInfo* release_threat_info();
2121 ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info();
2122 void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info);
2123 private:
2124 const ::mozilla::safebrowsing::ThreatInfo& _internal_threat_info() const;
2125 ::mozilla::safebrowsing::ThreatInfo* _internal_mutable_threat_info();
2126 public:
2127
2128 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesRequest)
2129 private:
2130 class _Internal;
2131
2132 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
2133 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2134 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2135 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> client_states_;
2136 ::mozilla::safebrowsing::ClientInfo* client_;
2137 ::mozilla::safebrowsing::ThreatInfo* threat_info_;
2138 friend struct ::TableStruct_safebrowsing_2eproto;
2139 };
2140 // -------------------------------------------------------------------
2141
2142 class FindFullHashesResponse :
2143 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindFullHashesResponse) */ {
2144 public:
2145 FindFullHashesResponse();
2146 virtual ~FindFullHashesResponse();
2147
2148 FindFullHashesResponse(const FindFullHashesResponse& from);
FindFullHashesResponse(FindFullHashesResponse && from)2149 FindFullHashesResponse(FindFullHashesResponse&& from) noexcept
2150 : FindFullHashesResponse() {
2151 *this = ::std::move(from);
2152 }
2153
2154 inline FindFullHashesResponse& operator=(const FindFullHashesResponse& from) {
2155 CopyFrom(from);
2156 return *this;
2157 }
2158 inline FindFullHashesResponse& operator=(FindFullHashesResponse&& from) noexcept {
2159 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2160 if (this != &from) InternalSwap(&from);
2161 } else {
2162 CopyFrom(from);
2163 }
2164 return *this;
2165 }
2166
unknown_fields()2167 inline const std::string& unknown_fields() const {
2168 return _internal_metadata_.unknown_fields();
2169 }
mutable_unknown_fields()2170 inline std::string* mutable_unknown_fields() {
2171 return _internal_metadata_.mutable_unknown_fields();
2172 }
2173
2174 static const FindFullHashesResponse& default_instance();
2175
2176 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()2177 static inline const FindFullHashesResponse* internal_default_instance() {
2178 return reinterpret_cast<const FindFullHashesResponse*>(
2179 &_FindFullHashesResponse_default_instance_);
2180 }
2181 static constexpr int kIndexInFileMessages =
2182 10;
2183
swap(FindFullHashesResponse & a,FindFullHashesResponse & b)2184 friend void swap(FindFullHashesResponse& a, FindFullHashesResponse& b) {
2185 a.Swap(&b);
2186 }
Swap(FindFullHashesResponse * other)2187 inline void Swap(FindFullHashesResponse* other) {
2188 if (other == this) return;
2189 InternalSwap(other);
2190 }
2191
2192 // implements Message ----------------------------------------------
2193
New()2194 inline FindFullHashesResponse* New() const final {
2195 return CreateMaybeMessage<FindFullHashesResponse>(nullptr);
2196 }
2197
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)2198 FindFullHashesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2199 return CreateMaybeMessage<FindFullHashesResponse>(arena);
2200 }
2201 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
2202 final;
2203 void CopyFrom(const FindFullHashesResponse& from);
2204 void MergeFrom(const FindFullHashesResponse& from);
2205 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2206 bool IsInitialized() const final;
2207
2208 size_t ByteSizeLong() const final;
2209 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2210 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2211 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2212 void DiscardUnknownFields();
GetCachedSize()2213 int GetCachedSize() const final { return _cached_size_.Get(); }
2214
2215 private:
2216 inline void SharedCtor();
2217 inline void SharedDtor();
2218 void SetCachedSize(int size) const;
2219 void InternalSwap(FindFullHashesResponse* other);
2220 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()2221 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2222 return "mozilla.safebrowsing.FindFullHashesResponse";
2223 }
2224 private:
GetArenaNoVirtual()2225 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2226 return nullptr;
2227 }
MaybeArenaPtr()2228 inline void* MaybeArenaPtr() const {
2229 return nullptr;
2230 }
2231 public:
2232
2233 std::string GetTypeName() const final;
2234
2235 // nested types ----------------------------------------------------
2236
2237 // accessors -------------------------------------------------------
2238
2239 enum : int {
2240 kMatchesFieldNumber = 1,
2241 kMinimumWaitDurationFieldNumber = 2,
2242 kNegativeCacheDurationFieldNumber = 3,
2243 };
2244 // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
2245 int matches_size() const;
2246 private:
2247 int _internal_matches_size() const;
2248 public:
2249 void clear_matches();
2250 ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index);
2251 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
2252 mutable_matches();
2253 private:
2254 const ::mozilla::safebrowsing::ThreatMatch& _internal_matches(int index) const;
2255 ::mozilla::safebrowsing::ThreatMatch* _internal_add_matches();
2256 public:
2257 const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const;
2258 ::mozilla::safebrowsing::ThreatMatch* add_matches();
2259 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
2260 matches() const;
2261
2262 // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
2263 bool has_minimum_wait_duration() const;
2264 private:
2265 bool _internal_has_minimum_wait_duration() const;
2266 public:
2267 void clear_minimum_wait_duration();
2268 const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const;
2269 ::mozilla::safebrowsing::Duration* release_minimum_wait_duration();
2270 ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration();
2271 void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration);
2272 private:
2273 const ::mozilla::safebrowsing::Duration& _internal_minimum_wait_duration() const;
2274 ::mozilla::safebrowsing::Duration* _internal_mutable_minimum_wait_duration();
2275 public:
2276
2277 // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
2278 bool has_negative_cache_duration() const;
2279 private:
2280 bool _internal_has_negative_cache_duration() const;
2281 public:
2282 void clear_negative_cache_duration();
2283 const ::mozilla::safebrowsing::Duration& negative_cache_duration() const;
2284 ::mozilla::safebrowsing::Duration* release_negative_cache_duration();
2285 ::mozilla::safebrowsing::Duration* mutable_negative_cache_duration();
2286 void set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration);
2287 private:
2288 const ::mozilla::safebrowsing::Duration& _internal_negative_cache_duration() const;
2289 ::mozilla::safebrowsing::Duration* _internal_mutable_negative_cache_duration();
2290 public:
2291
2292 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesResponse)
2293 private:
2294 class _Internal;
2295
2296 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
2297 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2298 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2299 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_;
2300 ::mozilla::safebrowsing::Duration* minimum_wait_duration_;
2301 ::mozilla::safebrowsing::Duration* negative_cache_duration_;
2302 friend struct ::TableStruct_safebrowsing_2eproto;
2303 };
2304 // -------------------------------------------------------------------
2305
2306 class ThreatHit_ThreatSource :
2307 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit.ThreatSource) */ {
2308 public:
2309 ThreatHit_ThreatSource();
2310 virtual ~ThreatHit_ThreatSource();
2311
2312 ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from);
ThreatHit_ThreatSource(ThreatHit_ThreatSource && from)2313 ThreatHit_ThreatSource(ThreatHit_ThreatSource&& from) noexcept
2314 : ThreatHit_ThreatSource() {
2315 *this = ::std::move(from);
2316 }
2317
2318 inline ThreatHit_ThreatSource& operator=(const ThreatHit_ThreatSource& from) {
2319 CopyFrom(from);
2320 return *this;
2321 }
2322 inline ThreatHit_ThreatSource& operator=(ThreatHit_ThreatSource&& from) noexcept {
2323 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2324 if (this != &from) InternalSwap(&from);
2325 } else {
2326 CopyFrom(from);
2327 }
2328 return *this;
2329 }
2330
unknown_fields()2331 inline const std::string& unknown_fields() const {
2332 return _internal_metadata_.unknown_fields();
2333 }
mutable_unknown_fields()2334 inline std::string* mutable_unknown_fields() {
2335 return _internal_metadata_.mutable_unknown_fields();
2336 }
2337
2338 static const ThreatHit_ThreatSource& default_instance();
2339
2340 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()2341 static inline const ThreatHit_ThreatSource* internal_default_instance() {
2342 return reinterpret_cast<const ThreatHit_ThreatSource*>(
2343 &_ThreatHit_ThreatSource_default_instance_);
2344 }
2345 static constexpr int kIndexInFileMessages =
2346 11;
2347
swap(ThreatHit_ThreatSource & a,ThreatHit_ThreatSource & b)2348 friend void swap(ThreatHit_ThreatSource& a, ThreatHit_ThreatSource& b) {
2349 a.Swap(&b);
2350 }
Swap(ThreatHit_ThreatSource * other)2351 inline void Swap(ThreatHit_ThreatSource* other) {
2352 if (other == this) return;
2353 InternalSwap(other);
2354 }
2355
2356 // implements Message ----------------------------------------------
2357
New()2358 inline ThreatHit_ThreatSource* New() const final {
2359 return CreateMaybeMessage<ThreatHit_ThreatSource>(nullptr);
2360 }
2361
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)2362 ThreatHit_ThreatSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2363 return CreateMaybeMessage<ThreatHit_ThreatSource>(arena);
2364 }
2365 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
2366 final;
2367 void CopyFrom(const ThreatHit_ThreatSource& from);
2368 void MergeFrom(const ThreatHit_ThreatSource& from);
2369 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2370 bool IsInitialized() const final;
2371
2372 size_t ByteSizeLong() const final;
2373 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2374 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2375 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2376 void DiscardUnknownFields();
GetCachedSize()2377 int GetCachedSize() const final { return _cached_size_.Get(); }
2378
2379 private:
2380 inline void SharedCtor();
2381 inline void SharedDtor();
2382 void SetCachedSize(int size) const;
2383 void InternalSwap(ThreatHit_ThreatSource* other);
2384 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()2385 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2386 return "mozilla.safebrowsing.ThreatHit.ThreatSource";
2387 }
2388 private:
GetArenaNoVirtual()2389 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2390 return nullptr;
2391 }
MaybeArenaPtr()2392 inline void* MaybeArenaPtr() const {
2393 return nullptr;
2394 }
2395 public:
2396
2397 std::string GetTypeName() const final;
2398
2399 // nested types ----------------------------------------------------
2400
2401 // accessors -------------------------------------------------------
2402
2403 enum : int {
2404 kUrlFieldNumber = 1,
2405 kRemoteIpFieldNumber = 3,
2406 kReferrerFieldNumber = 4,
2407 kTypeFieldNumber = 2,
2408 };
2409 // optional string url = 1;
2410 bool has_url() const;
2411 private:
2412 bool _internal_has_url() const;
2413 public:
2414 void clear_url();
2415 const std::string& url() const;
2416 void set_url(const std::string& value);
2417 void set_url(std::string&& value);
2418 void set_url(const char* value);
2419 void set_url(const char* value, size_t size);
2420 std::string* mutable_url();
2421 std::string* release_url();
2422 void set_allocated_url(std::string* url);
2423 private:
2424 const std::string& _internal_url() const;
2425 void _internal_set_url(const std::string& value);
2426 std::string* _internal_mutable_url();
2427 public:
2428
2429 // optional string remote_ip = 3;
2430 bool has_remote_ip() const;
2431 private:
2432 bool _internal_has_remote_ip() const;
2433 public:
2434 void clear_remote_ip();
2435 const std::string& remote_ip() const;
2436 void set_remote_ip(const std::string& value);
2437 void set_remote_ip(std::string&& value);
2438 void set_remote_ip(const char* value);
2439 void set_remote_ip(const char* value, size_t size);
2440 std::string* mutable_remote_ip();
2441 std::string* release_remote_ip();
2442 void set_allocated_remote_ip(std::string* remote_ip);
2443 private:
2444 const std::string& _internal_remote_ip() const;
2445 void _internal_set_remote_ip(const std::string& value);
2446 std::string* _internal_mutable_remote_ip();
2447 public:
2448
2449 // optional string referrer = 4;
2450 bool has_referrer() const;
2451 private:
2452 bool _internal_has_referrer() const;
2453 public:
2454 void clear_referrer();
2455 const std::string& referrer() const;
2456 void set_referrer(const std::string& value);
2457 void set_referrer(std::string&& value);
2458 void set_referrer(const char* value);
2459 void set_referrer(const char* value, size_t size);
2460 std::string* mutable_referrer();
2461 std::string* release_referrer();
2462 void set_allocated_referrer(std::string* referrer);
2463 private:
2464 const std::string& _internal_referrer() const;
2465 void _internal_set_referrer(const std::string& value);
2466 std::string* _internal_mutable_referrer();
2467 public:
2468
2469 // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
2470 bool has_type() const;
2471 private:
2472 bool _internal_has_type() const;
2473 public:
2474 void clear_type();
2475 ::mozilla::safebrowsing::ThreatHit_ThreatSourceType type() const;
2476 void set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value);
2477 private:
2478 ::mozilla::safebrowsing::ThreatHit_ThreatSourceType _internal_type() const;
2479 void _internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value);
2480 public:
2481
2482 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.ThreatSource)
2483 private:
2484 class _Internal;
2485
2486 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
2487 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2488 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2489 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
2490 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_ip_;
2491 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_;
2492 int type_;
2493 friend struct ::TableStruct_safebrowsing_2eproto;
2494 };
2495 // -------------------------------------------------------------------
2496
2497 class ThreatHit_UserInfo :
2498 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit.UserInfo) */ {
2499 public:
2500 ThreatHit_UserInfo();
2501 virtual ~ThreatHit_UserInfo();
2502
2503 ThreatHit_UserInfo(const ThreatHit_UserInfo& from);
ThreatHit_UserInfo(ThreatHit_UserInfo && from)2504 ThreatHit_UserInfo(ThreatHit_UserInfo&& from) noexcept
2505 : ThreatHit_UserInfo() {
2506 *this = ::std::move(from);
2507 }
2508
2509 inline ThreatHit_UserInfo& operator=(const ThreatHit_UserInfo& from) {
2510 CopyFrom(from);
2511 return *this;
2512 }
2513 inline ThreatHit_UserInfo& operator=(ThreatHit_UserInfo&& from) noexcept {
2514 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2515 if (this != &from) InternalSwap(&from);
2516 } else {
2517 CopyFrom(from);
2518 }
2519 return *this;
2520 }
2521
unknown_fields()2522 inline const std::string& unknown_fields() const {
2523 return _internal_metadata_.unknown_fields();
2524 }
mutable_unknown_fields()2525 inline std::string* mutable_unknown_fields() {
2526 return _internal_metadata_.mutable_unknown_fields();
2527 }
2528
2529 static const ThreatHit_UserInfo& default_instance();
2530
2531 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()2532 static inline const ThreatHit_UserInfo* internal_default_instance() {
2533 return reinterpret_cast<const ThreatHit_UserInfo*>(
2534 &_ThreatHit_UserInfo_default_instance_);
2535 }
2536 static constexpr int kIndexInFileMessages =
2537 12;
2538
swap(ThreatHit_UserInfo & a,ThreatHit_UserInfo & b)2539 friend void swap(ThreatHit_UserInfo& a, ThreatHit_UserInfo& b) {
2540 a.Swap(&b);
2541 }
Swap(ThreatHit_UserInfo * other)2542 inline void Swap(ThreatHit_UserInfo* other) {
2543 if (other == this) return;
2544 InternalSwap(other);
2545 }
2546
2547 // implements Message ----------------------------------------------
2548
New()2549 inline ThreatHit_UserInfo* New() const final {
2550 return CreateMaybeMessage<ThreatHit_UserInfo>(nullptr);
2551 }
2552
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)2553 ThreatHit_UserInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2554 return CreateMaybeMessage<ThreatHit_UserInfo>(arena);
2555 }
2556 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
2557 final;
2558 void CopyFrom(const ThreatHit_UserInfo& from);
2559 void MergeFrom(const ThreatHit_UserInfo& from);
2560 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2561 bool IsInitialized() const final;
2562
2563 size_t ByteSizeLong() const final;
2564 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2565 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2566 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2567 void DiscardUnknownFields();
GetCachedSize()2568 int GetCachedSize() const final { return _cached_size_.Get(); }
2569
2570 private:
2571 inline void SharedCtor();
2572 inline void SharedDtor();
2573 void SetCachedSize(int size) const;
2574 void InternalSwap(ThreatHit_UserInfo* other);
2575 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()2576 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2577 return "mozilla.safebrowsing.ThreatHit.UserInfo";
2578 }
2579 private:
GetArenaNoVirtual()2580 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2581 return nullptr;
2582 }
MaybeArenaPtr()2583 inline void* MaybeArenaPtr() const {
2584 return nullptr;
2585 }
2586 public:
2587
2588 std::string GetTypeName() const final;
2589
2590 // nested types ----------------------------------------------------
2591
2592 // accessors -------------------------------------------------------
2593
2594 enum : int {
2595 kRegionCodeFieldNumber = 1,
2596 kUserIdFieldNumber = 2,
2597 };
2598 // optional string region_code = 1;
2599 bool has_region_code() const;
2600 private:
2601 bool _internal_has_region_code() const;
2602 public:
2603 void clear_region_code();
2604 const std::string& region_code() const;
2605 void set_region_code(const std::string& value);
2606 void set_region_code(std::string&& value);
2607 void set_region_code(const char* value);
2608 void set_region_code(const char* value, size_t size);
2609 std::string* mutable_region_code();
2610 std::string* release_region_code();
2611 void set_allocated_region_code(std::string* region_code);
2612 private:
2613 const std::string& _internal_region_code() const;
2614 void _internal_set_region_code(const std::string& value);
2615 std::string* _internal_mutable_region_code();
2616 public:
2617
2618 // optional bytes user_id = 2;
2619 bool has_user_id() const;
2620 private:
2621 bool _internal_has_user_id() const;
2622 public:
2623 void clear_user_id();
2624 const std::string& user_id() const;
2625 void set_user_id(const std::string& value);
2626 void set_user_id(std::string&& value);
2627 void set_user_id(const char* value);
2628 void set_user_id(const void* value, size_t size);
2629 std::string* mutable_user_id();
2630 std::string* release_user_id();
2631 void set_allocated_user_id(std::string* user_id);
2632 private:
2633 const std::string& _internal_user_id() const;
2634 void _internal_set_user_id(const std::string& value);
2635 std::string* _internal_mutable_user_id();
2636 public:
2637
2638 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.UserInfo)
2639 private:
2640 class _Internal;
2641
2642 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
2643 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2644 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2645 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr region_code_;
2646 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr user_id_;
2647 friend struct ::TableStruct_safebrowsing_2eproto;
2648 };
2649 // -------------------------------------------------------------------
2650
2651 class ThreatHit :
2652 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit) */ {
2653 public:
2654 ThreatHit();
2655 virtual ~ThreatHit();
2656
2657 ThreatHit(const ThreatHit& from);
ThreatHit(ThreatHit && from)2658 ThreatHit(ThreatHit&& from) noexcept
2659 : ThreatHit() {
2660 *this = ::std::move(from);
2661 }
2662
2663 inline ThreatHit& operator=(const ThreatHit& from) {
2664 CopyFrom(from);
2665 return *this;
2666 }
2667 inline ThreatHit& operator=(ThreatHit&& from) noexcept {
2668 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2669 if (this != &from) InternalSwap(&from);
2670 } else {
2671 CopyFrom(from);
2672 }
2673 return *this;
2674 }
2675
unknown_fields()2676 inline const std::string& unknown_fields() const {
2677 return _internal_metadata_.unknown_fields();
2678 }
mutable_unknown_fields()2679 inline std::string* mutable_unknown_fields() {
2680 return _internal_metadata_.mutable_unknown_fields();
2681 }
2682
2683 static const ThreatHit& default_instance();
2684
2685 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()2686 static inline const ThreatHit* internal_default_instance() {
2687 return reinterpret_cast<const ThreatHit*>(
2688 &_ThreatHit_default_instance_);
2689 }
2690 static constexpr int kIndexInFileMessages =
2691 13;
2692
swap(ThreatHit & a,ThreatHit & b)2693 friend void swap(ThreatHit& a, ThreatHit& b) {
2694 a.Swap(&b);
2695 }
Swap(ThreatHit * other)2696 inline void Swap(ThreatHit* other) {
2697 if (other == this) return;
2698 InternalSwap(other);
2699 }
2700
2701 // implements Message ----------------------------------------------
2702
New()2703 inline ThreatHit* New() const final {
2704 return CreateMaybeMessage<ThreatHit>(nullptr);
2705 }
2706
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)2707 ThreatHit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2708 return CreateMaybeMessage<ThreatHit>(arena);
2709 }
2710 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
2711 final;
2712 void CopyFrom(const ThreatHit& from);
2713 void MergeFrom(const ThreatHit& from);
2714 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2715 bool IsInitialized() const final;
2716
2717 size_t ByteSizeLong() const final;
2718 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2719 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2720 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2721 void DiscardUnknownFields();
GetCachedSize()2722 int GetCachedSize() const final { return _cached_size_.Get(); }
2723
2724 private:
2725 inline void SharedCtor();
2726 inline void SharedDtor();
2727 void SetCachedSize(int size) const;
2728 void InternalSwap(ThreatHit* other);
2729 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()2730 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2731 return "mozilla.safebrowsing.ThreatHit";
2732 }
2733 private:
GetArenaNoVirtual()2734 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2735 return nullptr;
2736 }
MaybeArenaPtr()2737 inline void* MaybeArenaPtr() const {
2738 return nullptr;
2739 }
2740 public:
2741
2742 std::string GetTypeName() const final;
2743
2744 // nested types ----------------------------------------------------
2745
2746 typedef ThreatHit_ThreatSource ThreatSource;
2747 typedef ThreatHit_UserInfo UserInfo;
2748
2749 typedef ThreatHit_ThreatSourceType ThreatSourceType;
2750 static constexpr ThreatSourceType THREAT_SOURCE_TYPE_UNSPECIFIED =
2751 ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED;
2752 static constexpr ThreatSourceType MATCHING_URL =
2753 ThreatHit_ThreatSourceType_MATCHING_URL;
2754 static constexpr ThreatSourceType TAB_URL =
2755 ThreatHit_ThreatSourceType_TAB_URL;
2756 static constexpr ThreatSourceType TAB_REDIRECT =
2757 ThreatHit_ThreatSourceType_TAB_REDIRECT;
2758 static constexpr ThreatSourceType TAB_RESOURCE =
2759 ThreatHit_ThreatSourceType_TAB_RESOURCE;
ThreatSourceType_IsValid(int value)2760 static inline bool ThreatSourceType_IsValid(int value) {
2761 return ThreatHit_ThreatSourceType_IsValid(value);
2762 }
2763 static constexpr ThreatSourceType ThreatSourceType_MIN =
2764 ThreatHit_ThreatSourceType_ThreatSourceType_MIN;
2765 static constexpr ThreatSourceType ThreatSourceType_MAX =
2766 ThreatHit_ThreatSourceType_ThreatSourceType_MAX;
2767 static constexpr int ThreatSourceType_ARRAYSIZE =
2768 ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE;
2769 template<typename T>
ThreatSourceType_Name(T enum_t_value)2770 static inline const std::string& ThreatSourceType_Name(T enum_t_value) {
2771 static_assert(::std::is_same<T, ThreatSourceType>::value ||
2772 ::std::is_integral<T>::value,
2773 "Incorrect type passed to function ThreatSourceType_Name.");
2774 return ThreatHit_ThreatSourceType_Name(enum_t_value);
2775 }
ThreatSourceType_Parse(const std::string & name,ThreatSourceType * value)2776 static inline bool ThreatSourceType_Parse(const std::string& name,
2777 ThreatSourceType* value) {
2778 return ThreatHit_ThreatSourceType_Parse(name, value);
2779 }
2780
2781 // accessors -------------------------------------------------------
2782
2783 enum : int {
2784 kResourcesFieldNumber = 4,
2785 kEntryFieldNumber = 3,
2786 kClientInfoFieldNumber = 5,
2787 kUserInfoFieldNumber = 6,
2788 kThreatTypeFieldNumber = 1,
2789 kPlatformTypeFieldNumber = 2,
2790 };
2791 // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
2792 int resources_size() const;
2793 private:
2794 int _internal_resources_size() const;
2795 public:
2796 void clear_resources();
2797 ::mozilla::safebrowsing::ThreatHit_ThreatSource* mutable_resources(int index);
2798 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >*
2799 mutable_resources();
2800 private:
2801 const ::mozilla::safebrowsing::ThreatHit_ThreatSource& _internal_resources(int index) const;
2802 ::mozilla::safebrowsing::ThreatHit_ThreatSource* _internal_add_resources();
2803 public:
2804 const ::mozilla::safebrowsing::ThreatHit_ThreatSource& resources(int index) const;
2805 ::mozilla::safebrowsing::ThreatHit_ThreatSource* add_resources();
2806 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >&
2807 resources() const;
2808
2809 // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
2810 bool has_entry() const;
2811 private:
2812 bool _internal_has_entry() const;
2813 public:
2814 void clear_entry();
2815 const ::mozilla::safebrowsing::ThreatEntry& entry() const;
2816 ::mozilla::safebrowsing::ThreatEntry* release_entry();
2817 ::mozilla::safebrowsing::ThreatEntry* mutable_entry();
2818 void set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry);
2819 private:
2820 const ::mozilla::safebrowsing::ThreatEntry& _internal_entry() const;
2821 ::mozilla::safebrowsing::ThreatEntry* _internal_mutable_entry();
2822 public:
2823
2824 // optional .mozilla.safebrowsing.ClientInfo client_info = 5;
2825 bool has_client_info() const;
2826 private:
2827 bool _internal_has_client_info() const;
2828 public:
2829 void clear_client_info();
2830 const ::mozilla::safebrowsing::ClientInfo& client_info() const;
2831 ::mozilla::safebrowsing::ClientInfo* release_client_info();
2832 ::mozilla::safebrowsing::ClientInfo* mutable_client_info();
2833 void set_allocated_client_info(::mozilla::safebrowsing::ClientInfo* client_info);
2834 private:
2835 const ::mozilla::safebrowsing::ClientInfo& _internal_client_info() const;
2836 ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client_info();
2837 public:
2838
2839 // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6;
2840 bool has_user_info() const;
2841 private:
2842 bool _internal_has_user_info() const;
2843 public:
2844 void clear_user_info();
2845 const ::mozilla::safebrowsing::ThreatHit_UserInfo& user_info() const;
2846 ::mozilla::safebrowsing::ThreatHit_UserInfo* release_user_info();
2847 ::mozilla::safebrowsing::ThreatHit_UserInfo* mutable_user_info();
2848 void set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo* user_info);
2849 private:
2850 const ::mozilla::safebrowsing::ThreatHit_UserInfo& _internal_user_info() const;
2851 ::mozilla::safebrowsing::ThreatHit_UserInfo* _internal_mutable_user_info();
2852 public:
2853
2854 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
2855 bool has_threat_type() const;
2856 private:
2857 bool _internal_has_threat_type() const;
2858 public:
2859 void clear_threat_type();
2860 ::mozilla::safebrowsing::ThreatType threat_type() const;
2861 void set_threat_type(::mozilla::safebrowsing::ThreatType value);
2862 private:
2863 ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
2864 void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
2865 public:
2866
2867 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
2868 bool has_platform_type() const;
2869 private:
2870 bool _internal_has_platform_type() const;
2871 public:
2872 void clear_platform_type();
2873 ::mozilla::safebrowsing::PlatformType platform_type() const;
2874 void set_platform_type(::mozilla::safebrowsing::PlatformType value);
2875 private:
2876 ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
2877 void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
2878 public:
2879
2880 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit)
2881 private:
2882 class _Internal;
2883
2884 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
2885 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2886 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2887 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource > resources_;
2888 ::mozilla::safebrowsing::ThreatEntry* entry_;
2889 ::mozilla::safebrowsing::ClientInfo* client_info_;
2890 ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info_;
2891 int threat_type_;
2892 int platform_type_;
2893 friend struct ::TableStruct_safebrowsing_2eproto;
2894 };
2895 // -------------------------------------------------------------------
2896
2897 class ClientInfo :
2898 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ClientInfo) */ {
2899 public:
2900 ClientInfo();
2901 virtual ~ClientInfo();
2902
2903 ClientInfo(const ClientInfo& from);
ClientInfo(ClientInfo && from)2904 ClientInfo(ClientInfo&& from) noexcept
2905 : ClientInfo() {
2906 *this = ::std::move(from);
2907 }
2908
2909 inline ClientInfo& operator=(const ClientInfo& from) {
2910 CopyFrom(from);
2911 return *this;
2912 }
2913 inline ClientInfo& operator=(ClientInfo&& from) noexcept {
2914 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2915 if (this != &from) InternalSwap(&from);
2916 } else {
2917 CopyFrom(from);
2918 }
2919 return *this;
2920 }
2921
unknown_fields()2922 inline const std::string& unknown_fields() const {
2923 return _internal_metadata_.unknown_fields();
2924 }
mutable_unknown_fields()2925 inline std::string* mutable_unknown_fields() {
2926 return _internal_metadata_.mutable_unknown_fields();
2927 }
2928
2929 static const ClientInfo& default_instance();
2930
2931 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()2932 static inline const ClientInfo* internal_default_instance() {
2933 return reinterpret_cast<const ClientInfo*>(
2934 &_ClientInfo_default_instance_);
2935 }
2936 static constexpr int kIndexInFileMessages =
2937 14;
2938
swap(ClientInfo & a,ClientInfo & b)2939 friend void swap(ClientInfo& a, ClientInfo& b) {
2940 a.Swap(&b);
2941 }
Swap(ClientInfo * other)2942 inline void Swap(ClientInfo* other) {
2943 if (other == this) return;
2944 InternalSwap(other);
2945 }
2946
2947 // implements Message ----------------------------------------------
2948
New()2949 inline ClientInfo* New() const final {
2950 return CreateMaybeMessage<ClientInfo>(nullptr);
2951 }
2952
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)2953 ClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2954 return CreateMaybeMessage<ClientInfo>(arena);
2955 }
2956 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
2957 final;
2958 void CopyFrom(const ClientInfo& from);
2959 void MergeFrom(const ClientInfo& from);
2960 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2961 bool IsInitialized() const final;
2962
2963 size_t ByteSizeLong() const final;
2964 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2965 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2966 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2967 void DiscardUnknownFields();
GetCachedSize()2968 int GetCachedSize() const final { return _cached_size_.Get(); }
2969
2970 private:
2971 inline void SharedCtor();
2972 inline void SharedDtor();
2973 void SetCachedSize(int size) const;
2974 void InternalSwap(ClientInfo* other);
2975 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()2976 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2977 return "mozilla.safebrowsing.ClientInfo";
2978 }
2979 private:
GetArenaNoVirtual()2980 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2981 return nullptr;
2982 }
MaybeArenaPtr()2983 inline void* MaybeArenaPtr() const {
2984 return nullptr;
2985 }
2986 public:
2987
2988 std::string GetTypeName() const final;
2989
2990 // nested types ----------------------------------------------------
2991
2992 // accessors -------------------------------------------------------
2993
2994 enum : int {
2995 kClientIdFieldNumber = 1,
2996 kClientVersionFieldNumber = 2,
2997 };
2998 // optional string client_id = 1;
2999 bool has_client_id() const;
3000 private:
3001 bool _internal_has_client_id() const;
3002 public:
3003 void clear_client_id();
3004 const std::string& client_id() const;
3005 void set_client_id(const std::string& value);
3006 void set_client_id(std::string&& value);
3007 void set_client_id(const char* value);
3008 void set_client_id(const char* value, size_t size);
3009 std::string* mutable_client_id();
3010 std::string* release_client_id();
3011 void set_allocated_client_id(std::string* client_id);
3012 private:
3013 const std::string& _internal_client_id() const;
3014 void _internal_set_client_id(const std::string& value);
3015 std::string* _internal_mutable_client_id();
3016 public:
3017
3018 // optional string client_version = 2;
3019 bool has_client_version() const;
3020 private:
3021 bool _internal_has_client_version() const;
3022 public:
3023 void clear_client_version();
3024 const std::string& client_version() const;
3025 void set_client_version(const std::string& value);
3026 void set_client_version(std::string&& value);
3027 void set_client_version(const char* value);
3028 void set_client_version(const char* value, size_t size);
3029 std::string* mutable_client_version();
3030 std::string* release_client_version();
3031 void set_allocated_client_version(std::string* client_version);
3032 private:
3033 const std::string& _internal_client_version() const;
3034 void _internal_set_client_version(const std::string& value);
3035 std::string* _internal_mutable_client_version();
3036 public:
3037
3038 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ClientInfo)
3039 private:
3040 class _Internal;
3041
3042 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3043 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3044 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3045 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_id_;
3046 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_version_;
3047 friend struct ::TableStruct_safebrowsing_2eproto;
3048 };
3049 // -------------------------------------------------------------------
3050
3051 class ChromeClientInfo :
3052 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ChromeClientInfo) */ {
3053 public:
3054 ChromeClientInfo();
3055 virtual ~ChromeClientInfo();
3056
3057 ChromeClientInfo(const ChromeClientInfo& from);
ChromeClientInfo(ChromeClientInfo && from)3058 ChromeClientInfo(ChromeClientInfo&& from) noexcept
3059 : ChromeClientInfo() {
3060 *this = ::std::move(from);
3061 }
3062
3063 inline ChromeClientInfo& operator=(const ChromeClientInfo& from) {
3064 CopyFrom(from);
3065 return *this;
3066 }
3067 inline ChromeClientInfo& operator=(ChromeClientInfo&& from) noexcept {
3068 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3069 if (this != &from) InternalSwap(&from);
3070 } else {
3071 CopyFrom(from);
3072 }
3073 return *this;
3074 }
3075
unknown_fields()3076 inline const std::string& unknown_fields() const {
3077 return _internal_metadata_.unknown_fields();
3078 }
mutable_unknown_fields()3079 inline std::string* mutable_unknown_fields() {
3080 return _internal_metadata_.mutable_unknown_fields();
3081 }
3082
3083 static const ChromeClientInfo& default_instance();
3084
3085 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()3086 static inline const ChromeClientInfo* internal_default_instance() {
3087 return reinterpret_cast<const ChromeClientInfo*>(
3088 &_ChromeClientInfo_default_instance_);
3089 }
3090 static constexpr int kIndexInFileMessages =
3091 15;
3092
swap(ChromeClientInfo & a,ChromeClientInfo & b)3093 friend void swap(ChromeClientInfo& a, ChromeClientInfo& b) {
3094 a.Swap(&b);
3095 }
Swap(ChromeClientInfo * other)3096 inline void Swap(ChromeClientInfo* other) {
3097 if (other == this) return;
3098 InternalSwap(other);
3099 }
3100
3101 // implements Message ----------------------------------------------
3102
New()3103 inline ChromeClientInfo* New() const final {
3104 return CreateMaybeMessage<ChromeClientInfo>(nullptr);
3105 }
3106
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)3107 ChromeClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3108 return CreateMaybeMessage<ChromeClientInfo>(arena);
3109 }
3110 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
3111 final;
3112 void CopyFrom(const ChromeClientInfo& from);
3113 void MergeFrom(const ChromeClientInfo& from);
3114 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3115 bool IsInitialized() const final;
3116
3117 size_t ByteSizeLong() const final;
3118 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3119 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3120 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3121 void DiscardUnknownFields();
GetCachedSize()3122 int GetCachedSize() const final { return _cached_size_.Get(); }
3123
3124 private:
3125 inline void SharedCtor();
3126 inline void SharedDtor();
3127 void SetCachedSize(int size) const;
3128 void InternalSwap(ChromeClientInfo* other);
3129 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()3130 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3131 return "mozilla.safebrowsing.ChromeClientInfo";
3132 }
3133 private:
GetArenaNoVirtual()3134 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3135 return nullptr;
3136 }
MaybeArenaPtr()3137 inline void* MaybeArenaPtr() const {
3138 return nullptr;
3139 }
3140 public:
3141
3142 std::string GetTypeName() const final;
3143
3144 // nested types ----------------------------------------------------
3145
3146 typedef ChromeClientInfo_SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation;
3147 static constexpr SafeBrowsingReportingPopulation UNSPECIFIED =
3148 ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED;
3149 static constexpr SafeBrowsingReportingPopulation OPT_OUT =
3150 ChromeClientInfo_SafeBrowsingReportingPopulation_OPT_OUT;
3151 static constexpr SafeBrowsingReportingPopulation EXTENDED =
3152 ChromeClientInfo_SafeBrowsingReportingPopulation_EXTENDED;
3153 static constexpr SafeBrowsingReportingPopulation SCOUT =
3154 ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT;
SafeBrowsingReportingPopulation_IsValid(int value)3155 static inline bool SafeBrowsingReportingPopulation_IsValid(int value) {
3156 return ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(value);
3157 }
3158 static constexpr SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation_MIN =
3159 ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MIN;
3160 static constexpr SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation_MAX =
3161 ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX;
3162 static constexpr int SafeBrowsingReportingPopulation_ARRAYSIZE =
3163 ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_ARRAYSIZE;
3164 template<typename T>
SafeBrowsingReportingPopulation_Name(T enum_t_value)3165 static inline const std::string& SafeBrowsingReportingPopulation_Name(T enum_t_value) {
3166 static_assert(::std::is_same<T, SafeBrowsingReportingPopulation>::value ||
3167 ::std::is_integral<T>::value,
3168 "Incorrect type passed to function SafeBrowsingReportingPopulation_Name.");
3169 return ChromeClientInfo_SafeBrowsingReportingPopulation_Name(enum_t_value);
3170 }
SafeBrowsingReportingPopulation_Parse(const std::string & name,SafeBrowsingReportingPopulation * value)3171 static inline bool SafeBrowsingReportingPopulation_Parse(const std::string& name,
3172 SafeBrowsingReportingPopulation* value) {
3173 return ChromeClientInfo_SafeBrowsingReportingPopulation_Parse(name, value);
3174 }
3175
3176 // accessors -------------------------------------------------------
3177
3178 enum : int {
3179 kReportingPopulationFieldNumber = 1,
3180 };
3181 // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1;
3182 bool has_reporting_population() const;
3183 private:
3184 bool _internal_has_reporting_population() const;
3185 public:
3186 void clear_reporting_population();
3187 ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation reporting_population() const;
3188 void set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value);
3189 private:
3190 ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation _internal_reporting_population() const;
3191 void _internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value);
3192 public:
3193
3194 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ChromeClientInfo)
3195 private:
3196 class _Internal;
3197
3198 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3199 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3200 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3201 int reporting_population_;
3202 friend struct ::TableStruct_safebrowsing_2eproto;
3203 };
3204 // -------------------------------------------------------------------
3205
3206 class Checksum :
3207 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.Checksum) */ {
3208 public:
3209 Checksum();
3210 virtual ~Checksum();
3211
3212 Checksum(const Checksum& from);
Checksum(Checksum && from)3213 Checksum(Checksum&& from) noexcept
3214 : Checksum() {
3215 *this = ::std::move(from);
3216 }
3217
3218 inline Checksum& operator=(const Checksum& from) {
3219 CopyFrom(from);
3220 return *this;
3221 }
3222 inline Checksum& operator=(Checksum&& from) noexcept {
3223 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3224 if (this != &from) InternalSwap(&from);
3225 } else {
3226 CopyFrom(from);
3227 }
3228 return *this;
3229 }
3230
unknown_fields()3231 inline const std::string& unknown_fields() const {
3232 return _internal_metadata_.unknown_fields();
3233 }
mutable_unknown_fields()3234 inline std::string* mutable_unknown_fields() {
3235 return _internal_metadata_.mutable_unknown_fields();
3236 }
3237
3238 static const Checksum& default_instance();
3239
3240 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()3241 static inline const Checksum* internal_default_instance() {
3242 return reinterpret_cast<const Checksum*>(
3243 &_Checksum_default_instance_);
3244 }
3245 static constexpr int kIndexInFileMessages =
3246 16;
3247
swap(Checksum & a,Checksum & b)3248 friend void swap(Checksum& a, Checksum& b) {
3249 a.Swap(&b);
3250 }
Swap(Checksum * other)3251 inline void Swap(Checksum* other) {
3252 if (other == this) return;
3253 InternalSwap(other);
3254 }
3255
3256 // implements Message ----------------------------------------------
3257
New()3258 inline Checksum* New() const final {
3259 return CreateMaybeMessage<Checksum>(nullptr);
3260 }
3261
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)3262 Checksum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3263 return CreateMaybeMessage<Checksum>(arena);
3264 }
3265 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
3266 final;
3267 void CopyFrom(const Checksum& from);
3268 void MergeFrom(const Checksum& from);
3269 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3270 bool IsInitialized() const final;
3271
3272 size_t ByteSizeLong() const final;
3273 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3274 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3275 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3276 void DiscardUnknownFields();
GetCachedSize()3277 int GetCachedSize() const final { return _cached_size_.Get(); }
3278
3279 private:
3280 inline void SharedCtor();
3281 inline void SharedDtor();
3282 void SetCachedSize(int size) const;
3283 void InternalSwap(Checksum* other);
3284 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()3285 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3286 return "mozilla.safebrowsing.Checksum";
3287 }
3288 private:
GetArenaNoVirtual()3289 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3290 return nullptr;
3291 }
MaybeArenaPtr()3292 inline void* MaybeArenaPtr() const {
3293 return nullptr;
3294 }
3295 public:
3296
3297 std::string GetTypeName() const final;
3298
3299 // nested types ----------------------------------------------------
3300
3301 // accessors -------------------------------------------------------
3302
3303 enum : int {
3304 kSha256FieldNumber = 1,
3305 };
3306 // optional bytes sha256 = 1;
3307 bool has_sha256() const;
3308 private:
3309 bool _internal_has_sha256() const;
3310 public:
3311 void clear_sha256();
3312 const std::string& sha256() const;
3313 void set_sha256(const std::string& value);
3314 void set_sha256(std::string&& value);
3315 void set_sha256(const char* value);
3316 void set_sha256(const void* value, size_t size);
3317 std::string* mutable_sha256();
3318 std::string* release_sha256();
3319 void set_allocated_sha256(std::string* sha256);
3320 private:
3321 const std::string& _internal_sha256() const;
3322 void _internal_set_sha256(const std::string& value);
3323 std::string* _internal_mutable_sha256();
3324 public:
3325
3326 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Checksum)
3327 private:
3328 class _Internal;
3329
3330 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3331 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3332 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3333 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha256_;
3334 friend struct ::TableStruct_safebrowsing_2eproto;
3335 };
3336 // -------------------------------------------------------------------
3337
3338 class ThreatEntry :
3339 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntry) */ {
3340 public:
3341 ThreatEntry();
3342 virtual ~ThreatEntry();
3343
3344 ThreatEntry(const ThreatEntry& from);
ThreatEntry(ThreatEntry && from)3345 ThreatEntry(ThreatEntry&& from) noexcept
3346 : ThreatEntry() {
3347 *this = ::std::move(from);
3348 }
3349
3350 inline ThreatEntry& operator=(const ThreatEntry& from) {
3351 CopyFrom(from);
3352 return *this;
3353 }
3354 inline ThreatEntry& operator=(ThreatEntry&& from) noexcept {
3355 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3356 if (this != &from) InternalSwap(&from);
3357 } else {
3358 CopyFrom(from);
3359 }
3360 return *this;
3361 }
3362
unknown_fields()3363 inline const std::string& unknown_fields() const {
3364 return _internal_metadata_.unknown_fields();
3365 }
mutable_unknown_fields()3366 inline std::string* mutable_unknown_fields() {
3367 return _internal_metadata_.mutable_unknown_fields();
3368 }
3369
3370 static const ThreatEntry& default_instance();
3371
3372 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()3373 static inline const ThreatEntry* internal_default_instance() {
3374 return reinterpret_cast<const ThreatEntry*>(
3375 &_ThreatEntry_default_instance_);
3376 }
3377 static constexpr int kIndexInFileMessages =
3378 17;
3379
swap(ThreatEntry & a,ThreatEntry & b)3380 friend void swap(ThreatEntry& a, ThreatEntry& b) {
3381 a.Swap(&b);
3382 }
Swap(ThreatEntry * other)3383 inline void Swap(ThreatEntry* other) {
3384 if (other == this) return;
3385 InternalSwap(other);
3386 }
3387
3388 // implements Message ----------------------------------------------
3389
New()3390 inline ThreatEntry* New() const final {
3391 return CreateMaybeMessage<ThreatEntry>(nullptr);
3392 }
3393
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)3394 ThreatEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3395 return CreateMaybeMessage<ThreatEntry>(arena);
3396 }
3397 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
3398 final;
3399 void CopyFrom(const ThreatEntry& from);
3400 void MergeFrom(const ThreatEntry& from);
3401 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3402 bool IsInitialized() const final;
3403
3404 size_t ByteSizeLong() const final;
3405 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3406 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3407 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3408 void DiscardUnknownFields();
GetCachedSize()3409 int GetCachedSize() const final { return _cached_size_.Get(); }
3410
3411 private:
3412 inline void SharedCtor();
3413 inline void SharedDtor();
3414 void SetCachedSize(int size) const;
3415 void InternalSwap(ThreatEntry* other);
3416 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()3417 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3418 return "mozilla.safebrowsing.ThreatEntry";
3419 }
3420 private:
GetArenaNoVirtual()3421 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3422 return nullptr;
3423 }
MaybeArenaPtr()3424 inline void* MaybeArenaPtr() const {
3425 return nullptr;
3426 }
3427 public:
3428
3429 std::string GetTypeName() const final;
3430
3431 // nested types ----------------------------------------------------
3432
3433 // accessors -------------------------------------------------------
3434
3435 enum : int {
3436 kHashFieldNumber = 1,
3437 kUrlFieldNumber = 2,
3438 };
3439 // optional bytes hash = 1;
3440 bool has_hash() const;
3441 private:
3442 bool _internal_has_hash() const;
3443 public:
3444 void clear_hash();
3445 const std::string& hash() const;
3446 void set_hash(const std::string& value);
3447 void set_hash(std::string&& value);
3448 void set_hash(const char* value);
3449 void set_hash(const void* value, size_t size);
3450 std::string* mutable_hash();
3451 std::string* release_hash();
3452 void set_allocated_hash(std::string* hash);
3453 private:
3454 const std::string& _internal_hash() const;
3455 void _internal_set_hash(const std::string& value);
3456 std::string* _internal_mutable_hash();
3457 public:
3458
3459 // optional string url = 2;
3460 bool has_url() const;
3461 private:
3462 bool _internal_has_url() const;
3463 public:
3464 void clear_url();
3465 const std::string& url() const;
3466 void set_url(const std::string& value);
3467 void set_url(std::string&& value);
3468 void set_url(const char* value);
3469 void set_url(const char* value, size_t size);
3470 std::string* mutable_url();
3471 std::string* release_url();
3472 void set_allocated_url(std::string* url);
3473 private:
3474 const std::string& _internal_url() const;
3475 void _internal_set_url(const std::string& value);
3476 std::string* _internal_mutable_url();
3477 public:
3478
3479 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntry)
3480 private:
3481 class _Internal;
3482
3483 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3484 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3485 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3486 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
3487 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
3488 friend struct ::TableStruct_safebrowsing_2eproto;
3489 };
3490 // -------------------------------------------------------------------
3491
3492 class ThreatEntrySet :
3493 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntrySet) */ {
3494 public:
3495 ThreatEntrySet();
3496 virtual ~ThreatEntrySet();
3497
3498 ThreatEntrySet(const ThreatEntrySet& from);
ThreatEntrySet(ThreatEntrySet && from)3499 ThreatEntrySet(ThreatEntrySet&& from) noexcept
3500 : ThreatEntrySet() {
3501 *this = ::std::move(from);
3502 }
3503
3504 inline ThreatEntrySet& operator=(const ThreatEntrySet& from) {
3505 CopyFrom(from);
3506 return *this;
3507 }
3508 inline ThreatEntrySet& operator=(ThreatEntrySet&& from) noexcept {
3509 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3510 if (this != &from) InternalSwap(&from);
3511 } else {
3512 CopyFrom(from);
3513 }
3514 return *this;
3515 }
3516
unknown_fields()3517 inline const std::string& unknown_fields() const {
3518 return _internal_metadata_.unknown_fields();
3519 }
mutable_unknown_fields()3520 inline std::string* mutable_unknown_fields() {
3521 return _internal_metadata_.mutable_unknown_fields();
3522 }
3523
3524 static const ThreatEntrySet& default_instance();
3525
3526 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()3527 static inline const ThreatEntrySet* internal_default_instance() {
3528 return reinterpret_cast<const ThreatEntrySet*>(
3529 &_ThreatEntrySet_default_instance_);
3530 }
3531 static constexpr int kIndexInFileMessages =
3532 18;
3533
swap(ThreatEntrySet & a,ThreatEntrySet & b)3534 friend void swap(ThreatEntrySet& a, ThreatEntrySet& b) {
3535 a.Swap(&b);
3536 }
Swap(ThreatEntrySet * other)3537 inline void Swap(ThreatEntrySet* other) {
3538 if (other == this) return;
3539 InternalSwap(other);
3540 }
3541
3542 // implements Message ----------------------------------------------
3543
New()3544 inline ThreatEntrySet* New() const final {
3545 return CreateMaybeMessage<ThreatEntrySet>(nullptr);
3546 }
3547
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)3548 ThreatEntrySet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3549 return CreateMaybeMessage<ThreatEntrySet>(arena);
3550 }
3551 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
3552 final;
3553 void CopyFrom(const ThreatEntrySet& from);
3554 void MergeFrom(const ThreatEntrySet& from);
3555 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3556 bool IsInitialized() const final;
3557
3558 size_t ByteSizeLong() const final;
3559 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3560 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3561 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3562 void DiscardUnknownFields();
GetCachedSize()3563 int GetCachedSize() const final { return _cached_size_.Get(); }
3564
3565 private:
3566 inline void SharedCtor();
3567 inline void SharedDtor();
3568 void SetCachedSize(int size) const;
3569 void InternalSwap(ThreatEntrySet* other);
3570 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()3571 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3572 return "mozilla.safebrowsing.ThreatEntrySet";
3573 }
3574 private:
GetArenaNoVirtual()3575 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3576 return nullptr;
3577 }
MaybeArenaPtr()3578 inline void* MaybeArenaPtr() const {
3579 return nullptr;
3580 }
3581 public:
3582
3583 std::string GetTypeName() const final;
3584
3585 // nested types ----------------------------------------------------
3586
3587 // accessors -------------------------------------------------------
3588
3589 enum : int {
3590 kRawHashesFieldNumber = 2,
3591 kRawIndicesFieldNumber = 3,
3592 kRiceHashesFieldNumber = 4,
3593 kRiceIndicesFieldNumber = 5,
3594 kCompressionTypeFieldNumber = 1,
3595 };
3596 // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
3597 bool has_raw_hashes() const;
3598 private:
3599 bool _internal_has_raw_hashes() const;
3600 public:
3601 void clear_raw_hashes();
3602 const ::mozilla::safebrowsing::RawHashes& raw_hashes() const;
3603 ::mozilla::safebrowsing::RawHashes* release_raw_hashes();
3604 ::mozilla::safebrowsing::RawHashes* mutable_raw_hashes();
3605 void set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes);
3606 private:
3607 const ::mozilla::safebrowsing::RawHashes& _internal_raw_hashes() const;
3608 ::mozilla::safebrowsing::RawHashes* _internal_mutable_raw_hashes();
3609 public:
3610
3611 // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
3612 bool has_raw_indices() const;
3613 private:
3614 bool _internal_has_raw_indices() const;
3615 public:
3616 void clear_raw_indices();
3617 const ::mozilla::safebrowsing::RawIndices& raw_indices() const;
3618 ::mozilla::safebrowsing::RawIndices* release_raw_indices();
3619 ::mozilla::safebrowsing::RawIndices* mutable_raw_indices();
3620 void set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices);
3621 private:
3622 const ::mozilla::safebrowsing::RawIndices& _internal_raw_indices() const;
3623 ::mozilla::safebrowsing::RawIndices* _internal_mutable_raw_indices();
3624 public:
3625
3626 // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
3627 bool has_rice_hashes() const;
3628 private:
3629 bool _internal_has_rice_hashes() const;
3630 public:
3631 void clear_rice_hashes();
3632 const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_hashes() const;
3633 ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_hashes();
3634 ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_hashes();
3635 void set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes);
3636 private:
3637 const ::mozilla::safebrowsing::RiceDeltaEncoding& _internal_rice_hashes() const;
3638 ::mozilla::safebrowsing::RiceDeltaEncoding* _internal_mutable_rice_hashes();
3639 public:
3640
3641 // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
3642 bool has_rice_indices() const;
3643 private:
3644 bool _internal_has_rice_indices() const;
3645 public:
3646 void clear_rice_indices();
3647 const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_indices() const;
3648 ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_indices();
3649 ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_indices();
3650 void set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices);
3651 private:
3652 const ::mozilla::safebrowsing::RiceDeltaEncoding& _internal_rice_indices() const;
3653 ::mozilla::safebrowsing::RiceDeltaEncoding* _internal_mutable_rice_indices();
3654 public:
3655
3656 // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
3657 bool has_compression_type() const;
3658 private:
3659 bool _internal_has_compression_type() const;
3660 public:
3661 void clear_compression_type();
3662 ::mozilla::safebrowsing::CompressionType compression_type() const;
3663 void set_compression_type(::mozilla::safebrowsing::CompressionType value);
3664 private:
3665 ::mozilla::safebrowsing::CompressionType _internal_compression_type() const;
3666 void _internal_set_compression_type(::mozilla::safebrowsing::CompressionType value);
3667 public:
3668
3669 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntrySet)
3670 private:
3671 class _Internal;
3672
3673 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3674 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3675 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3676 ::mozilla::safebrowsing::RawHashes* raw_hashes_;
3677 ::mozilla::safebrowsing::RawIndices* raw_indices_;
3678 ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes_;
3679 ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices_;
3680 int compression_type_;
3681 friend struct ::TableStruct_safebrowsing_2eproto;
3682 };
3683 // -------------------------------------------------------------------
3684
3685 class RawIndices :
3686 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RawIndices) */ {
3687 public:
3688 RawIndices();
3689 virtual ~RawIndices();
3690
3691 RawIndices(const RawIndices& from);
RawIndices(RawIndices && from)3692 RawIndices(RawIndices&& from) noexcept
3693 : RawIndices() {
3694 *this = ::std::move(from);
3695 }
3696
3697 inline RawIndices& operator=(const RawIndices& from) {
3698 CopyFrom(from);
3699 return *this;
3700 }
3701 inline RawIndices& operator=(RawIndices&& from) noexcept {
3702 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3703 if (this != &from) InternalSwap(&from);
3704 } else {
3705 CopyFrom(from);
3706 }
3707 return *this;
3708 }
3709
unknown_fields()3710 inline const std::string& unknown_fields() const {
3711 return _internal_metadata_.unknown_fields();
3712 }
mutable_unknown_fields()3713 inline std::string* mutable_unknown_fields() {
3714 return _internal_metadata_.mutable_unknown_fields();
3715 }
3716
3717 static const RawIndices& default_instance();
3718
3719 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()3720 static inline const RawIndices* internal_default_instance() {
3721 return reinterpret_cast<const RawIndices*>(
3722 &_RawIndices_default_instance_);
3723 }
3724 static constexpr int kIndexInFileMessages =
3725 19;
3726
swap(RawIndices & a,RawIndices & b)3727 friend void swap(RawIndices& a, RawIndices& b) {
3728 a.Swap(&b);
3729 }
Swap(RawIndices * other)3730 inline void Swap(RawIndices* other) {
3731 if (other == this) return;
3732 InternalSwap(other);
3733 }
3734
3735 // implements Message ----------------------------------------------
3736
New()3737 inline RawIndices* New() const final {
3738 return CreateMaybeMessage<RawIndices>(nullptr);
3739 }
3740
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)3741 RawIndices* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3742 return CreateMaybeMessage<RawIndices>(arena);
3743 }
3744 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
3745 final;
3746 void CopyFrom(const RawIndices& from);
3747 void MergeFrom(const RawIndices& from);
3748 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3749 bool IsInitialized() const final;
3750
3751 size_t ByteSizeLong() const final;
3752 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3753 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3754 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3755 void DiscardUnknownFields();
GetCachedSize()3756 int GetCachedSize() const final { return _cached_size_.Get(); }
3757
3758 private:
3759 inline void SharedCtor();
3760 inline void SharedDtor();
3761 void SetCachedSize(int size) const;
3762 void InternalSwap(RawIndices* other);
3763 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()3764 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3765 return "mozilla.safebrowsing.RawIndices";
3766 }
3767 private:
GetArenaNoVirtual()3768 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3769 return nullptr;
3770 }
MaybeArenaPtr()3771 inline void* MaybeArenaPtr() const {
3772 return nullptr;
3773 }
3774 public:
3775
3776 std::string GetTypeName() const final;
3777
3778 // nested types ----------------------------------------------------
3779
3780 // accessors -------------------------------------------------------
3781
3782 enum : int {
3783 kIndicesFieldNumber = 1,
3784 };
3785 // repeated int32 indices = 1;
3786 int indices_size() const;
3787 private:
3788 int _internal_indices_size() const;
3789 public:
3790 void clear_indices();
3791 private:
3792 ::PROTOBUF_NAMESPACE_ID::int32 _internal_indices(int index) const;
3793 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
3794 _internal_indices() const;
3795 void _internal_add_indices(::PROTOBUF_NAMESPACE_ID::int32 value);
3796 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
3797 _internal_mutable_indices();
3798 public:
3799 ::PROTOBUF_NAMESPACE_ID::int32 indices(int index) const;
3800 void set_indices(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
3801 void add_indices(::PROTOBUF_NAMESPACE_ID::int32 value);
3802 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
3803 indices() const;
3804 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
3805 mutable_indices();
3806
3807 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawIndices)
3808 private:
3809 class _Internal;
3810
3811 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3812 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3813 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3814 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > indices_;
3815 friend struct ::TableStruct_safebrowsing_2eproto;
3816 };
3817 // -------------------------------------------------------------------
3818
3819 class RawHashes :
3820 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RawHashes) */ {
3821 public:
3822 RawHashes();
3823 virtual ~RawHashes();
3824
3825 RawHashes(const RawHashes& from);
RawHashes(RawHashes && from)3826 RawHashes(RawHashes&& from) noexcept
3827 : RawHashes() {
3828 *this = ::std::move(from);
3829 }
3830
3831 inline RawHashes& operator=(const RawHashes& from) {
3832 CopyFrom(from);
3833 return *this;
3834 }
3835 inline RawHashes& operator=(RawHashes&& from) noexcept {
3836 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3837 if (this != &from) InternalSwap(&from);
3838 } else {
3839 CopyFrom(from);
3840 }
3841 return *this;
3842 }
3843
unknown_fields()3844 inline const std::string& unknown_fields() const {
3845 return _internal_metadata_.unknown_fields();
3846 }
mutable_unknown_fields()3847 inline std::string* mutable_unknown_fields() {
3848 return _internal_metadata_.mutable_unknown_fields();
3849 }
3850
3851 static const RawHashes& default_instance();
3852
3853 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()3854 static inline const RawHashes* internal_default_instance() {
3855 return reinterpret_cast<const RawHashes*>(
3856 &_RawHashes_default_instance_);
3857 }
3858 static constexpr int kIndexInFileMessages =
3859 20;
3860
swap(RawHashes & a,RawHashes & b)3861 friend void swap(RawHashes& a, RawHashes& b) {
3862 a.Swap(&b);
3863 }
Swap(RawHashes * other)3864 inline void Swap(RawHashes* other) {
3865 if (other == this) return;
3866 InternalSwap(other);
3867 }
3868
3869 // implements Message ----------------------------------------------
3870
New()3871 inline RawHashes* New() const final {
3872 return CreateMaybeMessage<RawHashes>(nullptr);
3873 }
3874
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)3875 RawHashes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3876 return CreateMaybeMessage<RawHashes>(arena);
3877 }
3878 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
3879 final;
3880 void CopyFrom(const RawHashes& from);
3881 void MergeFrom(const RawHashes& from);
3882 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3883 bool IsInitialized() const final;
3884
3885 size_t ByteSizeLong() const final;
3886 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3887 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3888 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3889 void DiscardUnknownFields();
GetCachedSize()3890 int GetCachedSize() const final { return _cached_size_.Get(); }
3891
3892 private:
3893 inline void SharedCtor();
3894 inline void SharedDtor();
3895 void SetCachedSize(int size) const;
3896 void InternalSwap(RawHashes* other);
3897 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()3898 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3899 return "mozilla.safebrowsing.RawHashes";
3900 }
3901 private:
GetArenaNoVirtual()3902 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3903 return nullptr;
3904 }
MaybeArenaPtr()3905 inline void* MaybeArenaPtr() const {
3906 return nullptr;
3907 }
3908 public:
3909
3910 std::string GetTypeName() const final;
3911
3912 // nested types ----------------------------------------------------
3913
3914 // accessors -------------------------------------------------------
3915
3916 enum : int {
3917 kRawHashesFieldNumber = 2,
3918 kPrefixSizeFieldNumber = 1,
3919 };
3920 // optional bytes raw_hashes = 2;
3921 bool has_raw_hashes() const;
3922 private:
3923 bool _internal_has_raw_hashes() const;
3924 public:
3925 void clear_raw_hashes();
3926 const std::string& raw_hashes() const;
3927 void set_raw_hashes(const std::string& value);
3928 void set_raw_hashes(std::string&& value);
3929 void set_raw_hashes(const char* value);
3930 void set_raw_hashes(const void* value, size_t size);
3931 std::string* mutable_raw_hashes();
3932 std::string* release_raw_hashes();
3933 void set_allocated_raw_hashes(std::string* raw_hashes);
3934 private:
3935 const std::string& _internal_raw_hashes() const;
3936 void _internal_set_raw_hashes(const std::string& value);
3937 std::string* _internal_mutable_raw_hashes();
3938 public:
3939
3940 // optional int32 prefix_size = 1;
3941 bool has_prefix_size() const;
3942 private:
3943 bool _internal_has_prefix_size() const;
3944 public:
3945 void clear_prefix_size();
3946 ::PROTOBUF_NAMESPACE_ID::int32 prefix_size() const;
3947 void set_prefix_size(::PROTOBUF_NAMESPACE_ID::int32 value);
3948 private:
3949 ::PROTOBUF_NAMESPACE_ID::int32 _internal_prefix_size() const;
3950 void _internal_set_prefix_size(::PROTOBUF_NAMESPACE_ID::int32 value);
3951 public:
3952
3953 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawHashes)
3954 private:
3955 class _Internal;
3956
3957 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
3958 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3959 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3960 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_hashes_;
3961 ::PROTOBUF_NAMESPACE_ID::int32 prefix_size_;
3962 friend struct ::TableStruct_safebrowsing_2eproto;
3963 };
3964 // -------------------------------------------------------------------
3965
3966 class RiceDeltaEncoding :
3967 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RiceDeltaEncoding) */ {
3968 public:
3969 RiceDeltaEncoding();
3970 virtual ~RiceDeltaEncoding();
3971
3972 RiceDeltaEncoding(const RiceDeltaEncoding& from);
RiceDeltaEncoding(RiceDeltaEncoding && from)3973 RiceDeltaEncoding(RiceDeltaEncoding&& from) noexcept
3974 : RiceDeltaEncoding() {
3975 *this = ::std::move(from);
3976 }
3977
3978 inline RiceDeltaEncoding& operator=(const RiceDeltaEncoding& from) {
3979 CopyFrom(from);
3980 return *this;
3981 }
3982 inline RiceDeltaEncoding& operator=(RiceDeltaEncoding&& from) noexcept {
3983 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3984 if (this != &from) InternalSwap(&from);
3985 } else {
3986 CopyFrom(from);
3987 }
3988 return *this;
3989 }
3990
unknown_fields()3991 inline const std::string& unknown_fields() const {
3992 return _internal_metadata_.unknown_fields();
3993 }
mutable_unknown_fields()3994 inline std::string* mutable_unknown_fields() {
3995 return _internal_metadata_.mutable_unknown_fields();
3996 }
3997
3998 static const RiceDeltaEncoding& default_instance();
3999
4000 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()4001 static inline const RiceDeltaEncoding* internal_default_instance() {
4002 return reinterpret_cast<const RiceDeltaEncoding*>(
4003 &_RiceDeltaEncoding_default_instance_);
4004 }
4005 static constexpr int kIndexInFileMessages =
4006 21;
4007
swap(RiceDeltaEncoding & a,RiceDeltaEncoding & b)4008 friend void swap(RiceDeltaEncoding& a, RiceDeltaEncoding& b) {
4009 a.Swap(&b);
4010 }
Swap(RiceDeltaEncoding * other)4011 inline void Swap(RiceDeltaEncoding* other) {
4012 if (other == this) return;
4013 InternalSwap(other);
4014 }
4015
4016 // implements Message ----------------------------------------------
4017
New()4018 inline RiceDeltaEncoding* New() const final {
4019 return CreateMaybeMessage<RiceDeltaEncoding>(nullptr);
4020 }
4021
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)4022 RiceDeltaEncoding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4023 return CreateMaybeMessage<RiceDeltaEncoding>(arena);
4024 }
4025 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
4026 final;
4027 void CopyFrom(const RiceDeltaEncoding& from);
4028 void MergeFrom(const RiceDeltaEncoding& from);
4029 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4030 bool IsInitialized() const final;
4031
4032 size_t ByteSizeLong() const final;
4033 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4034 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4035 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4036 void DiscardUnknownFields();
GetCachedSize()4037 int GetCachedSize() const final { return _cached_size_.Get(); }
4038
4039 private:
4040 inline void SharedCtor();
4041 inline void SharedDtor();
4042 void SetCachedSize(int size) const;
4043 void InternalSwap(RiceDeltaEncoding* other);
4044 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()4045 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4046 return "mozilla.safebrowsing.RiceDeltaEncoding";
4047 }
4048 private:
GetArenaNoVirtual()4049 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4050 return nullptr;
4051 }
MaybeArenaPtr()4052 inline void* MaybeArenaPtr() const {
4053 return nullptr;
4054 }
4055 public:
4056
4057 std::string GetTypeName() const final;
4058
4059 // nested types ----------------------------------------------------
4060
4061 // accessors -------------------------------------------------------
4062
4063 enum : int {
4064 kEncodedDataFieldNumber = 4,
4065 kFirstValueFieldNumber = 1,
4066 kRiceParameterFieldNumber = 2,
4067 kNumEntriesFieldNumber = 3,
4068 };
4069 // optional bytes encoded_data = 4;
4070 bool has_encoded_data() const;
4071 private:
4072 bool _internal_has_encoded_data() const;
4073 public:
4074 void clear_encoded_data();
4075 const std::string& encoded_data() const;
4076 void set_encoded_data(const std::string& value);
4077 void set_encoded_data(std::string&& value);
4078 void set_encoded_data(const char* value);
4079 void set_encoded_data(const void* value, size_t size);
4080 std::string* mutable_encoded_data();
4081 std::string* release_encoded_data();
4082 void set_allocated_encoded_data(std::string* encoded_data);
4083 private:
4084 const std::string& _internal_encoded_data() const;
4085 void _internal_set_encoded_data(const std::string& value);
4086 std::string* _internal_mutable_encoded_data();
4087 public:
4088
4089 // optional int64 first_value = 1;
4090 bool has_first_value() const;
4091 private:
4092 bool _internal_has_first_value() const;
4093 public:
4094 void clear_first_value();
4095 ::PROTOBUF_NAMESPACE_ID::int64 first_value() const;
4096 void set_first_value(::PROTOBUF_NAMESPACE_ID::int64 value);
4097 private:
4098 ::PROTOBUF_NAMESPACE_ID::int64 _internal_first_value() const;
4099 void _internal_set_first_value(::PROTOBUF_NAMESPACE_ID::int64 value);
4100 public:
4101
4102 // optional int32 rice_parameter = 2;
4103 bool has_rice_parameter() const;
4104 private:
4105 bool _internal_has_rice_parameter() const;
4106 public:
4107 void clear_rice_parameter();
4108 ::PROTOBUF_NAMESPACE_ID::int32 rice_parameter() const;
4109 void set_rice_parameter(::PROTOBUF_NAMESPACE_ID::int32 value);
4110 private:
4111 ::PROTOBUF_NAMESPACE_ID::int32 _internal_rice_parameter() const;
4112 void _internal_set_rice_parameter(::PROTOBUF_NAMESPACE_ID::int32 value);
4113 public:
4114
4115 // optional int32 num_entries = 3;
4116 bool has_num_entries() const;
4117 private:
4118 bool _internal_has_num_entries() const;
4119 public:
4120 void clear_num_entries();
4121 ::PROTOBUF_NAMESPACE_ID::int32 num_entries() const;
4122 void set_num_entries(::PROTOBUF_NAMESPACE_ID::int32 value);
4123 private:
4124 ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_entries() const;
4125 void _internal_set_num_entries(::PROTOBUF_NAMESPACE_ID::int32 value);
4126 public:
4127
4128 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RiceDeltaEncoding)
4129 private:
4130 class _Internal;
4131
4132 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
4133 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4134 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4135 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
4136 ::PROTOBUF_NAMESPACE_ID::int64 first_value_;
4137 ::PROTOBUF_NAMESPACE_ID::int32 rice_parameter_;
4138 ::PROTOBUF_NAMESPACE_ID::int32 num_entries_;
4139 friend struct ::TableStruct_safebrowsing_2eproto;
4140 };
4141 // -------------------------------------------------------------------
4142
4143 class ThreatEntryMetadata_MetadataEntry :
4144 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) */ {
4145 public:
4146 ThreatEntryMetadata_MetadataEntry();
4147 virtual ~ThreatEntryMetadata_MetadataEntry();
4148
4149 ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from);
ThreatEntryMetadata_MetadataEntry(ThreatEntryMetadata_MetadataEntry && from)4150 ThreatEntryMetadata_MetadataEntry(ThreatEntryMetadata_MetadataEntry&& from) noexcept
4151 : ThreatEntryMetadata_MetadataEntry() {
4152 *this = ::std::move(from);
4153 }
4154
4155 inline ThreatEntryMetadata_MetadataEntry& operator=(const ThreatEntryMetadata_MetadataEntry& from) {
4156 CopyFrom(from);
4157 return *this;
4158 }
4159 inline ThreatEntryMetadata_MetadataEntry& operator=(ThreatEntryMetadata_MetadataEntry&& from) noexcept {
4160 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4161 if (this != &from) InternalSwap(&from);
4162 } else {
4163 CopyFrom(from);
4164 }
4165 return *this;
4166 }
4167
unknown_fields()4168 inline const std::string& unknown_fields() const {
4169 return _internal_metadata_.unknown_fields();
4170 }
mutable_unknown_fields()4171 inline std::string* mutable_unknown_fields() {
4172 return _internal_metadata_.mutable_unknown_fields();
4173 }
4174
4175 static const ThreatEntryMetadata_MetadataEntry& default_instance();
4176
4177 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()4178 static inline const ThreatEntryMetadata_MetadataEntry* internal_default_instance() {
4179 return reinterpret_cast<const ThreatEntryMetadata_MetadataEntry*>(
4180 &_ThreatEntryMetadata_MetadataEntry_default_instance_);
4181 }
4182 static constexpr int kIndexInFileMessages =
4183 22;
4184
swap(ThreatEntryMetadata_MetadataEntry & a,ThreatEntryMetadata_MetadataEntry & b)4185 friend void swap(ThreatEntryMetadata_MetadataEntry& a, ThreatEntryMetadata_MetadataEntry& b) {
4186 a.Swap(&b);
4187 }
Swap(ThreatEntryMetadata_MetadataEntry * other)4188 inline void Swap(ThreatEntryMetadata_MetadataEntry* other) {
4189 if (other == this) return;
4190 InternalSwap(other);
4191 }
4192
4193 // implements Message ----------------------------------------------
4194
New()4195 inline ThreatEntryMetadata_MetadataEntry* New() const final {
4196 return CreateMaybeMessage<ThreatEntryMetadata_MetadataEntry>(nullptr);
4197 }
4198
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)4199 ThreatEntryMetadata_MetadataEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4200 return CreateMaybeMessage<ThreatEntryMetadata_MetadataEntry>(arena);
4201 }
4202 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
4203 final;
4204 void CopyFrom(const ThreatEntryMetadata_MetadataEntry& from);
4205 void MergeFrom(const ThreatEntryMetadata_MetadataEntry& from);
4206 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4207 bool IsInitialized() const final;
4208
4209 size_t ByteSizeLong() const final;
4210 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4211 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4212 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4213 void DiscardUnknownFields();
GetCachedSize()4214 int GetCachedSize() const final { return _cached_size_.Get(); }
4215
4216 private:
4217 inline void SharedCtor();
4218 inline void SharedDtor();
4219 void SetCachedSize(int size) const;
4220 void InternalSwap(ThreatEntryMetadata_MetadataEntry* other);
4221 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()4222 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4223 return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry";
4224 }
4225 private:
GetArenaNoVirtual()4226 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4227 return nullptr;
4228 }
MaybeArenaPtr()4229 inline void* MaybeArenaPtr() const {
4230 return nullptr;
4231 }
4232 public:
4233
4234 std::string GetTypeName() const final;
4235
4236 // nested types ----------------------------------------------------
4237
4238 // accessors -------------------------------------------------------
4239
4240 enum : int {
4241 kKeyFieldNumber = 1,
4242 kValueFieldNumber = 2,
4243 };
4244 // optional bytes key = 1;
4245 bool has_key() const;
4246 private:
4247 bool _internal_has_key() const;
4248 public:
4249 void clear_key();
4250 const std::string& key() const;
4251 void set_key(const std::string& value);
4252 void set_key(std::string&& value);
4253 void set_key(const char* value);
4254 void set_key(const void* value, size_t size);
4255 std::string* mutable_key();
4256 std::string* release_key();
4257 void set_allocated_key(std::string* key);
4258 private:
4259 const std::string& _internal_key() const;
4260 void _internal_set_key(const std::string& value);
4261 std::string* _internal_mutable_key();
4262 public:
4263
4264 // optional bytes value = 2;
4265 bool has_value() const;
4266 private:
4267 bool _internal_has_value() const;
4268 public:
4269 void clear_value();
4270 const std::string& value() const;
4271 void set_value(const std::string& value);
4272 void set_value(std::string&& value);
4273 void set_value(const char* value);
4274 void set_value(const void* value, size_t size);
4275 std::string* mutable_value();
4276 std::string* release_value();
4277 void set_allocated_value(std::string* value);
4278 private:
4279 const std::string& _internal_value() const;
4280 void _internal_set_value(const std::string& value);
4281 std::string* _internal_mutable_value();
4282 public:
4283
4284 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
4285 private:
4286 class _Internal;
4287
4288 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
4289 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4290 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4291 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
4292 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
4293 friend struct ::TableStruct_safebrowsing_2eproto;
4294 };
4295 // -------------------------------------------------------------------
4296
4297 class ThreatEntryMetadata :
4298 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntryMetadata) */ {
4299 public:
4300 ThreatEntryMetadata();
4301 virtual ~ThreatEntryMetadata();
4302
4303 ThreatEntryMetadata(const ThreatEntryMetadata& from);
ThreatEntryMetadata(ThreatEntryMetadata && from)4304 ThreatEntryMetadata(ThreatEntryMetadata&& from) noexcept
4305 : ThreatEntryMetadata() {
4306 *this = ::std::move(from);
4307 }
4308
4309 inline ThreatEntryMetadata& operator=(const ThreatEntryMetadata& from) {
4310 CopyFrom(from);
4311 return *this;
4312 }
4313 inline ThreatEntryMetadata& operator=(ThreatEntryMetadata&& from) noexcept {
4314 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4315 if (this != &from) InternalSwap(&from);
4316 } else {
4317 CopyFrom(from);
4318 }
4319 return *this;
4320 }
4321
unknown_fields()4322 inline const std::string& unknown_fields() const {
4323 return _internal_metadata_.unknown_fields();
4324 }
mutable_unknown_fields()4325 inline std::string* mutable_unknown_fields() {
4326 return _internal_metadata_.mutable_unknown_fields();
4327 }
4328
4329 static const ThreatEntryMetadata& default_instance();
4330
4331 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()4332 static inline const ThreatEntryMetadata* internal_default_instance() {
4333 return reinterpret_cast<const ThreatEntryMetadata*>(
4334 &_ThreatEntryMetadata_default_instance_);
4335 }
4336 static constexpr int kIndexInFileMessages =
4337 23;
4338
swap(ThreatEntryMetadata & a,ThreatEntryMetadata & b)4339 friend void swap(ThreatEntryMetadata& a, ThreatEntryMetadata& b) {
4340 a.Swap(&b);
4341 }
Swap(ThreatEntryMetadata * other)4342 inline void Swap(ThreatEntryMetadata* other) {
4343 if (other == this) return;
4344 InternalSwap(other);
4345 }
4346
4347 // implements Message ----------------------------------------------
4348
New()4349 inline ThreatEntryMetadata* New() const final {
4350 return CreateMaybeMessage<ThreatEntryMetadata>(nullptr);
4351 }
4352
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)4353 ThreatEntryMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4354 return CreateMaybeMessage<ThreatEntryMetadata>(arena);
4355 }
4356 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
4357 final;
4358 void CopyFrom(const ThreatEntryMetadata& from);
4359 void MergeFrom(const ThreatEntryMetadata& from);
4360 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4361 bool IsInitialized() const final;
4362
4363 size_t ByteSizeLong() const final;
4364 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4365 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4366 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4367 void DiscardUnknownFields();
GetCachedSize()4368 int GetCachedSize() const final { return _cached_size_.Get(); }
4369
4370 private:
4371 inline void SharedCtor();
4372 inline void SharedDtor();
4373 void SetCachedSize(int size) const;
4374 void InternalSwap(ThreatEntryMetadata* other);
4375 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()4376 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4377 return "mozilla.safebrowsing.ThreatEntryMetadata";
4378 }
4379 private:
GetArenaNoVirtual()4380 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4381 return nullptr;
4382 }
MaybeArenaPtr()4383 inline void* MaybeArenaPtr() const {
4384 return nullptr;
4385 }
4386 public:
4387
4388 std::string GetTypeName() const final;
4389
4390 // nested types ----------------------------------------------------
4391
4392 typedef ThreatEntryMetadata_MetadataEntry MetadataEntry;
4393
4394 // accessors -------------------------------------------------------
4395
4396 enum : int {
4397 kEntriesFieldNumber = 1,
4398 };
4399 // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
4400 int entries_size() const;
4401 private:
4402 int _internal_entries_size() const;
4403 public:
4404 void clear_entries();
4405 ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* mutable_entries(int index);
4406 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >*
4407 mutable_entries();
4408 private:
4409 const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& _internal_entries(int index) const;
4410 ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* _internal_add_entries();
4411 public:
4412 const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& entries(int index) const;
4413 ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* add_entries();
4414 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >&
4415 entries() const;
4416
4417 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata)
4418 private:
4419 class _Internal;
4420
4421 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
4422 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4423 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4424 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry > entries_;
4425 friend struct ::TableStruct_safebrowsing_2eproto;
4426 };
4427 // -------------------------------------------------------------------
4428
4429 class ThreatListDescriptor :
4430 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatListDescriptor) */ {
4431 public:
4432 ThreatListDescriptor();
4433 virtual ~ThreatListDescriptor();
4434
4435 ThreatListDescriptor(const ThreatListDescriptor& from);
ThreatListDescriptor(ThreatListDescriptor && from)4436 ThreatListDescriptor(ThreatListDescriptor&& from) noexcept
4437 : ThreatListDescriptor() {
4438 *this = ::std::move(from);
4439 }
4440
4441 inline ThreatListDescriptor& operator=(const ThreatListDescriptor& from) {
4442 CopyFrom(from);
4443 return *this;
4444 }
4445 inline ThreatListDescriptor& operator=(ThreatListDescriptor&& from) noexcept {
4446 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4447 if (this != &from) InternalSwap(&from);
4448 } else {
4449 CopyFrom(from);
4450 }
4451 return *this;
4452 }
4453
unknown_fields()4454 inline const std::string& unknown_fields() const {
4455 return _internal_metadata_.unknown_fields();
4456 }
mutable_unknown_fields()4457 inline std::string* mutable_unknown_fields() {
4458 return _internal_metadata_.mutable_unknown_fields();
4459 }
4460
4461 static const ThreatListDescriptor& default_instance();
4462
4463 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()4464 static inline const ThreatListDescriptor* internal_default_instance() {
4465 return reinterpret_cast<const ThreatListDescriptor*>(
4466 &_ThreatListDescriptor_default_instance_);
4467 }
4468 static constexpr int kIndexInFileMessages =
4469 24;
4470
swap(ThreatListDescriptor & a,ThreatListDescriptor & b)4471 friend void swap(ThreatListDescriptor& a, ThreatListDescriptor& b) {
4472 a.Swap(&b);
4473 }
Swap(ThreatListDescriptor * other)4474 inline void Swap(ThreatListDescriptor* other) {
4475 if (other == this) return;
4476 InternalSwap(other);
4477 }
4478
4479 // implements Message ----------------------------------------------
4480
New()4481 inline ThreatListDescriptor* New() const final {
4482 return CreateMaybeMessage<ThreatListDescriptor>(nullptr);
4483 }
4484
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)4485 ThreatListDescriptor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4486 return CreateMaybeMessage<ThreatListDescriptor>(arena);
4487 }
4488 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
4489 final;
4490 void CopyFrom(const ThreatListDescriptor& from);
4491 void MergeFrom(const ThreatListDescriptor& from);
4492 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4493 bool IsInitialized() const final;
4494
4495 size_t ByteSizeLong() const final;
4496 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4497 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4498 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4499 void DiscardUnknownFields();
GetCachedSize()4500 int GetCachedSize() const final { return _cached_size_.Get(); }
4501
4502 private:
4503 inline void SharedCtor();
4504 inline void SharedDtor();
4505 void SetCachedSize(int size) const;
4506 void InternalSwap(ThreatListDescriptor* other);
4507 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()4508 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4509 return "mozilla.safebrowsing.ThreatListDescriptor";
4510 }
4511 private:
GetArenaNoVirtual()4512 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4513 return nullptr;
4514 }
MaybeArenaPtr()4515 inline void* MaybeArenaPtr() const {
4516 return nullptr;
4517 }
4518 public:
4519
4520 std::string GetTypeName() const final;
4521
4522 // nested types ----------------------------------------------------
4523
4524 // accessors -------------------------------------------------------
4525
4526 enum : int {
4527 kThreatTypeFieldNumber = 1,
4528 kPlatformTypeFieldNumber = 2,
4529 kThreatEntryTypeFieldNumber = 3,
4530 };
4531 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
4532 bool has_threat_type() const;
4533 private:
4534 bool _internal_has_threat_type() const;
4535 public:
4536 void clear_threat_type();
4537 ::mozilla::safebrowsing::ThreatType threat_type() const;
4538 void set_threat_type(::mozilla::safebrowsing::ThreatType value);
4539 private:
4540 ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
4541 void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
4542 public:
4543
4544 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
4545 bool has_platform_type() const;
4546 private:
4547 bool _internal_has_platform_type() const;
4548 public:
4549 void clear_platform_type();
4550 ::mozilla::safebrowsing::PlatformType platform_type() const;
4551 void set_platform_type(::mozilla::safebrowsing::PlatformType value);
4552 private:
4553 ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
4554 void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
4555 public:
4556
4557 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
4558 bool has_threat_entry_type() const;
4559 private:
4560 bool _internal_has_threat_entry_type() const;
4561 public:
4562 void clear_threat_entry_type();
4563 ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
4564 void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
4565 private:
4566 ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
4567 void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
4568 public:
4569
4570 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatListDescriptor)
4571 private:
4572 class _Internal;
4573
4574 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
4575 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4576 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4577 int threat_type_;
4578 int platform_type_;
4579 int threat_entry_type_;
4580 friend struct ::TableStruct_safebrowsing_2eproto;
4581 };
4582 // -------------------------------------------------------------------
4583
4584 class ListThreatListsResponse :
4585 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ListThreatListsResponse) */ {
4586 public:
4587 ListThreatListsResponse();
4588 virtual ~ListThreatListsResponse();
4589
4590 ListThreatListsResponse(const ListThreatListsResponse& from);
ListThreatListsResponse(ListThreatListsResponse && from)4591 ListThreatListsResponse(ListThreatListsResponse&& from) noexcept
4592 : ListThreatListsResponse() {
4593 *this = ::std::move(from);
4594 }
4595
4596 inline ListThreatListsResponse& operator=(const ListThreatListsResponse& from) {
4597 CopyFrom(from);
4598 return *this;
4599 }
4600 inline ListThreatListsResponse& operator=(ListThreatListsResponse&& from) noexcept {
4601 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4602 if (this != &from) InternalSwap(&from);
4603 } else {
4604 CopyFrom(from);
4605 }
4606 return *this;
4607 }
4608
unknown_fields()4609 inline const std::string& unknown_fields() const {
4610 return _internal_metadata_.unknown_fields();
4611 }
mutable_unknown_fields()4612 inline std::string* mutable_unknown_fields() {
4613 return _internal_metadata_.mutable_unknown_fields();
4614 }
4615
4616 static const ListThreatListsResponse& default_instance();
4617
4618 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()4619 static inline const ListThreatListsResponse* internal_default_instance() {
4620 return reinterpret_cast<const ListThreatListsResponse*>(
4621 &_ListThreatListsResponse_default_instance_);
4622 }
4623 static constexpr int kIndexInFileMessages =
4624 25;
4625
swap(ListThreatListsResponse & a,ListThreatListsResponse & b)4626 friend void swap(ListThreatListsResponse& a, ListThreatListsResponse& b) {
4627 a.Swap(&b);
4628 }
Swap(ListThreatListsResponse * other)4629 inline void Swap(ListThreatListsResponse* other) {
4630 if (other == this) return;
4631 InternalSwap(other);
4632 }
4633
4634 // implements Message ----------------------------------------------
4635
New()4636 inline ListThreatListsResponse* New() const final {
4637 return CreateMaybeMessage<ListThreatListsResponse>(nullptr);
4638 }
4639
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)4640 ListThreatListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4641 return CreateMaybeMessage<ListThreatListsResponse>(arena);
4642 }
4643 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
4644 final;
4645 void CopyFrom(const ListThreatListsResponse& from);
4646 void MergeFrom(const ListThreatListsResponse& from);
4647 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4648 bool IsInitialized() const final;
4649
4650 size_t ByteSizeLong() const final;
4651 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4652 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4653 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4654 void DiscardUnknownFields();
GetCachedSize()4655 int GetCachedSize() const final { return _cached_size_.Get(); }
4656
4657 private:
4658 inline void SharedCtor();
4659 inline void SharedDtor();
4660 void SetCachedSize(int size) const;
4661 void InternalSwap(ListThreatListsResponse* other);
4662 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()4663 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4664 return "mozilla.safebrowsing.ListThreatListsResponse";
4665 }
4666 private:
GetArenaNoVirtual()4667 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4668 return nullptr;
4669 }
MaybeArenaPtr()4670 inline void* MaybeArenaPtr() const {
4671 return nullptr;
4672 }
4673 public:
4674
4675 std::string GetTypeName() const final;
4676
4677 // nested types ----------------------------------------------------
4678
4679 // accessors -------------------------------------------------------
4680
4681 enum : int {
4682 kThreatListsFieldNumber = 1,
4683 };
4684 // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
4685 int threat_lists_size() const;
4686 private:
4687 int _internal_threat_lists_size() const;
4688 public:
4689 void clear_threat_lists();
4690 ::mozilla::safebrowsing::ThreatListDescriptor* mutable_threat_lists(int index);
4691 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >*
4692 mutable_threat_lists();
4693 private:
4694 const ::mozilla::safebrowsing::ThreatListDescriptor& _internal_threat_lists(int index) const;
4695 ::mozilla::safebrowsing::ThreatListDescriptor* _internal_add_threat_lists();
4696 public:
4697 const ::mozilla::safebrowsing::ThreatListDescriptor& threat_lists(int index) const;
4698 ::mozilla::safebrowsing::ThreatListDescriptor* add_threat_lists();
4699 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >&
4700 threat_lists() const;
4701
4702 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ListThreatListsResponse)
4703 private:
4704 class _Internal;
4705
4706 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
4707 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4708 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4709 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor > threat_lists_;
4710 friend struct ::TableStruct_safebrowsing_2eproto;
4711 };
4712 // -------------------------------------------------------------------
4713
4714 class Duration :
4715 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.Duration) */ {
4716 public:
4717 Duration();
4718 virtual ~Duration();
4719
4720 Duration(const Duration& from);
Duration(Duration && from)4721 Duration(Duration&& from) noexcept
4722 : Duration() {
4723 *this = ::std::move(from);
4724 }
4725
4726 inline Duration& operator=(const Duration& from) {
4727 CopyFrom(from);
4728 return *this;
4729 }
4730 inline Duration& operator=(Duration&& from) noexcept {
4731 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4732 if (this != &from) InternalSwap(&from);
4733 } else {
4734 CopyFrom(from);
4735 }
4736 return *this;
4737 }
4738
unknown_fields()4739 inline const std::string& unknown_fields() const {
4740 return _internal_metadata_.unknown_fields();
4741 }
mutable_unknown_fields()4742 inline std::string* mutable_unknown_fields() {
4743 return _internal_metadata_.mutable_unknown_fields();
4744 }
4745
4746 static const Duration& default_instance();
4747
4748 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
internal_default_instance()4749 static inline const Duration* internal_default_instance() {
4750 return reinterpret_cast<const Duration*>(
4751 &_Duration_default_instance_);
4752 }
4753 static constexpr int kIndexInFileMessages =
4754 26;
4755
swap(Duration & a,Duration & b)4756 friend void swap(Duration& a, Duration& b) {
4757 a.Swap(&b);
4758 }
Swap(Duration * other)4759 inline void Swap(Duration* other) {
4760 if (other == this) return;
4761 InternalSwap(other);
4762 }
4763
4764 // implements Message ----------------------------------------------
4765
New()4766 inline Duration* New() const final {
4767 return CreateMaybeMessage<Duration>(nullptr);
4768 }
4769
New(::PROTOBUF_NAMESPACE_ID::Arena * arena)4770 Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4771 return CreateMaybeMessage<Duration>(arena);
4772 }
4773 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
4774 final;
4775 void CopyFrom(const Duration& from);
4776 void MergeFrom(const Duration& from);
4777 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4778 bool IsInitialized() const final;
4779
4780 size_t ByteSizeLong() const final;
4781 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4782 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4783 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4784 void DiscardUnknownFields();
GetCachedSize()4785 int GetCachedSize() const final { return _cached_size_.Get(); }
4786
4787 private:
4788 inline void SharedCtor();
4789 inline void SharedDtor();
4790 void SetCachedSize(int size) const;
4791 void InternalSwap(Duration* other);
4792 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
FullMessageName()4793 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4794 return "mozilla.safebrowsing.Duration";
4795 }
4796 private:
GetArenaNoVirtual()4797 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4798 return nullptr;
4799 }
MaybeArenaPtr()4800 inline void* MaybeArenaPtr() const {
4801 return nullptr;
4802 }
4803 public:
4804
4805 std::string GetTypeName() const final;
4806
4807 // nested types ----------------------------------------------------
4808
4809 // accessors -------------------------------------------------------
4810
4811 enum : int {
4812 kSecondsFieldNumber = 1,
4813 kNanosFieldNumber = 2,
4814 };
4815 // optional int64 seconds = 1;
4816 bool has_seconds() const;
4817 private:
4818 bool _internal_has_seconds() const;
4819 public:
4820 void clear_seconds();
4821 ::PROTOBUF_NAMESPACE_ID::int64 seconds() const;
4822 void set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
4823 private:
4824 ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds() const;
4825 void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
4826 public:
4827
4828 // optional int32 nanos = 2;
4829 bool has_nanos() const;
4830 private:
4831 bool _internal_has_nanos() const;
4832 public:
4833 void clear_nanos();
4834 ::PROTOBUF_NAMESPACE_ID::int32 nanos() const;
4835 void set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value);
4836 private:
4837 ::PROTOBUF_NAMESPACE_ID::int32 _internal_nanos() const;
4838 void _internal_set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value);
4839 public:
4840
4841 // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Duration)
4842 private:
4843 class _Internal;
4844
4845 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
4846 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4847 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4848 ::PROTOBUF_NAMESPACE_ID::int64 seconds_;
4849 ::PROTOBUF_NAMESPACE_ID::int32 nanos_;
4850 friend struct ::TableStruct_safebrowsing_2eproto;
4851 };
4852 // ===================================================================
4853
4854
4855 // ===================================================================
4856
4857 #ifdef __GNUC__
4858 #pragma GCC diagnostic push
4859 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
4860 #endif // __GNUC__
4861 // ThreatInfo
4862
4863 // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
_internal_threat_types_size()4864 inline int ThreatInfo::_internal_threat_types_size() const {
4865 return threat_types_.size();
4866 }
threat_types_size()4867 inline int ThreatInfo::threat_types_size() const {
4868 return _internal_threat_types_size();
4869 }
clear_threat_types()4870 inline void ThreatInfo::clear_threat_types() {
4871 threat_types_.Clear();
4872 }
_internal_threat_types(int index)4873 inline ::mozilla::safebrowsing::ThreatType ThreatInfo::_internal_threat_types(int index) const {
4874 return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_types_.Get(index));
4875 }
threat_types(int index)4876 inline ::mozilla::safebrowsing::ThreatType ThreatInfo::threat_types(int index) const {
4877 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_types)
4878 return _internal_threat_types(index);
4879 }
set_threat_types(int index,::mozilla::safebrowsing::ThreatType value)4880 inline void ThreatInfo::set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value) {
4881 assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
4882 threat_types_.Set(index, value);
4883 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_types)
4884 }
_internal_add_threat_types(::mozilla::safebrowsing::ThreatType value)4885 inline void ThreatInfo::_internal_add_threat_types(::mozilla::safebrowsing::ThreatType value) {
4886 assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
4887 threat_types_.Add(value);
4888 }
add_threat_types(::mozilla::safebrowsing::ThreatType value)4889 inline void ThreatInfo::add_threat_types(::mozilla::safebrowsing::ThreatType value) {
4890 // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_types)
4891 _internal_add_threat_types(value);
4892 }
4893 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
threat_types()4894 ThreatInfo::threat_types() const {
4895 // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_types)
4896 return threat_types_;
4897 }
4898 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
_internal_mutable_threat_types()4899 ThreatInfo::_internal_mutable_threat_types() {
4900 return &threat_types_;
4901 }
4902 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
mutable_threat_types()4903 ThreatInfo::mutable_threat_types() {
4904 // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_types)
4905 return _internal_mutable_threat_types();
4906 }
4907
4908 // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
_internal_platform_types_size()4909 inline int ThreatInfo::_internal_platform_types_size() const {
4910 return platform_types_.size();
4911 }
platform_types_size()4912 inline int ThreatInfo::platform_types_size() const {
4913 return _internal_platform_types_size();
4914 }
clear_platform_types()4915 inline void ThreatInfo::clear_platform_types() {
4916 platform_types_.Clear();
4917 }
_internal_platform_types(int index)4918 inline ::mozilla::safebrowsing::PlatformType ThreatInfo::_internal_platform_types(int index) const {
4919 return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_types_.Get(index));
4920 }
platform_types(int index)4921 inline ::mozilla::safebrowsing::PlatformType ThreatInfo::platform_types(int index) const {
4922 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.platform_types)
4923 return _internal_platform_types(index);
4924 }
set_platform_types(int index,::mozilla::safebrowsing::PlatformType value)4925 inline void ThreatInfo::set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value) {
4926 assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
4927 platform_types_.Set(index, value);
4928 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.platform_types)
4929 }
_internal_add_platform_types(::mozilla::safebrowsing::PlatformType value)4930 inline void ThreatInfo::_internal_add_platform_types(::mozilla::safebrowsing::PlatformType value) {
4931 assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
4932 platform_types_.Add(value);
4933 }
add_platform_types(::mozilla::safebrowsing::PlatformType value)4934 inline void ThreatInfo::add_platform_types(::mozilla::safebrowsing::PlatformType value) {
4935 // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.platform_types)
4936 _internal_add_platform_types(value);
4937 }
4938 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
platform_types()4939 ThreatInfo::platform_types() const {
4940 // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.platform_types)
4941 return platform_types_;
4942 }
4943 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
_internal_mutable_platform_types()4944 ThreatInfo::_internal_mutable_platform_types() {
4945 return &platform_types_;
4946 }
4947 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
mutable_platform_types()4948 ThreatInfo::mutable_platform_types() {
4949 // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.platform_types)
4950 return _internal_mutable_platform_types();
4951 }
4952
4953 // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
_internal_threat_entry_types_size()4954 inline int ThreatInfo::_internal_threat_entry_types_size() const {
4955 return threat_entry_types_.size();
4956 }
threat_entry_types_size()4957 inline int ThreatInfo::threat_entry_types_size() const {
4958 return _internal_threat_entry_types_size();
4959 }
clear_threat_entry_types()4960 inline void ThreatInfo::clear_threat_entry_types() {
4961 threat_entry_types_.Clear();
4962 }
_internal_threat_entry_types(int index)4963 inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::_internal_threat_entry_types(int index) const {
4964 return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_types_.Get(index));
4965 }
threat_entry_types(int index)4966 inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::threat_entry_types(int index) const {
4967 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
4968 return _internal_threat_entry_types(index);
4969 }
set_threat_entry_types(int index,::mozilla::safebrowsing::ThreatEntryType value)4970 inline void ThreatInfo::set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value) {
4971 assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
4972 threat_entry_types_.Set(index, value);
4973 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
4974 }
_internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value)4975 inline void ThreatInfo::_internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) {
4976 assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
4977 threat_entry_types_.Add(value);
4978 }
add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value)4979 inline void ThreatInfo::add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) {
4980 // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
4981 _internal_add_threat_entry_types(value);
4982 }
4983 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
threat_entry_types()4984 ThreatInfo::threat_entry_types() const {
4985 // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
4986 return threat_entry_types_;
4987 }
4988 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
_internal_mutable_threat_entry_types()4989 ThreatInfo::_internal_mutable_threat_entry_types() {
4990 return &threat_entry_types_;
4991 }
4992 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
mutable_threat_entry_types()4993 ThreatInfo::mutable_threat_entry_types() {
4994 // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
4995 return _internal_mutable_threat_entry_types();
4996 }
4997
4998 // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
_internal_threat_entries_size()4999 inline int ThreatInfo::_internal_threat_entries_size() const {
5000 return threat_entries_.size();
5001 }
threat_entries_size()5002 inline int ThreatInfo::threat_entries_size() const {
5003 return _internal_threat_entries_size();
5004 }
clear_threat_entries()5005 inline void ThreatInfo::clear_threat_entries() {
5006 threat_entries_.Clear();
5007 }
mutable_threat_entries(int index)5008 inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::mutable_threat_entries(int index) {
5009 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatInfo.threat_entries)
5010 return threat_entries_.Mutable(index);
5011 }
5012 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >*
mutable_threat_entries()5013 ThreatInfo::mutable_threat_entries() {
5014 // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entries)
5015 return &threat_entries_;
5016 }
_internal_threat_entries(int index)5017 inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::_internal_threat_entries(int index) const {
5018 return threat_entries_.Get(index);
5019 }
threat_entries(int index)5020 inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::threat_entries(int index) const {
5021 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entries)
5022 return _internal_threat_entries(index);
5023 }
_internal_add_threat_entries()5024 inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::_internal_add_threat_entries() {
5025 return threat_entries_.Add();
5026 }
add_threat_entries()5027 inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::add_threat_entries() {
5028 // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entries)
5029 return _internal_add_threat_entries();
5030 }
5031 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >&
threat_entries()5032 ThreatInfo::threat_entries() const {
5033 // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entries)
5034 return threat_entries_;
5035 }
5036
5037 // -------------------------------------------------------------------
5038
5039 // ThreatMatch
5040
5041 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
_internal_has_threat_type()5042 inline bool ThreatMatch::_internal_has_threat_type() const {
5043 bool value = (_has_bits_[0] & 0x00000008u) != 0;
5044 return value;
5045 }
has_threat_type()5046 inline bool ThreatMatch::has_threat_type() const {
5047 return _internal_has_threat_type();
5048 }
clear_threat_type()5049 inline void ThreatMatch::clear_threat_type() {
5050 threat_type_ = 0;
5051 _has_bits_[0] &= ~0x00000008u;
5052 }
_internal_threat_type()5053 inline ::mozilla::safebrowsing::ThreatType ThreatMatch::_internal_threat_type() const {
5054 return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
5055 }
threat_type()5056 inline ::mozilla::safebrowsing::ThreatType ThreatMatch::threat_type() const {
5057 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_type)
5058 return _internal_threat_type();
5059 }
_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value)5060 inline void ThreatMatch::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
5061 assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
5062 _has_bits_[0] |= 0x00000008u;
5063 threat_type_ = value;
5064 }
set_threat_type(::mozilla::safebrowsing::ThreatType value)5065 inline void ThreatMatch::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
5066 _internal_set_threat_type(value);
5067 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_type)
5068 }
5069
5070 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
_internal_has_platform_type()5071 inline bool ThreatMatch::_internal_has_platform_type() const {
5072 bool value = (_has_bits_[0] & 0x00000010u) != 0;
5073 return value;
5074 }
has_platform_type()5075 inline bool ThreatMatch::has_platform_type() const {
5076 return _internal_has_platform_type();
5077 }
clear_platform_type()5078 inline void ThreatMatch::clear_platform_type() {
5079 platform_type_ = 0;
5080 _has_bits_[0] &= ~0x00000010u;
5081 }
_internal_platform_type()5082 inline ::mozilla::safebrowsing::PlatformType ThreatMatch::_internal_platform_type() const {
5083 return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
5084 }
platform_type()5085 inline ::mozilla::safebrowsing::PlatformType ThreatMatch::platform_type() const {
5086 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.platform_type)
5087 return _internal_platform_type();
5088 }
_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value)5089 inline void ThreatMatch::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
5090 assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
5091 _has_bits_[0] |= 0x00000010u;
5092 platform_type_ = value;
5093 }
set_platform_type(::mozilla::safebrowsing::PlatformType value)5094 inline void ThreatMatch::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
5095 _internal_set_platform_type(value);
5096 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.platform_type)
5097 }
5098
5099 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
_internal_has_threat_entry_type()5100 inline bool ThreatMatch::_internal_has_threat_entry_type() const {
5101 bool value = (_has_bits_[0] & 0x00000020u) != 0;
5102 return value;
5103 }
has_threat_entry_type()5104 inline bool ThreatMatch::has_threat_entry_type() const {
5105 return _internal_has_threat_entry_type();
5106 }
clear_threat_entry_type()5107 inline void ThreatMatch::clear_threat_entry_type() {
5108 threat_entry_type_ = 0;
5109 _has_bits_[0] &= ~0x00000020u;
5110 }
_internal_threat_entry_type()5111 inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::_internal_threat_entry_type() const {
5112 return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
5113 }
threat_entry_type()5114 inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::threat_entry_type() const {
5115 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_type)
5116 return _internal_threat_entry_type();
5117 }
_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)5118 inline void ThreatMatch::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
5119 assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
5120 _has_bits_[0] |= 0x00000020u;
5121 threat_entry_type_ = value;
5122 }
set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)5123 inline void ThreatMatch::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
5124 _internal_set_threat_entry_type(value);
5125 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_entry_type)
5126 }
5127
5128 // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
_internal_has_threat()5129 inline bool ThreatMatch::_internal_has_threat() const {
5130 bool value = (_has_bits_[0] & 0x00000001u) != 0;
5131 PROTOBUF_ASSUME(!value || threat_ != nullptr);
5132 return value;
5133 }
has_threat()5134 inline bool ThreatMatch::has_threat() const {
5135 return _internal_has_threat();
5136 }
clear_threat()5137 inline void ThreatMatch::clear_threat() {
5138 if (threat_ != nullptr) threat_->Clear();
5139 _has_bits_[0] &= ~0x00000001u;
5140 }
_internal_threat()5141 inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::_internal_threat() const {
5142 const ::mozilla::safebrowsing::ThreatEntry* p = threat_;
5143 return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntry*>(
5144 &::mozilla::safebrowsing::_ThreatEntry_default_instance_);
5145 }
threat()5146 inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::threat() const {
5147 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat)
5148 return _internal_threat();
5149 }
release_threat()5150 inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::release_threat() {
5151 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.threat)
5152 _has_bits_[0] &= ~0x00000001u;
5153 ::mozilla::safebrowsing::ThreatEntry* temp = threat_;
5154 threat_ = nullptr;
5155 return temp;
5156 }
_internal_mutable_threat()5157 inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::_internal_mutable_threat() {
5158 _has_bits_[0] |= 0x00000001u;
5159 if (threat_ == nullptr) {
5160 auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(GetArenaNoVirtual());
5161 threat_ = p;
5162 }
5163 return threat_;
5164 }
mutable_threat()5165 inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::mutable_threat() {
5166 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat)
5167 return _internal_mutable_threat();
5168 }
set_allocated_threat(::mozilla::safebrowsing::ThreatEntry * threat)5169 inline void ThreatMatch::set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat) {
5170 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5171 if (message_arena == nullptr) {
5172 delete threat_;
5173 }
5174 if (threat) {
5175 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5176 if (message_arena != submessage_arena) {
5177 threat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5178 message_arena, threat, submessage_arena);
5179 }
5180 _has_bits_[0] |= 0x00000001u;
5181 } else {
5182 _has_bits_[0] &= ~0x00000001u;
5183 }
5184 threat_ = threat;
5185 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat)
5186 }
5187
5188 // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
_internal_has_threat_entry_metadata()5189 inline bool ThreatMatch::_internal_has_threat_entry_metadata() const {
5190 bool value = (_has_bits_[0] & 0x00000002u) != 0;
5191 PROTOBUF_ASSUME(!value || threat_entry_metadata_ != nullptr);
5192 return value;
5193 }
has_threat_entry_metadata()5194 inline bool ThreatMatch::has_threat_entry_metadata() const {
5195 return _internal_has_threat_entry_metadata();
5196 }
clear_threat_entry_metadata()5197 inline void ThreatMatch::clear_threat_entry_metadata() {
5198 if (threat_entry_metadata_ != nullptr) threat_entry_metadata_->Clear();
5199 _has_bits_[0] &= ~0x00000002u;
5200 }
_internal_threat_entry_metadata()5201 inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::_internal_threat_entry_metadata() const {
5202 const ::mozilla::safebrowsing::ThreatEntryMetadata* p = threat_entry_metadata_;
5203 return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntryMetadata*>(
5204 &::mozilla::safebrowsing::_ThreatEntryMetadata_default_instance_);
5205 }
threat_entry_metadata()5206 inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::threat_entry_metadata() const {
5207 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
5208 return _internal_threat_entry_metadata();
5209 }
release_threat_entry_metadata()5210 inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::release_threat_entry_metadata() {
5211 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
5212 _has_bits_[0] &= ~0x00000002u;
5213 ::mozilla::safebrowsing::ThreatEntryMetadata* temp = threat_entry_metadata_;
5214 threat_entry_metadata_ = nullptr;
5215 return temp;
5216 }
_internal_mutable_threat_entry_metadata()5217 inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::_internal_mutable_threat_entry_metadata() {
5218 _has_bits_[0] |= 0x00000002u;
5219 if (threat_entry_metadata_ == nullptr) {
5220 auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata>(GetArenaNoVirtual());
5221 threat_entry_metadata_ = p;
5222 }
5223 return threat_entry_metadata_;
5224 }
mutable_threat_entry_metadata()5225 inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::mutable_threat_entry_metadata() {
5226 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
5227 return _internal_mutable_threat_entry_metadata();
5228 }
set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata * threat_entry_metadata)5229 inline void ThreatMatch::set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) {
5230 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5231 if (message_arena == nullptr) {
5232 delete threat_entry_metadata_;
5233 }
5234 if (threat_entry_metadata) {
5235 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5236 if (message_arena != submessage_arena) {
5237 threat_entry_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5238 message_arena, threat_entry_metadata, submessage_arena);
5239 }
5240 _has_bits_[0] |= 0x00000002u;
5241 } else {
5242 _has_bits_[0] &= ~0x00000002u;
5243 }
5244 threat_entry_metadata_ = threat_entry_metadata;
5245 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
5246 }
5247
5248 // optional .mozilla.safebrowsing.Duration cache_duration = 5;
_internal_has_cache_duration()5249 inline bool ThreatMatch::_internal_has_cache_duration() const {
5250 bool value = (_has_bits_[0] & 0x00000004u) != 0;
5251 PROTOBUF_ASSUME(!value || cache_duration_ != nullptr);
5252 return value;
5253 }
has_cache_duration()5254 inline bool ThreatMatch::has_cache_duration() const {
5255 return _internal_has_cache_duration();
5256 }
clear_cache_duration()5257 inline void ThreatMatch::clear_cache_duration() {
5258 if (cache_duration_ != nullptr) cache_duration_->Clear();
5259 _has_bits_[0] &= ~0x00000004u;
5260 }
_internal_cache_duration()5261 inline const ::mozilla::safebrowsing::Duration& ThreatMatch::_internal_cache_duration() const {
5262 const ::mozilla::safebrowsing::Duration* p = cache_duration_;
5263 return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::Duration*>(
5264 &::mozilla::safebrowsing::_Duration_default_instance_);
5265 }
cache_duration()5266 inline const ::mozilla::safebrowsing::Duration& ThreatMatch::cache_duration() const {
5267 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.cache_duration)
5268 return _internal_cache_duration();
5269 }
release_cache_duration()5270 inline ::mozilla::safebrowsing::Duration* ThreatMatch::release_cache_duration() {
5271 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.cache_duration)
5272 _has_bits_[0] &= ~0x00000004u;
5273 ::mozilla::safebrowsing::Duration* temp = cache_duration_;
5274 cache_duration_ = nullptr;
5275 return temp;
5276 }
_internal_mutable_cache_duration()5277 inline ::mozilla::safebrowsing::Duration* ThreatMatch::_internal_mutable_cache_duration() {
5278 _has_bits_[0] |= 0x00000004u;
5279 if (cache_duration_ == nullptr) {
5280 auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaNoVirtual());
5281 cache_duration_ = p;
5282 }
5283 return cache_duration_;
5284 }
mutable_cache_duration()5285 inline ::mozilla::safebrowsing::Duration* ThreatMatch::mutable_cache_duration() {
5286 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.cache_duration)
5287 return _internal_mutable_cache_duration();
5288 }
set_allocated_cache_duration(::mozilla::safebrowsing::Duration * cache_duration)5289 inline void ThreatMatch::set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration) {
5290 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5291 if (message_arena == nullptr) {
5292 delete cache_duration_;
5293 }
5294 if (cache_duration) {
5295 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5296 if (message_arena != submessage_arena) {
5297 cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5298 message_arena, cache_duration, submessage_arena);
5299 }
5300 _has_bits_[0] |= 0x00000004u;
5301 } else {
5302 _has_bits_[0] &= ~0x00000004u;
5303 }
5304 cache_duration_ = cache_duration;
5305 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration)
5306 }
5307
5308 // -------------------------------------------------------------------
5309
5310 // FindThreatMatchesRequest
5311
5312 // optional .mozilla.safebrowsing.ClientInfo client = 1;
_internal_has_client()5313 inline bool FindThreatMatchesRequest::_internal_has_client() const {
5314 bool value = (_has_bits_[0] & 0x00000001u) != 0;
5315 PROTOBUF_ASSUME(!value || client_ != nullptr);
5316 return value;
5317 }
has_client()5318 inline bool FindThreatMatchesRequest::has_client() const {
5319 return _internal_has_client();
5320 }
clear_client()5321 inline void FindThreatMatchesRequest::clear_client() {
5322 if (client_ != nullptr) client_->Clear();
5323 _has_bits_[0] &= ~0x00000001u;
5324 }
_internal_client()5325 inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::_internal_client() const {
5326 const ::mozilla::safebrowsing::ClientInfo* p = client_;
5327 return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo*>(
5328 &::mozilla::safebrowsing::_ClientInfo_default_instance_);
5329 }
client()5330 inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::client() const {
5331 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.client)
5332 return _internal_client();
5333 }
release_client()5334 inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::release_client() {
5335 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindThreatMatchesRequest.client)
5336 _has_bits_[0] &= ~0x00000001u;
5337 ::mozilla::safebrowsing::ClientInfo* temp = client_;
5338 client_ = nullptr;
5339 return temp;
5340 }
_internal_mutable_client()5341 inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::_internal_mutable_client() {
5342 _has_bits_[0] |= 0x00000001u;
5343 if (client_ == nullptr) {
5344 auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaNoVirtual());
5345 client_ = p;
5346 }
5347 return client_;
5348 }
mutable_client()5349 inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::mutable_client() {
5350 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.client)
5351 return _internal_mutable_client();
5352 }
set_allocated_client(::mozilla::safebrowsing::ClientInfo * client)5353 inline void FindThreatMatchesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
5354 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5355 if (message_arena == nullptr) {
5356 delete client_;
5357 }
5358 if (client) {
5359 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5360 if (message_arena != submessage_arena) {
5361 client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5362 message_arena, client, submessage_arena);
5363 }
5364 _has_bits_[0] |= 0x00000001u;
5365 } else {
5366 _has_bits_[0] &= ~0x00000001u;
5367 }
5368 client_ = client;
5369 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client)
5370 }
5371
5372 // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
_internal_has_threat_info()5373 inline bool FindThreatMatchesRequest::_internal_has_threat_info() const {
5374 bool value = (_has_bits_[0] & 0x00000002u) != 0;
5375 PROTOBUF_ASSUME(!value || threat_info_ != nullptr);
5376 return value;
5377 }
has_threat_info()5378 inline bool FindThreatMatchesRequest::has_threat_info() const {
5379 return _internal_has_threat_info();
5380 }
clear_threat_info()5381 inline void FindThreatMatchesRequest::clear_threat_info() {
5382 if (threat_info_ != nullptr) threat_info_->Clear();
5383 _has_bits_[0] &= ~0x00000002u;
5384 }
_internal_threat_info()5385 inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::_internal_threat_info() const {
5386 const ::mozilla::safebrowsing::ThreatInfo* p = threat_info_;
5387 return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ThreatInfo*>(
5388 &::mozilla::safebrowsing::_ThreatInfo_default_instance_);
5389 }
threat_info()5390 inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::threat_info() const {
5391 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
5392 return _internal_threat_info();
5393 }
release_threat_info()5394 inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::release_threat_info() {
5395 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
5396 _has_bits_[0] &= ~0x00000002u;
5397 ::mozilla::safebrowsing::ThreatInfo* temp = threat_info_;
5398 threat_info_ = nullptr;
5399 return temp;
5400 }
_internal_mutable_threat_info()5401 inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::_internal_mutable_threat_info() {
5402 _has_bits_[0] |= 0x00000002u;
5403 if (threat_info_ == nullptr) {
5404 auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(GetArenaNoVirtual());
5405 threat_info_ = p;
5406 }
5407 return threat_info_;
5408 }
mutable_threat_info()5409 inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::mutable_threat_info() {
5410 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
5411 return _internal_mutable_threat_info();
5412 }
set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo * threat_info)5413 inline void FindThreatMatchesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) {
5414 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5415 if (message_arena == nullptr) {
5416 delete threat_info_;
5417 }
5418 if (threat_info) {
5419 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5420 if (message_arena != submessage_arena) {
5421 threat_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5422 message_arena, threat_info, submessage_arena);
5423 }
5424 _has_bits_[0] |= 0x00000002u;
5425 } else {
5426 _has_bits_[0] &= ~0x00000002u;
5427 }
5428 threat_info_ = threat_info;
5429 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
5430 }
5431
5432 // -------------------------------------------------------------------
5433
5434 // FindThreatMatchesResponse
5435
5436 // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
_internal_matches_size()5437 inline int FindThreatMatchesResponse::_internal_matches_size() const {
5438 return matches_.size();
5439 }
matches_size()5440 inline int FindThreatMatchesResponse::matches_size() const {
5441 return _internal_matches_size();
5442 }
clear_matches()5443 inline void FindThreatMatchesResponse::clear_matches() {
5444 matches_.Clear();
5445 }
mutable_matches(int index)5446 inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::mutable_matches(int index) {
5447 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
5448 return matches_.Mutable(index);
5449 }
5450 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
mutable_matches()5451 FindThreatMatchesResponse::mutable_matches() {
5452 // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
5453 return &matches_;
5454 }
_internal_matches(int index)5455 inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::_internal_matches(int index) const {
5456 return matches_.Get(index);
5457 }
matches(int index)5458 inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::matches(int index) const {
5459 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
5460 return _internal_matches(index);
5461 }
_internal_add_matches()5462 inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::_internal_add_matches() {
5463 return matches_.Add();
5464 }
add_matches()5465 inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::add_matches() {
5466 // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
5467 return _internal_add_matches();
5468 }
5469 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
matches()5470 FindThreatMatchesResponse::matches() const {
5471 // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
5472 return matches_;
5473 }
5474
5475 // -------------------------------------------------------------------
5476
5477 // FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints
5478
5479 // optional int32 max_update_entries = 1;
_internal_has_max_update_entries()5480 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_max_update_entries() const {
5481 bool value = (_has_bits_[0] & 0x00000002u) != 0;
5482 return value;
5483 }
has_max_update_entries()5484 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_update_entries() const {
5485 return _internal_has_max_update_entries();
5486 }
clear_max_update_entries()5487 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_update_entries() {
5488 max_update_entries_ = 0;
5489 _has_bits_[0] &= ~0x00000002u;
5490 }
_internal_max_update_entries()5491 inline ::PROTOBUF_NAMESPACE_ID::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_max_update_entries() const {
5492 return max_update_entries_;
5493 }
max_update_entries()5494 inline ::PROTOBUF_NAMESPACE_ID::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_update_entries() const {
5495 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries)
5496 return _internal_max_update_entries();
5497 }
_internal_set_max_update_entries(::PROTOBUF_NAMESPACE_ID::int32 value)5498 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_max_update_entries(::PROTOBUF_NAMESPACE_ID::int32 value) {
5499 _has_bits_[0] |= 0x00000002u;
5500 max_update_entries_ = value;
5501 }
set_max_update_entries(::PROTOBUF_NAMESPACE_ID::int32 value)5502 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_update_entries(::PROTOBUF_NAMESPACE_ID::int32 value) {
5503 _internal_set_max_update_entries(value);
5504 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries)
5505 }
5506
5507 // optional int32 max_database_entries = 2;
_internal_has_max_database_entries()5508 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_max_database_entries() const {
5509 bool value = (_has_bits_[0] & 0x00000004u) != 0;
5510 return value;
5511 }
has_max_database_entries()5512 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_database_entries() const {
5513 return _internal_has_max_database_entries();
5514 }
clear_max_database_entries()5515 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_database_entries() {
5516 max_database_entries_ = 0;
5517 _has_bits_[0] &= ~0x00000004u;
5518 }
_internal_max_database_entries()5519 inline ::PROTOBUF_NAMESPACE_ID::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_max_database_entries() const {
5520 return max_database_entries_;
5521 }
max_database_entries()5522 inline ::PROTOBUF_NAMESPACE_ID::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_database_entries() const {
5523 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries)
5524 return _internal_max_database_entries();
5525 }
_internal_set_max_database_entries(::PROTOBUF_NAMESPACE_ID::int32 value)5526 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_max_database_entries(::PROTOBUF_NAMESPACE_ID::int32 value) {
5527 _has_bits_[0] |= 0x00000004u;
5528 max_database_entries_ = value;
5529 }
set_max_database_entries(::PROTOBUF_NAMESPACE_ID::int32 value)5530 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_database_entries(::PROTOBUF_NAMESPACE_ID::int32 value) {
5531 _internal_set_max_database_entries(value);
5532 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries)
5533 }
5534
5535 // optional string region = 3;
_internal_has_region()5536 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_region() const {
5537 bool value = (_has_bits_[0] & 0x00000001u) != 0;
5538 return value;
5539 }
has_region()5540 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_region() const {
5541 return _internal_has_region();
5542 }
clear_region()5543 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_region() {
5544 region_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5545 _has_bits_[0] &= ~0x00000001u;
5546 }
region()5547 inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::region() const {
5548 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5549 return _internal_region();
5550 }
set_region(const std::string & value)5551 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const std::string& value) {
5552 _internal_set_region(value);
5553 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5554 }
mutable_region()5555 inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_region() {
5556 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5557 return _internal_mutable_region();
5558 }
_internal_region()5559 inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_region() const {
5560 return region_.GetNoArena();
5561 }
_internal_set_region(const std::string & value)5562 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_region(const std::string& value) {
5563 _has_bits_[0] |= 0x00000001u;
5564 region_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
5565 }
set_region(std::string && value)5566 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(std::string&& value) {
5567 _has_bits_[0] |= 0x00000001u;
5568 region_.SetNoArena(
5569 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5570 // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5571 }
set_region(const char * value)5572 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const char* value) {
5573 GOOGLE_DCHECK(value != nullptr);
5574 _has_bits_[0] |= 0x00000001u;
5575 region_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5576 // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5577 }
set_region(const char * value,size_t size)5578 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const char* value, size_t size) {
5579 _has_bits_[0] |= 0x00000001u;
5580 region_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5581 ::std::string(reinterpret_cast<const char*>(value), size));
5582 // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5583 }
_internal_mutable_region()5584 inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_mutable_region() {
5585 _has_bits_[0] |= 0x00000001u;
5586 return region_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5587 }
release_region()5588 inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::release_region() {
5589 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5590 if (!_internal_has_region()) {
5591 return nullptr;
5592 }
5593 _has_bits_[0] &= ~0x00000001u;
5594 return region_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5595 }
set_allocated_region(std::string * region)5596 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_allocated_region(std::string* region) {
5597 if (region != nullptr) {
5598 _has_bits_[0] |= 0x00000001u;
5599 } else {
5600 _has_bits_[0] &= ~0x00000001u;
5601 }
5602 region_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), region);
5603 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
5604 }
5605
5606 // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
_internal_supported_compressions_size()5607 inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_supported_compressions_size() const {
5608 return supported_compressions_.size();
5609 }
supported_compressions_size()5610 inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions_size() const {
5611 return _internal_supported_compressions_size();
5612 }
clear_supported_compressions()5613 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_supported_compressions() {
5614 supported_compressions_.Clear();
5615 }
_internal_supported_compressions(int index)5616 inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_supported_compressions(int index) const {
5617 return static_cast< ::mozilla::safebrowsing::CompressionType >(supported_compressions_.Get(index));
5618 }
supported_compressions(int index)5619 inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions(int index) const {
5620 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
5621 return _internal_supported_compressions(index);
5622 }
set_supported_compressions(int index,::mozilla::safebrowsing::CompressionType value)5623 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value) {
5624 assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
5625 supported_compressions_.Set(index, value);
5626 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
5627 }
_internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value)5628 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value) {
5629 assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
5630 supported_compressions_.Add(value);
5631 }
add_supported_compressions(::mozilla::safebrowsing::CompressionType value)5632 inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::add_supported_compressions(::mozilla::safebrowsing::CompressionType value) {
5633 // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
5634 _internal_add_supported_compressions(value);
5635 }
5636 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
supported_compressions()5637 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions() const {
5638 // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
5639 return supported_compressions_;
5640 }
5641 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
_internal_mutable_supported_compressions()5642 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_mutable_supported_compressions() {
5643 return &supported_compressions_;
5644 }
5645 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
mutable_supported_compressions()5646 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_supported_compressions() {
5647 // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
5648 return _internal_mutable_supported_compressions();
5649 }
5650
5651 // -------------------------------------------------------------------
5652
5653 // FetchThreatListUpdatesRequest_ListUpdateRequest
5654
5655 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
_internal_has_threat_type()5656 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_threat_type() const {
5657 bool value = (_has_bits_[0] & 0x00000004u) != 0;
5658 return value;
5659 }
has_threat_type()5660 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_type() const {
5661 return _internal_has_threat_type();
5662 }
clear_threat_type()5663 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_type() {
5664 threat_type_ = 0;
5665 _has_bits_[0] &= ~0x00000004u;
5666 }
_internal_threat_type()5667 inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_threat_type() const {
5668 return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
5669 }
threat_type()5670 inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_type() const {
5671 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type)
5672 return _internal_threat_type();
5673 }
_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value)5674 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
5675 assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
5676 _has_bits_[0] |= 0x00000004u;
5677 threat_type_ = value;
5678 }
set_threat_type(::mozilla::safebrowsing::ThreatType value)5679 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
5680 _internal_set_threat_type(value);
5681 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type)
5682 }
5683
5684 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
_internal_has_platform_type()5685 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_platform_type() const {
5686 bool value = (_has_bits_[0] & 0x00000008u) != 0;
5687 return value;
5688 }
has_platform_type()5689 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_platform_type() const {
5690 return _internal_has_platform_type();
5691 }
clear_platform_type()5692 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_platform_type() {
5693 platform_type_ = 0;
5694 _has_bits_[0] &= ~0x00000008u;
5695 }
_internal_platform_type()5696 inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_platform_type() const {
5697 return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
5698 }
platform_type()5699 inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::platform_type() const {
5700 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type)
5701 return _internal_platform_type();
5702 }
_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value)5703 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
5704 assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
5705 _has_bits_[0] |= 0x00000008u;
5706 platform_type_ = value;
5707 }
set_platform_type(::mozilla::safebrowsing::PlatformType value)5708 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
5709 _internal_set_platform_type(value);
5710 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type)
5711 }
5712
5713 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
_internal_has_threat_entry_type()5714 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_threat_entry_type() const {
5715 bool value = (_has_bits_[0] & 0x00000010u) != 0;
5716 return value;
5717 }
has_threat_entry_type()5718 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_entry_type() const {
5719 return _internal_has_threat_entry_type();
5720 }
clear_threat_entry_type()5721 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_entry_type() {
5722 threat_entry_type_ = 0;
5723 _has_bits_[0] &= ~0x00000010u;
5724 }
_internal_threat_entry_type()5725 inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_threat_entry_type() const {
5726 return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
5727 }
threat_entry_type()5728 inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_entry_type() const {
5729 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type)
5730 return _internal_threat_entry_type();
5731 }
_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)5732 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
5733 assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
5734 _has_bits_[0] |= 0x00000010u;
5735 threat_entry_type_ = value;
5736 }
set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)5737 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
5738 _internal_set_threat_entry_type(value);
5739 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type)
5740 }
5741
5742 // optional bytes state = 3;
_internal_has_state()5743 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_state() const {
5744 bool value = (_has_bits_[0] & 0x00000001u) != 0;
5745 return value;
5746 }
has_state()5747 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_state() const {
5748 return _internal_has_state();
5749 }
clear_state()5750 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_state() {
5751 state_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5752 _has_bits_[0] &= ~0x00000001u;
5753 }
state()5754 inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::state() const {
5755 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5756 return _internal_state();
5757 }
set_state(const std::string & value)5758 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const std::string& value) {
5759 _internal_set_state(value);
5760 // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5761 }
mutable_state()5762 inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_state() {
5763 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5764 return _internal_mutable_state();
5765 }
_internal_state()5766 inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_state() const {
5767 return state_.GetNoArena();
5768 }
_internal_set_state(const std::string & value)5769 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_state(const std::string& value) {
5770 _has_bits_[0] |= 0x00000001u;
5771 state_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
5772 }
set_state(std::string && value)5773 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(std::string&& value) {
5774 _has_bits_[0] |= 0x00000001u;
5775 state_.SetNoArena(
5776 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5777 // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5778 }
set_state(const char * value)5779 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const char* value) {
5780 GOOGLE_DCHECK(value != nullptr);
5781 _has_bits_[0] |= 0x00000001u;
5782 state_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5783 // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5784 }
set_state(const void * value,size_t size)5785 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const void* value, size_t size) {
5786 _has_bits_[0] |= 0x00000001u;
5787 state_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5788 ::std::string(reinterpret_cast<const char*>(value), size));
5789 // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5790 }
_internal_mutable_state()5791 inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_mutable_state() {
5792 _has_bits_[0] |= 0x00000001u;
5793 return state_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5794 }
release_state()5795 inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::release_state() {
5796 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5797 if (!_internal_has_state()) {
5798 return nullptr;
5799 }
5800 _has_bits_[0] &= ~0x00000001u;
5801 return state_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5802 }
set_allocated_state(std::string * state)5803 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_state(std::string* state) {
5804 if (state != nullptr) {
5805 _has_bits_[0] |= 0x00000001u;
5806 } else {
5807 _has_bits_[0] &= ~0x00000001u;
5808 }
5809 state_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), state);
5810 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
5811 }
5812
5813 // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
_internal_has_constraints()5814 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_constraints() const {
5815 bool value = (_has_bits_[0] & 0x00000002u) != 0;
5816 PROTOBUF_ASSUME(!value || constraints_ != nullptr);
5817 return value;
5818 }
has_constraints()5819 inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_constraints() const {
5820 return _internal_has_constraints();
5821 }
clear_constraints()5822 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_constraints() {
5823 if (constraints_ != nullptr) constraints_->Clear();
5824 _has_bits_[0] &= ~0x00000002u;
5825 }
_internal_constraints()5826 inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_constraints() const {
5827 const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* p = constraints_;
5828 return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(
5829 &::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_);
5830 }
constraints()5831 inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::constraints() const {
5832 // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
5833 return _internal_constraints();
5834 }
release_constraints()5835 inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::release_constraints() {
5836 // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
5837 _has_bits_[0] &= ~0x00000002u;
5838 ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = constraints_;
5839 constraints_ = nullptr;
5840 return temp;
5841 }
_internal_mutable_constraints()5842 inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_mutable_constraints() {
5843 _has_bits_[0] |= 0x00000002u;
5844 if (constraints_ == nullptr) {
5845 auto* p = CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(GetArenaNoVirtual());
5846 constraints_ = p;
5847 }
5848 return constraints_;
5849 }
mutable_constraints()5850 inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_constraints() {
5851 // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
5852 return _internal_mutable_constraints();
5853 }
set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints * constraints)5854 inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) {
5855 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5856 if (message_arena == nullptr) {
5857 delete constraints_;
5858 }
5859 if (constraints) {
5860 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5861 if (message_arena != submessage_arena) {
5862 constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5863 message_arena, constraints, submessage_arena);
5864 }
5865 _has_bits_[0] |= 0x00000002u;
5866 } else {
5867 _has_bits_[0] &= ~0x00000002u;
5868 }
5869 constraints_ = constraints;
5870 // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
5871 }
5872
5873 // -------------------------------------------------------------------
5874
5875 // FetchThreatListUpdatesRequest
5876
5877 // optional .mozilla.safebrowsing.ClientInfo client = 1;
_internal_has_client()5878 inline bool FetchThreatListUpdatesRequest::_internal_has_client() const {
5879 bool value = (_has_bits_[0] & 0x00000001u) != 0;
5880 PROTOBUF_ASSUME(!value || client_ != nullptr);
5881 return value;
5882 }
has_client()5883