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