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 inline bool FetchThreatListUpdatesRequest::has_client() const {
5884   return _internal_has_client();
5885 }
clear_client()5886 inline void FetchThreatListUpdatesRequest::clear_client() {
5887   if (client_ != nullptr) client_->Clear();
5888   _has_bits_[0] &= ~0x00000001u;
5889 }
_internal_client()5890 inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::_internal_client() const {
5891   const ::mozilla::safebrowsing::ClientInfo* p = client_;
5892   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo*>(
5893       &::mozilla::safebrowsing::_ClientInfo_default_instance_);
5894 }
client()5895 inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::client() const {
5896   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
5897   return _internal_client();
5898 }
release_client()5899 inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::release_client() {
5900   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
5901   _has_bits_[0] &= ~0x00000001u;
5902   ::mozilla::safebrowsing::ClientInfo* temp = client_;
5903   client_ = nullptr;
5904   return temp;
5905 }
_internal_mutable_client()5906 inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::_internal_mutable_client() {
5907   _has_bits_[0] |= 0x00000001u;
5908   if (client_ == nullptr) {
5909     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaNoVirtual());
5910     client_ = p;
5911   }
5912   return client_;
5913 }
mutable_client()5914 inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::mutable_client() {
5915   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
5916   return _internal_mutable_client();
5917 }
set_allocated_client(::mozilla::safebrowsing::ClientInfo * client)5918 inline void FetchThreatListUpdatesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
5919   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5920   if (message_arena == nullptr) {
5921     delete client_;
5922   }
5923   if (client) {
5924     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5925     if (message_arena != submessage_arena) {
5926       client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5927           message_arena, client, submessage_arena);
5928     }
5929     _has_bits_[0] |= 0x00000001u;
5930   } else {
5931     _has_bits_[0] &= ~0x00000001u;
5932   }
5933   client_ = client;
5934   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
5935 }
5936 
5937 // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
_internal_list_update_requests_size()5938 inline int FetchThreatListUpdatesRequest::_internal_list_update_requests_size() const {
5939   return list_update_requests_.size();
5940 }
list_update_requests_size()5941 inline int FetchThreatListUpdatesRequest::list_update_requests_size() const {
5942   return _internal_list_update_requests_size();
5943 }
clear_list_update_requests()5944 inline void FetchThreatListUpdatesRequest::clear_list_update_requests() {
5945   list_update_requests_.Clear();
5946 }
mutable_list_update_requests(int index)5947 inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::mutable_list_update_requests(int index) {
5948   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
5949   return list_update_requests_.Mutable(index);
5950 }
5951 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >*
mutable_list_update_requests()5952 FetchThreatListUpdatesRequest::mutable_list_update_requests() {
5953   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
5954   return &list_update_requests_;
5955 }
_internal_list_update_requests(int index)5956 inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::_internal_list_update_requests(int index) const {
5957   return list_update_requests_.Get(index);
5958 }
list_update_requests(int index)5959 inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::list_update_requests(int index) const {
5960   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
5961   return _internal_list_update_requests(index);
5962 }
_internal_add_list_update_requests()5963 inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::_internal_add_list_update_requests() {
5964   return list_update_requests_.Add();
5965 }
add_list_update_requests()5966 inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::add_list_update_requests() {
5967   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
5968   return _internal_add_list_update_requests();
5969 }
5970 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >&
list_update_requests()5971 FetchThreatListUpdatesRequest::list_update_requests() const {
5972   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
5973   return list_update_requests_;
5974 }
5975 
5976 // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4;
_internal_has_chrome_client_info()5977 inline bool FetchThreatListUpdatesRequest::_internal_has_chrome_client_info() const {
5978   bool value = (_has_bits_[0] & 0x00000002u) != 0;
5979   PROTOBUF_ASSUME(!value || chrome_client_info_ != nullptr);
5980   return value;
5981 }
has_chrome_client_info()5982 inline bool FetchThreatListUpdatesRequest::has_chrome_client_info() const {
5983   return _internal_has_chrome_client_info();
5984 }
clear_chrome_client_info()5985 inline void FetchThreatListUpdatesRequest::clear_chrome_client_info() {
5986   if (chrome_client_info_ != nullptr) chrome_client_info_->Clear();
5987   _has_bits_[0] &= ~0x00000002u;
5988 }
_internal_chrome_client_info()5989 inline const ::mozilla::safebrowsing::ChromeClientInfo& FetchThreatListUpdatesRequest::_internal_chrome_client_info() const {
5990   const ::mozilla::safebrowsing::ChromeClientInfo* p = chrome_client_info_;
5991   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ChromeClientInfo*>(
5992       &::mozilla::safebrowsing::_ChromeClientInfo_default_instance_);
5993 }
chrome_client_info()5994 inline const ::mozilla::safebrowsing::ChromeClientInfo& FetchThreatListUpdatesRequest::chrome_client_info() const {
5995   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
5996   return _internal_chrome_client_info();
5997 }
release_chrome_client_info()5998 inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::release_chrome_client_info() {
5999   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
6000   _has_bits_[0] &= ~0x00000002u;
6001   ::mozilla::safebrowsing::ChromeClientInfo* temp = chrome_client_info_;
6002   chrome_client_info_ = nullptr;
6003   return temp;
6004 }
_internal_mutable_chrome_client_info()6005 inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::_internal_mutable_chrome_client_info() {
6006   _has_bits_[0] |= 0x00000002u;
6007   if (chrome_client_info_ == nullptr) {
6008     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ChromeClientInfo>(GetArenaNoVirtual());
6009     chrome_client_info_ = p;
6010   }
6011   return chrome_client_info_;
6012 }
mutable_chrome_client_info()6013 inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::mutable_chrome_client_info() {
6014   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
6015   return _internal_mutable_chrome_client_info();
6016 }
set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo * chrome_client_info)6017 inline void FetchThreatListUpdatesRequest::set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info) {
6018   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6019   if (message_arena == nullptr) {
6020     delete chrome_client_info_;
6021   }
6022   if (chrome_client_info) {
6023     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6024     if (message_arena != submessage_arena) {
6025       chrome_client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6026           message_arena, chrome_client_info, submessage_arena);
6027     }
6028     _has_bits_[0] |= 0x00000002u;
6029   } else {
6030     _has_bits_[0] &= ~0x00000002u;
6031   }
6032   chrome_client_info_ = chrome_client_info;
6033   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
6034 }
6035 
6036 // -------------------------------------------------------------------
6037 
6038 // FetchThreatListUpdatesResponse_ListUpdateResponse
6039 
6040 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
_internal_has_threat_type()6041 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_threat_type() const {
6042   bool value = (_has_bits_[0] & 0x00000004u) != 0;
6043   return value;
6044 }
has_threat_type()6045 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_type() const {
6046   return _internal_has_threat_type();
6047 }
clear_threat_type()6048 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_type() {
6049   threat_type_ = 0;
6050   _has_bits_[0] &= ~0x00000004u;
6051 }
_internal_threat_type()6052 inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_threat_type() const {
6053   return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
6054 }
threat_type()6055 inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_type() const {
6056   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type)
6057   return _internal_threat_type();
6058 }
_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value)6059 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
6060   assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
6061   _has_bits_[0] |= 0x00000004u;
6062   threat_type_ = value;
6063 }
set_threat_type(::mozilla::safebrowsing::ThreatType value)6064 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
6065   _internal_set_threat_type(value);
6066   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type)
6067 }
6068 
6069 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
_internal_has_threat_entry_type()6070 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_threat_entry_type() const {
6071   bool value = (_has_bits_[0] & 0x00000008u) != 0;
6072   return value;
6073 }
has_threat_entry_type()6074 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_entry_type() const {
6075   return _internal_has_threat_entry_type();
6076 }
clear_threat_entry_type()6077 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_entry_type() {
6078   threat_entry_type_ = 0;
6079   _has_bits_[0] &= ~0x00000008u;
6080 }
_internal_threat_entry_type()6081 inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_threat_entry_type() const {
6082   return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
6083 }
threat_entry_type()6084 inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_entry_type() const {
6085   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type)
6086   return _internal_threat_entry_type();
6087 }
_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)6088 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
6089   assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
6090   _has_bits_[0] |= 0x00000008u;
6091   threat_entry_type_ = value;
6092 }
set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)6093 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
6094   _internal_set_threat_entry_type(value);
6095   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type)
6096 }
6097 
6098 // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
_internal_has_platform_type()6099 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_platform_type() const {
6100   bool value = (_has_bits_[0] & 0x00000010u) != 0;
6101   return value;
6102 }
has_platform_type()6103 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_platform_type() const {
6104   return _internal_has_platform_type();
6105 }
clear_platform_type()6106 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_platform_type() {
6107   platform_type_ = 0;
6108   _has_bits_[0] &= ~0x00000010u;
6109 }
_internal_platform_type()6110 inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_platform_type() const {
6111   return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
6112 }
platform_type()6113 inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::platform_type() const {
6114   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type)
6115   return _internal_platform_type();
6116 }
_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value)6117 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
6118   assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
6119   _has_bits_[0] |= 0x00000010u;
6120   platform_type_ = value;
6121 }
set_platform_type(::mozilla::safebrowsing::PlatformType value)6122 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
6123   _internal_set_platform_type(value);
6124   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type)
6125 }
6126 
6127 // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
_internal_has_response_type()6128 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_response_type() const {
6129   bool value = (_has_bits_[0] & 0x00000020u) != 0;
6130   return value;
6131 }
has_response_type()6132 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_response_type() const {
6133   return _internal_has_response_type();
6134 }
clear_response_type()6135 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_response_type() {
6136   response_type_ = 0;
6137   _has_bits_[0] &= ~0x00000020u;
6138 }
_internal_response_type()6139 inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_response_type() const {
6140   return static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(response_type_);
6141 }
response_type()6142 inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::response_type() const {
6143   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type)
6144   return _internal_response_type();
6145 }
_internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value)6146 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) {
6147   assert(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value));
6148   _has_bits_[0] |= 0x00000020u;
6149   response_type_ = value;
6150 }
set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value)6151 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) {
6152   _internal_set_response_type(value);
6153   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type)
6154 }
6155 
6156 // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
_internal_additions_size()6157 inline int FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_additions_size() const {
6158   return additions_.size();
6159 }
additions_size()6160 inline int FetchThreatListUpdatesResponse_ListUpdateResponse::additions_size() const {
6161   return _internal_additions_size();
6162 }
clear_additions()6163 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_additions() {
6164   additions_.Clear();
6165 }
mutable_additions(int index)6166 inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions(int index) {
6167   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
6168   return additions_.Mutable(index);
6169 }
6170 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
mutable_additions()6171 FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions() {
6172   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
6173   return &additions_;
6174 }
_internal_additions(int index)6175 inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_additions(int index) const {
6176   return additions_.Get(index);
6177 }
additions(int index)6178 inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::additions(int index) const {
6179   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
6180   return _internal_additions(index);
6181 }
_internal_add_additions()6182 inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_add_additions() {
6183   return additions_.Add();
6184 }
add_additions()6185 inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_additions() {
6186   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
6187   return _internal_add_additions();
6188 }
6189 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
additions()6190 FetchThreatListUpdatesResponse_ListUpdateResponse::additions() const {
6191   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
6192   return additions_;
6193 }
6194 
6195 // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
_internal_removals_size()6196 inline int FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_removals_size() const {
6197   return removals_.size();
6198 }
removals_size()6199 inline int FetchThreatListUpdatesResponse_ListUpdateResponse::removals_size() const {
6200   return _internal_removals_size();
6201 }
clear_removals()6202 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_removals() {
6203   removals_.Clear();
6204 }
mutable_removals(int index)6205 inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals(int index) {
6206   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
6207   return removals_.Mutable(index);
6208 }
6209 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
mutable_removals()6210 FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals() {
6211   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
6212   return &removals_;
6213 }
_internal_removals(int index)6214 inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_removals(int index) const {
6215   return removals_.Get(index);
6216 }
removals(int index)6217 inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::removals(int index) const {
6218   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
6219   return _internal_removals(index);
6220 }
_internal_add_removals()6221 inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_add_removals() {
6222   return removals_.Add();
6223 }
add_removals()6224 inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_removals() {
6225   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
6226   return _internal_add_removals();
6227 }
6228 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
removals()6229 FetchThreatListUpdatesResponse_ListUpdateResponse::removals() const {
6230   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
6231   return removals_;
6232 }
6233 
6234 // optional bytes new_client_state = 7;
_internal_has_new_client_state()6235 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_new_client_state() const {
6236   bool value = (_has_bits_[0] & 0x00000001u) != 0;
6237   return value;
6238 }
has_new_client_state()6239 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_new_client_state() const {
6240   return _internal_has_new_client_state();
6241 }
clear_new_client_state()6242 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_new_client_state() {
6243   new_client_state_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6244   _has_bits_[0] &= ~0x00000001u;
6245 }
new_client_state()6246 inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::new_client_state() const {
6247   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6248   return _internal_new_client_state();
6249 }
set_new_client_state(const std::string & value)6250 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const std::string& value) {
6251   _internal_set_new_client_state(value);
6252   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6253 }
mutable_new_client_state()6254 inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_new_client_state() {
6255   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6256   return _internal_mutable_new_client_state();
6257 }
_internal_new_client_state()6258 inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_new_client_state() const {
6259   return new_client_state_.GetNoArena();
6260 }
_internal_set_new_client_state(const std::string & value)6261 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_new_client_state(const std::string& value) {
6262   _has_bits_[0] |= 0x00000001u;
6263   new_client_state_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6264 }
set_new_client_state(std::string && value)6265 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(std::string&& value) {
6266   _has_bits_[0] |= 0x00000001u;
6267   new_client_state_.SetNoArena(
6268     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6269   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6270 }
set_new_client_state(const char * value)6271 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const char* value) {
6272   GOOGLE_DCHECK(value != nullptr);
6273   _has_bits_[0] |= 0x00000001u;
6274   new_client_state_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6275   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6276 }
set_new_client_state(const void * value,size_t size)6277 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const void* value, size_t size) {
6278   _has_bits_[0] |= 0x00000001u;
6279   new_client_state_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6280       ::std::string(reinterpret_cast<const char*>(value), size));
6281   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6282 }
_internal_mutable_new_client_state()6283 inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_mutable_new_client_state() {
6284   _has_bits_[0] |= 0x00000001u;
6285   return new_client_state_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6286 }
release_new_client_state()6287 inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::release_new_client_state() {
6288   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6289   if (!_internal_has_new_client_state()) {
6290     return nullptr;
6291   }
6292   _has_bits_[0] &= ~0x00000001u;
6293   return new_client_state_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6294 }
set_allocated_new_client_state(std::string * new_client_state)6295 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_new_client_state(std::string* new_client_state) {
6296   if (new_client_state != nullptr) {
6297     _has_bits_[0] |= 0x00000001u;
6298   } else {
6299     _has_bits_[0] &= ~0x00000001u;
6300   }
6301   new_client_state_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), new_client_state);
6302   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
6303 }
6304 
6305 // optional .mozilla.safebrowsing.Checksum checksum = 8;
_internal_has_checksum()6306 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_checksum() const {
6307   bool value = (_has_bits_[0] & 0x00000002u) != 0;
6308   PROTOBUF_ASSUME(!value || checksum_ != nullptr);
6309   return value;
6310 }
has_checksum()6311 inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_checksum() const {
6312   return _internal_has_checksum();
6313 }
clear_checksum()6314 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_checksum() {
6315   if (checksum_ != nullptr) checksum_->Clear();
6316   _has_bits_[0] &= ~0x00000002u;
6317 }
_internal_checksum()6318 inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_checksum() const {
6319   const ::mozilla::safebrowsing::Checksum* p = checksum_;
6320   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::Checksum*>(
6321       &::mozilla::safebrowsing::_Checksum_default_instance_);
6322 }
checksum()6323 inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::checksum() const {
6324   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
6325   return _internal_checksum();
6326 }
release_checksum()6327 inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::release_checksum() {
6328   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
6329   _has_bits_[0] &= ~0x00000002u;
6330   ::mozilla::safebrowsing::Checksum* temp = checksum_;
6331   checksum_ = nullptr;
6332   return temp;
6333 }
_internal_mutable_checksum()6334 inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_mutable_checksum() {
6335   _has_bits_[0] |= 0x00000002u;
6336   if (checksum_ == nullptr) {
6337     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Checksum>(GetArenaNoVirtual());
6338     checksum_ = p;
6339   }
6340   return checksum_;
6341 }
mutable_checksum()6342 inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_checksum() {
6343   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
6344   return _internal_mutable_checksum();
6345 }
set_allocated_checksum(::mozilla::safebrowsing::Checksum * checksum)6346 inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum) {
6347   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6348   if (message_arena == nullptr) {
6349     delete checksum_;
6350   }
6351   if (checksum) {
6352     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6353     if (message_arena != submessage_arena) {
6354       checksum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6355           message_arena, checksum, submessage_arena);
6356     }
6357     _has_bits_[0] |= 0x00000002u;
6358   } else {
6359     _has_bits_[0] &= ~0x00000002u;
6360   }
6361   checksum_ = checksum;
6362   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
6363 }
6364 
6365 // -------------------------------------------------------------------
6366 
6367 // FetchThreatListUpdatesResponse
6368 
6369 // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
_internal_list_update_responses_size()6370 inline int FetchThreatListUpdatesResponse::_internal_list_update_responses_size() const {
6371   return list_update_responses_.size();
6372 }
list_update_responses_size()6373 inline int FetchThreatListUpdatesResponse::list_update_responses_size() const {
6374   return _internal_list_update_responses_size();
6375 }
clear_list_update_responses()6376 inline void FetchThreatListUpdatesResponse::clear_list_update_responses() {
6377   list_update_responses_.Clear();
6378 }
mutable_list_update_responses(int index)6379 inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::mutable_list_update_responses(int index) {
6380   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
6381   return list_update_responses_.Mutable(index);
6382 }
6383 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >*
mutable_list_update_responses()6384 FetchThreatListUpdatesResponse::mutable_list_update_responses() {
6385   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
6386   return &list_update_responses_;
6387 }
_internal_list_update_responses(int index)6388 inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::_internal_list_update_responses(int index) const {
6389   return list_update_responses_.Get(index);
6390 }
list_update_responses(int index)6391 inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::list_update_responses(int index) const {
6392   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
6393   return _internal_list_update_responses(index);
6394 }
_internal_add_list_update_responses()6395 inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::_internal_add_list_update_responses() {
6396   return list_update_responses_.Add();
6397 }
add_list_update_responses()6398 inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::add_list_update_responses() {
6399   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
6400   return _internal_add_list_update_responses();
6401 }
6402 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >&
list_update_responses()6403 FetchThreatListUpdatesResponse::list_update_responses() const {
6404   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
6405   return list_update_responses_;
6406 }
6407 
6408 // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
_internal_has_minimum_wait_duration()6409 inline bool FetchThreatListUpdatesResponse::_internal_has_minimum_wait_duration() const {
6410   bool value = (_has_bits_[0] & 0x00000001u) != 0;
6411   PROTOBUF_ASSUME(!value || minimum_wait_duration_ != nullptr);
6412   return value;
6413 }
has_minimum_wait_duration()6414 inline bool FetchThreatListUpdatesResponse::has_minimum_wait_duration() const {
6415   return _internal_has_minimum_wait_duration();
6416 }
clear_minimum_wait_duration()6417 inline void FetchThreatListUpdatesResponse::clear_minimum_wait_duration() {
6418   if (minimum_wait_duration_ != nullptr) minimum_wait_duration_->Clear();
6419   _has_bits_[0] &= ~0x00000001u;
6420 }
_internal_minimum_wait_duration()6421 inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::_internal_minimum_wait_duration() const {
6422   const ::mozilla::safebrowsing::Duration* p = minimum_wait_duration_;
6423   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::Duration*>(
6424       &::mozilla::safebrowsing::_Duration_default_instance_);
6425 }
minimum_wait_duration()6426 inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::minimum_wait_duration() const {
6427   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
6428   return _internal_minimum_wait_duration();
6429 }
release_minimum_wait_duration()6430 inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::release_minimum_wait_duration() {
6431   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
6432   _has_bits_[0] &= ~0x00000001u;
6433   ::mozilla::safebrowsing::Duration* temp = minimum_wait_duration_;
6434   minimum_wait_duration_ = nullptr;
6435   return temp;
6436 }
_internal_mutable_minimum_wait_duration()6437 inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::_internal_mutable_minimum_wait_duration() {
6438   _has_bits_[0] |= 0x00000001u;
6439   if (minimum_wait_duration_ == nullptr) {
6440     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaNoVirtual());
6441     minimum_wait_duration_ = p;
6442   }
6443   return minimum_wait_duration_;
6444 }
mutable_minimum_wait_duration()6445 inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::mutable_minimum_wait_duration() {
6446   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
6447   return _internal_mutable_minimum_wait_duration();
6448 }
set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration * minimum_wait_duration)6449 inline void FetchThreatListUpdatesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) {
6450   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6451   if (message_arena == nullptr) {
6452     delete minimum_wait_duration_;
6453   }
6454   if (minimum_wait_duration) {
6455     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6456     if (message_arena != submessage_arena) {
6457       minimum_wait_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6458           message_arena, minimum_wait_duration, submessage_arena);
6459     }
6460     _has_bits_[0] |= 0x00000001u;
6461   } else {
6462     _has_bits_[0] &= ~0x00000001u;
6463   }
6464   minimum_wait_duration_ = minimum_wait_duration;
6465   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
6466 }
6467 
6468 // -------------------------------------------------------------------
6469 
6470 // FindFullHashesRequest
6471 
6472 // optional .mozilla.safebrowsing.ClientInfo client = 1;
_internal_has_client()6473 inline bool FindFullHashesRequest::_internal_has_client() const {
6474   bool value = (_has_bits_[0] & 0x00000001u) != 0;
6475   PROTOBUF_ASSUME(!value || client_ != nullptr);
6476   return value;
6477 }
has_client()6478 inline bool FindFullHashesRequest::has_client() const {
6479   return _internal_has_client();
6480 }
clear_client()6481 inline void FindFullHashesRequest::clear_client() {
6482   if (client_ != nullptr) client_->Clear();
6483   _has_bits_[0] &= ~0x00000001u;
6484 }
_internal_client()6485 inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::_internal_client() const {
6486   const ::mozilla::safebrowsing::ClientInfo* p = client_;
6487   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo*>(
6488       &::mozilla::safebrowsing::_ClientInfo_default_instance_);
6489 }
client()6490 inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::client() const {
6491   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client)
6492   return _internal_client();
6493 }
release_client()6494 inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::release_client() {
6495   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesRequest.client)
6496   _has_bits_[0] &= ~0x00000001u;
6497   ::mozilla::safebrowsing::ClientInfo* temp = client_;
6498   client_ = nullptr;
6499   return temp;
6500 }
_internal_mutable_client()6501 inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::_internal_mutable_client() {
6502   _has_bits_[0] |= 0x00000001u;
6503   if (client_ == nullptr) {
6504     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaNoVirtual());
6505     client_ = p;
6506   }
6507   return client_;
6508 }
mutable_client()6509 inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::mutable_client() {
6510   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client)
6511   return _internal_mutable_client();
6512 }
set_allocated_client(::mozilla::safebrowsing::ClientInfo * client)6513 inline void FindFullHashesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
6514   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6515   if (message_arena == nullptr) {
6516     delete client_;
6517   }
6518   if (client) {
6519     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6520     if (message_arena != submessage_arena) {
6521       client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6522           message_arena, client, submessage_arena);
6523     }
6524     _has_bits_[0] |= 0x00000001u;
6525   } else {
6526     _has_bits_[0] &= ~0x00000001u;
6527   }
6528   client_ = client;
6529   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client)
6530 }
6531 
6532 // repeated bytes client_states = 2;
_internal_client_states_size()6533 inline int FindFullHashesRequest::_internal_client_states_size() const {
6534   return client_states_.size();
6535 }
client_states_size()6536 inline int FindFullHashesRequest::client_states_size() const {
6537   return _internal_client_states_size();
6538 }
clear_client_states()6539 inline void FindFullHashesRequest::clear_client_states() {
6540   client_states_.Clear();
6541 }
add_client_states()6542 inline std::string* FindFullHashesRequest::add_client_states() {
6543   // @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6544   return _internal_add_client_states();
6545 }
_internal_client_states(int index)6546 inline const std::string& FindFullHashesRequest::_internal_client_states(int index) const {
6547   return client_states_.Get(index);
6548 }
client_states(int index)6549 inline const std::string& FindFullHashesRequest::client_states(int index) const {
6550   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6551   return _internal_client_states(index);
6552 }
mutable_client_states(int index)6553 inline std::string* FindFullHashesRequest::mutable_client_states(int index) {
6554   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6555   return client_states_.Mutable(index);
6556 }
set_client_states(int index,const std::string & value)6557 inline void FindFullHashesRequest::set_client_states(int index, const std::string& value) {
6558   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6559   client_states_.Mutable(index)->assign(value);
6560 }
set_client_states(int index,std::string && value)6561 inline void FindFullHashesRequest::set_client_states(int index, std::string&& value) {
6562   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6563   client_states_.Mutable(index)->assign(std::move(value));
6564 }
set_client_states(int index,const char * value)6565 inline void FindFullHashesRequest::set_client_states(int index, const char* value) {
6566   GOOGLE_DCHECK(value != nullptr);
6567   client_states_.Mutable(index)->assign(value);
6568   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6569 }
set_client_states(int index,const void * value,size_t size)6570 inline void FindFullHashesRequest::set_client_states(int index, const void* value, size_t size) {
6571   client_states_.Mutable(index)->assign(
6572     reinterpret_cast<const char*>(value), size);
6573   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6574 }
_internal_add_client_states()6575 inline std::string* FindFullHashesRequest::_internal_add_client_states() {
6576   return client_states_.Add();
6577 }
add_client_states(const std::string & value)6578 inline void FindFullHashesRequest::add_client_states(const std::string& value) {
6579   client_states_.Add()->assign(value);
6580   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6581 }
add_client_states(std::string && value)6582 inline void FindFullHashesRequest::add_client_states(std::string&& value) {
6583   client_states_.Add(std::move(value));
6584   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6585 }
add_client_states(const char * value)6586 inline void FindFullHashesRequest::add_client_states(const char* value) {
6587   GOOGLE_DCHECK(value != nullptr);
6588   client_states_.Add()->assign(value);
6589   // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6590 }
add_client_states(const void * value,size_t size)6591 inline void FindFullHashesRequest::add_client_states(const void* value, size_t size) {
6592   client_states_.Add()->assign(reinterpret_cast<const char*>(value), size);
6593   // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6594 }
6595 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
client_states()6596 FindFullHashesRequest::client_states() const {
6597   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6598   return client_states_;
6599 }
6600 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_client_states()6601 FindFullHashesRequest::mutable_client_states() {
6602   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesRequest.client_states)
6603   return &client_states_;
6604 }
6605 
6606 // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
_internal_has_threat_info()6607 inline bool FindFullHashesRequest::_internal_has_threat_info() const {
6608   bool value = (_has_bits_[0] & 0x00000002u) != 0;
6609   PROTOBUF_ASSUME(!value || threat_info_ != nullptr);
6610   return value;
6611 }
has_threat_info()6612 inline bool FindFullHashesRequest::has_threat_info() const {
6613   return _internal_has_threat_info();
6614 }
clear_threat_info()6615 inline void FindFullHashesRequest::clear_threat_info() {
6616   if (threat_info_ != nullptr) threat_info_->Clear();
6617   _has_bits_[0] &= ~0x00000002u;
6618 }
_internal_threat_info()6619 inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::_internal_threat_info() const {
6620   const ::mozilla::safebrowsing::ThreatInfo* p = threat_info_;
6621   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ThreatInfo*>(
6622       &::mozilla::safebrowsing::_ThreatInfo_default_instance_);
6623 }
threat_info()6624 inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::threat_info() const {
6625   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
6626   return _internal_threat_info();
6627 }
release_threat_info()6628 inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::release_threat_info() {
6629   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
6630   _has_bits_[0] &= ~0x00000002u;
6631   ::mozilla::safebrowsing::ThreatInfo* temp = threat_info_;
6632   threat_info_ = nullptr;
6633   return temp;
6634 }
_internal_mutable_threat_info()6635 inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::_internal_mutable_threat_info() {
6636   _has_bits_[0] |= 0x00000002u;
6637   if (threat_info_ == nullptr) {
6638     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(GetArenaNoVirtual());
6639     threat_info_ = p;
6640   }
6641   return threat_info_;
6642 }
mutable_threat_info()6643 inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::mutable_threat_info() {
6644   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
6645   return _internal_mutable_threat_info();
6646 }
set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo * threat_info)6647 inline void FindFullHashesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) {
6648   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6649   if (message_arena == nullptr) {
6650     delete threat_info_;
6651   }
6652   if (threat_info) {
6653     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6654     if (message_arena != submessage_arena) {
6655       threat_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6656           message_arena, threat_info, submessage_arena);
6657     }
6658     _has_bits_[0] |= 0x00000002u;
6659   } else {
6660     _has_bits_[0] &= ~0x00000002u;
6661   }
6662   threat_info_ = threat_info;
6663   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
6664 }
6665 
6666 // -------------------------------------------------------------------
6667 
6668 // FindFullHashesResponse
6669 
6670 // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
_internal_matches_size()6671 inline int FindFullHashesResponse::_internal_matches_size() const {
6672   return matches_.size();
6673 }
matches_size()6674 inline int FindFullHashesResponse::matches_size() const {
6675   return _internal_matches_size();
6676 }
clear_matches()6677 inline void FindFullHashesResponse::clear_matches() {
6678   matches_.Clear();
6679 }
mutable_matches(int index)6680 inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::mutable_matches(int index) {
6681   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.matches)
6682   return matches_.Mutable(index);
6683 }
6684 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
mutable_matches()6685 FindFullHashesResponse::mutable_matches() {
6686   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesResponse.matches)
6687   return &matches_;
6688 }
_internal_matches(int index)6689 inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::_internal_matches(int index) const {
6690   return matches_.Get(index);
6691 }
matches(int index)6692 inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::matches(int index) const {
6693   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.matches)
6694   return _internal_matches(index);
6695 }
_internal_add_matches()6696 inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::_internal_add_matches() {
6697   return matches_.Add();
6698 }
add_matches()6699 inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::add_matches() {
6700   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesResponse.matches)
6701   return _internal_add_matches();
6702 }
6703 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
matches()6704 FindFullHashesResponse::matches() const {
6705   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesResponse.matches)
6706   return matches_;
6707 }
6708 
6709 // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
_internal_has_minimum_wait_duration()6710 inline bool FindFullHashesResponse::_internal_has_minimum_wait_duration() const {
6711   bool value = (_has_bits_[0] & 0x00000001u) != 0;
6712   PROTOBUF_ASSUME(!value || minimum_wait_duration_ != nullptr);
6713   return value;
6714 }
has_minimum_wait_duration()6715 inline bool FindFullHashesResponse::has_minimum_wait_duration() const {
6716   return _internal_has_minimum_wait_duration();
6717 }
clear_minimum_wait_duration()6718 inline void FindFullHashesResponse::clear_minimum_wait_duration() {
6719   if (minimum_wait_duration_ != nullptr) minimum_wait_duration_->Clear();
6720   _has_bits_[0] &= ~0x00000001u;
6721 }
_internal_minimum_wait_duration()6722 inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::_internal_minimum_wait_duration() const {
6723   const ::mozilla::safebrowsing::Duration* p = minimum_wait_duration_;
6724   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::Duration*>(
6725       &::mozilla::safebrowsing::_Duration_default_instance_);
6726 }
minimum_wait_duration()6727 inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::minimum_wait_duration() const {
6728   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
6729   return _internal_minimum_wait_duration();
6730 }
release_minimum_wait_duration()6731 inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_minimum_wait_duration() {
6732   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
6733   _has_bits_[0] &= ~0x00000001u;
6734   ::mozilla::safebrowsing::Duration* temp = minimum_wait_duration_;
6735   minimum_wait_duration_ = nullptr;
6736   return temp;
6737 }
_internal_mutable_minimum_wait_duration()6738 inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::_internal_mutable_minimum_wait_duration() {
6739   _has_bits_[0] |= 0x00000001u;
6740   if (minimum_wait_duration_ == nullptr) {
6741     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaNoVirtual());
6742     minimum_wait_duration_ = p;
6743   }
6744   return minimum_wait_duration_;
6745 }
mutable_minimum_wait_duration()6746 inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_minimum_wait_duration() {
6747   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
6748   return _internal_mutable_minimum_wait_duration();
6749 }
set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration * minimum_wait_duration)6750 inline void FindFullHashesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) {
6751   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6752   if (message_arena == nullptr) {
6753     delete minimum_wait_duration_;
6754   }
6755   if (minimum_wait_duration) {
6756     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6757     if (message_arena != submessage_arena) {
6758       minimum_wait_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6759           message_arena, minimum_wait_duration, submessage_arena);
6760     }
6761     _has_bits_[0] |= 0x00000001u;
6762   } else {
6763     _has_bits_[0] &= ~0x00000001u;
6764   }
6765   minimum_wait_duration_ = minimum_wait_duration;
6766   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
6767 }
6768 
6769 // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
_internal_has_negative_cache_duration()6770 inline bool FindFullHashesResponse::_internal_has_negative_cache_duration() const {
6771   bool value = (_has_bits_[0] & 0x00000002u) != 0;
6772   PROTOBUF_ASSUME(!value || negative_cache_duration_ != nullptr);
6773   return value;
6774 }
has_negative_cache_duration()6775 inline bool FindFullHashesResponse::has_negative_cache_duration() const {
6776   return _internal_has_negative_cache_duration();
6777 }
clear_negative_cache_duration()6778 inline void FindFullHashesResponse::clear_negative_cache_duration() {
6779   if (negative_cache_duration_ != nullptr) negative_cache_duration_->Clear();
6780   _has_bits_[0] &= ~0x00000002u;
6781 }
_internal_negative_cache_duration()6782 inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::_internal_negative_cache_duration() const {
6783   const ::mozilla::safebrowsing::Duration* p = negative_cache_duration_;
6784   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::Duration*>(
6785       &::mozilla::safebrowsing::_Duration_default_instance_);
6786 }
negative_cache_duration()6787 inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::negative_cache_duration() const {
6788   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
6789   return _internal_negative_cache_duration();
6790 }
release_negative_cache_duration()6791 inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_negative_cache_duration() {
6792   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
6793   _has_bits_[0] &= ~0x00000002u;
6794   ::mozilla::safebrowsing::Duration* temp = negative_cache_duration_;
6795   negative_cache_duration_ = nullptr;
6796   return temp;
6797 }
_internal_mutable_negative_cache_duration()6798 inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::_internal_mutable_negative_cache_duration() {
6799   _has_bits_[0] |= 0x00000002u;
6800   if (negative_cache_duration_ == nullptr) {
6801     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaNoVirtual());
6802     negative_cache_duration_ = p;
6803   }
6804   return negative_cache_duration_;
6805 }
mutable_negative_cache_duration()6806 inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_negative_cache_duration() {
6807   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
6808   return _internal_mutable_negative_cache_duration();
6809 }
set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration * negative_cache_duration)6810 inline void FindFullHashesResponse::set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration) {
6811   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6812   if (message_arena == nullptr) {
6813     delete negative_cache_duration_;
6814   }
6815   if (negative_cache_duration) {
6816     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6817     if (message_arena != submessage_arena) {
6818       negative_cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6819           message_arena, negative_cache_duration, submessage_arena);
6820     }
6821     _has_bits_[0] |= 0x00000002u;
6822   } else {
6823     _has_bits_[0] &= ~0x00000002u;
6824   }
6825   negative_cache_duration_ = negative_cache_duration;
6826   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
6827 }
6828 
6829 // -------------------------------------------------------------------
6830 
6831 // ThreatHit_ThreatSource
6832 
6833 // optional string url = 1;
_internal_has_url()6834 inline bool ThreatHit_ThreatSource::_internal_has_url() const {
6835   bool value = (_has_bits_[0] & 0x00000001u) != 0;
6836   return value;
6837 }
has_url()6838 inline bool ThreatHit_ThreatSource::has_url() const {
6839   return _internal_has_url();
6840 }
clear_url()6841 inline void ThreatHit_ThreatSource::clear_url() {
6842   url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6843   _has_bits_[0] &= ~0x00000001u;
6844 }
url()6845 inline const std::string& ThreatHit_ThreatSource::url() const {
6846   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6847   return _internal_url();
6848 }
set_url(const std::string & value)6849 inline void ThreatHit_ThreatSource::set_url(const std::string& value) {
6850   _internal_set_url(value);
6851   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6852 }
mutable_url()6853 inline std::string* ThreatHit_ThreatSource::mutable_url() {
6854   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6855   return _internal_mutable_url();
6856 }
_internal_url()6857 inline const std::string& ThreatHit_ThreatSource::_internal_url() const {
6858   return url_.GetNoArena();
6859 }
_internal_set_url(const std::string & value)6860 inline void ThreatHit_ThreatSource::_internal_set_url(const std::string& value) {
6861   _has_bits_[0] |= 0x00000001u;
6862   url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6863 }
set_url(std::string && value)6864 inline void ThreatHit_ThreatSource::set_url(std::string&& value) {
6865   _has_bits_[0] |= 0x00000001u;
6866   url_.SetNoArena(
6867     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6868   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6869 }
set_url(const char * value)6870 inline void ThreatHit_ThreatSource::set_url(const char* value) {
6871   GOOGLE_DCHECK(value != nullptr);
6872   _has_bits_[0] |= 0x00000001u;
6873   url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6874   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6875 }
set_url(const char * value,size_t size)6876 inline void ThreatHit_ThreatSource::set_url(const char* value, size_t size) {
6877   _has_bits_[0] |= 0x00000001u;
6878   url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6879       ::std::string(reinterpret_cast<const char*>(value), size));
6880   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6881 }
_internal_mutable_url()6882 inline std::string* ThreatHit_ThreatSource::_internal_mutable_url() {
6883   _has_bits_[0] |= 0x00000001u;
6884   return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6885 }
release_url()6886 inline std::string* ThreatHit_ThreatSource::release_url() {
6887   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6888   if (!_internal_has_url()) {
6889     return nullptr;
6890   }
6891   _has_bits_[0] &= ~0x00000001u;
6892   return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6893 }
set_allocated_url(std::string * url)6894 inline void ThreatHit_ThreatSource::set_allocated_url(std::string* url) {
6895   if (url != nullptr) {
6896     _has_bits_[0] |= 0x00000001u;
6897   } else {
6898     _has_bits_[0] &= ~0x00000001u;
6899   }
6900   url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url);
6901   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
6902 }
6903 
6904 // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
_internal_has_type()6905 inline bool ThreatHit_ThreatSource::_internal_has_type() const {
6906   bool value = (_has_bits_[0] & 0x00000008u) != 0;
6907   return value;
6908 }
has_type()6909 inline bool ThreatHit_ThreatSource::has_type() const {
6910   return _internal_has_type();
6911 }
clear_type()6912 inline void ThreatHit_ThreatSource::clear_type() {
6913   type_ = 0;
6914   _has_bits_[0] &= ~0x00000008u;
6915 }
_internal_type()6916 inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::_internal_type() const {
6917   return static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(type_);
6918 }
type()6919 inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::type() const {
6920   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.type)
6921   return _internal_type();
6922 }
_internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value)6923 inline void ThreatHit_ThreatSource::_internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) {
6924   assert(::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value));
6925   _has_bits_[0] |= 0x00000008u;
6926   type_ = value;
6927 }
set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value)6928 inline void ThreatHit_ThreatSource::set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) {
6929   _internal_set_type(value);
6930   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.type)
6931 }
6932 
6933 // optional string remote_ip = 3;
_internal_has_remote_ip()6934 inline bool ThreatHit_ThreatSource::_internal_has_remote_ip() const {
6935   bool value = (_has_bits_[0] & 0x00000002u) != 0;
6936   return value;
6937 }
has_remote_ip()6938 inline bool ThreatHit_ThreatSource::has_remote_ip() const {
6939   return _internal_has_remote_ip();
6940 }
clear_remote_ip()6941 inline void ThreatHit_ThreatSource::clear_remote_ip() {
6942   remote_ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6943   _has_bits_[0] &= ~0x00000002u;
6944 }
remote_ip()6945 inline const std::string& ThreatHit_ThreatSource::remote_ip() const {
6946   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6947   return _internal_remote_ip();
6948 }
set_remote_ip(const std::string & value)6949 inline void ThreatHit_ThreatSource::set_remote_ip(const std::string& value) {
6950   _internal_set_remote_ip(value);
6951   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6952 }
mutable_remote_ip()6953 inline std::string* ThreatHit_ThreatSource::mutable_remote_ip() {
6954   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6955   return _internal_mutable_remote_ip();
6956 }
_internal_remote_ip()6957 inline const std::string& ThreatHit_ThreatSource::_internal_remote_ip() const {
6958   return remote_ip_.GetNoArena();
6959 }
_internal_set_remote_ip(const std::string & value)6960 inline void ThreatHit_ThreatSource::_internal_set_remote_ip(const std::string& value) {
6961   _has_bits_[0] |= 0x00000002u;
6962   remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6963 }
set_remote_ip(std::string && value)6964 inline void ThreatHit_ThreatSource::set_remote_ip(std::string&& value) {
6965   _has_bits_[0] |= 0x00000002u;
6966   remote_ip_.SetNoArena(
6967     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6968   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6969 }
set_remote_ip(const char * value)6970 inline void ThreatHit_ThreatSource::set_remote_ip(const char* value) {
6971   GOOGLE_DCHECK(value != nullptr);
6972   _has_bits_[0] |= 0x00000002u;
6973   remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6974   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6975 }
set_remote_ip(const char * value,size_t size)6976 inline void ThreatHit_ThreatSource::set_remote_ip(const char* value, size_t size) {
6977   _has_bits_[0] |= 0x00000002u;
6978   remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6979       ::std::string(reinterpret_cast<const char*>(value), size));
6980   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6981 }
_internal_mutable_remote_ip()6982 inline std::string* ThreatHit_ThreatSource::_internal_mutable_remote_ip() {
6983   _has_bits_[0] |= 0x00000002u;
6984   return remote_ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6985 }
release_remote_ip()6986 inline std::string* ThreatHit_ThreatSource::release_remote_ip() {
6987   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
6988   if (!_internal_has_remote_ip()) {
6989     return nullptr;
6990   }
6991   _has_bits_[0] &= ~0x00000002u;
6992   return remote_ip_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6993 }
set_allocated_remote_ip(std::string * remote_ip)6994 inline void ThreatHit_ThreatSource::set_allocated_remote_ip(std::string* remote_ip) {
6995   if (remote_ip != nullptr) {
6996     _has_bits_[0] |= 0x00000002u;
6997   } else {
6998     _has_bits_[0] &= ~0x00000002u;
6999   }
7000   remote_ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), remote_ip);
7001   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
7002 }
7003 
7004 // optional string referrer = 4;
_internal_has_referrer()7005 inline bool ThreatHit_ThreatSource::_internal_has_referrer() const {
7006   bool value = (_has_bits_[0] & 0x00000004u) != 0;
7007   return value;
7008 }
has_referrer()7009 inline bool ThreatHit_ThreatSource::has_referrer() const {
7010   return _internal_has_referrer();
7011 }
clear_referrer()7012 inline void ThreatHit_ThreatSource::clear_referrer() {
7013   referrer_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7014   _has_bits_[0] &= ~0x00000004u;
7015 }
referrer()7016 inline const std::string& ThreatHit_ThreatSource::referrer() const {
7017   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7018   return _internal_referrer();
7019 }
set_referrer(const std::string & value)7020 inline void ThreatHit_ThreatSource::set_referrer(const std::string& value) {
7021   _internal_set_referrer(value);
7022   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7023 }
mutable_referrer()7024 inline std::string* ThreatHit_ThreatSource::mutable_referrer() {
7025   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7026   return _internal_mutable_referrer();
7027 }
_internal_referrer()7028 inline const std::string& ThreatHit_ThreatSource::_internal_referrer() const {
7029   return referrer_.GetNoArena();
7030 }
_internal_set_referrer(const std::string & value)7031 inline void ThreatHit_ThreatSource::_internal_set_referrer(const std::string& value) {
7032   _has_bits_[0] |= 0x00000004u;
7033   referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7034 }
set_referrer(std::string && value)7035 inline void ThreatHit_ThreatSource::set_referrer(std::string&& value) {
7036   _has_bits_[0] |= 0x00000004u;
7037   referrer_.SetNoArena(
7038     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7039   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7040 }
set_referrer(const char * value)7041 inline void ThreatHit_ThreatSource::set_referrer(const char* value) {
7042   GOOGLE_DCHECK(value != nullptr);
7043   _has_bits_[0] |= 0x00000004u;
7044   referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7045   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7046 }
set_referrer(const char * value,size_t size)7047 inline void ThreatHit_ThreatSource::set_referrer(const char* value, size_t size) {
7048   _has_bits_[0] |= 0x00000004u;
7049   referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7050       ::std::string(reinterpret_cast<const char*>(value), size));
7051   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7052 }
_internal_mutable_referrer()7053 inline std::string* ThreatHit_ThreatSource::_internal_mutable_referrer() {
7054   _has_bits_[0] |= 0x00000004u;
7055   return referrer_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7056 }
release_referrer()7057 inline std::string* ThreatHit_ThreatSource::release_referrer() {
7058   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7059   if (!_internal_has_referrer()) {
7060     return nullptr;
7061   }
7062   _has_bits_[0] &= ~0x00000004u;
7063   return referrer_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7064 }
set_allocated_referrer(std::string * referrer)7065 inline void ThreatHit_ThreatSource::set_allocated_referrer(std::string* referrer) {
7066   if (referrer != nullptr) {
7067     _has_bits_[0] |= 0x00000004u;
7068   } else {
7069     _has_bits_[0] &= ~0x00000004u;
7070   }
7071   referrer_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer);
7072   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
7073 }
7074 
7075 // -------------------------------------------------------------------
7076 
7077 // ThreatHit_UserInfo
7078 
7079 // optional string region_code = 1;
_internal_has_region_code()7080 inline bool ThreatHit_UserInfo::_internal_has_region_code() const {
7081   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7082   return value;
7083 }
has_region_code()7084 inline bool ThreatHit_UserInfo::has_region_code() const {
7085   return _internal_has_region_code();
7086 }
clear_region_code()7087 inline void ThreatHit_UserInfo::clear_region_code() {
7088   region_code_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7089   _has_bits_[0] &= ~0x00000001u;
7090 }
region_code()7091 inline const std::string& ThreatHit_UserInfo::region_code() const {
7092   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7093   return _internal_region_code();
7094 }
set_region_code(const std::string & value)7095 inline void ThreatHit_UserInfo::set_region_code(const std::string& value) {
7096   _internal_set_region_code(value);
7097   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7098 }
mutable_region_code()7099 inline std::string* ThreatHit_UserInfo::mutable_region_code() {
7100   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7101   return _internal_mutable_region_code();
7102 }
_internal_region_code()7103 inline const std::string& ThreatHit_UserInfo::_internal_region_code() const {
7104   return region_code_.GetNoArena();
7105 }
_internal_set_region_code(const std::string & value)7106 inline void ThreatHit_UserInfo::_internal_set_region_code(const std::string& value) {
7107   _has_bits_[0] |= 0x00000001u;
7108   region_code_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7109 }
set_region_code(std::string && value)7110 inline void ThreatHit_UserInfo::set_region_code(std::string&& value) {
7111   _has_bits_[0] |= 0x00000001u;
7112   region_code_.SetNoArena(
7113     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7114   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7115 }
set_region_code(const char * value)7116 inline void ThreatHit_UserInfo::set_region_code(const char* value) {
7117   GOOGLE_DCHECK(value != nullptr);
7118   _has_bits_[0] |= 0x00000001u;
7119   region_code_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7120   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7121 }
set_region_code(const char * value,size_t size)7122 inline void ThreatHit_UserInfo::set_region_code(const char* value, size_t size) {
7123   _has_bits_[0] |= 0x00000001u;
7124   region_code_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7125       ::std::string(reinterpret_cast<const char*>(value), size));
7126   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7127 }
_internal_mutable_region_code()7128 inline std::string* ThreatHit_UserInfo::_internal_mutable_region_code() {
7129   _has_bits_[0] |= 0x00000001u;
7130   return region_code_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7131 }
release_region_code()7132 inline std::string* ThreatHit_UserInfo::release_region_code() {
7133   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7134   if (!_internal_has_region_code()) {
7135     return nullptr;
7136   }
7137   _has_bits_[0] &= ~0x00000001u;
7138   return region_code_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7139 }
set_allocated_region_code(std::string * region_code)7140 inline void ThreatHit_UserInfo::set_allocated_region_code(std::string* region_code) {
7141   if (region_code != nullptr) {
7142     _has_bits_[0] |= 0x00000001u;
7143   } else {
7144     _has_bits_[0] &= ~0x00000001u;
7145   }
7146   region_code_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), region_code);
7147   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
7148 }
7149 
7150 // optional bytes user_id = 2;
_internal_has_user_id()7151 inline bool ThreatHit_UserInfo::_internal_has_user_id() const {
7152   bool value = (_has_bits_[0] & 0x00000002u) != 0;
7153   return value;
7154 }
has_user_id()7155 inline bool ThreatHit_UserInfo::has_user_id() const {
7156   return _internal_has_user_id();
7157 }
clear_user_id()7158 inline void ThreatHit_UserInfo::clear_user_id() {
7159   user_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7160   _has_bits_[0] &= ~0x00000002u;
7161 }
user_id()7162 inline const std::string& ThreatHit_UserInfo::user_id() const {
7163   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7164   return _internal_user_id();
7165 }
set_user_id(const std::string & value)7166 inline void ThreatHit_UserInfo::set_user_id(const std::string& value) {
7167   _internal_set_user_id(value);
7168   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7169 }
mutable_user_id()7170 inline std::string* ThreatHit_UserInfo::mutable_user_id() {
7171   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7172   return _internal_mutable_user_id();
7173 }
_internal_user_id()7174 inline const std::string& ThreatHit_UserInfo::_internal_user_id() const {
7175   return user_id_.GetNoArena();
7176 }
_internal_set_user_id(const std::string & value)7177 inline void ThreatHit_UserInfo::_internal_set_user_id(const std::string& value) {
7178   _has_bits_[0] |= 0x00000002u;
7179   user_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7180 }
set_user_id(std::string && value)7181 inline void ThreatHit_UserInfo::set_user_id(std::string&& value) {
7182   _has_bits_[0] |= 0x00000002u;
7183   user_id_.SetNoArena(
7184     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7185   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7186 }
set_user_id(const char * value)7187 inline void ThreatHit_UserInfo::set_user_id(const char* value) {
7188   GOOGLE_DCHECK(value != nullptr);
7189   _has_bits_[0] |= 0x00000002u;
7190   user_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7191   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7192 }
set_user_id(const void * value,size_t size)7193 inline void ThreatHit_UserInfo::set_user_id(const void* value, size_t size) {
7194   _has_bits_[0] |= 0x00000002u;
7195   user_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7196       ::std::string(reinterpret_cast<const char*>(value), size));
7197   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7198 }
_internal_mutable_user_id()7199 inline std::string* ThreatHit_UserInfo::_internal_mutable_user_id() {
7200   _has_bits_[0] |= 0x00000002u;
7201   return user_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7202 }
release_user_id()7203 inline std::string* ThreatHit_UserInfo::release_user_id() {
7204   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7205   if (!_internal_has_user_id()) {
7206     return nullptr;
7207   }
7208   _has_bits_[0] &= ~0x00000002u;
7209   return user_id_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7210 }
set_allocated_user_id(std::string * user_id)7211 inline void ThreatHit_UserInfo::set_allocated_user_id(std::string* user_id) {
7212   if (user_id != nullptr) {
7213     _has_bits_[0] |= 0x00000002u;
7214   } else {
7215     _has_bits_[0] &= ~0x00000002u;
7216   }
7217   user_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), user_id);
7218   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
7219 }
7220 
7221 // -------------------------------------------------------------------
7222 
7223 // ThreatHit
7224 
7225 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
_internal_has_threat_type()7226 inline bool ThreatHit::_internal_has_threat_type() const {
7227   bool value = (_has_bits_[0] & 0x00000008u) != 0;
7228   return value;
7229 }
has_threat_type()7230 inline bool ThreatHit::has_threat_type() const {
7231   return _internal_has_threat_type();
7232 }
clear_threat_type()7233 inline void ThreatHit::clear_threat_type() {
7234   threat_type_ = 0;
7235   _has_bits_[0] &= ~0x00000008u;
7236 }
_internal_threat_type()7237 inline ::mozilla::safebrowsing::ThreatType ThreatHit::_internal_threat_type() const {
7238   return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
7239 }
threat_type()7240 inline ::mozilla::safebrowsing::ThreatType ThreatHit::threat_type() const {
7241   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.threat_type)
7242   return _internal_threat_type();
7243 }
_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value)7244 inline void ThreatHit::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
7245   assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
7246   _has_bits_[0] |= 0x00000008u;
7247   threat_type_ = value;
7248 }
set_threat_type(::mozilla::safebrowsing::ThreatType value)7249 inline void ThreatHit::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
7250   _internal_set_threat_type(value);
7251   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.threat_type)
7252 }
7253 
7254 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
_internal_has_platform_type()7255 inline bool ThreatHit::_internal_has_platform_type() const {
7256   bool value = (_has_bits_[0] & 0x00000010u) != 0;
7257   return value;
7258 }
has_platform_type()7259 inline bool ThreatHit::has_platform_type() const {
7260   return _internal_has_platform_type();
7261 }
clear_platform_type()7262 inline void ThreatHit::clear_platform_type() {
7263   platform_type_ = 0;
7264   _has_bits_[0] &= ~0x00000010u;
7265 }
_internal_platform_type()7266 inline ::mozilla::safebrowsing::PlatformType ThreatHit::_internal_platform_type() const {
7267   return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
7268 }
platform_type()7269 inline ::mozilla::safebrowsing::PlatformType ThreatHit::platform_type() const {
7270   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.platform_type)
7271   return _internal_platform_type();
7272 }
_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value)7273 inline void ThreatHit::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
7274   assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
7275   _has_bits_[0] |= 0x00000010u;
7276   platform_type_ = value;
7277 }
set_platform_type(::mozilla::safebrowsing::PlatformType value)7278 inline void ThreatHit::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
7279   _internal_set_platform_type(value);
7280   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.platform_type)
7281 }
7282 
7283 // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
_internal_has_entry()7284 inline bool ThreatHit::_internal_has_entry() const {
7285   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7286   PROTOBUF_ASSUME(!value || entry_ != nullptr);
7287   return value;
7288 }
has_entry()7289 inline bool ThreatHit::has_entry() const {
7290   return _internal_has_entry();
7291 }
clear_entry()7292 inline void ThreatHit::clear_entry() {
7293   if (entry_ != nullptr) entry_->Clear();
7294   _has_bits_[0] &= ~0x00000001u;
7295 }
_internal_entry()7296 inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::_internal_entry() const {
7297   const ::mozilla::safebrowsing::ThreatEntry* p = entry_;
7298   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntry*>(
7299       &::mozilla::safebrowsing::_ThreatEntry_default_instance_);
7300 }
entry()7301 inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::entry() const {
7302   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.entry)
7303   return _internal_entry();
7304 }
release_entry()7305 inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::release_entry() {
7306   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.entry)
7307   _has_bits_[0] &= ~0x00000001u;
7308   ::mozilla::safebrowsing::ThreatEntry* temp = entry_;
7309   entry_ = nullptr;
7310   return temp;
7311 }
_internal_mutable_entry()7312 inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::_internal_mutable_entry() {
7313   _has_bits_[0] |= 0x00000001u;
7314   if (entry_ == nullptr) {
7315     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(GetArenaNoVirtual());
7316     entry_ = p;
7317   }
7318   return entry_;
7319 }
mutable_entry()7320 inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::mutable_entry() {
7321   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.entry)
7322   return _internal_mutable_entry();
7323 }
set_allocated_entry(::mozilla::safebrowsing::ThreatEntry * entry)7324 inline void ThreatHit::set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry) {
7325   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
7326   if (message_arena == nullptr) {
7327     delete entry_;
7328   }
7329   if (entry) {
7330     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
7331     if (message_arena != submessage_arena) {
7332       entry = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7333           message_arena, entry, submessage_arena);
7334     }
7335     _has_bits_[0] |= 0x00000001u;
7336   } else {
7337     _has_bits_[0] &= ~0x00000001u;
7338   }
7339   entry_ = entry;
7340   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.entry)
7341 }
7342 
7343 // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
_internal_resources_size()7344 inline int ThreatHit::_internal_resources_size() const {
7345   return resources_.size();
7346 }
resources_size()7347 inline int ThreatHit::resources_size() const {
7348   return _internal_resources_size();
7349 }
clear_resources()7350 inline void ThreatHit::clear_resources() {
7351   resources_.Clear();
7352 }
mutable_resources(int index)7353 inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::mutable_resources(int index) {
7354   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.resources)
7355   return resources_.Mutable(index);
7356 }
7357 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >*
mutable_resources()7358 ThreatHit::mutable_resources() {
7359   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatHit.resources)
7360   return &resources_;
7361 }
_internal_resources(int index)7362 inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::_internal_resources(int index) const {
7363   return resources_.Get(index);
7364 }
resources(int index)7365 inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::resources(int index) const {
7366   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.resources)
7367   return _internal_resources(index);
7368 }
_internal_add_resources()7369 inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::_internal_add_resources() {
7370   return resources_.Add();
7371 }
add_resources()7372 inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::add_resources() {
7373   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatHit.resources)
7374   return _internal_add_resources();
7375 }
7376 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >&
resources()7377 ThreatHit::resources() const {
7378   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatHit.resources)
7379   return resources_;
7380 }
7381 
7382 // optional .mozilla.safebrowsing.ClientInfo client_info = 5;
_internal_has_client_info()7383 inline bool ThreatHit::_internal_has_client_info() const {
7384   bool value = (_has_bits_[0] & 0x00000002u) != 0;
7385   PROTOBUF_ASSUME(!value || client_info_ != nullptr);
7386   return value;
7387 }
has_client_info()7388 inline bool ThreatHit::has_client_info() const {
7389   return _internal_has_client_info();
7390 }
clear_client_info()7391 inline void ThreatHit::clear_client_info() {
7392   if (client_info_ != nullptr) client_info_->Clear();
7393   _has_bits_[0] &= ~0x00000002u;
7394 }
_internal_client_info()7395 inline const ::mozilla::safebrowsing::ClientInfo& ThreatHit::_internal_client_info() const {
7396   const ::mozilla::safebrowsing::ClientInfo* p = client_info_;
7397   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo*>(
7398       &::mozilla::safebrowsing::_ClientInfo_default_instance_);
7399 }
client_info()7400 inline const ::mozilla::safebrowsing::ClientInfo& ThreatHit::client_info() const {
7401   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.client_info)
7402   return _internal_client_info();
7403 }
release_client_info()7404 inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::release_client_info() {
7405   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.client_info)
7406   _has_bits_[0] &= ~0x00000002u;
7407   ::mozilla::safebrowsing::ClientInfo* temp = client_info_;
7408   client_info_ = nullptr;
7409   return temp;
7410 }
_internal_mutable_client_info()7411 inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::_internal_mutable_client_info() {
7412   _has_bits_[0] |= 0x00000002u;
7413   if (client_info_ == nullptr) {
7414     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaNoVirtual());
7415     client_info_ = p;
7416   }
7417   return client_info_;
7418 }
mutable_client_info()7419 inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::mutable_client_info() {
7420   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.client_info)
7421   return _internal_mutable_client_info();
7422 }
set_allocated_client_info(::mozilla::safebrowsing::ClientInfo * client_info)7423 inline void ThreatHit::set_allocated_client_info(::mozilla::safebrowsing::ClientInfo* client_info) {
7424   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
7425   if (message_arena == nullptr) {
7426     delete client_info_;
7427   }
7428   if (client_info) {
7429     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
7430     if (message_arena != submessage_arena) {
7431       client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7432           message_arena, client_info, submessage_arena);
7433     }
7434     _has_bits_[0] |= 0x00000002u;
7435   } else {
7436     _has_bits_[0] &= ~0x00000002u;
7437   }
7438   client_info_ = client_info;
7439   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.client_info)
7440 }
7441 
7442 // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6;
_internal_has_user_info()7443 inline bool ThreatHit::_internal_has_user_info() const {
7444   bool value = (_has_bits_[0] & 0x00000004u) != 0;
7445   PROTOBUF_ASSUME(!value || user_info_ != nullptr);
7446   return value;
7447 }
has_user_info()7448 inline bool ThreatHit::has_user_info() const {
7449   return _internal_has_user_info();
7450 }
clear_user_info()7451 inline void ThreatHit::clear_user_info() {
7452   if (user_info_ != nullptr) user_info_->Clear();
7453   _has_bits_[0] &= ~0x00000004u;
7454 }
_internal_user_info()7455 inline const ::mozilla::safebrowsing::ThreatHit_UserInfo& ThreatHit::_internal_user_info() const {
7456   const ::mozilla::safebrowsing::ThreatHit_UserInfo* p = user_info_;
7457   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::ThreatHit_UserInfo*>(
7458       &::mozilla::safebrowsing::_ThreatHit_UserInfo_default_instance_);
7459 }
user_info()7460 inline const ::mozilla::safebrowsing::ThreatHit_UserInfo& ThreatHit::user_info() const {
7461   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.user_info)
7462   return _internal_user_info();
7463 }
release_user_info()7464 inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::release_user_info() {
7465   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.user_info)
7466   _has_bits_[0] &= ~0x00000004u;
7467   ::mozilla::safebrowsing::ThreatHit_UserInfo* temp = user_info_;
7468   user_info_ = nullptr;
7469   return temp;
7470 }
_internal_mutable_user_info()7471 inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::_internal_mutable_user_info() {
7472   _has_bits_[0] |= 0x00000004u;
7473   if (user_info_ == nullptr) {
7474     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_UserInfo>(GetArenaNoVirtual());
7475     user_info_ = p;
7476   }
7477   return user_info_;
7478 }
mutable_user_info()7479 inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::mutable_user_info() {
7480   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.user_info)
7481   return _internal_mutable_user_info();
7482 }
set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo * user_info)7483 inline void ThreatHit::set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo* user_info) {
7484   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
7485   if (message_arena == nullptr) {
7486     delete user_info_;
7487   }
7488   if (user_info) {
7489     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
7490     if (message_arena != submessage_arena) {
7491       user_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7492           message_arena, user_info, submessage_arena);
7493     }
7494     _has_bits_[0] |= 0x00000004u;
7495   } else {
7496     _has_bits_[0] &= ~0x00000004u;
7497   }
7498   user_info_ = user_info;
7499   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.user_info)
7500 }
7501 
7502 // -------------------------------------------------------------------
7503 
7504 // ClientInfo
7505 
7506 // optional string client_id = 1;
_internal_has_client_id()7507 inline bool ClientInfo::_internal_has_client_id() const {
7508   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7509   return value;
7510 }
has_client_id()7511 inline bool ClientInfo::has_client_id() const {
7512   return _internal_has_client_id();
7513 }
clear_client_id()7514 inline void ClientInfo::clear_client_id() {
7515   client_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7516   _has_bits_[0] &= ~0x00000001u;
7517 }
client_id()7518 inline const std::string& ClientInfo::client_id() const {
7519   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_id)
7520   return _internal_client_id();
7521 }
set_client_id(const std::string & value)7522 inline void ClientInfo::set_client_id(const std::string& value) {
7523   _internal_set_client_id(value);
7524   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_id)
7525 }
mutable_client_id()7526 inline std::string* ClientInfo::mutable_client_id() {
7527   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_id)
7528   return _internal_mutable_client_id();
7529 }
_internal_client_id()7530 inline const std::string& ClientInfo::_internal_client_id() const {
7531   return client_id_.GetNoArena();
7532 }
_internal_set_client_id(const std::string & value)7533 inline void ClientInfo::_internal_set_client_id(const std::string& value) {
7534   _has_bits_[0] |= 0x00000001u;
7535   client_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7536 }
set_client_id(std::string && value)7537 inline void ClientInfo::set_client_id(std::string&& value) {
7538   _has_bits_[0] |= 0x00000001u;
7539   client_id_.SetNoArena(
7540     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7541   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ClientInfo.client_id)
7542 }
set_client_id(const char * value)7543 inline void ClientInfo::set_client_id(const char* value) {
7544   GOOGLE_DCHECK(value != nullptr);
7545   _has_bits_[0] |= 0x00000001u;
7546   client_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7547   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ClientInfo.client_id)
7548 }
set_client_id(const char * value,size_t size)7549 inline void ClientInfo::set_client_id(const char* value, size_t size) {
7550   _has_bits_[0] |= 0x00000001u;
7551   client_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7552       ::std::string(reinterpret_cast<const char*>(value), size));
7553   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ClientInfo.client_id)
7554 }
_internal_mutable_client_id()7555 inline std::string* ClientInfo::_internal_mutable_client_id() {
7556   _has_bits_[0] |= 0x00000001u;
7557   return client_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7558 }
release_client_id()7559 inline std::string* ClientInfo::release_client_id() {
7560   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ClientInfo.client_id)
7561   if (!_internal_has_client_id()) {
7562     return nullptr;
7563   }
7564   _has_bits_[0] &= ~0x00000001u;
7565   return client_id_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7566 }
set_allocated_client_id(std::string * client_id)7567 inline void ClientInfo::set_allocated_client_id(std::string* client_id) {
7568   if (client_id != nullptr) {
7569     _has_bits_[0] |= 0x00000001u;
7570   } else {
7571     _has_bits_[0] &= ~0x00000001u;
7572   }
7573   client_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_id);
7574   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_id)
7575 }
7576 
7577 // optional string client_version = 2;
_internal_has_client_version()7578 inline bool ClientInfo::_internal_has_client_version() const {
7579   bool value = (_has_bits_[0] & 0x00000002u) != 0;
7580   return value;
7581 }
has_client_version()7582 inline bool ClientInfo::has_client_version() const {
7583   return _internal_has_client_version();
7584 }
clear_client_version()7585 inline void ClientInfo::clear_client_version() {
7586   client_version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7587   _has_bits_[0] &= ~0x00000002u;
7588 }
client_version()7589 inline const std::string& ClientInfo::client_version() const {
7590   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_version)
7591   return _internal_client_version();
7592 }
set_client_version(const std::string & value)7593 inline void ClientInfo::set_client_version(const std::string& value) {
7594   _internal_set_client_version(value);
7595   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_version)
7596 }
mutable_client_version()7597 inline std::string* ClientInfo::mutable_client_version() {
7598   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_version)
7599   return _internal_mutable_client_version();
7600 }
_internal_client_version()7601 inline const std::string& ClientInfo::_internal_client_version() const {
7602   return client_version_.GetNoArena();
7603 }
_internal_set_client_version(const std::string & value)7604 inline void ClientInfo::_internal_set_client_version(const std::string& value) {
7605   _has_bits_[0] |= 0x00000002u;
7606   client_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7607 }
set_client_version(std::string && value)7608 inline void ClientInfo::set_client_version(std::string&& value) {
7609   _has_bits_[0] |= 0x00000002u;
7610   client_version_.SetNoArena(
7611     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7612   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ClientInfo.client_version)
7613 }
set_client_version(const char * value)7614 inline void ClientInfo::set_client_version(const char* value) {
7615   GOOGLE_DCHECK(value != nullptr);
7616   _has_bits_[0] |= 0x00000002u;
7617   client_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7618   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ClientInfo.client_version)
7619 }
set_client_version(const char * value,size_t size)7620 inline void ClientInfo::set_client_version(const char* value, size_t size) {
7621   _has_bits_[0] |= 0x00000002u;
7622   client_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7623       ::std::string(reinterpret_cast<const char*>(value), size));
7624   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ClientInfo.client_version)
7625 }
_internal_mutable_client_version()7626 inline std::string* ClientInfo::_internal_mutable_client_version() {
7627   _has_bits_[0] |= 0x00000002u;
7628   return client_version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7629 }
release_client_version()7630 inline std::string* ClientInfo::release_client_version() {
7631   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ClientInfo.client_version)
7632   if (!_internal_has_client_version()) {
7633     return nullptr;
7634   }
7635   _has_bits_[0] &= ~0x00000002u;
7636   return client_version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7637 }
set_allocated_client_version(std::string * client_version)7638 inline void ClientInfo::set_allocated_client_version(std::string* client_version) {
7639   if (client_version != nullptr) {
7640     _has_bits_[0] |= 0x00000002u;
7641   } else {
7642     _has_bits_[0] &= ~0x00000002u;
7643   }
7644   client_version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_version);
7645   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_version)
7646 }
7647 
7648 // -------------------------------------------------------------------
7649 
7650 // ChromeClientInfo
7651 
7652 // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1;
_internal_has_reporting_population()7653 inline bool ChromeClientInfo::_internal_has_reporting_population() const {
7654   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7655   return value;
7656 }
has_reporting_population()7657 inline bool ChromeClientInfo::has_reporting_population() const {
7658   return _internal_has_reporting_population();
7659 }
clear_reporting_population()7660 inline void ChromeClientInfo::clear_reporting_population() {
7661   reporting_population_ = 0;
7662   _has_bits_[0] &= ~0x00000001u;
7663 }
_internal_reporting_population()7664 inline ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::_internal_reporting_population() const {
7665   return static_cast< ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation >(reporting_population_);
7666 }
reporting_population()7667 inline ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::reporting_population() const {
7668   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ChromeClientInfo.reporting_population)
7669   return _internal_reporting_population();
7670 }
_internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value)7671 inline void ChromeClientInfo::_internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value) {
7672   assert(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(value));
7673   _has_bits_[0] |= 0x00000001u;
7674   reporting_population_ = value;
7675 }
set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value)7676 inline void ChromeClientInfo::set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value) {
7677   _internal_set_reporting_population(value);
7678   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ChromeClientInfo.reporting_population)
7679 }
7680 
7681 // -------------------------------------------------------------------
7682 
7683 // Checksum
7684 
7685 // optional bytes sha256 = 1;
_internal_has_sha256()7686 inline bool Checksum::_internal_has_sha256() const {
7687   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7688   return value;
7689 }
has_sha256()7690 inline bool Checksum::has_sha256() const {
7691   return _internal_has_sha256();
7692 }
clear_sha256()7693 inline void Checksum::clear_sha256() {
7694   sha256_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7695   _has_bits_[0] &= ~0x00000001u;
7696 }
sha256()7697 inline const std::string& Checksum::sha256() const {
7698   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Checksum.sha256)
7699   return _internal_sha256();
7700 }
set_sha256(const std::string & value)7701 inline void Checksum::set_sha256(const std::string& value) {
7702   _internal_set_sha256(value);
7703   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Checksum.sha256)
7704 }
mutable_sha256()7705 inline std::string* Checksum::mutable_sha256() {
7706   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.Checksum.sha256)
7707   return _internal_mutable_sha256();
7708 }
_internal_sha256()7709 inline const std::string& Checksum::_internal_sha256() const {
7710   return sha256_.GetNoArena();
7711 }
_internal_set_sha256(const std::string & value)7712 inline void Checksum::_internal_set_sha256(const std::string& value) {
7713   _has_bits_[0] |= 0x00000001u;
7714   sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7715 }
set_sha256(std::string && value)7716 inline void Checksum::set_sha256(std::string&& value) {
7717   _has_bits_[0] |= 0x00000001u;
7718   sha256_.SetNoArena(
7719     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7720   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.Checksum.sha256)
7721 }
set_sha256(const char * value)7722 inline void Checksum::set_sha256(const char* value) {
7723   GOOGLE_DCHECK(value != nullptr);
7724   _has_bits_[0] |= 0x00000001u;
7725   sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7726   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.Checksum.sha256)
7727 }
set_sha256(const void * value,size_t size)7728 inline void Checksum::set_sha256(const void* value, size_t size) {
7729   _has_bits_[0] |= 0x00000001u;
7730   sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7731       ::std::string(reinterpret_cast<const char*>(value), size));
7732   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.Checksum.sha256)
7733 }
_internal_mutable_sha256()7734 inline std::string* Checksum::_internal_mutable_sha256() {
7735   _has_bits_[0] |= 0x00000001u;
7736   return sha256_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7737 }
release_sha256()7738 inline std::string* Checksum::release_sha256() {
7739   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.Checksum.sha256)
7740   if (!_internal_has_sha256()) {
7741     return nullptr;
7742   }
7743   _has_bits_[0] &= ~0x00000001u;
7744   return sha256_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7745 }
set_allocated_sha256(std::string * sha256)7746 inline void Checksum::set_allocated_sha256(std::string* sha256) {
7747   if (sha256 != nullptr) {
7748     _has_bits_[0] |= 0x00000001u;
7749   } else {
7750     _has_bits_[0] &= ~0x00000001u;
7751   }
7752   sha256_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sha256);
7753   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.Checksum.sha256)
7754 }
7755 
7756 // -------------------------------------------------------------------
7757 
7758 // ThreatEntry
7759 
7760 // optional bytes hash = 1;
_internal_has_hash()7761 inline bool ThreatEntry::_internal_has_hash() const {
7762   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7763   return value;
7764 }
has_hash()7765 inline bool ThreatEntry::has_hash() const {
7766   return _internal_has_hash();
7767 }
clear_hash()7768 inline void ThreatEntry::clear_hash() {
7769   hash_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7770   _has_bits_[0] &= ~0x00000001u;
7771 }
hash()7772 inline const std::string& ThreatEntry::hash() const {
7773   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.hash)
7774   return _internal_hash();
7775 }
set_hash(const std::string & value)7776 inline void ThreatEntry::set_hash(const std::string& value) {
7777   _internal_set_hash(value);
7778   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.hash)
7779 }
mutable_hash()7780 inline std::string* ThreatEntry::mutable_hash() {
7781   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.hash)
7782   return _internal_mutable_hash();
7783 }
_internal_hash()7784 inline const std::string& ThreatEntry::_internal_hash() const {
7785   return hash_.GetNoArena();
7786 }
_internal_set_hash(const std::string & value)7787 inline void ThreatEntry::_internal_set_hash(const std::string& value) {
7788   _has_bits_[0] |= 0x00000001u;
7789   hash_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7790 }
set_hash(std::string && value)7791 inline void ThreatEntry::set_hash(std::string&& value) {
7792   _has_bits_[0] |= 0x00000001u;
7793   hash_.SetNoArena(
7794     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7795   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatEntry.hash)
7796 }
set_hash(const char * value)7797 inline void ThreatEntry::set_hash(const char* value) {
7798   GOOGLE_DCHECK(value != nullptr);
7799   _has_bits_[0] |= 0x00000001u;
7800   hash_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7801   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntry.hash)
7802 }
set_hash(const void * value,size_t size)7803 inline void ThreatEntry::set_hash(const void* value, size_t size) {
7804   _has_bits_[0] |= 0x00000001u;
7805   hash_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7806       ::std::string(reinterpret_cast<const char*>(value), size));
7807   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntry.hash)
7808 }
_internal_mutable_hash()7809 inline std::string* ThreatEntry::_internal_mutable_hash() {
7810   _has_bits_[0] |= 0x00000001u;
7811   return hash_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7812 }
release_hash()7813 inline std::string* ThreatEntry::release_hash() {
7814   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntry.hash)
7815   if (!_internal_has_hash()) {
7816     return nullptr;
7817   }
7818   _has_bits_[0] &= ~0x00000001u;
7819   return hash_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7820 }
set_allocated_hash(std::string * hash)7821 inline void ThreatEntry::set_allocated_hash(std::string* hash) {
7822   if (hash != nullptr) {
7823     _has_bits_[0] |= 0x00000001u;
7824   } else {
7825     _has_bits_[0] &= ~0x00000001u;
7826   }
7827   hash_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hash);
7828   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.hash)
7829 }
7830 
7831 // optional string url = 2;
_internal_has_url()7832 inline bool ThreatEntry::_internal_has_url() const {
7833   bool value = (_has_bits_[0] & 0x00000002u) != 0;
7834   return value;
7835 }
has_url()7836 inline bool ThreatEntry::has_url() const {
7837   return _internal_has_url();
7838 }
clear_url()7839 inline void ThreatEntry::clear_url() {
7840   url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7841   _has_bits_[0] &= ~0x00000002u;
7842 }
url()7843 inline const std::string& ThreatEntry::url() const {
7844   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.url)
7845   return _internal_url();
7846 }
set_url(const std::string & value)7847 inline void ThreatEntry::set_url(const std::string& value) {
7848   _internal_set_url(value);
7849   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.url)
7850 }
mutable_url()7851 inline std::string* ThreatEntry::mutable_url() {
7852   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.url)
7853   return _internal_mutable_url();
7854 }
_internal_url()7855 inline const std::string& ThreatEntry::_internal_url() const {
7856   return url_.GetNoArena();
7857 }
_internal_set_url(const std::string & value)7858 inline void ThreatEntry::_internal_set_url(const std::string& value) {
7859   _has_bits_[0] |= 0x00000002u;
7860   url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
7861 }
set_url(std::string && value)7862 inline void ThreatEntry::set_url(std::string&& value) {
7863   _has_bits_[0] |= 0x00000002u;
7864   url_.SetNoArena(
7865     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7866   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatEntry.url)
7867 }
set_url(const char * value)7868 inline void ThreatEntry::set_url(const char* value) {
7869   GOOGLE_DCHECK(value != nullptr);
7870   _has_bits_[0] |= 0x00000002u;
7871   url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7872   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntry.url)
7873 }
set_url(const char * value,size_t size)7874 inline void ThreatEntry::set_url(const char* value, size_t size) {
7875   _has_bits_[0] |= 0x00000002u;
7876   url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
7877       ::std::string(reinterpret_cast<const char*>(value), size));
7878   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntry.url)
7879 }
_internal_mutable_url()7880 inline std::string* ThreatEntry::_internal_mutable_url() {
7881   _has_bits_[0] |= 0x00000002u;
7882   return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7883 }
release_url()7884 inline std::string* ThreatEntry::release_url() {
7885   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntry.url)
7886   if (!_internal_has_url()) {
7887     return nullptr;
7888   }
7889   _has_bits_[0] &= ~0x00000002u;
7890   return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
7891 }
set_allocated_url(std::string * url)7892 inline void ThreatEntry::set_allocated_url(std::string* url) {
7893   if (url != nullptr) {
7894     _has_bits_[0] |= 0x00000002u;
7895   } else {
7896     _has_bits_[0] &= ~0x00000002u;
7897   }
7898   url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url);
7899   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.url)
7900 }
7901 
7902 // -------------------------------------------------------------------
7903 
7904 // ThreatEntrySet
7905 
7906 // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
_internal_has_compression_type()7907 inline bool ThreatEntrySet::_internal_has_compression_type() const {
7908   bool value = (_has_bits_[0] & 0x00000010u) != 0;
7909   return value;
7910 }
has_compression_type()7911 inline bool ThreatEntrySet::has_compression_type() const {
7912   return _internal_has_compression_type();
7913 }
clear_compression_type()7914 inline void ThreatEntrySet::clear_compression_type() {
7915   compression_type_ = 0;
7916   _has_bits_[0] &= ~0x00000010u;
7917 }
_internal_compression_type()7918 inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::_internal_compression_type() const {
7919   return static_cast< ::mozilla::safebrowsing::CompressionType >(compression_type_);
7920 }
compression_type()7921 inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::compression_type() const {
7922   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.compression_type)
7923   return _internal_compression_type();
7924 }
_internal_set_compression_type(::mozilla::safebrowsing::CompressionType value)7925 inline void ThreatEntrySet::_internal_set_compression_type(::mozilla::safebrowsing::CompressionType value) {
7926   assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
7927   _has_bits_[0] |= 0x00000010u;
7928   compression_type_ = value;
7929 }
set_compression_type(::mozilla::safebrowsing::CompressionType value)7930 inline void ThreatEntrySet::set_compression_type(::mozilla::safebrowsing::CompressionType value) {
7931   _internal_set_compression_type(value);
7932   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntrySet.compression_type)
7933 }
7934 
7935 // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
_internal_has_raw_hashes()7936 inline bool ThreatEntrySet::_internal_has_raw_hashes() const {
7937   bool value = (_has_bits_[0] & 0x00000001u) != 0;
7938   PROTOBUF_ASSUME(!value || raw_hashes_ != nullptr);
7939   return value;
7940 }
has_raw_hashes()7941 inline bool ThreatEntrySet::has_raw_hashes() const {
7942   return _internal_has_raw_hashes();
7943 }
clear_raw_hashes()7944 inline void ThreatEntrySet::clear_raw_hashes() {
7945   if (raw_hashes_ != nullptr) raw_hashes_->Clear();
7946   _has_bits_[0] &= ~0x00000001u;
7947 }
_internal_raw_hashes()7948 inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::_internal_raw_hashes() const {
7949   const ::mozilla::safebrowsing::RawHashes* p = raw_hashes_;
7950   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::RawHashes*>(
7951       &::mozilla::safebrowsing::_RawHashes_default_instance_);
7952 }
raw_hashes()7953 inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::raw_hashes() const {
7954   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
7955   return _internal_raw_hashes();
7956 }
release_raw_hashes()7957 inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::release_raw_hashes() {
7958   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
7959   _has_bits_[0] &= ~0x00000001u;
7960   ::mozilla::safebrowsing::RawHashes* temp = raw_hashes_;
7961   raw_hashes_ = nullptr;
7962   return temp;
7963 }
_internal_mutable_raw_hashes()7964 inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::_internal_mutable_raw_hashes() {
7965   _has_bits_[0] |= 0x00000001u;
7966   if (raw_hashes_ == nullptr) {
7967     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RawHashes>(GetArenaNoVirtual());
7968     raw_hashes_ = p;
7969   }
7970   return raw_hashes_;
7971 }
mutable_raw_hashes()7972 inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::mutable_raw_hashes() {
7973   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
7974   return _internal_mutable_raw_hashes();
7975 }
set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes * raw_hashes)7976 inline void ThreatEntrySet::set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes) {
7977   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
7978   if (message_arena == nullptr) {
7979     delete raw_hashes_;
7980   }
7981   if (raw_hashes) {
7982     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
7983     if (message_arena != submessage_arena) {
7984       raw_hashes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7985           message_arena, raw_hashes, submessage_arena);
7986     }
7987     _has_bits_[0] |= 0x00000001u;
7988   } else {
7989     _has_bits_[0] &= ~0x00000001u;
7990   }
7991   raw_hashes_ = raw_hashes;
7992   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
7993 }
7994 
7995 // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
_internal_has_raw_indices()7996 inline bool ThreatEntrySet::_internal_has_raw_indices() const {
7997   bool value = (_has_bits_[0] & 0x00000002u) != 0;
7998   PROTOBUF_ASSUME(!value || raw_indices_ != nullptr);
7999   return value;
8000 }
has_raw_indices()8001 inline bool ThreatEntrySet::has_raw_indices() const {
8002   return _internal_has_raw_indices();
8003 }
clear_raw_indices()8004 inline void ThreatEntrySet::clear_raw_indices() {
8005   if (raw_indices_ != nullptr) raw_indices_->Clear();
8006   _has_bits_[0] &= ~0x00000002u;
8007 }
_internal_raw_indices()8008 inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::_internal_raw_indices() const {
8009   const ::mozilla::safebrowsing::RawIndices* p = raw_indices_;
8010   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::RawIndices*>(
8011       &::mozilla::safebrowsing::_RawIndices_default_instance_);
8012 }
raw_indices()8013 inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::raw_indices() const {
8014   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
8015   return _internal_raw_indices();
8016 }
release_raw_indices()8017 inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::release_raw_indices() {
8018   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
8019   _has_bits_[0] &= ~0x00000002u;
8020   ::mozilla::safebrowsing::RawIndices* temp = raw_indices_;
8021   raw_indices_ = nullptr;
8022   return temp;
8023 }
_internal_mutable_raw_indices()8024 inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::_internal_mutable_raw_indices() {
8025   _has_bits_[0] |= 0x00000002u;
8026   if (raw_indices_ == nullptr) {
8027     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RawIndices>(GetArenaNoVirtual());
8028     raw_indices_ = p;
8029   }
8030   return raw_indices_;
8031 }
mutable_raw_indices()8032 inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::mutable_raw_indices() {
8033   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
8034   return _internal_mutable_raw_indices();
8035 }
set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices * raw_indices)8036 inline void ThreatEntrySet::set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices) {
8037   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
8038   if (message_arena == nullptr) {
8039     delete raw_indices_;
8040   }
8041   if (raw_indices) {
8042     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
8043     if (message_arena != submessage_arena) {
8044       raw_indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8045           message_arena, raw_indices, submessage_arena);
8046     }
8047     _has_bits_[0] |= 0x00000002u;
8048   } else {
8049     _has_bits_[0] &= ~0x00000002u;
8050   }
8051   raw_indices_ = raw_indices;
8052   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
8053 }
8054 
8055 // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
_internal_has_rice_hashes()8056 inline bool ThreatEntrySet::_internal_has_rice_hashes() const {
8057   bool value = (_has_bits_[0] & 0x00000004u) != 0;
8058   PROTOBUF_ASSUME(!value || rice_hashes_ != nullptr);
8059   return value;
8060 }
has_rice_hashes()8061 inline bool ThreatEntrySet::has_rice_hashes() const {
8062   return _internal_has_rice_hashes();
8063 }
clear_rice_hashes()8064 inline void ThreatEntrySet::clear_rice_hashes() {
8065   if (rice_hashes_ != nullptr) rice_hashes_->Clear();
8066   _has_bits_[0] &= ~0x00000004u;
8067 }
_internal_rice_hashes()8068 inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::_internal_rice_hashes() const {
8069   const ::mozilla::safebrowsing::RiceDeltaEncoding* p = rice_hashes_;
8070   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::RiceDeltaEncoding*>(
8071       &::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_);
8072 }
rice_hashes()8073 inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_hashes() const {
8074   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
8075   return _internal_rice_hashes();
8076 }
release_rice_hashes()8077 inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_hashes() {
8078   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
8079   _has_bits_[0] &= ~0x00000004u;
8080   ::mozilla::safebrowsing::RiceDeltaEncoding* temp = rice_hashes_;
8081   rice_hashes_ = nullptr;
8082   return temp;
8083 }
_internal_mutable_rice_hashes()8084 inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::_internal_mutable_rice_hashes() {
8085   _has_bits_[0] |= 0x00000004u;
8086   if (rice_hashes_ == nullptr) {
8087     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(GetArenaNoVirtual());
8088     rice_hashes_ = p;
8089   }
8090   return rice_hashes_;
8091 }
mutable_rice_hashes()8092 inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_hashes() {
8093   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
8094   return _internal_mutable_rice_hashes();
8095 }
set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding * rice_hashes)8096 inline void ThreatEntrySet::set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) {
8097   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
8098   if (message_arena == nullptr) {
8099     delete rice_hashes_;
8100   }
8101   if (rice_hashes) {
8102     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
8103     if (message_arena != submessage_arena) {
8104       rice_hashes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8105           message_arena, rice_hashes, submessage_arena);
8106     }
8107     _has_bits_[0] |= 0x00000004u;
8108   } else {
8109     _has_bits_[0] &= ~0x00000004u;
8110   }
8111   rice_hashes_ = rice_hashes;
8112   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
8113 }
8114 
8115 // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
_internal_has_rice_indices()8116 inline bool ThreatEntrySet::_internal_has_rice_indices() const {
8117   bool value = (_has_bits_[0] & 0x00000008u) != 0;
8118   PROTOBUF_ASSUME(!value || rice_indices_ != nullptr);
8119   return value;
8120 }
has_rice_indices()8121 inline bool ThreatEntrySet::has_rice_indices() const {
8122   return _internal_has_rice_indices();
8123 }
clear_rice_indices()8124 inline void ThreatEntrySet::clear_rice_indices() {
8125   if (rice_indices_ != nullptr) rice_indices_->Clear();
8126   _has_bits_[0] &= ~0x00000008u;
8127 }
_internal_rice_indices()8128 inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::_internal_rice_indices() const {
8129   const ::mozilla::safebrowsing::RiceDeltaEncoding* p = rice_indices_;
8130   return p != nullptr ? *p : *reinterpret_cast<const ::mozilla::safebrowsing::RiceDeltaEncoding*>(
8131       &::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_);
8132 }
rice_indices()8133 inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_indices() const {
8134   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
8135   return _internal_rice_indices();
8136 }
release_rice_indices()8137 inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_indices() {
8138   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
8139   _has_bits_[0] &= ~0x00000008u;
8140   ::mozilla::safebrowsing::RiceDeltaEncoding* temp = rice_indices_;
8141   rice_indices_ = nullptr;
8142   return temp;
8143 }
_internal_mutable_rice_indices()8144 inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::_internal_mutable_rice_indices() {
8145   _has_bits_[0] |= 0x00000008u;
8146   if (rice_indices_ == nullptr) {
8147     auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(GetArenaNoVirtual());
8148     rice_indices_ = p;
8149   }
8150   return rice_indices_;
8151 }
mutable_rice_indices()8152 inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_indices() {
8153   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
8154   return _internal_mutable_rice_indices();
8155 }
set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding * rice_indices)8156 inline void ThreatEntrySet::set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) {
8157   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
8158   if (message_arena == nullptr) {
8159     delete rice_indices_;
8160   }
8161   if (rice_indices) {
8162     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
8163     if (message_arena != submessage_arena) {
8164       rice_indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8165           message_arena, rice_indices, submessage_arena);
8166     }
8167     _has_bits_[0] |= 0x00000008u;
8168   } else {
8169     _has_bits_[0] &= ~0x00000008u;
8170   }
8171   rice_indices_ = rice_indices;
8172   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
8173 }
8174 
8175 // -------------------------------------------------------------------
8176 
8177 // RawIndices
8178 
8179 // repeated int32 indices = 1;
_internal_indices_size()8180 inline int RawIndices::_internal_indices_size() const {
8181   return indices_.size();
8182 }
indices_size()8183 inline int RawIndices::indices_size() const {
8184   return _internal_indices_size();
8185 }
clear_indices()8186 inline void RawIndices::clear_indices() {
8187   indices_.Clear();
8188 }
_internal_indices(int index)8189 inline ::PROTOBUF_NAMESPACE_ID::int32 RawIndices::_internal_indices(int index) const {
8190   return indices_.Get(index);
8191 }
indices(int index)8192 inline ::PROTOBUF_NAMESPACE_ID::int32 RawIndices::indices(int index) const {
8193   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawIndices.indices)
8194   return _internal_indices(index);
8195 }
set_indices(int index,::PROTOBUF_NAMESPACE_ID::int32 value)8196 inline void RawIndices::set_indices(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
8197   indices_.Set(index, value);
8198   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawIndices.indices)
8199 }
_internal_add_indices(::PROTOBUF_NAMESPACE_ID::int32 value)8200 inline void RawIndices::_internal_add_indices(::PROTOBUF_NAMESPACE_ID::int32 value) {
8201   indices_.Add(value);
8202 }
add_indices(::PROTOBUF_NAMESPACE_ID::int32 value)8203 inline void RawIndices::add_indices(::PROTOBUF_NAMESPACE_ID::int32 value) {
8204   _internal_add_indices(value);
8205   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.RawIndices.indices)
8206 }
8207 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_indices()8208 RawIndices::_internal_indices() const {
8209   return indices_;
8210 }
8211 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
indices()8212 RawIndices::indices() const {
8213   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.RawIndices.indices)
8214   return _internal_indices();
8215 }
8216 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_indices()8217 RawIndices::_internal_mutable_indices() {
8218   return &indices_;
8219 }
8220 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_indices()8221 RawIndices::mutable_indices() {
8222   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.RawIndices.indices)
8223   return _internal_mutable_indices();
8224 }
8225 
8226 // -------------------------------------------------------------------
8227 
8228 // RawHashes
8229 
8230 // optional int32 prefix_size = 1;
_internal_has_prefix_size()8231 inline bool RawHashes::_internal_has_prefix_size() const {
8232   bool value = (_has_bits_[0] & 0x00000002u) != 0;
8233   return value;
8234 }
has_prefix_size()8235 inline bool RawHashes::has_prefix_size() const {
8236   return _internal_has_prefix_size();
8237 }
clear_prefix_size()8238 inline void RawHashes::clear_prefix_size() {
8239   prefix_size_ = 0;
8240   _has_bits_[0] &= ~0x00000002u;
8241 }
_internal_prefix_size()8242 inline ::PROTOBUF_NAMESPACE_ID::int32 RawHashes::_internal_prefix_size() const {
8243   return prefix_size_;
8244 }
prefix_size()8245 inline ::PROTOBUF_NAMESPACE_ID::int32 RawHashes::prefix_size() const {
8246   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.prefix_size)
8247   return _internal_prefix_size();
8248 }
_internal_set_prefix_size(::PROTOBUF_NAMESPACE_ID::int32 value)8249 inline void RawHashes::_internal_set_prefix_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
8250   _has_bits_[0] |= 0x00000002u;
8251   prefix_size_ = value;
8252 }
set_prefix_size(::PROTOBUF_NAMESPACE_ID::int32 value)8253 inline void RawHashes::set_prefix_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
8254   _internal_set_prefix_size(value);
8255   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.prefix_size)
8256 }
8257 
8258 // optional bytes raw_hashes = 2;
_internal_has_raw_hashes()8259 inline bool RawHashes::_internal_has_raw_hashes() const {
8260   bool value = (_has_bits_[0] & 0x00000001u) != 0;
8261   return value;
8262 }
has_raw_hashes()8263 inline bool RawHashes::has_raw_hashes() const {
8264   return _internal_has_raw_hashes();
8265 }
clear_raw_hashes()8266 inline void RawHashes::clear_raw_hashes() {
8267   raw_hashes_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8268   _has_bits_[0] &= ~0x00000001u;
8269 }
raw_hashes()8270 inline const std::string& RawHashes::raw_hashes() const {
8271   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.raw_hashes)
8272   return _internal_raw_hashes();
8273 }
set_raw_hashes(const std::string & value)8274 inline void RawHashes::set_raw_hashes(const std::string& value) {
8275   _internal_set_raw_hashes(value);
8276   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.raw_hashes)
8277 }
mutable_raw_hashes()8278 inline std::string* RawHashes::mutable_raw_hashes() {
8279   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RawHashes.raw_hashes)
8280   return _internal_mutable_raw_hashes();
8281 }
_internal_raw_hashes()8282 inline const std::string& RawHashes::_internal_raw_hashes() const {
8283   return raw_hashes_.GetNoArena();
8284 }
_internal_set_raw_hashes(const std::string & value)8285 inline void RawHashes::_internal_set_raw_hashes(const std::string& value) {
8286   _has_bits_[0] |= 0x00000001u;
8287   raw_hashes_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
8288 }
set_raw_hashes(std::string && value)8289 inline void RawHashes::set_raw_hashes(std::string&& value) {
8290   _has_bits_[0] |= 0x00000001u;
8291   raw_hashes_.SetNoArena(
8292     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8293   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.RawHashes.raw_hashes)
8294 }
set_raw_hashes(const char * value)8295 inline void RawHashes::set_raw_hashes(const char* value) {
8296   GOOGLE_DCHECK(value != nullptr);
8297   _has_bits_[0] |= 0x00000001u;
8298   raw_hashes_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8299   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.RawHashes.raw_hashes)
8300 }
set_raw_hashes(const void * value,size_t size)8301 inline void RawHashes::set_raw_hashes(const void* value, size_t size) {
8302   _has_bits_[0] |= 0x00000001u;
8303   raw_hashes_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
8304       ::std::string(reinterpret_cast<const char*>(value), size));
8305   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.RawHashes.raw_hashes)
8306 }
_internal_mutable_raw_hashes()8307 inline std::string* RawHashes::_internal_mutable_raw_hashes() {
8308   _has_bits_[0] |= 0x00000001u;
8309   return raw_hashes_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8310 }
release_raw_hashes()8311 inline std::string* RawHashes::release_raw_hashes() {
8312   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.RawHashes.raw_hashes)
8313   if (!_internal_has_raw_hashes()) {
8314     return nullptr;
8315   }
8316   _has_bits_[0] &= ~0x00000001u;
8317   return raw_hashes_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8318 }
set_allocated_raw_hashes(std::string * raw_hashes)8319 inline void RawHashes::set_allocated_raw_hashes(std::string* raw_hashes) {
8320   if (raw_hashes != nullptr) {
8321     _has_bits_[0] |= 0x00000001u;
8322   } else {
8323     _has_bits_[0] &= ~0x00000001u;
8324   }
8325   raw_hashes_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), raw_hashes);
8326   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RawHashes.raw_hashes)
8327 }
8328 
8329 // -------------------------------------------------------------------
8330 
8331 // RiceDeltaEncoding
8332 
8333 // optional int64 first_value = 1;
_internal_has_first_value()8334 inline bool RiceDeltaEncoding::_internal_has_first_value() const {
8335   bool value = (_has_bits_[0] & 0x00000002u) != 0;
8336   return value;
8337 }
has_first_value()8338 inline bool RiceDeltaEncoding::has_first_value() const {
8339   return _internal_has_first_value();
8340 }
clear_first_value()8341 inline void RiceDeltaEncoding::clear_first_value() {
8342   first_value_ = PROTOBUF_LONGLONG(0);
8343   _has_bits_[0] &= ~0x00000002u;
8344 }
_internal_first_value()8345 inline ::PROTOBUF_NAMESPACE_ID::int64 RiceDeltaEncoding::_internal_first_value() const {
8346   return first_value_;
8347 }
first_value()8348 inline ::PROTOBUF_NAMESPACE_ID::int64 RiceDeltaEncoding::first_value() const {
8349   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.first_value)
8350   return _internal_first_value();
8351 }
_internal_set_first_value(::PROTOBUF_NAMESPACE_ID::int64 value)8352 inline void RiceDeltaEncoding::_internal_set_first_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
8353   _has_bits_[0] |= 0x00000002u;
8354   first_value_ = value;
8355 }
set_first_value(::PROTOBUF_NAMESPACE_ID::int64 value)8356 inline void RiceDeltaEncoding::set_first_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
8357   _internal_set_first_value(value);
8358   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.first_value)
8359 }
8360 
8361 // optional int32 rice_parameter = 2;
_internal_has_rice_parameter()8362 inline bool RiceDeltaEncoding::_internal_has_rice_parameter() const {
8363   bool value = (_has_bits_[0] & 0x00000004u) != 0;
8364   return value;
8365 }
has_rice_parameter()8366 inline bool RiceDeltaEncoding::has_rice_parameter() const {
8367   return _internal_has_rice_parameter();
8368 }
clear_rice_parameter()8369 inline void RiceDeltaEncoding::clear_rice_parameter() {
8370   rice_parameter_ = 0;
8371   _has_bits_[0] &= ~0x00000004u;
8372 }
_internal_rice_parameter()8373 inline ::PROTOBUF_NAMESPACE_ID::int32 RiceDeltaEncoding::_internal_rice_parameter() const {
8374   return rice_parameter_;
8375 }
rice_parameter()8376 inline ::PROTOBUF_NAMESPACE_ID::int32 RiceDeltaEncoding::rice_parameter() const {
8377   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter)
8378   return _internal_rice_parameter();
8379 }
_internal_set_rice_parameter(::PROTOBUF_NAMESPACE_ID::int32 value)8380 inline void RiceDeltaEncoding::_internal_set_rice_parameter(::PROTOBUF_NAMESPACE_ID::int32 value) {
8381   _has_bits_[0] |= 0x00000004u;
8382   rice_parameter_ = value;
8383 }
set_rice_parameter(::PROTOBUF_NAMESPACE_ID::int32 value)8384 inline void RiceDeltaEncoding::set_rice_parameter(::PROTOBUF_NAMESPACE_ID::int32 value) {
8385   _internal_set_rice_parameter(value);
8386   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter)
8387 }
8388 
8389 // optional int32 num_entries = 3;
_internal_has_num_entries()8390 inline bool RiceDeltaEncoding::_internal_has_num_entries() const {
8391   bool value = (_has_bits_[0] & 0x00000008u) != 0;
8392   return value;
8393 }
has_num_entries()8394 inline bool RiceDeltaEncoding::has_num_entries() const {
8395   return _internal_has_num_entries();
8396 }
clear_num_entries()8397 inline void RiceDeltaEncoding::clear_num_entries() {
8398   num_entries_ = 0;
8399   _has_bits_[0] &= ~0x00000008u;
8400 }
_internal_num_entries()8401 inline ::PROTOBUF_NAMESPACE_ID::int32 RiceDeltaEncoding::_internal_num_entries() const {
8402   return num_entries_;
8403 }
num_entries()8404 inline ::PROTOBUF_NAMESPACE_ID::int32 RiceDeltaEncoding::num_entries() const {
8405   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.num_entries)
8406   return _internal_num_entries();
8407 }
_internal_set_num_entries(::PROTOBUF_NAMESPACE_ID::int32 value)8408 inline void RiceDeltaEncoding::_internal_set_num_entries(::PROTOBUF_NAMESPACE_ID::int32 value) {
8409   _has_bits_[0] |= 0x00000008u;
8410   num_entries_ = value;
8411 }
set_num_entries(::PROTOBUF_NAMESPACE_ID::int32 value)8412 inline void RiceDeltaEncoding::set_num_entries(::PROTOBUF_NAMESPACE_ID::int32 value) {
8413   _internal_set_num_entries(value);
8414   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.num_entries)
8415 }
8416 
8417 // optional bytes encoded_data = 4;
_internal_has_encoded_data()8418 inline bool RiceDeltaEncoding::_internal_has_encoded_data() const {
8419   bool value = (_has_bits_[0] & 0x00000001u) != 0;
8420   return value;
8421 }
has_encoded_data()8422 inline bool RiceDeltaEncoding::has_encoded_data() const {
8423   return _internal_has_encoded_data();
8424 }
clear_encoded_data()8425 inline void RiceDeltaEncoding::clear_encoded_data() {
8426   encoded_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8427   _has_bits_[0] &= ~0x00000001u;
8428 }
encoded_data()8429 inline const std::string& RiceDeltaEncoding::encoded_data() const {
8430   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8431   return _internal_encoded_data();
8432 }
set_encoded_data(const std::string & value)8433 inline void RiceDeltaEncoding::set_encoded_data(const std::string& value) {
8434   _internal_set_encoded_data(value);
8435   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8436 }
mutable_encoded_data()8437 inline std::string* RiceDeltaEncoding::mutable_encoded_data() {
8438   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8439   return _internal_mutable_encoded_data();
8440 }
_internal_encoded_data()8441 inline const std::string& RiceDeltaEncoding::_internal_encoded_data() const {
8442   return encoded_data_.GetNoArena();
8443 }
_internal_set_encoded_data(const std::string & value)8444 inline void RiceDeltaEncoding::_internal_set_encoded_data(const std::string& value) {
8445   _has_bits_[0] |= 0x00000001u;
8446   encoded_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
8447 }
set_encoded_data(std::string && value)8448 inline void RiceDeltaEncoding::set_encoded_data(std::string&& value) {
8449   _has_bits_[0] |= 0x00000001u;
8450   encoded_data_.SetNoArena(
8451     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8452   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8453 }
set_encoded_data(const char * value)8454 inline void RiceDeltaEncoding::set_encoded_data(const char* value) {
8455   GOOGLE_DCHECK(value != nullptr);
8456   _has_bits_[0] |= 0x00000001u;
8457   encoded_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8458   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8459 }
set_encoded_data(const void * value,size_t size)8460 inline void RiceDeltaEncoding::set_encoded_data(const void* value, size_t size) {
8461   _has_bits_[0] |= 0x00000001u;
8462   encoded_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
8463       ::std::string(reinterpret_cast<const char*>(value), size));
8464   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8465 }
_internal_mutable_encoded_data()8466 inline std::string* RiceDeltaEncoding::_internal_mutable_encoded_data() {
8467   _has_bits_[0] |= 0x00000001u;
8468   return encoded_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8469 }
release_encoded_data()8470 inline std::string* RiceDeltaEncoding::release_encoded_data() {
8471   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8472   if (!_internal_has_encoded_data()) {
8473     return nullptr;
8474   }
8475   _has_bits_[0] &= ~0x00000001u;
8476   return encoded_data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8477 }
set_allocated_encoded_data(std::string * encoded_data)8478 inline void RiceDeltaEncoding::set_allocated_encoded_data(std::string* encoded_data) {
8479   if (encoded_data != nullptr) {
8480     _has_bits_[0] |= 0x00000001u;
8481   } else {
8482     _has_bits_[0] &= ~0x00000001u;
8483   }
8484   encoded_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encoded_data);
8485   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
8486 }
8487 
8488 // -------------------------------------------------------------------
8489 
8490 // ThreatEntryMetadata_MetadataEntry
8491 
8492 // optional bytes key = 1;
_internal_has_key()8493 inline bool ThreatEntryMetadata_MetadataEntry::_internal_has_key() const {
8494   bool value = (_has_bits_[0] & 0x00000001u) != 0;
8495   return value;
8496 }
has_key()8497 inline bool ThreatEntryMetadata_MetadataEntry::has_key() const {
8498   return _internal_has_key();
8499 }
clear_key()8500 inline void ThreatEntryMetadata_MetadataEntry::clear_key() {
8501   key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8502   _has_bits_[0] &= ~0x00000001u;
8503 }
key()8504 inline const std::string& ThreatEntryMetadata_MetadataEntry::key() const {
8505   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8506   return _internal_key();
8507 }
set_key(const std::string & value)8508 inline void ThreatEntryMetadata_MetadataEntry::set_key(const std::string& value) {
8509   _internal_set_key(value);
8510   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8511 }
mutable_key()8512 inline std::string* ThreatEntryMetadata_MetadataEntry::mutable_key() {
8513   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8514   return _internal_mutable_key();
8515 }
_internal_key()8516 inline const std::string& ThreatEntryMetadata_MetadataEntry::_internal_key() const {
8517   return key_.GetNoArena();
8518 }
_internal_set_key(const std::string & value)8519 inline void ThreatEntryMetadata_MetadataEntry::_internal_set_key(const std::string& value) {
8520   _has_bits_[0] |= 0x00000001u;
8521   key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
8522 }
set_key(std::string && value)8523 inline void ThreatEntryMetadata_MetadataEntry::set_key(std::string&& value) {
8524   _has_bits_[0] |= 0x00000001u;
8525   key_.SetNoArena(
8526     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8527   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8528 }
set_key(const char * value)8529 inline void ThreatEntryMetadata_MetadataEntry::set_key(const char* value) {
8530   GOOGLE_DCHECK(value != nullptr);
8531   _has_bits_[0] |= 0x00000001u;
8532   key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8533   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8534 }
set_key(const void * value,size_t size)8535 inline void ThreatEntryMetadata_MetadataEntry::set_key(const void* value, size_t size) {
8536   _has_bits_[0] |= 0x00000001u;
8537   key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
8538       ::std::string(reinterpret_cast<const char*>(value), size));
8539   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8540 }
_internal_mutable_key()8541 inline std::string* ThreatEntryMetadata_MetadataEntry::_internal_mutable_key() {
8542   _has_bits_[0] |= 0x00000001u;
8543   return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8544 }
release_key()8545 inline std::string* ThreatEntryMetadata_MetadataEntry::release_key() {
8546   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8547   if (!_internal_has_key()) {
8548     return nullptr;
8549   }
8550   _has_bits_[0] &= ~0x00000001u;
8551   return key_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8552 }
set_allocated_key(std::string * key)8553 inline void ThreatEntryMetadata_MetadataEntry::set_allocated_key(std::string* key) {
8554   if (key != nullptr) {
8555     _has_bits_[0] |= 0x00000001u;
8556   } else {
8557     _has_bits_[0] &= ~0x00000001u;
8558   }
8559   key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
8560   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
8561 }
8562 
8563 // optional bytes value = 2;
_internal_has_value()8564 inline bool ThreatEntryMetadata_MetadataEntry::_internal_has_value() const {
8565   bool value = (_has_bits_[0] & 0x00000002u) != 0;
8566   return value;
8567 }
has_value()8568 inline bool ThreatEntryMetadata_MetadataEntry::has_value() const {
8569   return _internal_has_value();
8570 }
clear_value()8571 inline void ThreatEntryMetadata_MetadataEntry::clear_value() {
8572   value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8573   _has_bits_[0] &= ~0x00000002u;
8574 }
value()8575 inline const std::string& ThreatEntryMetadata_MetadataEntry::value() const {
8576   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8577   return _internal_value();
8578 }
set_value(const std::string & value)8579 inline void ThreatEntryMetadata_MetadataEntry::set_value(const std::string& value) {
8580   _internal_set_value(value);
8581   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8582 }
mutable_value()8583 inline std::string* ThreatEntryMetadata_MetadataEntry::mutable_value() {
8584   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8585   return _internal_mutable_value();
8586 }
_internal_value()8587 inline const std::string& ThreatEntryMetadata_MetadataEntry::_internal_value() const {
8588   return value_.GetNoArena();
8589 }
_internal_set_value(const std::string & value)8590 inline void ThreatEntryMetadata_MetadataEntry::_internal_set_value(const std::string& value) {
8591   _has_bits_[0] |= 0x00000002u;
8592   value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
8593 }
set_value(std::string && value)8594 inline void ThreatEntryMetadata_MetadataEntry::set_value(std::string&& value) {
8595   _has_bits_[0] |= 0x00000002u;
8596   value_.SetNoArena(
8597     &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8598   // @@protoc_insertion_point(field_set_rvalue:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8599 }
set_value(const char * value)8600 inline void ThreatEntryMetadata_MetadataEntry::set_value(const char* value) {
8601   GOOGLE_DCHECK(value != nullptr);
8602   _has_bits_[0] |= 0x00000002u;
8603   value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8604   // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8605 }
set_value(const void * value,size_t size)8606 inline void ThreatEntryMetadata_MetadataEntry::set_value(const void* value, size_t size) {
8607   _has_bits_[0] |= 0x00000002u;
8608   value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
8609       ::std::string(reinterpret_cast<const char*>(value), size));
8610   // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8611 }
_internal_mutable_value()8612 inline std::string* ThreatEntryMetadata_MetadataEntry::_internal_mutable_value() {
8613   _has_bits_[0] |= 0x00000002u;
8614   return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8615 }
release_value()8616 inline std::string* ThreatEntryMetadata_MetadataEntry::release_value() {
8617   // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8618   if (!_internal_has_value()) {
8619     return nullptr;
8620   }
8621   _has_bits_[0] &= ~0x00000002u;
8622   return value_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
8623 }
set_allocated_value(std::string * value)8624 inline void ThreatEntryMetadata_MetadataEntry::set_allocated_value(std::string* value) {
8625   if (value != nullptr) {
8626     _has_bits_[0] |= 0x00000002u;
8627   } else {
8628     _has_bits_[0] &= ~0x00000002u;
8629   }
8630   value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
8631   // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
8632 }
8633 
8634 // -------------------------------------------------------------------
8635 
8636 // ThreatEntryMetadata
8637 
8638 // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
_internal_entries_size()8639 inline int ThreatEntryMetadata::_internal_entries_size() const {
8640   return entries_.size();
8641 }
entries_size()8642 inline int ThreatEntryMetadata::entries_size() const {
8643   return _internal_entries_size();
8644 }
clear_entries()8645 inline void ThreatEntryMetadata::clear_entries() {
8646   entries_.Clear();
8647 }
mutable_entries(int index)8648 inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::mutable_entries(int index) {
8649   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.entries)
8650   return entries_.Mutable(index);
8651 }
8652 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >*
mutable_entries()8653 ThreatEntryMetadata::mutable_entries() {
8654   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatEntryMetadata.entries)
8655   return &entries_;
8656 }
_internal_entries(int index)8657 inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::_internal_entries(int index) const {
8658   return entries_.Get(index);
8659 }
entries(int index)8660 inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::entries(int index) const {
8661   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.entries)
8662   return _internal_entries(index);
8663 }
_internal_add_entries()8664 inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::_internal_add_entries() {
8665   return entries_.Add();
8666 }
add_entries()8667 inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::add_entries() {
8668   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatEntryMetadata.entries)
8669   return _internal_add_entries();
8670 }
8671 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >&
entries()8672 ThreatEntryMetadata::entries() const {
8673   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatEntryMetadata.entries)
8674   return entries_;
8675 }
8676 
8677 // -------------------------------------------------------------------
8678 
8679 // ThreatListDescriptor
8680 
8681 // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
_internal_has_threat_type()8682 inline bool ThreatListDescriptor::_internal_has_threat_type() const {
8683   bool value = (_has_bits_[0] & 0x00000001u) != 0;
8684   return value;
8685 }
has_threat_type()8686 inline bool ThreatListDescriptor::has_threat_type() const {
8687   return _internal_has_threat_type();
8688 }
clear_threat_type()8689 inline void ThreatListDescriptor::clear_threat_type() {
8690   threat_type_ = 0;
8691   _has_bits_[0] &= ~0x00000001u;
8692 }
_internal_threat_type()8693 inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::_internal_threat_type() const {
8694   return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
8695 }
threat_type()8696 inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::threat_type() const {
8697   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_type)
8698   return _internal_threat_type();
8699 }
_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value)8700 inline void ThreatListDescriptor::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
8701   assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
8702   _has_bits_[0] |= 0x00000001u;
8703   threat_type_ = value;
8704 }
set_threat_type(::mozilla::safebrowsing::ThreatType value)8705 inline void ThreatListDescriptor::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
8706   _internal_set_threat_type(value);
8707   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_type)
8708 }
8709 
8710 // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
_internal_has_platform_type()8711 inline bool ThreatListDescriptor::_internal_has_platform_type() const {
8712   bool value = (_has_bits_[0] & 0x00000002u) != 0;
8713   return value;
8714 }
has_platform_type()8715 inline bool ThreatListDescriptor::has_platform_type() const {
8716   return _internal_has_platform_type();
8717 }
clear_platform_type()8718 inline void ThreatListDescriptor::clear_platform_type() {
8719   platform_type_ = 0;
8720   _has_bits_[0] &= ~0x00000002u;
8721 }
_internal_platform_type()8722 inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::_internal_platform_type() const {
8723   return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
8724 }
platform_type()8725 inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::platform_type() const {
8726   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.platform_type)
8727   return _internal_platform_type();
8728 }
_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value)8729 inline void ThreatListDescriptor::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
8730   assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
8731   _has_bits_[0] |= 0x00000002u;
8732   platform_type_ = value;
8733 }
set_platform_type(::mozilla::safebrowsing::PlatformType value)8734 inline void ThreatListDescriptor::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
8735   _internal_set_platform_type(value);
8736   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.platform_type)
8737 }
8738 
8739 // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
_internal_has_threat_entry_type()8740 inline bool ThreatListDescriptor::_internal_has_threat_entry_type() const {
8741   bool value = (_has_bits_[0] & 0x00000004u) != 0;
8742   return value;
8743 }
has_threat_entry_type()8744 inline bool ThreatListDescriptor::has_threat_entry_type() const {
8745   return _internal_has_threat_entry_type();
8746 }
clear_threat_entry_type()8747 inline void ThreatListDescriptor::clear_threat_entry_type() {
8748   threat_entry_type_ = 0;
8749   _has_bits_[0] &= ~0x00000004u;
8750 }
_internal_threat_entry_type()8751 inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::_internal_threat_entry_type() const {
8752   return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
8753 }
threat_entry_type()8754 inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::threat_entry_type() const {
8755   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type)
8756   return _internal_threat_entry_type();
8757 }
_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)8758 inline void ThreatListDescriptor::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
8759   assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
8760   _has_bits_[0] |= 0x00000004u;
8761   threat_entry_type_ = value;
8762 }
set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value)8763 inline void ThreatListDescriptor::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
8764   _internal_set_threat_entry_type(value);
8765   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type)
8766 }
8767 
8768 // -------------------------------------------------------------------
8769 
8770 // ListThreatListsResponse
8771 
8772 // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
_internal_threat_lists_size()8773 inline int ListThreatListsResponse::_internal_threat_lists_size() const {
8774   return threat_lists_.size();
8775 }
threat_lists_size()8776 inline int ListThreatListsResponse::threat_lists_size() const {
8777   return _internal_threat_lists_size();
8778 }
clear_threat_lists()8779 inline void ListThreatListsResponse::clear_threat_lists() {
8780   threat_lists_.Clear();
8781 }
mutable_threat_lists(int index)8782 inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::mutable_threat_lists(int index) {
8783   // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
8784   return threat_lists_.Mutable(index);
8785 }
8786 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >*
mutable_threat_lists()8787 ListThreatListsResponse::mutable_threat_lists() {
8788   // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
8789   return &threat_lists_;
8790 }
_internal_threat_lists(int index)8791 inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::_internal_threat_lists(int index) const {
8792   return threat_lists_.Get(index);
8793 }
threat_lists(int index)8794 inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::threat_lists(int index) const {
8795   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
8796   return _internal_threat_lists(index);
8797 }
_internal_add_threat_lists()8798 inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::_internal_add_threat_lists() {
8799   return threat_lists_.Add();
8800 }
add_threat_lists()8801 inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::add_threat_lists() {
8802   // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
8803   return _internal_add_threat_lists();
8804 }
8805 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >&
threat_lists()8806 ListThreatListsResponse::threat_lists() const {
8807   // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
8808   return threat_lists_;
8809 }
8810 
8811 // -------------------------------------------------------------------
8812 
8813 // Duration
8814 
8815 // optional int64 seconds = 1;
_internal_has_seconds()8816 inline bool Duration::_internal_has_seconds() const {
8817   bool value = (_has_bits_[0] & 0x00000001u) != 0;
8818   return value;
8819 }
has_seconds()8820 inline bool Duration::has_seconds() const {
8821   return _internal_has_seconds();
8822 }
clear_seconds()8823 inline void Duration::clear_seconds() {
8824   seconds_ = PROTOBUF_LONGLONG(0);
8825   _has_bits_[0] &= ~0x00000001u;
8826 }
_internal_seconds()8827 inline ::PROTOBUF_NAMESPACE_ID::int64 Duration::_internal_seconds() const {
8828   return seconds_;
8829 }
seconds()8830 inline ::PROTOBUF_NAMESPACE_ID::int64 Duration::seconds() const {
8831   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.seconds)
8832   return _internal_seconds();
8833 }
_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value)8834 inline void Duration::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
8835   _has_bits_[0] |= 0x00000001u;
8836   seconds_ = value;
8837 }
set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value)8838 inline void Duration::set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
8839   _internal_set_seconds(value);
8840   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.seconds)
8841 }
8842 
8843 // optional int32 nanos = 2;
_internal_has_nanos()8844 inline bool Duration::_internal_has_nanos() const {
8845   bool value = (_has_bits_[0] & 0x00000002u) != 0;
8846   return value;
8847 }
has_nanos()8848 inline bool Duration::has_nanos() const {
8849   return _internal_has_nanos();
8850 }
clear_nanos()8851 inline void Duration::clear_nanos() {
8852   nanos_ = 0;
8853   _has_bits_[0] &= ~0x00000002u;
8854 }
_internal_nanos()8855 inline ::PROTOBUF_NAMESPACE_ID::int32 Duration::_internal_nanos() const {
8856   return nanos_;
8857 }
nanos()8858 inline ::PROTOBUF_NAMESPACE_ID::int32 Duration::nanos() const {
8859   // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.nanos)
8860   return _internal_nanos();
8861 }
_internal_set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value)8862 inline void Duration::_internal_set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value) {
8863   _has_bits_[0] |= 0x00000002u;
8864   nanos_ = value;
8865 }
set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value)8866 inline void Duration::set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value) {
8867   _internal_set_nanos(value);
8868   // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.nanos)
8869 }
8870 
8871 #ifdef __GNUC__
8872   #pragma GCC diagnostic pop
8873 #endif  // __GNUC__
8874 // -------------------------------------------------------------------
8875 
8876 // -------------------------------------------------------------------
8877 
8878 // -------------------------------------------------------------------
8879 
8880 // -------------------------------------------------------------------
8881 
8882 // -------------------------------------------------------------------
8883 
8884 // -------------------------------------------------------------------
8885 
8886 // -------------------------------------------------------------------
8887 
8888 // -------------------------------------------------------------------
8889 
8890 // -------------------------------------------------------------------
8891 
8892 // -------------------------------------------------------------------
8893 
8894 // -------------------------------------------------------------------
8895 
8896 // -------------------------------------------------------------------
8897 
8898 // -------------------------------------------------------------------
8899 
8900 // -------------------------------------------------------------------
8901 
8902 // -------------------------------------------------------------------
8903 
8904 // -------------------------------------------------------------------
8905 
8906 // -------------------------------------------------------------------
8907 
8908 // -------------------------------------------------------------------
8909 
8910 // -------------------------------------------------------------------
8911 
8912 // -------------------------------------------------------------------
8913 
8914 // -------------------------------------------------------------------
8915 
8916 // -------------------------------------------------------------------
8917 
8918 // -------------------------------------------------------------------
8919 
8920 // -------------------------------------------------------------------
8921 
8922 // -------------------------------------------------------------------
8923 
8924 // -------------------------------------------------------------------
8925 
8926 
8927 // @@protoc_insertion_point(namespace_scope)
8928 
8929 }  // namespace safebrowsing
8930 }  // namespace mozilla
8931 
8932 PROTOBUF_NAMESPACE_OPEN
8933 
8934 template <> struct is_proto_enum< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType> : ::std::true_type {};
8935 template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType> : ::std::true_type {};
8936 template <> struct is_proto_enum< ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation> : ::std::true_type {};
8937 template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatType> : ::std::true_type {};
8938 template <> struct is_proto_enum< ::mozilla::safebrowsing::PlatformType> : ::std::true_type {};
8939 template <> struct is_proto_enum< ::mozilla::safebrowsing::CompressionType> : ::std::true_type {};
8940 template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatEntryType> : ::std::true_type {};
8941 
8942 PROTOBUF_NAMESPACE_CLOSE
8943 
8944 // @@protoc_insertion_point(global_scope)
8945 
8946 #include <google/protobuf/port_undef.inc>
8947 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto
8948