diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /toolkit/components/url-classifier/chromium/safebrowsing.pb.h | |
parent | Initial commit. (diff) | |
download | thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | toolkit/components/url-classifier/chromium/safebrowsing.pb.h | 10010 |
1 files changed, 10010 insertions, 0 deletions
diff --git a/toolkit/components/url-classifier/chromium/safebrowsing.pb.h b/toolkit/components/url-classifier/chromium/safebrowsing.pb.h new file mode 100644 index 0000000000..194b2c410f --- /dev/null +++ b/toolkit/components/url-classifier/chromium/safebrowsing.pb.h @@ -0,0 +1,10010 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: safebrowsing.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto + +#include <limits> +#include <string> + +#include <google/protobuf/port_def.inc> +#if PROTOBUF_VERSION < 3021000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include <google/protobuf/port_undef.inc> +#include <google/protobuf/io/coded_stream.h> +#include <google/protobuf/arena.h> +#include <google/protobuf/arenastring.h> +#include <google/protobuf/generated_message_util.h> +#include <google/protobuf/metadata_lite.h> +#include <google/protobuf/message_lite.h> +#include <google/protobuf/repeated_field.h> // IWYU pragma: export +#include <google/protobuf/extension_set.h> // IWYU pragma: export +#include <google/protobuf/generated_enum_util.h> +// @@protoc_insertion_point(includes) +#include <google/protobuf/port_def.inc> +#define PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_safebrowsing_2eproto { + static const uint32_t offsets[]; +}; +namespace mozilla { +namespace safebrowsing { +class Checksum; +struct ChecksumDefaultTypeInternal; +extern ChecksumDefaultTypeInternal _Checksum_default_instance_; +class ChromeClientInfo; +struct ChromeClientInfoDefaultTypeInternal; +extern ChromeClientInfoDefaultTypeInternal _ChromeClientInfo_default_instance_; +class ClientInfo; +struct ClientInfoDefaultTypeInternal; +extern ClientInfoDefaultTypeInternal _ClientInfo_default_instance_; +class Duration; +struct DurationDefaultTypeInternal; +extern DurationDefaultTypeInternal _Duration_default_instance_; +class FetchThreatListUpdatesRequest; +struct FetchThreatListUpdatesRequestDefaultTypeInternal; +extern FetchThreatListUpdatesRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_default_instance_; +class FetchThreatListUpdatesRequest_ListUpdateRequest; +struct FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal; +extern FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_; +class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints; +struct FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal; +extern FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_; +class FetchThreatListUpdatesResponse; +struct FetchThreatListUpdatesResponseDefaultTypeInternal; +extern FetchThreatListUpdatesResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_default_instance_; +class FetchThreatListUpdatesResponse_ListUpdateResponse; +struct FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal; +extern FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_; +class FindFullHashesRequest; +struct FindFullHashesRequestDefaultTypeInternal; +extern FindFullHashesRequestDefaultTypeInternal _FindFullHashesRequest_default_instance_; +class FindFullHashesResponse; +struct FindFullHashesResponseDefaultTypeInternal; +extern FindFullHashesResponseDefaultTypeInternal _FindFullHashesResponse_default_instance_; +class FindThreatMatchesRequest; +struct FindThreatMatchesRequestDefaultTypeInternal; +extern FindThreatMatchesRequestDefaultTypeInternal _FindThreatMatchesRequest_default_instance_; +class FindThreatMatchesResponse; +struct FindThreatMatchesResponseDefaultTypeInternal; +extern FindThreatMatchesResponseDefaultTypeInternal _FindThreatMatchesResponse_default_instance_; +class ListThreatListsResponse; +struct ListThreatListsResponseDefaultTypeInternal; +extern ListThreatListsResponseDefaultTypeInternal _ListThreatListsResponse_default_instance_; +class RawHashes; +struct RawHashesDefaultTypeInternal; +extern RawHashesDefaultTypeInternal _RawHashes_default_instance_; +class RawIndices; +struct RawIndicesDefaultTypeInternal; +extern RawIndicesDefaultTypeInternal _RawIndices_default_instance_; +class RiceDeltaEncoding; +struct RiceDeltaEncodingDefaultTypeInternal; +extern RiceDeltaEncodingDefaultTypeInternal _RiceDeltaEncoding_default_instance_; +class ThreatEntry; +struct ThreatEntryDefaultTypeInternal; +extern ThreatEntryDefaultTypeInternal _ThreatEntry_default_instance_; +class ThreatEntryMetadata; +struct ThreatEntryMetadataDefaultTypeInternal; +extern ThreatEntryMetadataDefaultTypeInternal _ThreatEntryMetadata_default_instance_; +class ThreatEntryMetadata_MetadataEntry; +struct ThreatEntryMetadata_MetadataEntryDefaultTypeInternal; +extern ThreatEntryMetadata_MetadataEntryDefaultTypeInternal _ThreatEntryMetadata_MetadataEntry_default_instance_; +class ThreatEntrySet; +struct ThreatEntrySetDefaultTypeInternal; +extern ThreatEntrySetDefaultTypeInternal _ThreatEntrySet_default_instance_; +class ThreatHit; +struct ThreatHitDefaultTypeInternal; +extern ThreatHitDefaultTypeInternal _ThreatHit_default_instance_; +class ThreatHit_ThreatSource; +struct ThreatHit_ThreatSourceDefaultTypeInternal; +extern ThreatHit_ThreatSourceDefaultTypeInternal _ThreatHit_ThreatSource_default_instance_; +class ThreatHit_UserInfo; +struct ThreatHit_UserInfoDefaultTypeInternal; +extern ThreatHit_UserInfoDefaultTypeInternal _ThreatHit_UserInfo_default_instance_; +class ThreatInfo; +struct ThreatInfoDefaultTypeInternal; +extern ThreatInfoDefaultTypeInternal _ThreatInfo_default_instance_; +class ThreatListDescriptor; +struct ThreatListDescriptorDefaultTypeInternal; +extern ThreatListDescriptorDefaultTypeInternal _ThreatListDescriptor_default_instance_; +class ThreatMatch; +struct ThreatMatchDefaultTypeInternal; +extern ThreatMatchDefaultTypeInternal _ThreatMatch_default_instance_; +} // namespace safebrowsing +} // namespace mozilla +PROTOBUF_NAMESPACE_OPEN +template<> ::mozilla::safebrowsing::Checksum* Arena::CreateMaybeMessage<::mozilla::safebrowsing::Checksum>(Arena*); +template<> ::mozilla::safebrowsing::ChromeClientInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ChromeClientInfo>(Arena*); +template<> ::mozilla::safebrowsing::ClientInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(Arena*); +template<> ::mozilla::safebrowsing::Duration* Arena::CreateMaybeMessage<::mozilla::safebrowsing::Duration>(Arena*); +template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest>(Arena*); +template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest>(Arena*); +template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(Arena*); +template<> ::mozilla::safebrowsing::FetchThreatListUpdatesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesResponse>(Arena*); +template<> ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse>(Arena*); +template<> ::mozilla::safebrowsing::FindFullHashesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindFullHashesRequest>(Arena*); +template<> ::mozilla::safebrowsing::FindFullHashesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindFullHashesResponse>(Arena*); +template<> ::mozilla::safebrowsing::FindThreatMatchesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindThreatMatchesRequest>(Arena*); +template<> ::mozilla::safebrowsing::FindThreatMatchesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindThreatMatchesResponse>(Arena*); +template<> ::mozilla::safebrowsing::ListThreatListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ListThreatListsResponse>(Arena*); +template<> ::mozilla::safebrowsing::RawHashes* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RawHashes>(Arena*); +template<> ::mozilla::safebrowsing::RawIndices* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RawIndices>(Arena*); +template<> ::mozilla::safebrowsing::RiceDeltaEncoding* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(Arena*); +template<> ::mozilla::safebrowsing::ThreatEntry* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(Arena*); +template<> ::mozilla::safebrowsing::ThreatEntryMetadata* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata>(Arena*); +template<> ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry>(Arena*); +template<> ::mozilla::safebrowsing::ThreatEntrySet* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntrySet>(Arena*); +template<> ::mozilla::safebrowsing::ThreatHit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit>(Arena*); +template<> ::mozilla::safebrowsing::ThreatHit_ThreatSource* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_ThreatSource>(Arena*); +template<> ::mozilla::safebrowsing::ThreatHit_UserInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_UserInfo>(Arena*); +template<> ::mozilla::safebrowsing::ThreatInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(Arena*); +template<> ::mozilla::safebrowsing::ThreatListDescriptor* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatListDescriptor>(Arena*); +template<> ::mozilla::safebrowsing::ThreatMatch* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatMatch>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace mozilla { +namespace safebrowsing { + +enum FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType : int { + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED = 0, + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE = 1, + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE = 2 +}; +bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value); +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED; +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE; +constexpr int FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX + 1; + +const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value); +template<typename T> +inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(T enum_t_value) { + static_assert(::std::is_same<T, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name."); + return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(static_cast<FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>(enum_t_value)); +} +bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType* value); +enum ThreatHit_ThreatSourceType : int { + ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED = 0, + ThreatHit_ThreatSourceType_MATCHING_URL = 1, + ThreatHit_ThreatSourceType_TAB_URL = 2, + ThreatHit_ThreatSourceType_TAB_REDIRECT = 3, + ThreatHit_ThreatSourceType_TAB_RESOURCE = 4 +}; +bool ThreatHit_ThreatSourceType_IsValid(int value); +constexpr ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MIN = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED; +constexpr ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MAX = ThreatHit_ThreatSourceType_TAB_RESOURCE; +constexpr int ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE = ThreatHit_ThreatSourceType_ThreatSourceType_MAX + 1; + +const std::string& ThreatHit_ThreatSourceType_Name(ThreatHit_ThreatSourceType value); +template<typename T> +inline const std::string& ThreatHit_ThreatSourceType_Name(T enum_t_value) { + static_assert(::std::is_same<T, ThreatHit_ThreatSourceType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function ThreatHit_ThreatSourceType_Name."); + return ThreatHit_ThreatSourceType_Name(static_cast<ThreatHit_ThreatSourceType>(enum_t_value)); +} +bool ThreatHit_ThreatSourceType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatHit_ThreatSourceType* value); +enum ChromeClientInfo_SafeBrowsingReportingPopulation : int { + ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED = 0, + ChromeClientInfo_SafeBrowsingReportingPopulation_OPT_OUT = 1, + ChromeClientInfo_SafeBrowsingReportingPopulation_EXTENDED = 2, + ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT = 3 +}; +bool ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(int value); +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MIN = ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED; +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX = ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT; +constexpr int ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_ARRAYSIZE = ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX + 1; + +const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name(ChromeClientInfo_SafeBrowsingReportingPopulation value); +template<typename T> +inline const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name(T enum_t_value) { + static_assert(::std::is_same<T, ChromeClientInfo_SafeBrowsingReportingPopulation>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function ChromeClientInfo_SafeBrowsingReportingPopulation_Name."); + return ChromeClientInfo_SafeBrowsingReportingPopulation_Name(static_cast<ChromeClientInfo_SafeBrowsingReportingPopulation>(enum_t_value)); +} +bool ChromeClientInfo_SafeBrowsingReportingPopulation_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeClientInfo_SafeBrowsingReportingPopulation* value); +enum ThreatType : int { + THREAT_TYPE_UNSPECIFIED = 0, + MALWARE_THREAT = 1, + SOCIAL_ENGINEERING_PUBLIC = 2, + UNWANTED_SOFTWARE = 3, + POTENTIALLY_HARMFUL_APPLICATION = 4, + SOCIAL_ENGINEERING = 5, + API_ABUSE = 6, + MALICIOUS_BINARY = 7, + CSD_WHITELIST = 8, + CSD_DOWNLOAD_WHITELIST = 9, + CLIENT_INCIDENT = 10, + SUBRESOURCE_FILTER = 13 +}; +bool ThreatType_IsValid(int value); +constexpr ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED; +constexpr ThreatType ThreatType_MAX = SUBRESOURCE_FILTER; +constexpr int ThreatType_ARRAYSIZE = ThreatType_MAX + 1; + +const std::string& ThreatType_Name(ThreatType value); +template<typename T> +inline const std::string& ThreatType_Name(T enum_t_value) { + static_assert(::std::is_same<T, ThreatType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function ThreatType_Name."); + return ThreatType_Name(static_cast<ThreatType>(enum_t_value)); +} +bool ThreatType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatType* value); +enum PlatformType : int { + PLATFORM_TYPE_UNSPECIFIED = 0, + WINDOWS_PLATFORM = 1, + LINUX_PLATFORM = 2, + ANDROID_PLATFORM = 3, + OSX_PLATFORM = 4, + IOS_PLATFORM = 5, + ANY_PLATFORM = 6, + ALL_PLATFORMS = 7, + CHROME_PLATFORM = 8 +}; +bool PlatformType_IsValid(int value); +constexpr PlatformType PlatformType_MIN = PLATFORM_TYPE_UNSPECIFIED; +constexpr PlatformType PlatformType_MAX = CHROME_PLATFORM; +constexpr int PlatformType_ARRAYSIZE = PlatformType_MAX + 1; + +const std::string& PlatformType_Name(PlatformType value); +template<typename T> +inline const std::string& PlatformType_Name(T enum_t_value) { + static_assert(::std::is_same<T, PlatformType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function PlatformType_Name."); + return PlatformType_Name(static_cast<PlatformType>(enum_t_value)); +} +bool PlatformType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlatformType* value); +enum CompressionType : int { + COMPRESSION_TYPE_UNSPECIFIED = 0, + RAW = 1, + RICE = 2 +}; +bool CompressionType_IsValid(int value); +constexpr CompressionType CompressionType_MIN = COMPRESSION_TYPE_UNSPECIFIED; +constexpr CompressionType CompressionType_MAX = RICE; +constexpr int CompressionType_ARRAYSIZE = CompressionType_MAX + 1; + +const std::string& CompressionType_Name(CompressionType value); +template<typename T> +inline const std::string& CompressionType_Name(T enum_t_value) { + static_assert(::std::is_same<T, CompressionType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function CompressionType_Name."); + return CompressionType_Name(static_cast<CompressionType>(enum_t_value)); +} +bool CompressionType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressionType* value); +enum ThreatEntryType : int { + THREAT_ENTRY_TYPE_UNSPECIFIED = 0, + URL = 1, + EXECUTABLE = 2, + IP_RANGE = 3, + CHROME_EXTENSION = 4, + FILENAME = 5, + CERT = 6 +}; +bool ThreatEntryType_IsValid(int value); +constexpr ThreatEntryType ThreatEntryType_MIN = THREAT_ENTRY_TYPE_UNSPECIFIED; +constexpr ThreatEntryType ThreatEntryType_MAX = CERT; +constexpr int ThreatEntryType_ARRAYSIZE = ThreatEntryType_MAX + 1; + +const std::string& ThreatEntryType_Name(ThreatEntryType value); +template<typename T> +inline const std::string& ThreatEntryType_Name(T enum_t_value) { + static_assert(::std::is_same<T, ThreatEntryType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function ThreatEntryType_Name."); + return ThreatEntryType_Name(static_cast<ThreatEntryType>(enum_t_value)); +} +bool ThreatEntryType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatEntryType* value); +// =================================================================== + +class ThreatInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatInfo) */ { + public: + inline ThreatInfo() : ThreatInfo(nullptr) {} + ~ThreatInfo() override; + explicit PROTOBUF_CONSTEXPR ThreatInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatInfo(const ThreatInfo& from); + ThreatInfo(ThreatInfo&& from) noexcept + : ThreatInfo() { + *this = ::std::move(from); + } + + inline ThreatInfo& operator=(const ThreatInfo& from) { + CopyFrom(from); + return *this; + } + inline ThreatInfo& operator=(ThreatInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatInfo* internal_default_instance() { + return reinterpret_cast<const ThreatInfo*>( + &_ThreatInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(ThreatInfo& a, ThreatInfo& b) { + a.Swap(&b); + } + inline void Swap(ThreatInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatInfo>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatInfo& from); + void MergeFrom(const ThreatInfo& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatInfo"; + } + protected: + explicit ThreatInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kThreatTypesFieldNumber = 1, + kPlatformTypesFieldNumber = 2, + kThreatEntriesFieldNumber = 3, + kThreatEntryTypesFieldNumber = 4, + }; + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + int threat_types_size() const; + private: + int _internal_threat_types_size() const; + public: + void clear_threat_types(); + private: + ::mozilla::safebrowsing::ThreatType _internal_threat_types(int index) const; + void _internal_add_threat_types(::mozilla::safebrowsing::ThreatType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_types(); + public: + ::mozilla::safebrowsing::ThreatType threat_types(int index) const; + void set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value); + void add_threat_types(::mozilla::safebrowsing::ThreatType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_types(); + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + int platform_types_size() const; + private: + int _internal_platform_types_size() const; + public: + void clear_platform_types(); + private: + ::mozilla::safebrowsing::PlatformType _internal_platform_types(int index) const; + void _internal_add_platform_types(::mozilla::safebrowsing::PlatformType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_platform_types(); + public: + ::mozilla::safebrowsing::PlatformType platform_types(int index) const; + void set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value); + void add_platform_types(::mozilla::safebrowsing::PlatformType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& platform_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_platform_types(); + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + int threat_entries_size() const; + private: + int _internal_threat_entries_size() const; + public: + void clear_threat_entries(); + ::mozilla::safebrowsing::ThreatEntry* mutable_threat_entries(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >* + mutable_threat_entries(); + private: + const ::mozilla::safebrowsing::ThreatEntry& _internal_threat_entries(int index) const; + ::mozilla::safebrowsing::ThreatEntry* _internal_add_threat_entries(); + public: + const ::mozilla::safebrowsing::ThreatEntry& threat_entries(int index) const; + ::mozilla::safebrowsing::ThreatEntry* add_threat_entries(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >& + threat_entries() const; + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + int threat_entry_types_size() const; + private: + int _internal_threat_entry_types_size() const; + public: + void clear_threat_entry_types(); + private: + ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_types(int index) const; + void _internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_entry_types(); + public: + ::mozilla::safebrowsing::ThreatEntryType threat_entry_types(int index) const; + void set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value); + void add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_entry_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_entry_types(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatInfo) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_types_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> platform_types_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry > threat_entries_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_entry_types_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatMatch final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatMatch) */ { + public: + inline ThreatMatch() : ThreatMatch(nullptr) {} + ~ThreatMatch() override; + explicit PROTOBUF_CONSTEXPR ThreatMatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatMatch(const ThreatMatch& from); + ThreatMatch(ThreatMatch&& from) noexcept + : ThreatMatch() { + *this = ::std::move(from); + } + + inline ThreatMatch& operator=(const ThreatMatch& from) { + CopyFrom(from); + return *this; + } + inline ThreatMatch& operator=(ThreatMatch&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatMatch& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatMatch* internal_default_instance() { + return reinterpret_cast<const ThreatMatch*>( + &_ThreatMatch_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(ThreatMatch& a, ThreatMatch& b) { + a.Swap(&b); + } + inline void Swap(ThreatMatch* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatMatch* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatMatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatMatch>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatMatch& from); + void MergeFrom(const ThreatMatch& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatMatch* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatMatch"; + } + protected: + explicit ThreatMatch(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kThreatFieldNumber = 3, + kThreatEntryMetadataFieldNumber = 4, + kCacheDurationFieldNumber = 5, + kThreatTypeFieldNumber = 1, + kPlatformTypeFieldNumber = 2, + kThreatEntryTypeFieldNumber = 6, + }; + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + bool has_threat() const; + private: + bool _internal_has_threat() const; + public: + void clear_threat(); + const ::mozilla::safebrowsing::ThreatEntry& threat() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatEntry* release_threat(); + ::mozilla::safebrowsing::ThreatEntry* mutable_threat(); + void set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat); + private: + const ::mozilla::safebrowsing::ThreatEntry& _internal_threat() const; + ::mozilla::safebrowsing::ThreatEntry* _internal_mutable_threat(); + public: + void unsafe_arena_set_allocated_threat( + ::mozilla::safebrowsing::ThreatEntry* threat); + ::mozilla::safebrowsing::ThreatEntry* unsafe_arena_release_threat(); + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + bool has_threat_entry_metadata() const; + private: + bool _internal_has_threat_entry_metadata() const; + public: + void clear_threat_entry_metadata(); + const ::mozilla::safebrowsing::ThreatEntryMetadata& threat_entry_metadata() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatEntryMetadata* release_threat_entry_metadata(); + ::mozilla::safebrowsing::ThreatEntryMetadata* mutable_threat_entry_metadata(); + void set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata); + private: + const ::mozilla::safebrowsing::ThreatEntryMetadata& _internal_threat_entry_metadata() const; + ::mozilla::safebrowsing::ThreatEntryMetadata* _internal_mutable_threat_entry_metadata(); + public: + void unsafe_arena_set_allocated_threat_entry_metadata( + ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata); + ::mozilla::safebrowsing::ThreatEntryMetadata* unsafe_arena_release_threat_entry_metadata(); + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + bool has_cache_duration() const; + private: + bool _internal_has_cache_duration() const; + public: + void clear_cache_duration(); + const ::mozilla::safebrowsing::Duration& cache_duration() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_cache_duration(); + ::mozilla::safebrowsing::Duration* mutable_cache_duration(); + void set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration); + private: + const ::mozilla::safebrowsing::Duration& _internal_cache_duration() const; + ::mozilla::safebrowsing::Duration* _internal_mutable_cache_duration(); + public: + void unsafe_arena_set_allocated_cache_duration( + ::mozilla::safebrowsing::Duration* cache_duration); + ::mozilla::safebrowsing::Duration* unsafe_arena_release_cache_duration(); + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + bool has_threat_type() const; + private: + bool _internal_has_threat_type() const; + public: + void clear_threat_type(); + ::mozilla::safebrowsing::ThreatType threat_type() const; + void set_threat_type(::mozilla::safebrowsing::ThreatType value); + private: + ::mozilla::safebrowsing::ThreatType _internal_threat_type() const; + void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value); + public: + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + bool has_platform_type() const; + private: + bool _internal_has_platform_type() const; + public: + void clear_platform_type(); + ::mozilla::safebrowsing::PlatformType platform_type() const; + void set_platform_type(::mozilla::safebrowsing::PlatformType value); + private: + ::mozilla::safebrowsing::PlatformType _internal_platform_type() const; + void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value); + public: + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + bool has_threat_entry_type() const; + private: + bool _internal_has_threat_entry_type() const; + public: + void clear_threat_entry_type(); + ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + private: + ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const; + void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatMatch) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::mozilla::safebrowsing::ThreatEntry* threat_; + ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata_; + ::mozilla::safebrowsing::Duration* cache_duration_; + int threat_type_; + int platform_type_; + int threat_entry_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FindThreatMatchesRequest final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindThreatMatchesRequest) */ { + public: + inline FindThreatMatchesRequest() : FindThreatMatchesRequest(nullptr) {} + ~FindThreatMatchesRequest() override; + explicit PROTOBUF_CONSTEXPR FindThreatMatchesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FindThreatMatchesRequest(const FindThreatMatchesRequest& from); + FindThreatMatchesRequest(FindThreatMatchesRequest&& from) noexcept + : FindThreatMatchesRequest() { + *this = ::std::move(from); + } + + inline FindThreatMatchesRequest& operator=(const FindThreatMatchesRequest& from) { + CopyFrom(from); + return *this; + } + inline FindThreatMatchesRequest& operator=(FindThreatMatchesRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FindThreatMatchesRequest& default_instance() { + return *internal_default_instance(); + } + static inline const FindThreatMatchesRequest* internal_default_instance() { + return reinterpret_cast<const FindThreatMatchesRequest*>( + &_FindThreatMatchesRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(FindThreatMatchesRequest& a, FindThreatMatchesRequest& b) { + a.Swap(&b); + } + inline void Swap(FindThreatMatchesRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FindThreatMatchesRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FindThreatMatchesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FindThreatMatchesRequest>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FindThreatMatchesRequest& from); + void MergeFrom(const FindThreatMatchesRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FindThreatMatchesRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FindThreatMatchesRequest"; + } + protected: + explicit FindThreatMatchesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientFieldNumber = 1, + kThreatInfoFieldNumber = 2, + }; + // optional .mozilla.safebrowsing.ClientInfo client = 1; + bool has_client() const; + private: + bool _internal_has_client() const; + public: + void clear_client(); + const ::mozilla::safebrowsing::ClientInfo& client() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client(); + ::mozilla::safebrowsing::ClientInfo* mutable_client(); + void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client); + private: + const ::mozilla::safebrowsing::ClientInfo& _internal_client() const; + ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client(); + public: + void unsafe_arena_set_allocated_client( + ::mozilla::safebrowsing::ClientInfo* client); + ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client(); + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + bool has_threat_info() const; + private: + bool _internal_has_threat_info() const; + public: + void clear_threat_info(); + const ::mozilla::safebrowsing::ThreatInfo& threat_info() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatInfo* release_threat_info(); + ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info(); + void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info); + private: + const ::mozilla::safebrowsing::ThreatInfo& _internal_threat_info() const; + ::mozilla::safebrowsing::ThreatInfo* _internal_mutable_threat_info(); + public: + void unsafe_arena_set_allocated_threat_info( + ::mozilla::safebrowsing::ThreatInfo* threat_info); + ::mozilla::safebrowsing::ThreatInfo* unsafe_arena_release_threat_info(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::mozilla::safebrowsing::ClientInfo* client_; + ::mozilla::safebrowsing::ThreatInfo* threat_info_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FindThreatMatchesResponse final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindThreatMatchesResponse) */ { + public: + inline FindThreatMatchesResponse() : FindThreatMatchesResponse(nullptr) {} + ~FindThreatMatchesResponse() override; + explicit PROTOBUF_CONSTEXPR FindThreatMatchesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FindThreatMatchesResponse(const FindThreatMatchesResponse& from); + FindThreatMatchesResponse(FindThreatMatchesResponse&& from) noexcept + : FindThreatMatchesResponse() { + *this = ::std::move(from); + } + + inline FindThreatMatchesResponse& operator=(const FindThreatMatchesResponse& from) { + CopyFrom(from); + return *this; + } + inline FindThreatMatchesResponse& operator=(FindThreatMatchesResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FindThreatMatchesResponse& default_instance() { + return *internal_default_instance(); + } + static inline const FindThreatMatchesResponse* internal_default_instance() { + return reinterpret_cast<const FindThreatMatchesResponse*>( + &_FindThreatMatchesResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(FindThreatMatchesResponse& a, FindThreatMatchesResponse& b) { + a.Swap(&b); + } + inline void Swap(FindThreatMatchesResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FindThreatMatchesResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FindThreatMatchesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FindThreatMatchesResponse>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FindThreatMatchesResponse& from); + void MergeFrom(const FindThreatMatchesResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FindThreatMatchesResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FindThreatMatchesResponse"; + } + protected: + explicit FindThreatMatchesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMatchesFieldNumber = 1, + }; + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + int matches_size() const; + private: + int _internal_matches_size() const; + public: + void clear_matches(); + ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* + mutable_matches(); + private: + const ::mozilla::safebrowsing::ThreatMatch& _internal_matches(int index) const; + ::mozilla::safebrowsing::ThreatMatch* _internal_add_matches(); + public: + const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const; + ::mozilla::safebrowsing::ThreatMatch* add_matches(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& + matches() const; + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesResponse) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) */ { + public: + inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() : FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(nullptr) {} + ~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() override; + explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from); + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&& from) noexcept + : FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() { + *this = ::std::move(from); + } + + inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) { + CopyFrom(from); + return *this; + } + inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& default_instance() { + return *internal_default_instance(); + } + static inline const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* internal_default_instance() { + return reinterpret_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>( + &_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& a, FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& b) { + a.Swap(&b); + } + inline void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from); + void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints"; + } + protected: + explicit FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSupportedCompressionsFieldNumber = 4, + kRegionFieldNumber = 3, + kMaxUpdateEntriesFieldNumber = 1, + kMaxDatabaseEntriesFieldNumber = 2, + }; + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + int supported_compressions_size() const; + private: + int _internal_supported_compressions_size() const; + public: + void clear_supported_compressions(); + private: + ::mozilla::safebrowsing::CompressionType _internal_supported_compressions(int index) const; + void _internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_compressions(); + public: + ::mozilla::safebrowsing::CompressionType supported_compressions(int index) const; + void set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value); + void add_supported_compressions(::mozilla::safebrowsing::CompressionType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_compressions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_compressions(); + + // optional string region = 3; + bool has_region() const; + private: + bool _internal_has_region() const; + public: + void clear_region(); + const std::string& region() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_region(ArgT0&& arg0, ArgT... args); + std::string* mutable_region(); + PROTOBUF_NODISCARD std::string* release_region(); + void set_allocated_region(std::string* region); + private: + const std::string& _internal_region() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_region(const std::string& value); + std::string* _internal_mutable_region(); + public: + + // optional int32 max_update_entries = 1; + bool has_max_update_entries() const; + private: + bool _internal_has_max_update_entries() const; + public: + void clear_max_update_entries(); + int32_t max_update_entries() const; + void set_max_update_entries(int32_t value); + private: + int32_t _internal_max_update_entries() const; + void _internal_set_max_update_entries(int32_t value); + public: + + // optional int32 max_database_entries = 2; + bool has_max_database_entries() const; + private: + bool _internal_has_max_database_entries() const; + public: + void clear_max_database_entries(); + int32_t max_database_entries() const; + void set_max_database_entries(int32_t value); + private: + int32_t _internal_max_database_entries() const; + void _internal_set_max_database_entries(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_compressions_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr region_; + int32_t max_update_entries_; + int32_t max_database_entries_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesRequest_ListUpdateRequest final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) */ { + public: + inline FetchThreatListUpdatesRequest_ListUpdateRequest() : FetchThreatListUpdatesRequest_ListUpdateRequest(nullptr) {} + ~FetchThreatListUpdatesRequest_ListUpdateRequest() override; + explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from); + FetchThreatListUpdatesRequest_ListUpdateRequest(FetchThreatListUpdatesRequest_ListUpdateRequest&& from) noexcept + : FetchThreatListUpdatesRequest_ListUpdateRequest() { + *this = ::std::move(from); + } + + inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) { + CopyFrom(from); + return *this; + } + inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(FetchThreatListUpdatesRequest_ListUpdateRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FetchThreatListUpdatesRequest_ListUpdateRequest& default_instance() { + return *internal_default_instance(); + } + static inline const FetchThreatListUpdatesRequest_ListUpdateRequest* internal_default_instance() { + return reinterpret_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>( + &_FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(FetchThreatListUpdatesRequest_ListUpdateRequest& a, FetchThreatListUpdatesRequest_ListUpdateRequest& b) { + a.Swap(&b); + } + inline void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FetchThreatListUpdatesRequest_ListUpdateRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesRequest_ListUpdateRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from); + void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FetchThreatListUpdatesRequest_ListUpdateRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest"; + } + protected: + explicit FetchThreatListUpdatesRequest_ListUpdateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints Constraints; + + // accessors ------------------------------------------------------- + + enum : int { + kStateFieldNumber = 3, + kConstraintsFieldNumber = 4, + kThreatTypeFieldNumber = 1, + kPlatformTypeFieldNumber = 2, + kThreatEntryTypeFieldNumber = 5, + }; + // optional bytes state = 3; + bool has_state() const; + private: + bool _internal_has_state() const; + public: + void clear_state(); + const std::string& state() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_state(ArgT0&& arg0, ArgT... args); + std::string* mutable_state(); + PROTOBUF_NODISCARD std::string* release_state(); + void set_allocated_state(std::string* state); + private: + const std::string& _internal_state() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_state(const std::string& value); + std::string* _internal_mutable_state(); + public: + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + bool has_constraints() const; + private: + bool _internal_has_constraints() const; + public: + void clear_constraints(); + const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& constraints() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* release_constraints(); + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* mutable_constraints(); + void set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints); + private: + const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& _internal_constraints() const; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* _internal_mutable_constraints(); + public: + void unsafe_arena_set_allocated_constraints( + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints); + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* unsafe_arena_release_constraints(); + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + bool has_threat_type() const; + private: + bool _internal_has_threat_type() const; + public: + void clear_threat_type(); + ::mozilla::safebrowsing::ThreatType threat_type() const; + void set_threat_type(::mozilla::safebrowsing::ThreatType value); + private: + ::mozilla::safebrowsing::ThreatType _internal_threat_type() const; + void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value); + public: + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + bool has_platform_type() const; + private: + bool _internal_has_platform_type() const; + public: + void clear_platform_type(); + ::mozilla::safebrowsing::PlatformType platform_type() const; + void set_platform_type(::mozilla::safebrowsing::PlatformType value); + private: + ::mozilla::safebrowsing::PlatformType _internal_platform_type() const; + void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value); + public: + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + bool has_threat_entry_type() const; + private: + bool _internal_has_threat_entry_type() const; + public: + void clear_threat_entry_type(); + ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + private: + ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const; + void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr state_; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints_; + int threat_type_; + int platform_type_; + int threat_entry_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesRequest final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest) */ { + public: + inline FetchThreatListUpdatesRequest() : FetchThreatListUpdatesRequest(nullptr) {} + ~FetchThreatListUpdatesRequest() override; + explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from); + FetchThreatListUpdatesRequest(FetchThreatListUpdatesRequest&& from) noexcept + : FetchThreatListUpdatesRequest() { + *this = ::std::move(from); + } + + inline FetchThreatListUpdatesRequest& operator=(const FetchThreatListUpdatesRequest& from) { + CopyFrom(from); + return *this; + } + inline FetchThreatListUpdatesRequest& operator=(FetchThreatListUpdatesRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FetchThreatListUpdatesRequest& default_instance() { + return *internal_default_instance(); + } + static inline const FetchThreatListUpdatesRequest* internal_default_instance() { + return reinterpret_cast<const FetchThreatListUpdatesRequest*>( + &_FetchThreatListUpdatesRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(FetchThreatListUpdatesRequest& a, FetchThreatListUpdatesRequest& b) { + a.Swap(&b); + } + inline void Swap(FetchThreatListUpdatesRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FetchThreatListUpdatesRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FetchThreatListUpdatesRequest>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FetchThreatListUpdatesRequest& from); + void MergeFrom(const FetchThreatListUpdatesRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FetchThreatListUpdatesRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest"; + } + protected: + explicit FetchThreatListUpdatesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesRequest_ListUpdateRequest ListUpdateRequest; + + // accessors ------------------------------------------------------- + + enum : int { + kListUpdateRequestsFieldNumber = 3, + kClientFieldNumber = 1, + kChromeClientInfoFieldNumber = 4, + }; + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + int list_update_requests_size() const; + private: + int _internal_list_update_requests_size() const; + public: + void clear_list_update_requests(); + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* mutable_list_update_requests(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >* + mutable_list_update_requests(); + private: + const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& _internal_list_update_requests(int index) const; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* _internal_add_list_update_requests(); + public: + const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& list_update_requests(int index) const; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* add_list_update_requests(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >& + list_update_requests() const; + + // optional .mozilla.safebrowsing.ClientInfo client = 1; + bool has_client() const; + private: + bool _internal_has_client() const; + public: + void clear_client(); + const ::mozilla::safebrowsing::ClientInfo& client() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client(); + ::mozilla::safebrowsing::ClientInfo* mutable_client(); + void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client); + private: + const ::mozilla::safebrowsing::ClientInfo& _internal_client() const; + ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client(); + public: + void unsafe_arena_set_allocated_client( + ::mozilla::safebrowsing::ClientInfo* client); + ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client(); + + // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4; + bool has_chrome_client_info() const; + private: + bool _internal_has_chrome_client_info() const; + public: + void clear_chrome_client_info(); + const ::mozilla::safebrowsing::ChromeClientInfo& chrome_client_info() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ChromeClientInfo* release_chrome_client_info(); + ::mozilla::safebrowsing::ChromeClientInfo* mutable_chrome_client_info(); + void set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info); + private: + const ::mozilla::safebrowsing::ChromeClientInfo& _internal_chrome_client_info() const; + ::mozilla::safebrowsing::ChromeClientInfo* _internal_mutable_chrome_client_info(); + public: + void unsafe_arena_set_allocated_chrome_client_info( + ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info); + ::mozilla::safebrowsing::ChromeClientInfo* unsafe_arena_release_chrome_client_info(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest > list_update_requests_; + ::mozilla::safebrowsing::ClientInfo* client_; + ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesResponse_ListUpdateResponse final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) */ { + public: + inline FetchThreatListUpdatesResponse_ListUpdateResponse() : FetchThreatListUpdatesResponse_ListUpdateResponse(nullptr) {} + ~FetchThreatListUpdatesResponse_ListUpdateResponse() override; + explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse_ListUpdateResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from); + FetchThreatListUpdatesResponse_ListUpdateResponse(FetchThreatListUpdatesResponse_ListUpdateResponse&& from) noexcept + : FetchThreatListUpdatesResponse_ListUpdateResponse() { + *this = ::std::move(from); + } + + inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) { + CopyFrom(from); + return *this; + } + inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(FetchThreatListUpdatesResponse_ListUpdateResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FetchThreatListUpdatesResponse_ListUpdateResponse& default_instance() { + return *internal_default_instance(); + } + static inline const FetchThreatListUpdatesResponse_ListUpdateResponse* internal_default_instance() { + return reinterpret_cast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>( + &_FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(FetchThreatListUpdatesResponse_ListUpdateResponse& a, FetchThreatListUpdatesResponse_ListUpdateResponse& b) { + a.Swap(&b); + } + inline void Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FetchThreatListUpdatesResponse_ListUpdateResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesResponse_ListUpdateResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FetchThreatListUpdatesResponse_ListUpdateResponse>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from); + void MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FetchThreatListUpdatesResponse_ListUpdateResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse"; + } + protected: + explicit FetchThreatListUpdatesResponse_ListUpdateResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType ResponseType; + static constexpr ResponseType RESPONSE_TYPE_UNSPECIFIED = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED; + static constexpr ResponseType PARTIAL_UPDATE = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE; + static constexpr ResponseType FULL_UPDATE = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE; + static inline bool ResponseType_IsValid(int value) { + return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value); + } + static constexpr ResponseType ResponseType_MIN = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN; + static constexpr ResponseType ResponseType_MAX = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX; + static constexpr int ResponseType_ARRAYSIZE = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE; + template<typename T> + static inline const std::string& ResponseType_Name(T enum_t_value) { + static_assert(::std::is_same<T, ResponseType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function ResponseType_Name."); + return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(enum_t_value); + } + static inline bool ResponseType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ResponseType* value) { + return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kAdditionsFieldNumber = 5, + kRemovalsFieldNumber = 6, + kNewClientStateFieldNumber = 7, + kChecksumFieldNumber = 8, + kThreatTypeFieldNumber = 1, + kThreatEntryTypeFieldNumber = 2, + kPlatformTypeFieldNumber = 3, + kResponseTypeFieldNumber = 4, + }; + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + int additions_size() const; + private: + int _internal_additions_size() const; + public: + void clear_additions(); + ::mozilla::safebrowsing::ThreatEntrySet* mutable_additions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* + mutable_additions(); + private: + const ::mozilla::safebrowsing::ThreatEntrySet& _internal_additions(int index) const; + ::mozilla::safebrowsing::ThreatEntrySet* _internal_add_additions(); + public: + const ::mozilla::safebrowsing::ThreatEntrySet& additions(int index) const; + ::mozilla::safebrowsing::ThreatEntrySet* add_additions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& + additions() const; + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + int removals_size() const; + private: + int _internal_removals_size() const; + public: + void clear_removals(); + ::mozilla::safebrowsing::ThreatEntrySet* mutable_removals(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* + mutable_removals(); + private: + const ::mozilla::safebrowsing::ThreatEntrySet& _internal_removals(int index) const; + ::mozilla::safebrowsing::ThreatEntrySet* _internal_add_removals(); + public: + const ::mozilla::safebrowsing::ThreatEntrySet& removals(int index) const; + ::mozilla::safebrowsing::ThreatEntrySet* add_removals(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& + removals() const; + + // optional bytes new_client_state = 7; + bool has_new_client_state() const; + private: + bool _internal_has_new_client_state() const; + public: + void clear_new_client_state(); + const std::string& new_client_state() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_new_client_state(ArgT0&& arg0, ArgT... args); + std::string* mutable_new_client_state(); + PROTOBUF_NODISCARD std::string* release_new_client_state(); + void set_allocated_new_client_state(std::string* new_client_state); + private: + const std::string& _internal_new_client_state() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_new_client_state(const std::string& value); + std::string* _internal_mutable_new_client_state(); + public: + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + bool has_checksum() const; + private: + bool _internal_has_checksum() const; + public: + void clear_checksum(); + const ::mozilla::safebrowsing::Checksum& checksum() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::Checksum* release_checksum(); + ::mozilla::safebrowsing::Checksum* mutable_checksum(); + void set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum); + private: + const ::mozilla::safebrowsing::Checksum& _internal_checksum() const; + ::mozilla::safebrowsing::Checksum* _internal_mutable_checksum(); + public: + void unsafe_arena_set_allocated_checksum( + ::mozilla::safebrowsing::Checksum* checksum); + ::mozilla::safebrowsing::Checksum* unsafe_arena_release_checksum(); + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + bool has_threat_type() const; + private: + bool _internal_has_threat_type() const; + public: + void clear_threat_type(); + ::mozilla::safebrowsing::ThreatType threat_type() const; + void set_threat_type(::mozilla::safebrowsing::ThreatType value); + private: + ::mozilla::safebrowsing::ThreatType _internal_threat_type() const; + void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value); + public: + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + bool has_threat_entry_type() const; + private: + bool _internal_has_threat_entry_type() const; + public: + void clear_threat_entry_type(); + ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + private: + ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const; + void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + public: + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + bool has_platform_type() const; + private: + bool _internal_has_platform_type() const; + public: + void clear_platform_type(); + ::mozilla::safebrowsing::PlatformType platform_type() const; + void set_platform_type(::mozilla::safebrowsing::PlatformType value); + private: + ::mozilla::safebrowsing::PlatformType _internal_platform_type() const; + void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value); + public: + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + bool has_response_type() const; + private: + bool _internal_has_response_type() const; + public: + void clear_response_type(); + ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType response_type() const; + void set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value); + private: + ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType _internal_response_type() const; + void _internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > additions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > removals_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_client_state_; + ::mozilla::safebrowsing::Checksum* checksum_; + int threat_type_; + int threat_entry_type_; + int platform_type_; + int response_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesResponse final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesResponse) */ { + public: + inline FetchThreatListUpdatesResponse() : FetchThreatListUpdatesResponse(nullptr) {} + ~FetchThreatListUpdatesResponse() override; + explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from); + FetchThreatListUpdatesResponse(FetchThreatListUpdatesResponse&& from) noexcept + : FetchThreatListUpdatesResponse() { + *this = ::std::move(from); + } + + inline FetchThreatListUpdatesResponse& operator=(const FetchThreatListUpdatesResponse& from) { + CopyFrom(from); + return *this; + } + inline FetchThreatListUpdatesResponse& operator=(FetchThreatListUpdatesResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FetchThreatListUpdatesResponse& default_instance() { + return *internal_default_instance(); + } + static inline const FetchThreatListUpdatesResponse* internal_default_instance() { + return reinterpret_cast<const FetchThreatListUpdatesResponse*>( + &_FetchThreatListUpdatesResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(FetchThreatListUpdatesResponse& a, FetchThreatListUpdatesResponse& b) { + a.Swap(&b); + } + inline void Swap(FetchThreatListUpdatesResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FetchThreatListUpdatesResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FetchThreatListUpdatesResponse>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FetchThreatListUpdatesResponse& from); + void MergeFrom(const FetchThreatListUpdatesResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FetchThreatListUpdatesResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FetchThreatListUpdatesResponse"; + } + protected: + explicit FetchThreatListUpdatesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesResponse_ListUpdateResponse ListUpdateResponse; + + // accessors ------------------------------------------------------- + + enum : int { + kListUpdateResponsesFieldNumber = 1, + kMinimumWaitDurationFieldNumber = 2, + }; + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + int list_update_responses_size() const; + private: + int _internal_list_update_responses_size() const; + public: + void clear_list_update_responses(); + ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* mutable_list_update_responses(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >* + mutable_list_update_responses(); + private: + const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& _internal_list_update_responses(int index) const; + ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* _internal_add_list_update_responses(); + public: + const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& list_update_responses(int index) const; + ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* add_list_update_responses(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >& + list_update_responses() const; + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + bool has_minimum_wait_duration() const; + private: + bool _internal_has_minimum_wait_duration() const; + public: + void clear_minimum_wait_duration(); + const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_minimum_wait_duration(); + ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration(); + void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration); + private: + const ::mozilla::safebrowsing::Duration& _internal_minimum_wait_duration() const; + ::mozilla::safebrowsing::Duration* _internal_mutable_minimum_wait_duration(); + public: + void unsafe_arena_set_allocated_minimum_wait_duration( + ::mozilla::safebrowsing::Duration* minimum_wait_duration); + ::mozilla::safebrowsing::Duration* unsafe_arena_release_minimum_wait_duration(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse > list_update_responses_; + ::mozilla::safebrowsing::Duration* minimum_wait_duration_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FindFullHashesRequest final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindFullHashesRequest) */ { + public: + inline FindFullHashesRequest() : FindFullHashesRequest(nullptr) {} + ~FindFullHashesRequest() override; + explicit PROTOBUF_CONSTEXPR FindFullHashesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FindFullHashesRequest(const FindFullHashesRequest& from); + FindFullHashesRequest(FindFullHashesRequest&& from) noexcept + : FindFullHashesRequest() { + *this = ::std::move(from); + } + + inline FindFullHashesRequest& operator=(const FindFullHashesRequest& from) { + CopyFrom(from); + return *this; + } + inline FindFullHashesRequest& operator=(FindFullHashesRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FindFullHashesRequest& default_instance() { + return *internal_default_instance(); + } + static inline const FindFullHashesRequest* internal_default_instance() { + return reinterpret_cast<const FindFullHashesRequest*>( + &_FindFullHashesRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(FindFullHashesRequest& a, FindFullHashesRequest& b) { + a.Swap(&b); + } + inline void Swap(FindFullHashesRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FindFullHashesRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FindFullHashesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FindFullHashesRequest>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FindFullHashesRequest& from); + void MergeFrom(const FindFullHashesRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FindFullHashesRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FindFullHashesRequest"; + } + protected: + explicit FindFullHashesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientStatesFieldNumber = 2, + kClientFieldNumber = 1, + kThreatInfoFieldNumber = 3, + }; + // repeated bytes client_states = 2; + int client_states_size() const; + private: + int _internal_client_states_size() const; + public: + void clear_client_states(); + const std::string& client_states(int index) const; + std::string* mutable_client_states(int index); + void set_client_states(int index, const std::string& value); + void set_client_states(int index, std::string&& value); + void set_client_states(int index, const char* value); + void set_client_states(int index, const void* value, size_t size); + std::string* add_client_states(); + void add_client_states(const std::string& value); + void add_client_states(std::string&& value); + void add_client_states(const char* value); + void add_client_states(const void* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& client_states() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_client_states(); + private: + const std::string& _internal_client_states(int index) const; + std::string* _internal_add_client_states(); + public: + + // optional .mozilla.safebrowsing.ClientInfo client = 1; + bool has_client() const; + private: + bool _internal_has_client() const; + public: + void clear_client(); + const ::mozilla::safebrowsing::ClientInfo& client() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client(); + ::mozilla::safebrowsing::ClientInfo* mutable_client(); + void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client); + private: + const ::mozilla::safebrowsing::ClientInfo& _internal_client() const; + ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client(); + public: + void unsafe_arena_set_allocated_client( + ::mozilla::safebrowsing::ClientInfo* client); + ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client(); + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + bool has_threat_info() const; + private: + bool _internal_has_threat_info() const; + public: + void clear_threat_info(); + const ::mozilla::safebrowsing::ThreatInfo& threat_info() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatInfo* release_threat_info(); + ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info(); + void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info); + private: + const ::mozilla::safebrowsing::ThreatInfo& _internal_threat_info() const; + ::mozilla::safebrowsing::ThreatInfo* _internal_mutable_threat_info(); + public: + void unsafe_arena_set_allocated_threat_info( + ::mozilla::safebrowsing::ThreatInfo* threat_info); + ::mozilla::safebrowsing::ThreatInfo* unsafe_arena_release_threat_info(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> client_states_; + ::mozilla::safebrowsing::ClientInfo* client_; + ::mozilla::safebrowsing::ThreatInfo* threat_info_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class FindFullHashesResponse final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindFullHashesResponse) */ { + public: + inline FindFullHashesResponse() : FindFullHashesResponse(nullptr) {} + ~FindFullHashesResponse() override; + explicit PROTOBUF_CONSTEXPR FindFullHashesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FindFullHashesResponse(const FindFullHashesResponse& from); + FindFullHashesResponse(FindFullHashesResponse&& from) noexcept + : FindFullHashesResponse() { + *this = ::std::move(from); + } + + inline FindFullHashesResponse& operator=(const FindFullHashesResponse& from) { + CopyFrom(from); + return *this; + } + inline FindFullHashesResponse& operator=(FindFullHashesResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const FindFullHashesResponse& default_instance() { + return *internal_default_instance(); + } + static inline const FindFullHashesResponse* internal_default_instance() { + return reinterpret_cast<const FindFullHashesResponse*>( + &_FindFullHashesResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(FindFullHashesResponse& a, FindFullHashesResponse& b) { + a.Swap(&b); + } + inline void Swap(FindFullHashesResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FindFullHashesResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FindFullHashesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<FindFullHashesResponse>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const FindFullHashesResponse& from); + void MergeFrom(const FindFullHashesResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FindFullHashesResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.FindFullHashesResponse"; + } + protected: + explicit FindFullHashesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMatchesFieldNumber = 1, + kMinimumWaitDurationFieldNumber = 2, + kNegativeCacheDurationFieldNumber = 3, + }; + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + int matches_size() const; + private: + int _internal_matches_size() const; + public: + void clear_matches(); + ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* + mutable_matches(); + private: + const ::mozilla::safebrowsing::ThreatMatch& _internal_matches(int index) const; + ::mozilla::safebrowsing::ThreatMatch* _internal_add_matches(); + public: + const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const; + ::mozilla::safebrowsing::ThreatMatch* add_matches(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& + matches() const; + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + bool has_minimum_wait_duration() const; + private: + bool _internal_has_minimum_wait_duration() const; + public: + void clear_minimum_wait_duration(); + const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_minimum_wait_duration(); + ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration(); + void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration); + private: + const ::mozilla::safebrowsing::Duration& _internal_minimum_wait_duration() const; + ::mozilla::safebrowsing::Duration* _internal_mutable_minimum_wait_duration(); + public: + void unsafe_arena_set_allocated_minimum_wait_duration( + ::mozilla::safebrowsing::Duration* minimum_wait_duration); + ::mozilla::safebrowsing::Duration* unsafe_arena_release_minimum_wait_duration(); + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + bool has_negative_cache_duration() const; + private: + bool _internal_has_negative_cache_duration() const; + public: + void clear_negative_cache_duration(); + const ::mozilla::safebrowsing::Duration& negative_cache_duration() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_negative_cache_duration(); + ::mozilla::safebrowsing::Duration* mutable_negative_cache_duration(); + void set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration); + private: + const ::mozilla::safebrowsing::Duration& _internal_negative_cache_duration() const; + ::mozilla::safebrowsing::Duration* _internal_mutable_negative_cache_duration(); + public: + void unsafe_arena_set_allocated_negative_cache_duration( + ::mozilla::safebrowsing::Duration* negative_cache_duration); + ::mozilla::safebrowsing::Duration* unsafe_arena_release_negative_cache_duration(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesResponse) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_; + ::mozilla::safebrowsing::Duration* minimum_wait_duration_; + ::mozilla::safebrowsing::Duration* negative_cache_duration_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatHit_ThreatSource final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit.ThreatSource) */ { + public: + inline ThreatHit_ThreatSource() : ThreatHit_ThreatSource(nullptr) {} + ~ThreatHit_ThreatSource() override; + explicit PROTOBUF_CONSTEXPR ThreatHit_ThreatSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from); + ThreatHit_ThreatSource(ThreatHit_ThreatSource&& from) noexcept + : ThreatHit_ThreatSource() { + *this = ::std::move(from); + } + + inline ThreatHit_ThreatSource& operator=(const ThreatHit_ThreatSource& from) { + CopyFrom(from); + return *this; + } + inline ThreatHit_ThreatSource& operator=(ThreatHit_ThreatSource&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatHit_ThreatSource& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatHit_ThreatSource* internal_default_instance() { + return reinterpret_cast<const ThreatHit_ThreatSource*>( + &_ThreatHit_ThreatSource_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(ThreatHit_ThreatSource& a, ThreatHit_ThreatSource& b) { + a.Swap(&b); + } + inline void Swap(ThreatHit_ThreatSource* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatHit_ThreatSource* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatHit_ThreatSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatHit_ThreatSource>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatHit_ThreatSource& from); + void MergeFrom(const ThreatHit_ThreatSource& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatHit_ThreatSource* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatHit.ThreatSource"; + } + protected: + explicit ThreatHit_ThreatSource(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kRemoteIpFieldNumber = 3, + kReferrerFieldNumber = 4, + kTypeFieldNumber = 2, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string remote_ip = 3; + bool has_remote_ip() const; + private: + bool _internal_has_remote_ip() const; + public: + void clear_remote_ip(); + const std::string& remote_ip() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_remote_ip(ArgT0&& arg0, ArgT... args); + std::string* mutable_remote_ip(); + PROTOBUF_NODISCARD std::string* release_remote_ip(); + void set_allocated_remote_ip(std::string* remote_ip); + private: + const std::string& _internal_remote_ip() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_ip(const std::string& value); + std::string* _internal_mutable_remote_ip(); + public: + + // optional string referrer = 4; + bool has_referrer() const; + private: + bool _internal_has_referrer() const; + public: + void clear_referrer(); + const std::string& referrer() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_referrer(ArgT0&& arg0, ArgT... args); + std::string* mutable_referrer(); + PROTOBUF_NODISCARD std::string* release_referrer(); + void set_allocated_referrer(std::string* referrer); + private: + const std::string& _internal_referrer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer(const std::string& value); + std::string* _internal_mutable_referrer(); + public: + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::mozilla::safebrowsing::ThreatHit_ThreatSourceType type() const; + void set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value); + private: + ::mozilla::safebrowsing::ThreatHit_ThreatSourceType _internal_type() const; + void _internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.ThreatSource) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_ip_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_; + int type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatHit_UserInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit.UserInfo) */ { + public: + inline ThreatHit_UserInfo() : ThreatHit_UserInfo(nullptr) {} + ~ThreatHit_UserInfo() override; + explicit PROTOBUF_CONSTEXPR ThreatHit_UserInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatHit_UserInfo(const ThreatHit_UserInfo& from); + ThreatHit_UserInfo(ThreatHit_UserInfo&& from) noexcept + : ThreatHit_UserInfo() { + *this = ::std::move(from); + } + + inline ThreatHit_UserInfo& operator=(const ThreatHit_UserInfo& from) { + CopyFrom(from); + return *this; + } + inline ThreatHit_UserInfo& operator=(ThreatHit_UserInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatHit_UserInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatHit_UserInfo* internal_default_instance() { + return reinterpret_cast<const ThreatHit_UserInfo*>( + &_ThreatHit_UserInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ThreatHit_UserInfo& a, ThreatHit_UserInfo& b) { + a.Swap(&b); + } + inline void Swap(ThreatHit_UserInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatHit_UserInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatHit_UserInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatHit_UserInfo>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatHit_UserInfo& from); + void MergeFrom(const ThreatHit_UserInfo& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatHit_UserInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatHit.UserInfo"; + } + protected: + explicit ThreatHit_UserInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRegionCodeFieldNumber = 1, + kUserIdFieldNumber = 2, + }; + // optional string region_code = 1; + bool has_region_code() const; + private: + bool _internal_has_region_code() const; + public: + void clear_region_code(); + const std::string& region_code() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_region_code(ArgT0&& arg0, ArgT... args); + std::string* mutable_region_code(); + PROTOBUF_NODISCARD std::string* release_region_code(); + void set_allocated_region_code(std::string* region_code); + private: + const std::string& _internal_region_code() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_region_code(const std::string& value); + std::string* _internal_mutable_region_code(); + public: + + // optional bytes user_id = 2; + bool has_user_id() const; + private: + bool _internal_has_user_id() const; + public: + void clear_user_id(); + const std::string& user_id() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_user_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_user_id(); + PROTOBUF_NODISCARD std::string* release_user_id(); + void set_allocated_user_id(std::string* user_id); + private: + const std::string& _internal_user_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_user_id(const std::string& value); + std::string* _internal_mutable_user_id(); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.UserInfo) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr region_code_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr user_id_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatHit final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit) */ { + public: + inline ThreatHit() : ThreatHit(nullptr) {} + ~ThreatHit() override; + explicit PROTOBUF_CONSTEXPR ThreatHit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatHit(const ThreatHit& from); + ThreatHit(ThreatHit&& from) noexcept + : ThreatHit() { + *this = ::std::move(from); + } + + inline ThreatHit& operator=(const ThreatHit& from) { + CopyFrom(from); + return *this; + } + inline ThreatHit& operator=(ThreatHit&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatHit& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatHit* internal_default_instance() { + return reinterpret_cast<const ThreatHit*>( + &_ThreatHit_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(ThreatHit& a, ThreatHit& b) { + a.Swap(&b); + } + inline void Swap(ThreatHit* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatHit* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatHit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatHit>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatHit& from); + void MergeFrom(const ThreatHit& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatHit* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatHit"; + } + protected: + explicit ThreatHit(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef ThreatHit_ThreatSource ThreatSource; + typedef ThreatHit_UserInfo UserInfo; + + typedef ThreatHit_ThreatSourceType ThreatSourceType; + static constexpr ThreatSourceType THREAT_SOURCE_TYPE_UNSPECIFIED = + ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED; + static constexpr ThreatSourceType MATCHING_URL = + ThreatHit_ThreatSourceType_MATCHING_URL; + static constexpr ThreatSourceType TAB_URL = + ThreatHit_ThreatSourceType_TAB_URL; + static constexpr ThreatSourceType TAB_REDIRECT = + ThreatHit_ThreatSourceType_TAB_REDIRECT; + static constexpr ThreatSourceType TAB_RESOURCE = + ThreatHit_ThreatSourceType_TAB_RESOURCE; + static inline bool ThreatSourceType_IsValid(int value) { + return ThreatHit_ThreatSourceType_IsValid(value); + } + static constexpr ThreatSourceType ThreatSourceType_MIN = + ThreatHit_ThreatSourceType_ThreatSourceType_MIN; + static constexpr ThreatSourceType ThreatSourceType_MAX = + ThreatHit_ThreatSourceType_ThreatSourceType_MAX; + static constexpr int ThreatSourceType_ARRAYSIZE = + ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE; + template<typename T> + static inline const std::string& ThreatSourceType_Name(T enum_t_value) { + static_assert(::std::is_same<T, ThreatSourceType>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function ThreatSourceType_Name."); + return ThreatHit_ThreatSourceType_Name(enum_t_value); + } + static inline bool ThreatSourceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ThreatSourceType* value) { + return ThreatHit_ThreatSourceType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kResourcesFieldNumber = 4, + kEntryFieldNumber = 3, + kClientInfoFieldNumber = 5, + kUserInfoFieldNumber = 6, + kThreatTypeFieldNumber = 1, + kPlatformTypeFieldNumber = 2, + }; + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + int resources_size() const; + private: + int _internal_resources_size() const; + public: + void clear_resources(); + ::mozilla::safebrowsing::ThreatHit_ThreatSource* mutable_resources(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >* + mutable_resources(); + private: + const ::mozilla::safebrowsing::ThreatHit_ThreatSource& _internal_resources(int index) const; + ::mozilla::safebrowsing::ThreatHit_ThreatSource* _internal_add_resources(); + public: + const ::mozilla::safebrowsing::ThreatHit_ThreatSource& resources(int index) const; + ::mozilla::safebrowsing::ThreatHit_ThreatSource* add_resources(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >& + resources() const; + + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + bool has_entry() const; + private: + bool _internal_has_entry() const; + public: + void clear_entry(); + const ::mozilla::safebrowsing::ThreatEntry& entry() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatEntry* release_entry(); + ::mozilla::safebrowsing::ThreatEntry* mutable_entry(); + void set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry); + private: + const ::mozilla::safebrowsing::ThreatEntry& _internal_entry() const; + ::mozilla::safebrowsing::ThreatEntry* _internal_mutable_entry(); + public: + void unsafe_arena_set_allocated_entry( + ::mozilla::safebrowsing::ThreatEntry* entry); + ::mozilla::safebrowsing::ThreatEntry* unsafe_arena_release_entry(); + + // optional .mozilla.safebrowsing.ClientInfo client_info = 5; + bool has_client_info() const; + private: + bool _internal_has_client_info() const; + public: + void clear_client_info(); + const ::mozilla::safebrowsing::ClientInfo& client_info() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client_info(); + ::mozilla::safebrowsing::ClientInfo* mutable_client_info(); + void set_allocated_client_info(::mozilla::safebrowsing::ClientInfo* client_info); + private: + const ::mozilla::safebrowsing::ClientInfo& _internal_client_info() const; + ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client_info(); + public: + void unsafe_arena_set_allocated_client_info( + ::mozilla::safebrowsing::ClientInfo* client_info); + ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client_info(); + + // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6; + bool has_user_info() const; + private: + bool _internal_has_user_info() const; + public: + void clear_user_info(); + const ::mozilla::safebrowsing::ThreatHit_UserInfo& user_info() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatHit_UserInfo* release_user_info(); + ::mozilla::safebrowsing::ThreatHit_UserInfo* mutable_user_info(); + void set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo* user_info); + private: + const ::mozilla::safebrowsing::ThreatHit_UserInfo& _internal_user_info() const; + ::mozilla::safebrowsing::ThreatHit_UserInfo* _internal_mutable_user_info(); + public: + void unsafe_arena_set_allocated_user_info( + ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info); + ::mozilla::safebrowsing::ThreatHit_UserInfo* unsafe_arena_release_user_info(); + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + bool has_threat_type() const; + private: + bool _internal_has_threat_type() const; + public: + void clear_threat_type(); + ::mozilla::safebrowsing::ThreatType threat_type() const; + void set_threat_type(::mozilla::safebrowsing::ThreatType value); + private: + ::mozilla::safebrowsing::ThreatType _internal_threat_type() const; + void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value); + public: + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + bool has_platform_type() const; + private: + bool _internal_has_platform_type() const; + public: + void clear_platform_type(); + ::mozilla::safebrowsing::PlatformType platform_type() const; + void set_platform_type(::mozilla::safebrowsing::PlatformType value); + private: + ::mozilla::safebrowsing::PlatformType _internal_platform_type() const; + void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource > resources_; + ::mozilla::safebrowsing::ThreatEntry* entry_; + ::mozilla::safebrowsing::ClientInfo* client_info_; + ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info_; + int threat_type_; + int platform_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ClientInfo) */ { + public: + inline ClientInfo() : ClientInfo(nullptr) {} + ~ClientInfo() override; + explicit PROTOBUF_CONSTEXPR ClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientInfo(const ClientInfo& from); + ClientInfo(ClientInfo&& from) noexcept + : ClientInfo() { + *this = ::std::move(from); + } + + inline ClientInfo& operator=(const ClientInfo& from) { + CopyFrom(from); + return *this; + } + inline ClientInfo& operator=(ClientInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ClientInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ClientInfo* internal_default_instance() { + return reinterpret_cast<const ClientInfo*>( + &_ClientInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(ClientInfo& a, ClientInfo& b) { + a.Swap(&b); + } + inline void Swap(ClientInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ClientInfo>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ClientInfo& from); + void MergeFrom(const ClientInfo& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ClientInfo"; + } + protected: + explicit ClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientIdFieldNumber = 1, + kClientVersionFieldNumber = 2, + }; + // optional string client_id = 1; + bool has_client_id() const; + private: + bool _internal_has_client_id() const; + public: + void clear_client_id(); + const std::string& client_id() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_client_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_client_id(); + PROTOBUF_NODISCARD std::string* release_client_id(); + void set_allocated_client_id(std::string* client_id); + private: + const std::string& _internal_client_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_id(const std::string& value); + std::string* _internal_mutable_client_id(); + public: + + // optional string client_version = 2; + bool has_client_version() const; + private: + bool _internal_has_client_version() const; + public: + void clear_client_version(); + const std::string& client_version() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_client_version(ArgT0&& arg0, ArgT... args); + std::string* mutable_client_version(); + PROTOBUF_NODISCARD std::string* release_client_version(); + void set_allocated_client_version(std::string* client_version); + private: + const std::string& _internal_client_version() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_version(const std::string& value); + std::string* _internal_mutable_client_version(); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ClientInfo) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_version_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ChromeClientInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ChromeClientInfo) */ { + public: + inline ChromeClientInfo() : ChromeClientInfo(nullptr) {} + ~ChromeClientInfo() override; + explicit PROTOBUF_CONSTEXPR ChromeClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ChromeClientInfo(const ChromeClientInfo& from); + ChromeClientInfo(ChromeClientInfo&& from) noexcept + : ChromeClientInfo() { + *this = ::std::move(from); + } + + inline ChromeClientInfo& operator=(const ChromeClientInfo& from) { + CopyFrom(from); + return *this; + } + inline ChromeClientInfo& operator=(ChromeClientInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ChromeClientInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ChromeClientInfo* internal_default_instance() { + return reinterpret_cast<const ChromeClientInfo*>( + &_ChromeClientInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(ChromeClientInfo& a, ChromeClientInfo& b) { + a.Swap(&b); + } + inline void Swap(ChromeClientInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChromeClientInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChromeClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ChromeClientInfo>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ChromeClientInfo& from); + void MergeFrom(const ChromeClientInfo& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ChromeClientInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ChromeClientInfo"; + } + protected: + explicit ChromeClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef ChromeClientInfo_SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation; + static constexpr SafeBrowsingReportingPopulation UNSPECIFIED = + ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED; + static constexpr SafeBrowsingReportingPopulation OPT_OUT = + ChromeClientInfo_SafeBrowsingReportingPopulation_OPT_OUT; + static constexpr SafeBrowsingReportingPopulation EXTENDED = + ChromeClientInfo_SafeBrowsingReportingPopulation_EXTENDED; + static constexpr SafeBrowsingReportingPopulation SCOUT = + ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT; + static inline bool SafeBrowsingReportingPopulation_IsValid(int value) { + return ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(value); + } + static constexpr SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation_MIN = + ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MIN; + static constexpr SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation_MAX = + ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX; + static constexpr int SafeBrowsingReportingPopulation_ARRAYSIZE = + ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_ARRAYSIZE; + template<typename T> + static inline const std::string& SafeBrowsingReportingPopulation_Name(T enum_t_value) { + static_assert(::std::is_same<T, SafeBrowsingReportingPopulation>::value || + ::std::is_integral<T>::value, + "Incorrect type passed to function SafeBrowsingReportingPopulation_Name."); + return ChromeClientInfo_SafeBrowsingReportingPopulation_Name(enum_t_value); + } + static inline bool SafeBrowsingReportingPopulation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SafeBrowsingReportingPopulation* value) { + return ChromeClientInfo_SafeBrowsingReportingPopulation_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kReportingPopulationFieldNumber = 1, + }; + // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1; + bool has_reporting_population() const; + private: + bool _internal_has_reporting_population() const; + public: + void clear_reporting_population(); + ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation reporting_population() const; + void set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value); + private: + ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation _internal_reporting_population() const; + void _internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ChromeClientInfo) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int reporting_population_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class Checksum final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.Checksum) */ { + public: + inline Checksum() : Checksum(nullptr) {} + ~Checksum() override; + explicit PROTOBUF_CONSTEXPR Checksum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Checksum(const Checksum& from); + Checksum(Checksum&& from) noexcept + : Checksum() { + *this = ::std::move(from); + } + + inline Checksum& operator=(const Checksum& from) { + CopyFrom(from); + return *this; + } + inline Checksum& operator=(Checksum&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const Checksum& default_instance() { + return *internal_default_instance(); + } + static inline const Checksum* internal_default_instance() { + return reinterpret_cast<const Checksum*>( + &_Checksum_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(Checksum& a, Checksum& b) { + a.Swap(&b); + } + inline void Swap(Checksum* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Checksum* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Checksum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<Checksum>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const Checksum& from); + void MergeFrom(const Checksum& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(Checksum* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.Checksum"; + } + protected: + explicit Checksum(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSha256FieldNumber = 1, + }; + // optional bytes sha256 = 1; + bool has_sha256() const; + private: + bool _internal_has_sha256() const; + public: + void clear_sha256(); + const std::string& sha256() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_sha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_sha256(); + PROTOBUF_NODISCARD std::string* release_sha256(); + void set_allocated_sha256(std::string* sha256); + private: + const std::string& _internal_sha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_sha256(const std::string& value); + std::string* _internal_mutable_sha256(); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Checksum) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha256_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatEntry final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntry) */ { + public: + inline ThreatEntry() : ThreatEntry(nullptr) {} + ~ThreatEntry() override; + explicit PROTOBUF_CONSTEXPR ThreatEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatEntry(const ThreatEntry& from); + ThreatEntry(ThreatEntry&& from) noexcept + : ThreatEntry() { + *this = ::std::move(from); + } + + inline ThreatEntry& operator=(const ThreatEntry& from) { + CopyFrom(from); + return *this; + } + inline ThreatEntry& operator=(ThreatEntry&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatEntry& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatEntry* internal_default_instance() { + return reinterpret_cast<const ThreatEntry*>( + &_ThreatEntry_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(ThreatEntry& a, ThreatEntry& b) { + a.Swap(&b); + } + inline void Swap(ThreatEntry* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatEntry* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatEntry>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatEntry& from); + void MergeFrom(const ThreatEntry& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatEntry* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatEntry"; + } + protected: + explicit ThreatEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kHashFieldNumber = 1, + kUrlFieldNumber = 2, + }; + // optional bytes hash = 1; + bool has_hash() const; + private: + bool _internal_has_hash() const; + public: + void clear_hash(); + const std::string& hash() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_hash(ArgT0&& arg0, ArgT... args); + std::string* mutable_hash(); + PROTOBUF_NODISCARD std::string* release_hash(); + void set_allocated_hash(std::string* hash); + private: + const std::string& _internal_hash() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value); + std::string* _internal_mutable_hash(); + public: + + // optional string url = 2; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntry) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatEntrySet final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntrySet) */ { + public: + inline ThreatEntrySet() : ThreatEntrySet(nullptr) {} + ~ThreatEntrySet() override; + explicit PROTOBUF_CONSTEXPR ThreatEntrySet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatEntrySet(const ThreatEntrySet& from); + ThreatEntrySet(ThreatEntrySet&& from) noexcept + : ThreatEntrySet() { + *this = ::std::move(from); + } + + inline ThreatEntrySet& operator=(const ThreatEntrySet& from) { + CopyFrom(from); + return *this; + } + inline ThreatEntrySet& operator=(ThreatEntrySet&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatEntrySet& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatEntrySet* internal_default_instance() { + return reinterpret_cast<const ThreatEntrySet*>( + &_ThreatEntrySet_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(ThreatEntrySet& a, ThreatEntrySet& b) { + a.Swap(&b); + } + inline void Swap(ThreatEntrySet* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatEntrySet* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatEntrySet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatEntrySet>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatEntrySet& from); + void MergeFrom(const ThreatEntrySet& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatEntrySet* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatEntrySet"; + } + protected: + explicit ThreatEntrySet(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRawHashesFieldNumber = 2, + kRawIndicesFieldNumber = 3, + kRiceHashesFieldNumber = 4, + kRiceIndicesFieldNumber = 5, + kCompressionTypeFieldNumber = 1, + }; + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + bool has_raw_hashes() const; + private: + bool _internal_has_raw_hashes() const; + public: + void clear_raw_hashes(); + const ::mozilla::safebrowsing::RawHashes& raw_hashes() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::RawHashes* release_raw_hashes(); + ::mozilla::safebrowsing::RawHashes* mutable_raw_hashes(); + void set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes); + private: + const ::mozilla::safebrowsing::RawHashes& _internal_raw_hashes() const; + ::mozilla::safebrowsing::RawHashes* _internal_mutable_raw_hashes(); + public: + void unsafe_arena_set_allocated_raw_hashes( + ::mozilla::safebrowsing::RawHashes* raw_hashes); + ::mozilla::safebrowsing::RawHashes* unsafe_arena_release_raw_hashes(); + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + bool has_raw_indices() const; + private: + bool _internal_has_raw_indices() const; + public: + void clear_raw_indices(); + const ::mozilla::safebrowsing::RawIndices& raw_indices() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::RawIndices* release_raw_indices(); + ::mozilla::safebrowsing::RawIndices* mutable_raw_indices(); + void set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices); + private: + const ::mozilla::safebrowsing::RawIndices& _internal_raw_indices() const; + ::mozilla::safebrowsing::RawIndices* _internal_mutable_raw_indices(); + public: + void unsafe_arena_set_allocated_raw_indices( + ::mozilla::safebrowsing::RawIndices* raw_indices); + ::mozilla::safebrowsing::RawIndices* unsafe_arena_release_raw_indices(); + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + bool has_rice_hashes() const; + private: + bool _internal_has_rice_hashes() const; + public: + void clear_rice_hashes(); + const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_hashes() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_hashes(); + ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_hashes(); + void set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes); + private: + const ::mozilla::safebrowsing::RiceDeltaEncoding& _internal_rice_hashes() const; + ::mozilla::safebrowsing::RiceDeltaEncoding* _internal_mutable_rice_hashes(); + public: + void unsafe_arena_set_allocated_rice_hashes( + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes); + ::mozilla::safebrowsing::RiceDeltaEncoding* unsafe_arena_release_rice_hashes(); + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + bool has_rice_indices() const; + private: + bool _internal_has_rice_indices() const; + public: + void clear_rice_indices(); + const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_indices() const; + PROTOBUF_NODISCARD ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_indices(); + ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_indices(); + void set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices); + private: + const ::mozilla::safebrowsing::RiceDeltaEncoding& _internal_rice_indices() const; + ::mozilla::safebrowsing::RiceDeltaEncoding* _internal_mutable_rice_indices(); + public: + void unsafe_arena_set_allocated_rice_indices( + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices); + ::mozilla::safebrowsing::RiceDeltaEncoding* unsafe_arena_release_rice_indices(); + + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + bool has_compression_type() const; + private: + bool _internal_has_compression_type() const; + public: + void clear_compression_type(); + ::mozilla::safebrowsing::CompressionType compression_type() const; + void set_compression_type(::mozilla::safebrowsing::CompressionType value); + private: + ::mozilla::safebrowsing::CompressionType _internal_compression_type() const; + void _internal_set_compression_type(::mozilla::safebrowsing::CompressionType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntrySet) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::mozilla::safebrowsing::RawHashes* raw_hashes_; + ::mozilla::safebrowsing::RawIndices* raw_indices_; + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes_; + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices_; + int compression_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class RawIndices final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RawIndices) */ { + public: + inline RawIndices() : RawIndices(nullptr) {} + ~RawIndices() override; + explicit PROTOBUF_CONSTEXPR RawIndices(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RawIndices(const RawIndices& from); + RawIndices(RawIndices&& from) noexcept + : RawIndices() { + *this = ::std::move(from); + } + + inline RawIndices& operator=(const RawIndices& from) { + CopyFrom(from); + return *this; + } + inline RawIndices& operator=(RawIndices&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const RawIndices& default_instance() { + return *internal_default_instance(); + } + static inline const RawIndices* internal_default_instance() { + return reinterpret_cast<const RawIndices*>( + &_RawIndices_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(RawIndices& a, RawIndices& b) { + a.Swap(&b); + } + inline void Swap(RawIndices* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RawIndices* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RawIndices* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<RawIndices>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const RawIndices& from); + void MergeFrom(const RawIndices& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(RawIndices* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.RawIndices"; + } + protected: + explicit RawIndices(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIndicesFieldNumber = 1, + }; + // repeated int32 indices = 1; + int indices_size() const; + private: + int _internal_indices_size() const; + public: + void clear_indices(); + private: + int32_t _internal_indices(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_indices() const; + void _internal_add_indices(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_indices(); + public: + int32_t indices(int index) const; + void set_indices(int index, int32_t value); + void add_indices(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + indices() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_indices(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawIndices) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > indices_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class RawHashes final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RawHashes) */ { + public: + inline RawHashes() : RawHashes(nullptr) {} + ~RawHashes() override; + explicit PROTOBUF_CONSTEXPR RawHashes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RawHashes(const RawHashes& from); + RawHashes(RawHashes&& from) noexcept + : RawHashes() { + *this = ::std::move(from); + } + + inline RawHashes& operator=(const RawHashes& from) { + CopyFrom(from); + return *this; + } + inline RawHashes& operator=(RawHashes&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const RawHashes& default_instance() { + return *internal_default_instance(); + } + static inline const RawHashes* internal_default_instance() { + return reinterpret_cast<const RawHashes*>( + &_RawHashes_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(RawHashes& a, RawHashes& b) { + a.Swap(&b); + } + inline void Swap(RawHashes* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RawHashes* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RawHashes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<RawHashes>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const RawHashes& from); + void MergeFrom(const RawHashes& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(RawHashes* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.RawHashes"; + } + protected: + explicit RawHashes(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRawHashesFieldNumber = 2, + kPrefixSizeFieldNumber = 1, + }; + // optional bytes raw_hashes = 2; + bool has_raw_hashes() const; + private: + bool _internal_has_raw_hashes() const; + public: + void clear_raw_hashes(); + const std::string& raw_hashes() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_raw_hashes(ArgT0&& arg0, ArgT... args); + std::string* mutable_raw_hashes(); + PROTOBUF_NODISCARD std::string* release_raw_hashes(); + void set_allocated_raw_hashes(std::string* raw_hashes); + private: + const std::string& _internal_raw_hashes() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_hashes(const std::string& value); + std::string* _internal_mutable_raw_hashes(); + public: + + // optional int32 prefix_size = 1; + bool has_prefix_size() const; + private: + bool _internal_has_prefix_size() const; + public: + void clear_prefix_size(); + int32_t prefix_size() const; + void set_prefix_size(int32_t value); + private: + int32_t _internal_prefix_size() const; + void _internal_set_prefix_size(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawHashes) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_hashes_; + int32_t prefix_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class RiceDeltaEncoding final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RiceDeltaEncoding) */ { + public: + inline RiceDeltaEncoding() : RiceDeltaEncoding(nullptr) {} + ~RiceDeltaEncoding() override; + explicit PROTOBUF_CONSTEXPR RiceDeltaEncoding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RiceDeltaEncoding(const RiceDeltaEncoding& from); + RiceDeltaEncoding(RiceDeltaEncoding&& from) noexcept + : RiceDeltaEncoding() { + *this = ::std::move(from); + } + + inline RiceDeltaEncoding& operator=(const RiceDeltaEncoding& from) { + CopyFrom(from); + return *this; + } + inline RiceDeltaEncoding& operator=(RiceDeltaEncoding&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const RiceDeltaEncoding& default_instance() { + return *internal_default_instance(); + } + static inline const RiceDeltaEncoding* internal_default_instance() { + return reinterpret_cast<const RiceDeltaEncoding*>( + &_RiceDeltaEncoding_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(RiceDeltaEncoding& a, RiceDeltaEncoding& b) { + a.Swap(&b); + } + inline void Swap(RiceDeltaEncoding* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RiceDeltaEncoding* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RiceDeltaEncoding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<RiceDeltaEncoding>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const RiceDeltaEncoding& from); + void MergeFrom(const RiceDeltaEncoding& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(RiceDeltaEncoding* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.RiceDeltaEncoding"; + } + protected: + explicit RiceDeltaEncoding(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEncodedDataFieldNumber = 4, + kFirstValueFieldNumber = 1, + kRiceParameterFieldNumber = 2, + kNumEntriesFieldNumber = 3, + }; + // optional bytes encoded_data = 4; + bool has_encoded_data() const; + private: + bool _internal_has_encoded_data() const; + public: + void clear_encoded_data(); + const std::string& encoded_data() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_encoded_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_encoded_data(); + PROTOBUF_NODISCARD std::string* release_encoded_data(); + void set_allocated_encoded_data(std::string* encoded_data); + private: + const std::string& _internal_encoded_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value); + std::string* _internal_mutable_encoded_data(); + public: + + // optional int64 first_value = 1; + bool has_first_value() const; + private: + bool _internal_has_first_value() const; + public: + void clear_first_value(); + int64_t first_value() const; + void set_first_value(int64_t value); + private: + int64_t _internal_first_value() const; + void _internal_set_first_value(int64_t value); + public: + + // optional int32 rice_parameter = 2; + bool has_rice_parameter() const; + private: + bool _internal_has_rice_parameter() const; + public: + void clear_rice_parameter(); + int32_t rice_parameter() const; + void set_rice_parameter(int32_t value); + private: + int32_t _internal_rice_parameter() const; + void _internal_set_rice_parameter(int32_t value); + public: + + // optional int32 num_entries = 3; + bool has_num_entries() const; + private: + bool _internal_has_num_entries() const; + public: + void clear_num_entries(); + int32_t num_entries() const; + void set_num_entries(int32_t value); + private: + int32_t _internal_num_entries() const; + void _internal_set_num_entries(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RiceDeltaEncoding) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_; + int64_t first_value_; + int32_t rice_parameter_; + int32_t num_entries_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatEntryMetadata_MetadataEntry final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) */ { + public: + inline ThreatEntryMetadata_MetadataEntry() : ThreatEntryMetadata_MetadataEntry(nullptr) {} + ~ThreatEntryMetadata_MetadataEntry() override; + explicit PROTOBUF_CONSTEXPR ThreatEntryMetadata_MetadataEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from); + ThreatEntryMetadata_MetadataEntry(ThreatEntryMetadata_MetadataEntry&& from) noexcept + : ThreatEntryMetadata_MetadataEntry() { + *this = ::std::move(from); + } + + inline ThreatEntryMetadata_MetadataEntry& operator=(const ThreatEntryMetadata_MetadataEntry& from) { + CopyFrom(from); + return *this; + } + inline ThreatEntryMetadata_MetadataEntry& operator=(ThreatEntryMetadata_MetadataEntry&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatEntryMetadata_MetadataEntry& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatEntryMetadata_MetadataEntry* internal_default_instance() { + return reinterpret_cast<const ThreatEntryMetadata_MetadataEntry*>( + &_ThreatEntryMetadata_MetadataEntry_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(ThreatEntryMetadata_MetadataEntry& a, ThreatEntryMetadata_MetadataEntry& b) { + a.Swap(&b); + } + inline void Swap(ThreatEntryMetadata_MetadataEntry* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatEntryMetadata_MetadataEntry* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatEntryMetadata_MetadataEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatEntryMetadata_MetadataEntry>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatEntryMetadata_MetadataEntry& from); + void MergeFrom(const ThreatEntryMetadata_MetadataEntry& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatEntryMetadata_MetadataEntry* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry"; + } + protected: + explicit ThreatEntryMetadata_MetadataEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + // optional bytes key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const std::string& key() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_key(); + PROTOBUF_NODISCARD std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // optional bytes value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const std::string& value() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_value(ArgT0&& arg0, ArgT... args); + std::string* mutable_value(); + PROTOBUF_NODISCARD std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value); + std::string* _internal_mutable_value(); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatEntryMetadata final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntryMetadata) */ { + public: + inline ThreatEntryMetadata() : ThreatEntryMetadata(nullptr) {} + ~ThreatEntryMetadata() override; + explicit PROTOBUF_CONSTEXPR ThreatEntryMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatEntryMetadata(const ThreatEntryMetadata& from); + ThreatEntryMetadata(ThreatEntryMetadata&& from) noexcept + : ThreatEntryMetadata() { + *this = ::std::move(from); + } + + inline ThreatEntryMetadata& operator=(const ThreatEntryMetadata& from) { + CopyFrom(from); + return *this; + } + inline ThreatEntryMetadata& operator=(ThreatEntryMetadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatEntryMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatEntryMetadata* internal_default_instance() { + return reinterpret_cast<const ThreatEntryMetadata*>( + &_ThreatEntryMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(ThreatEntryMetadata& a, ThreatEntryMetadata& b) { + a.Swap(&b); + } + inline void Swap(ThreatEntryMetadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatEntryMetadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatEntryMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatEntryMetadata>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatEntryMetadata& from); + void MergeFrom(const ThreatEntryMetadata& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatEntryMetadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatEntryMetadata"; + } + protected: + explicit ThreatEntryMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef ThreatEntryMetadata_MetadataEntry MetadataEntry; + + // accessors ------------------------------------------------------- + + enum : int { + kEntriesFieldNumber = 1, + }; + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + int entries_size() const; + private: + int _internal_entries_size() const; + public: + void clear_entries(); + ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* mutable_entries(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >* + mutable_entries(); + private: + const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& _internal_entries(int index) const; + ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* _internal_add_entries(); + public: + const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& entries(int index) const; + ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* add_entries(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >& + entries() const; + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry > entries_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ThreatListDescriptor final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatListDescriptor) */ { + public: + inline ThreatListDescriptor() : ThreatListDescriptor(nullptr) {} + ~ThreatListDescriptor() override; + explicit PROTOBUF_CONSTEXPR ThreatListDescriptor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ThreatListDescriptor(const ThreatListDescriptor& from); + ThreatListDescriptor(ThreatListDescriptor&& from) noexcept + : ThreatListDescriptor() { + *this = ::std::move(from); + } + + inline ThreatListDescriptor& operator=(const ThreatListDescriptor& from) { + CopyFrom(from); + return *this; + } + inline ThreatListDescriptor& operator=(ThreatListDescriptor&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ThreatListDescriptor& default_instance() { + return *internal_default_instance(); + } + static inline const ThreatListDescriptor* internal_default_instance() { + return reinterpret_cast<const ThreatListDescriptor*>( + &_ThreatListDescriptor_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(ThreatListDescriptor& a, ThreatListDescriptor& b) { + a.Swap(&b); + } + inline void Swap(ThreatListDescriptor* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ThreatListDescriptor* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ThreatListDescriptor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ThreatListDescriptor>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ThreatListDescriptor& from); + void MergeFrom(const ThreatListDescriptor& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThreatListDescriptor* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ThreatListDescriptor"; + } + protected: + explicit ThreatListDescriptor(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kThreatTypeFieldNumber = 1, + kPlatformTypeFieldNumber = 2, + kThreatEntryTypeFieldNumber = 3, + }; + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + bool has_threat_type() const; + private: + bool _internal_has_threat_type() const; + public: + void clear_threat_type(); + ::mozilla::safebrowsing::ThreatType threat_type() const; + void set_threat_type(::mozilla::safebrowsing::ThreatType value); + private: + ::mozilla::safebrowsing::ThreatType _internal_threat_type() const; + void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value); + public: + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + bool has_platform_type() const; + private: + bool _internal_has_platform_type() const; + public: + void clear_platform_type(); + ::mozilla::safebrowsing::PlatformType platform_type() const; + void set_platform_type(::mozilla::safebrowsing::PlatformType value); + private: + ::mozilla::safebrowsing::PlatformType _internal_platform_type() const; + void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value); + public: + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + bool has_threat_entry_type() const; + private: + bool _internal_has_threat_entry_type() const; + public: + void clear_threat_entry_type(); + ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + private: + ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const; + void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatListDescriptor) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int threat_type_; + int platform_type_; + int threat_entry_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class ListThreatListsResponse final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ListThreatListsResponse) */ { + public: + inline ListThreatListsResponse() : ListThreatListsResponse(nullptr) {} + ~ListThreatListsResponse() override; + explicit PROTOBUF_CONSTEXPR ListThreatListsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ListThreatListsResponse(const ListThreatListsResponse& from); + ListThreatListsResponse(ListThreatListsResponse&& from) noexcept + : ListThreatListsResponse() { + *this = ::std::move(from); + } + + inline ListThreatListsResponse& operator=(const ListThreatListsResponse& from) { + CopyFrom(from); + return *this; + } + inline ListThreatListsResponse& operator=(ListThreatListsResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const ListThreatListsResponse& default_instance() { + return *internal_default_instance(); + } + static inline const ListThreatListsResponse* internal_default_instance() { + return reinterpret_cast<const ListThreatListsResponse*>( + &_ListThreatListsResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(ListThreatListsResponse& a, ListThreatListsResponse& b) { + a.Swap(&b); + } + inline void Swap(ListThreatListsResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ListThreatListsResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ListThreatListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<ListThreatListsResponse>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ListThreatListsResponse& from); + void MergeFrom(const ListThreatListsResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ListThreatListsResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.ListThreatListsResponse"; + } + protected: + explicit ListThreatListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kThreatListsFieldNumber = 1, + }; + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + int threat_lists_size() const; + private: + int _internal_threat_lists_size() const; + public: + void clear_threat_lists(); + ::mozilla::safebrowsing::ThreatListDescriptor* mutable_threat_lists(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >* + mutable_threat_lists(); + private: + const ::mozilla::safebrowsing::ThreatListDescriptor& _internal_threat_lists(int index) const; + ::mozilla::safebrowsing::ThreatListDescriptor* _internal_add_threat_lists(); + public: + const ::mozilla::safebrowsing::ThreatListDescriptor& threat_lists(int index) const; + ::mozilla::safebrowsing::ThreatListDescriptor* add_threat_lists(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >& + threat_lists() const; + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ListThreatListsResponse) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor > threat_lists_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// ------------------------------------------------------------------- + +class Duration final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.Duration) */ { + public: + inline Duration() : Duration(nullptr) {} + ~Duration() override; + explicit PROTOBUF_CONSTEXPR Duration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Duration(const Duration& from); + Duration(Duration&& from) noexcept + : Duration() { + *this = ::std::move(from); + } + + inline Duration& operator=(const Duration& from) { + CopyFrom(from); + return *this; + } + inline Duration& operator=(Duration&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const Duration& default_instance() { + return *internal_default_instance(); + } + static inline const Duration* internal_default_instance() { + return reinterpret_cast<const Duration*>( + &_Duration_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(Duration& a, Duration& b) { + a.Swap(&b); + } + inline void Swap(Duration* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Duration* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<Duration>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const Duration& from); + void MergeFrom(const Duration& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(Duration* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.safebrowsing.Duration"; + } + protected: + explicit Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSecondsFieldNumber = 1, + kNanosFieldNumber = 2, + }; + // optional int64 seconds = 1; + bool has_seconds() const; + private: + bool _internal_has_seconds() const; + public: + void clear_seconds(); + int64_t seconds() const; + void set_seconds(int64_t value); + private: + int64_t _internal_seconds() const; + void _internal_set_seconds(int64_t value); + public: + + // optional int32 nanos = 2; + bool has_nanos() const; + private: + bool _internal_has_nanos() const; + public: + void clear_nanos(); + int32_t nanos() const; + void set_nanos(int32_t value); + private: + int32_t _internal_nanos() const; + void _internal_set_nanos(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Duration) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t seconds_; + int32_t nanos_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_safebrowsing_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ThreatInfo + +// repeated .mozilla.safebrowsing.ThreatType threat_types = 1; +inline int ThreatInfo::_internal_threat_types_size() const { + return _impl_.threat_types_.size(); +} +inline int ThreatInfo::threat_types_size() const { + return _internal_threat_types_size(); +} +inline void ThreatInfo::clear_threat_types() { + _impl_.threat_types_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatType ThreatInfo::_internal_threat_types(int index) const { + return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_types_.Get(index)); +} +inline ::mozilla::safebrowsing::ThreatType ThreatInfo::threat_types(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_types) + return _internal_threat_types(index); +} +inline void ThreatInfo::set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_.threat_types_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_types) +} +inline void ThreatInfo::_internal_add_threat_types(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_.threat_types_.Add(value); +} +inline void ThreatInfo::add_threat_types(::mozilla::safebrowsing::ThreatType value) { + _internal_add_threat_types(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_types) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& +ThreatInfo::threat_types() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_types) + return _impl_.threat_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ThreatInfo::_internal_mutable_threat_types() { + return &_impl_.threat_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ThreatInfo::mutable_threat_types() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_types) + return _internal_mutable_threat_types(); +} + +// repeated .mozilla.safebrowsing.PlatformType platform_types = 2; +inline int ThreatInfo::_internal_platform_types_size() const { + return _impl_.platform_types_.size(); +} +inline int ThreatInfo::platform_types_size() const { + return _internal_platform_types_size(); +} +inline void ThreatInfo::clear_platform_types() { + _impl_.platform_types_.Clear(); +} +inline ::mozilla::safebrowsing::PlatformType ThreatInfo::_internal_platform_types(int index) const { + return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_types_.Get(index)); +} +inline ::mozilla::safebrowsing::PlatformType ThreatInfo::platform_types(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.platform_types) + return _internal_platform_types(index); +} +inline void ThreatInfo::set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_.platform_types_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.platform_types) +} +inline void ThreatInfo::_internal_add_platform_types(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_.platform_types_.Add(value); +} +inline void ThreatInfo::add_platform_types(::mozilla::safebrowsing::PlatformType value) { + _internal_add_platform_types(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.platform_types) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& +ThreatInfo::platform_types() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.platform_types) + return _impl_.platform_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ThreatInfo::_internal_mutable_platform_types() { + return &_impl_.platform_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ThreatInfo::mutable_platform_types() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.platform_types) + return _internal_mutable_platform_types(); +} + +// repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; +inline int ThreatInfo::_internal_threat_entry_types_size() const { + return _impl_.threat_entry_types_.size(); +} +inline int ThreatInfo::threat_entry_types_size() const { + return _internal_threat_entry_types_size(); +} +inline void ThreatInfo::clear_threat_entry_types() { + _impl_.threat_entry_types_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::_internal_threat_entry_types(int index) const { + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_types_.Get(index)); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::threat_entry_types(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entry_types) + return _internal_threat_entry_types(index); +} +inline void ThreatInfo::set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + _impl_.threat_entry_types_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_entry_types) +} +inline void ThreatInfo::_internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + _impl_.threat_entry_types_.Add(value); +} +inline void ThreatInfo::add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) { + _internal_add_threat_entry_types(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entry_types) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& +ThreatInfo::threat_entry_types() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types) + return _impl_.threat_entry_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ThreatInfo::_internal_mutable_threat_entry_types() { + return &_impl_.threat_entry_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ThreatInfo::mutable_threat_entry_types() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types) + return _internal_mutable_threat_entry_types(); +} + +// repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; +inline int ThreatInfo::_internal_threat_entries_size() const { + return _impl_.threat_entries_.size(); +} +inline int ThreatInfo::threat_entries_size() const { + return _internal_threat_entries_size(); +} +inline void ThreatInfo::clear_threat_entries() { + _impl_.threat_entries_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::mutable_threat_entries(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatInfo.threat_entries) + return _impl_.threat_entries_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >* +ThreatInfo::mutable_threat_entries() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entries) + return &_impl_.threat_entries_; +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::_internal_threat_entries(int index) const { + return _impl_.threat_entries_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::threat_entries(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entries) + return _internal_threat_entries(index); +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::_internal_add_threat_entries() { + return _impl_.threat_entries_.Add(); +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::add_threat_entries() { + ::mozilla::safebrowsing::ThreatEntry* _add = _internal_add_threat_entries(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entries) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >& +ThreatInfo::threat_entries() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entries) + return _impl_.threat_entries_; +} + +// ------------------------------------------------------------------- + +// ThreatMatch + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool ThreatMatch::_internal_has_threat_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ThreatMatch::has_threat_type() const { + return _internal_has_threat_type(); +} +inline void ThreatMatch::clear_threat_type() { + _impl_.threat_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::mozilla::safebrowsing::ThreatType ThreatMatch::_internal_threat_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_); +} +inline ::mozilla::safebrowsing::ThreatType ThreatMatch::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_type) + return _internal_threat_type(); +} +inline void ThreatMatch::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.threat_type_ = value; +} +inline void ThreatMatch::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + _internal_set_threat_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool ThreatMatch::_internal_has_platform_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ThreatMatch::has_platform_type() const { + return _internal_has_platform_type(); +} +inline void ThreatMatch::clear_platform_type() { + _impl_.platform_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::mozilla::safebrowsing::PlatformType ThreatMatch::_internal_platform_type() const { + return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_); +} +inline ::mozilla::safebrowsing::PlatformType ThreatMatch::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.platform_type) + return _internal_platform_type(); +} +inline void ThreatMatch::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.platform_type_ = value; +} +inline void ThreatMatch::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + _internal_set_platform_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; +inline bool ThreatMatch::_internal_has_threat_entry_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ThreatMatch::has_threat_entry_type() const { + return _internal_has_threat_entry_type(); +} +inline void ThreatMatch::clear_threat_entry_type() { + _impl_.threat_entry_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::_internal_threat_entry_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_type) + return _internal_threat_entry_type(); +} +inline void ThreatMatch::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.threat_entry_type_ = value; +} +inline void ThreatMatch::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + _internal_set_threat_entry_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_entry_type) +} + +// optional .mozilla.safebrowsing.ThreatEntry threat = 3; +inline bool ThreatMatch::_internal_has_threat() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.threat_ != nullptr); + return value; +} +inline bool ThreatMatch::has_threat() const { + return _internal_has_threat(); +} +inline void ThreatMatch::clear_threat() { + if (_impl_.threat_ != nullptr) _impl_.threat_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::_internal_threat() const { + const ::mozilla::safebrowsing::ThreatEntry* p = _impl_.threat_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntry&>( + ::mozilla::safebrowsing::_ThreatEntry_default_instance_); +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::threat() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat) + return _internal_threat(); +} +inline void ThreatMatch::unsafe_arena_set_allocated_threat( + ::mozilla::safebrowsing::ThreatEntry* threat) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_); + } + _impl_.threat_ = threat; + if (threat) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatMatch.threat) +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::release_threat() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.threat_; + _impl_.threat_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::unsafe_arena_release_threat() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.threat) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.threat_; + _impl_.threat_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::_internal_mutable_threat() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.threat_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(GetArenaForAllocation()); + _impl_.threat_ = p; + } + return _impl_.threat_; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::mutable_threat() { + ::mozilla::safebrowsing::ThreatEntry* _msg = _internal_mutable_threat(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat) + return _msg; +} +inline void ThreatMatch::set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.threat_; + } + if (threat) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat); + if (message_arena != submessage_arena) { + threat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, threat, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.threat_ = threat; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat) +} + +// optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; +inline bool ThreatMatch::_internal_has_threat_entry_metadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.threat_entry_metadata_ != nullptr); + return value; +} +inline bool ThreatMatch::has_threat_entry_metadata() const { + return _internal_has_threat_entry_metadata(); +} +inline void ThreatMatch::clear_threat_entry_metadata() { + if (_impl_.threat_entry_metadata_ != nullptr) _impl_.threat_entry_metadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::_internal_threat_entry_metadata() const { + const ::mozilla::safebrowsing::ThreatEntryMetadata* p = _impl_.threat_entry_metadata_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntryMetadata&>( + ::mozilla::safebrowsing::_ThreatEntryMetadata_default_instance_); +} +inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::threat_entry_metadata() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) + return _internal_threat_entry_metadata(); +} +inline void ThreatMatch::unsafe_arena_set_allocated_threat_entry_metadata( + ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_entry_metadata_); + } + _impl_.threat_entry_metadata_ = threat_entry_metadata; + if (threat_entry_metadata) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::release_threat_entry_metadata() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ThreatEntryMetadata* temp = _impl_.threat_entry_metadata_; + _impl_.threat_entry_metadata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::unsafe_arena_release_threat_entry_metadata() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ThreatEntryMetadata* temp = _impl_.threat_entry_metadata_; + _impl_.threat_entry_metadata_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::_internal_mutable_threat_entry_metadata() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.threat_entry_metadata_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata>(GetArenaForAllocation()); + _impl_.threat_entry_metadata_ = p; + } + return _impl_.threat_entry_metadata_; +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::mutable_threat_entry_metadata() { + ::mozilla::safebrowsing::ThreatEntryMetadata* _msg = _internal_mutable_threat_entry_metadata(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) + return _msg; +} +inline void ThreatMatch::set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.threat_entry_metadata_; + } + if (threat_entry_metadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat_entry_metadata); + if (message_arena != submessage_arena) { + threat_entry_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, threat_entry_metadata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.threat_entry_metadata_ = threat_entry_metadata; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) +} + +// optional .mozilla.safebrowsing.Duration cache_duration = 5; +inline bool ThreatMatch::_internal_has_cache_duration() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.cache_duration_ != nullptr); + return value; +} +inline bool ThreatMatch::has_cache_duration() const { + return _internal_has_cache_duration(); +} +inline void ThreatMatch::clear_cache_duration() { + if (_impl_.cache_duration_ != nullptr) _impl_.cache_duration_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::mozilla::safebrowsing::Duration& ThreatMatch::_internal_cache_duration() const { + const ::mozilla::safebrowsing::Duration* p = _impl_.cache_duration_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>( + ::mozilla::safebrowsing::_Duration_default_instance_); +} +inline const ::mozilla::safebrowsing::Duration& ThreatMatch::cache_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.cache_duration) + return _internal_cache_duration(); +} +inline void ThreatMatch::unsafe_arena_set_allocated_cache_duration( + ::mozilla::safebrowsing::Duration* cache_duration) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cache_duration_); + } + _impl_.cache_duration_ = cache_duration; + if (cache_duration) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration) +} +inline ::mozilla::safebrowsing::Duration* ThreatMatch::release_cache_duration() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::mozilla::safebrowsing::Duration* temp = _impl_.cache_duration_; + _impl_.cache_duration_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::Duration* ThreatMatch::unsafe_arena_release_cache_duration() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.cache_duration) + _impl_._has_bits_[0] &= ~0x00000004u; + ::mozilla::safebrowsing::Duration* temp = _impl_.cache_duration_; + _impl_.cache_duration_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::Duration* ThreatMatch::_internal_mutable_cache_duration() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.cache_duration_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation()); + _impl_.cache_duration_ = p; + } + return _impl_.cache_duration_; +} +inline ::mozilla::safebrowsing::Duration* ThreatMatch::mutable_cache_duration() { + ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_cache_duration(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.cache_duration) + return _msg; +} +inline void ThreatMatch::set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.cache_duration_; + } + if (cache_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cache_duration); + if (message_arena != submessage_arena) { + cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cache_duration, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.cache_duration_ = cache_duration; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration) +} + +// ------------------------------------------------------------------- + +// FindThreatMatchesRequest + +// optional .mozilla.safebrowsing.ClientInfo client = 1; +inline bool FindThreatMatchesRequest::_internal_has_client() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.client_ != nullptr); + return value; +} +inline bool FindThreatMatchesRequest::has_client() const { + return _internal_has_client(); +} +inline void FindThreatMatchesRequest::clear_client() { + if (_impl_.client_ != nullptr) _impl_.client_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::_internal_client() const { + const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>( + ::mozilla::safebrowsing::_ClientInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::client() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.client) + return _internal_client(); +} +inline void FindThreatMatchesRequest::unsafe_arena_set_allocated_client( + ::mozilla::safebrowsing::ClientInfo* client) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_); + } + _impl_.client_ = client; + if (client) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client) +} +inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::release_client() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_; + _impl_.client_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::unsafe_arena_release_client() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindThreatMatchesRequest.client) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_; + _impl_.client_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::_internal_mutable_client() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.client_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation()); + _impl_.client_ = p; + } + return _impl_.client_; +} +inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::mutable_client() { + ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.client) + return _msg; +} +inline void FindThreatMatchesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.client_; + } + if (client) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client); + if (message_arena != submessage_arena) { + client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.client_ = client; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client) +} + +// optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; +inline bool FindThreatMatchesRequest::_internal_has_threat_info() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.threat_info_ != nullptr); + return value; +} +inline bool FindThreatMatchesRequest::has_threat_info() const { + return _internal_has_threat_info(); +} +inline void FindThreatMatchesRequest::clear_threat_info() { + if (_impl_.threat_info_ != nullptr) _impl_.threat_info_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::_internal_threat_info() const { + const ::mozilla::safebrowsing::ThreatInfo* p = _impl_.threat_info_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatInfo&>( + ::mozilla::safebrowsing::_ThreatInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::threat_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) + return _internal_threat_info(); +} +inline void FindThreatMatchesRequest::unsafe_arena_set_allocated_threat_info( + ::mozilla::safebrowsing::ThreatInfo* threat_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_info_); + } + _impl_.threat_info_ = threat_info; + if (threat_info) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) +} +inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::release_threat_info() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_; + _impl_.threat_info_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::unsafe_arena_release_threat_info() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_; + _impl_.threat_info_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::_internal_mutable_threat_info() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.threat_info_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(GetArenaForAllocation()); + _impl_.threat_info_ = p; + } + return _impl_.threat_info_; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::mutable_threat_info() { + ::mozilla::safebrowsing::ThreatInfo* _msg = _internal_mutable_threat_info(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) + return _msg; +} +inline void FindThreatMatchesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.threat_info_; + } + if (threat_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat_info); + if (message_arena != submessage_arena) { + threat_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, threat_info, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.threat_info_ = threat_info; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) +} + +// ------------------------------------------------------------------- + +// FindThreatMatchesResponse + +// repeated .mozilla.safebrowsing.ThreatMatch matches = 1; +inline int FindThreatMatchesResponse::_internal_matches_size() const { + return _impl_.matches_.size(); +} +inline int FindThreatMatchesResponse::matches_size() const { + return _internal_matches_size(); +} +inline void FindThreatMatchesResponse::clear_matches() { + _impl_.matches_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::mutable_matches(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return _impl_.matches_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* +FindThreatMatchesResponse::mutable_matches() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return &_impl_.matches_; +} +inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::_internal_matches(int index) const { + return _impl_.matches_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::matches(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return _internal_matches(index); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::_internal_add_matches() { + return _impl_.matches_.Add(); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::add_matches() { + ::mozilla::safebrowsing::ThreatMatch* _add = _internal_add_matches(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& +FindThreatMatchesResponse::matches() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return _impl_.matches_; +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints + +// optional int32 max_update_entries = 1; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_max_update_entries() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_update_entries() const { + return _internal_has_max_update_entries(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_update_entries() { + _impl_.max_update_entries_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_max_update_entries() const { + return _impl_.max_update_entries_; +} +inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_update_entries() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries) + return _internal_max_update_entries(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_max_update_entries(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.max_update_entries_ = value; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_update_entries(int32_t value) { + _internal_set_max_update_entries(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries) +} + +// optional int32 max_database_entries = 2; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_max_database_entries() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_database_entries() const { + return _internal_has_max_database_entries(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_database_entries() { + _impl_.max_database_entries_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_max_database_entries() const { + return _impl_.max_database_entries_; +} +inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_database_entries() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries) + return _internal_max_database_entries(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_max_database_entries(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.max_database_entries_ = value; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_database_entries(int32_t value) { + _internal_set_max_database_entries(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries) +} + +// optional string region = 3; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_region() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_region() const { + return _internal_has_region(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_region() { + _impl_.region_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::region() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) + return _internal_region(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.region_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) +} +inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_region() { + std::string* _s = _internal_mutable_region(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) + return _s; +} +inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_region() const { + return _impl_.region_.Get(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_region(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.region_.Set(value, GetArenaForAllocation()); +} +inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_mutable_region() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.region_.Mutable(GetArenaForAllocation()); +} +inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::release_region() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) + if (!_internal_has_region()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.region_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.region_.IsDefault()) { + _impl_.region_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_allocated_region(std::string* region) { + if (region != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.region_.SetAllocated(region, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.region_.IsDefault()) { + _impl_.region_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) +} + +// repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; +inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_supported_compressions_size() const { + return _impl_.supported_compressions_.size(); +} +inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions_size() const { + return _internal_supported_compressions_size(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_supported_compressions() { + _impl_.supported_compressions_.Clear(); +} +inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_supported_compressions(int index) const { + return static_cast< ::mozilla::safebrowsing::CompressionType >(_impl_.supported_compressions_.Get(index)); +} +inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) + return _internal_supported_compressions(index); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value) { + assert(::mozilla::safebrowsing::CompressionType_IsValid(value)); + _impl_.supported_compressions_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value) { + assert(::mozilla::safebrowsing::CompressionType_IsValid(value)); + _impl_.supported_compressions_.Add(value); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::add_supported_compressions(::mozilla::safebrowsing::CompressionType value) { + _internal_add_supported_compressions(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) + return _impl_.supported_compressions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_mutable_supported_compressions() { + return &_impl_.supported_compressions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_supported_compressions() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) + return _internal_mutable_supported_compressions(); +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesRequest_ListUpdateRequest + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_threat_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_type() const { + return _internal_has_threat_type(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_type() { + _impl_.threat_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_threat_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_); +} +inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type) + return _internal_threat_type(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.threat_type_ = value; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + _internal_set_threat_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_platform_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_platform_type() const { + return _internal_has_platform_type(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_platform_type() { + _impl_.platform_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_platform_type() const { + return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_); +} +inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type) + return _internal_platform_type(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.platform_type_ = value; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + _internal_set_platform_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_threat_entry_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_entry_type() const { + return _internal_has_threat_entry_type(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_entry_type() { + _impl_.threat_entry_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_threat_entry_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_); +} +inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type) + return _internal_threat_entry_type(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.threat_entry_type_ = value; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + _internal_set_threat_entry_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type) +} + +// optional bytes state = 3; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_state() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_state() const { + return _internal_has_state(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_state() { + _impl_.state_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::state() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) + return _internal_state(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.state_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) +} +inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_state() { + std::string* _s = _internal_mutable_state(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) + return _s; +} +inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_state() const { + return _impl_.state_.Get(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_state(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.state_.Set(value, GetArenaForAllocation()); +} +inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_mutable_state() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.state_.Mutable(GetArenaForAllocation()); +} +inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::release_state() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) + if (!_internal_has_state()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.state_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.state_.IsDefault()) { + _impl_.state_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_state(std::string* state) { + if (state != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.state_.SetAllocated(state, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.state_.IsDefault()) { + _impl_.state_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) +} + +// optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_constraints() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.constraints_ != nullptr); + return value; +} +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_constraints() const { + return _internal_has_constraints(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_constraints() { + if (_impl_.constraints_ != nullptr) _impl_.constraints_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_constraints() const { + const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* p = _impl_.constraints_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&>( + ::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_); +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::constraints() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) + return _internal_constraints(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::unsafe_arena_set_allocated_constraints( + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.constraints_); + } + _impl_.constraints_ = constraints; + if (constraints) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::release_constraints() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = _impl_.constraints_; + _impl_.constraints_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::unsafe_arena_release_constraints() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = _impl_.constraints_; + _impl_.constraints_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_mutable_constraints() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.constraints_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(GetArenaForAllocation()); + _impl_.constraints_ = p; + } + return _impl_.constraints_; +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_constraints() { + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* _msg = _internal_mutable_constraints(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) + return _msg; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.constraints_; + } + if (constraints) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(constraints); + if (message_arena != submessage_arena) { + constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, constraints, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.constraints_ = constraints; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesRequest + +// optional .mozilla.safebrowsing.ClientInfo client = 1; +inline bool FetchThreatListUpdatesRequest::_internal_has_client() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.client_ != nullptr); + return value; +} +inline bool FetchThreatListUpdatesRequest::has_client() const { + return _internal_has_client(); +} +inline void FetchThreatListUpdatesRequest::clear_client() { + if (_impl_.client_ != nullptr) _impl_.client_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::_internal_client() const { + const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>( + ::mozilla::safebrowsing::_ClientInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::client() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) + return _internal_client(); +} +inline void FetchThreatListUpdatesRequest::unsafe_arena_set_allocated_client( + ::mozilla::safebrowsing::ClientInfo* client) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_); + } + _impl_.client_ = client; + if (client) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) +} +inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::release_client() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_; + _impl_.client_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::unsafe_arena_release_client() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_; + _impl_.client_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::_internal_mutable_client() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.client_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation()); + _impl_.client_ = p; + } + return _impl_.client_; +} +inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::mutable_client() { + ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) + return _msg; +} +inline void FetchThreatListUpdatesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.client_; + } + if (client) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client); + if (message_arena != submessage_arena) { + client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.client_ = client; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) +} + +// repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; +inline int FetchThreatListUpdatesRequest::_internal_list_update_requests_size() const { + return _impl_.list_update_requests_.size(); +} +inline int FetchThreatListUpdatesRequest::list_update_requests_size() const { + return _internal_list_update_requests_size(); +} +inline void FetchThreatListUpdatesRequest::clear_list_update_requests() { + _impl_.list_update_requests_.Clear(); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::mutable_list_update_requests(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return _impl_.list_update_requests_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >* +FetchThreatListUpdatesRequest::mutable_list_update_requests() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return &_impl_.list_update_requests_; +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::_internal_list_update_requests(int index) const { + return _impl_.list_update_requests_.Get(index); +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::list_update_requests(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return _internal_list_update_requests(index); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::_internal_add_list_update_requests() { + return _impl_.list_update_requests_.Add(); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::add_list_update_requests() { + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* _add = _internal_add_list_update_requests(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >& +FetchThreatListUpdatesRequest::list_update_requests() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return _impl_.list_update_requests_; +} + +// optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4; +inline bool FetchThreatListUpdatesRequest::_internal_has_chrome_client_info() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.chrome_client_info_ != nullptr); + return value; +} +inline bool FetchThreatListUpdatesRequest::has_chrome_client_info() const { + return _internal_has_chrome_client_info(); +} +inline void FetchThreatListUpdatesRequest::clear_chrome_client_info() { + if (_impl_.chrome_client_info_ != nullptr) _impl_.chrome_client_info_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::ChromeClientInfo& FetchThreatListUpdatesRequest::_internal_chrome_client_info() const { + const ::mozilla::safebrowsing::ChromeClientInfo* p = _impl_.chrome_client_info_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ChromeClientInfo&>( + ::mozilla::safebrowsing::_ChromeClientInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ChromeClientInfo& FetchThreatListUpdatesRequest::chrome_client_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info) + return _internal_chrome_client_info(); +} +inline void FetchThreatListUpdatesRequest::unsafe_arena_set_allocated_chrome_client_info( + ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chrome_client_info_); + } + _impl_.chrome_client_info_ = chrome_client_info; + if (chrome_client_info) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info) +} +inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::release_chrome_client_info() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ChromeClientInfo* temp = _impl_.chrome_client_info_; + _impl_.chrome_client_info_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::unsafe_arena_release_chrome_client_info() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ChromeClientInfo* temp = _impl_.chrome_client_info_; + _impl_.chrome_client_info_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::_internal_mutable_chrome_client_info() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.chrome_client_info_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ChromeClientInfo>(GetArenaForAllocation()); + _impl_.chrome_client_info_ = p; + } + return _impl_.chrome_client_info_; +} +inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::mutable_chrome_client_info() { + ::mozilla::safebrowsing::ChromeClientInfo* _msg = _internal_mutable_chrome_client_info(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info) + return _msg; +} +inline void FetchThreatListUpdatesRequest::set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.chrome_client_info_; + } + if (chrome_client_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chrome_client_info); + if (message_arena != submessage_arena) { + chrome_client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, chrome_client_info, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.chrome_client_info_ = chrome_client_info; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info) +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesResponse_ListUpdateResponse + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_threat_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_type() const { + return _internal_has_threat_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_type() { + _impl_.threat_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_threat_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_); +} +inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type) + return _internal_threat_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.threat_type_ = value; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + _internal_set_threat_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_threat_entry_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_entry_type() const { + return _internal_has_threat_entry_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_entry_type() { + _impl_.threat_entry_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_threat_entry_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_); +} +inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type) + return _internal_threat_entry_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.threat_entry_type_ = value; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + _internal_set_threat_entry_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 3; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_platform_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_platform_type() const { + return _internal_has_platform_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_platform_type() { + _impl_.platform_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_platform_type() const { + return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_); +} +inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type) + return _internal_platform_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.platform_type_ = value; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + _internal_set_platform_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type) +} + +// optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_response_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_response_type() const { + return _internal_has_response_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_response_type() { + _impl_.response_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_response_type() const { + return static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(_impl_.response_type_); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::response_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type) + return _internal_response_type(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) { + assert(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.response_type_ = value; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) { + _internal_set_response_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type) +} + +// repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; +inline int FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_additions_size() const { + return _impl_.additions_.size(); +} +inline int FetchThreatListUpdatesResponse_ListUpdateResponse::additions_size() const { + return _internal_additions_size(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_additions() { + _impl_.additions_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return _impl_.additions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* +FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return &_impl_.additions_; +} +inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_additions(int index) const { + return _impl_.additions_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::additions(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return _internal_additions(index); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_add_additions() { + return _impl_.additions_.Add(); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_additions() { + ::mozilla::safebrowsing::ThreatEntrySet* _add = _internal_add_additions(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& +FetchThreatListUpdatesResponse_ListUpdateResponse::additions() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return _impl_.additions_; +} + +// repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; +inline int FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_removals_size() const { + return _impl_.removals_.size(); +} +inline int FetchThreatListUpdatesResponse_ListUpdateResponse::removals_size() const { + return _internal_removals_size(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_removals() { + _impl_.removals_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return _impl_.removals_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* +FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return &_impl_.removals_; +} +inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_removals(int index) const { + return _impl_.removals_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::removals(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return _internal_removals(index); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_add_removals() { + return _impl_.removals_.Add(); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_removals() { + ::mozilla::safebrowsing::ThreatEntrySet* _add = _internal_add_removals(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& +FetchThreatListUpdatesResponse_ListUpdateResponse::removals() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return _impl_.removals_; +} + +// optional bytes new_client_state = 7; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_new_client_state() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_new_client_state() const { + return _internal_has_new_client_state(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_new_client_state() { + _impl_.new_client_state_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::new_client_state() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) + return _internal_new_client_state(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.new_client_state_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) +} +inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_new_client_state() { + std::string* _s = _internal_mutable_new_client_state(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) + return _s; +} +inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_new_client_state() const { + return _impl_.new_client_state_.Get(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_new_client_state(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.new_client_state_.Set(value, GetArenaForAllocation()); +} +inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_mutable_new_client_state() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.new_client_state_.Mutable(GetArenaForAllocation()); +} +inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::release_new_client_state() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) + if (!_internal_has_new_client_state()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.new_client_state_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.new_client_state_.IsDefault()) { + _impl_.new_client_state_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_new_client_state(std::string* new_client_state) { + if (new_client_state != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.new_client_state_.SetAllocated(new_client_state, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.new_client_state_.IsDefault()) { + _impl_.new_client_state_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) +} + +// optional .mozilla.safebrowsing.Checksum checksum = 8; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_checksum() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.checksum_ != nullptr); + return value; +} +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_checksum() const { + return _internal_has_checksum(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_checksum() { + if (_impl_.checksum_ != nullptr) _impl_.checksum_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_checksum() const { + const ::mozilla::safebrowsing::Checksum* p = _impl_.checksum_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Checksum&>( + ::mozilla::safebrowsing::_Checksum_default_instance_); +} +inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::checksum() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) + return _internal_checksum(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::unsafe_arena_set_allocated_checksum( + ::mozilla::safebrowsing::Checksum* checksum) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.checksum_); + } + _impl_.checksum_ = checksum; + if (checksum) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) +} +inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::release_checksum() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::Checksum* temp = _impl_.checksum_; + _impl_.checksum_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::unsafe_arena_release_checksum() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::Checksum* temp = _impl_.checksum_; + _impl_.checksum_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_mutable_checksum() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.checksum_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Checksum>(GetArenaForAllocation()); + _impl_.checksum_ = p; + } + return _impl_.checksum_; +} +inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_checksum() { + ::mozilla::safebrowsing::Checksum* _msg = _internal_mutable_checksum(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) + return _msg; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.checksum_; + } + if (checksum) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(checksum); + if (message_arena != submessage_arena) { + checksum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, checksum, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.checksum_ = checksum; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesResponse + +// repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; +inline int FetchThreatListUpdatesResponse::_internal_list_update_responses_size() const { + return _impl_.list_update_responses_.size(); +} +inline int FetchThreatListUpdatesResponse::list_update_responses_size() const { + return _internal_list_update_responses_size(); +} +inline void FetchThreatListUpdatesResponse::clear_list_update_responses() { + _impl_.list_update_responses_.Clear(); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::mutable_list_update_responses(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return _impl_.list_update_responses_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >* +FetchThreatListUpdatesResponse::mutable_list_update_responses() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return &_impl_.list_update_responses_; +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::_internal_list_update_responses(int index) const { + return _impl_.list_update_responses_.Get(index); +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::list_update_responses(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return _internal_list_update_responses(index); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::_internal_add_list_update_responses() { + return _impl_.list_update_responses_.Add(); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::add_list_update_responses() { + ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* _add = _internal_add_list_update_responses(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >& +FetchThreatListUpdatesResponse::list_update_responses() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return _impl_.list_update_responses_; +} + +// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; +inline bool FetchThreatListUpdatesResponse::_internal_has_minimum_wait_duration() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.minimum_wait_duration_ != nullptr); + return value; +} +inline bool FetchThreatListUpdatesResponse::has_minimum_wait_duration() const { + return _internal_has_minimum_wait_duration(); +} +inline void FetchThreatListUpdatesResponse::clear_minimum_wait_duration() { + if (_impl_.minimum_wait_duration_ != nullptr) _impl_.minimum_wait_duration_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::_internal_minimum_wait_duration() const { + const ::mozilla::safebrowsing::Duration* p = _impl_.minimum_wait_duration_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>( + ::mozilla::safebrowsing::_Duration_default_instance_); +} +inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::minimum_wait_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) + return _internal_minimum_wait_duration(); +} +inline void FetchThreatListUpdatesResponse::unsafe_arena_set_allocated_minimum_wait_duration( + ::mozilla::safebrowsing::Duration* minimum_wait_duration) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.minimum_wait_duration_); + } + _impl_.minimum_wait_duration_ = minimum_wait_duration; + if (minimum_wait_duration) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) +} +inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::release_minimum_wait_duration() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::Duration* temp = _impl_.minimum_wait_duration_; + _impl_.minimum_wait_duration_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::unsafe_arena_release_minimum_wait_duration() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::Duration* temp = _impl_.minimum_wait_duration_; + _impl_.minimum_wait_duration_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::_internal_mutable_minimum_wait_duration() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.minimum_wait_duration_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation()); + _impl_.minimum_wait_duration_ = p; + } + return _impl_.minimum_wait_duration_; +} +inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::mutable_minimum_wait_duration() { + ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_minimum_wait_duration(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) + return _msg; +} +inline void FetchThreatListUpdatesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.minimum_wait_duration_; + } + if (minimum_wait_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(minimum_wait_duration); + if (message_arena != submessage_arena) { + minimum_wait_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, minimum_wait_duration, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.minimum_wait_duration_ = minimum_wait_duration; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) +} + +// ------------------------------------------------------------------- + +// FindFullHashesRequest + +// optional .mozilla.safebrowsing.ClientInfo client = 1; +inline bool FindFullHashesRequest::_internal_has_client() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.client_ != nullptr); + return value; +} +inline bool FindFullHashesRequest::has_client() const { + return _internal_has_client(); +} +inline void FindFullHashesRequest::clear_client() { + if (_impl_.client_ != nullptr) _impl_.client_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::_internal_client() const { + const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>( + ::mozilla::safebrowsing::_ClientInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::client() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client) + return _internal_client(); +} +inline void FindFullHashesRequest::unsafe_arena_set_allocated_client( + ::mozilla::safebrowsing::ClientInfo* client) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_); + } + _impl_.client_ = client; + if (client) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client) +} +inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::release_client() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_; + _impl_.client_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::unsafe_arena_release_client() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesRequest.client) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_; + _impl_.client_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::_internal_mutable_client() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.client_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation()); + _impl_.client_ = p; + } + return _impl_.client_; +} +inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::mutable_client() { + ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client) + return _msg; +} +inline void FindFullHashesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.client_; + } + if (client) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client); + if (message_arena != submessage_arena) { + client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.client_ = client; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client) +} + +// repeated bytes client_states = 2; +inline int FindFullHashesRequest::_internal_client_states_size() const { + return _impl_.client_states_.size(); +} +inline int FindFullHashesRequest::client_states_size() const { + return _internal_client_states_size(); +} +inline void FindFullHashesRequest::clear_client_states() { + _impl_.client_states_.Clear(); +} +inline std::string* FindFullHashesRequest::add_client_states() { + std::string* _s = _internal_add_client_states(); + // @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return _s; +} +inline const std::string& FindFullHashesRequest::_internal_client_states(int index) const { + return _impl_.client_states_.Get(index); +} +inline const std::string& FindFullHashesRequest::client_states(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return _internal_client_states(index); +} +inline std::string* FindFullHashesRequest::mutable_client_states(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return _impl_.client_states_.Mutable(index); +} +inline void FindFullHashesRequest::set_client_states(int index, const std::string& value) { + _impl_.client_states_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::set_client_states(int index, std::string&& value) { + _impl_.client_states_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::set_client_states(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.client_states_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::set_client_states(int index, const void* value, size_t size) { + _impl_.client_states_.Mutable(index)->assign( + reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline std::string* FindFullHashesRequest::_internal_add_client_states() { + return _impl_.client_states_.Add(); +} +inline void FindFullHashesRequest::add_client_states(const std::string& value) { + _impl_.client_states_.Add()->assign(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::add_client_states(std::string&& value) { + _impl_.client_states_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::add_client_states(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.client_states_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::add_client_states(const void* value, size_t size) { + _impl_.client_states_.Add()->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& +FindFullHashesRequest::client_states() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return _impl_.client_states_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* +FindFullHashesRequest::mutable_client_states() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return &_impl_.client_states_; +} + +// optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; +inline bool FindFullHashesRequest::_internal_has_threat_info() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.threat_info_ != nullptr); + return value; +} +inline bool FindFullHashesRequest::has_threat_info() const { + return _internal_has_threat_info(); +} +inline void FindFullHashesRequest::clear_threat_info() { + if (_impl_.threat_info_ != nullptr) _impl_.threat_info_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::_internal_threat_info() const { + const ::mozilla::safebrowsing::ThreatInfo* p = _impl_.threat_info_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatInfo&>( + ::mozilla::safebrowsing::_ThreatInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::threat_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.threat_info) + return _internal_threat_info(); +} +inline void FindFullHashesRequest::unsafe_arena_set_allocated_threat_info( + ::mozilla::safebrowsing::ThreatInfo* threat_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_info_); + } + _impl_.threat_info_ = threat_info; + if (threat_info) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info) +} +inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::release_threat_info() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_; + _impl_.threat_info_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::unsafe_arena_release_threat_info() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesRequest.threat_info) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_; + _impl_.threat_info_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::_internal_mutable_threat_info() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.threat_info_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(GetArenaForAllocation()); + _impl_.threat_info_ = p; + } + return _impl_.threat_info_; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::mutable_threat_info() { + ::mozilla::safebrowsing::ThreatInfo* _msg = _internal_mutable_threat_info(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.threat_info) + return _msg; +} +inline void FindFullHashesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.threat_info_; + } + if (threat_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat_info); + if (message_arena != submessage_arena) { + threat_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, threat_info, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.threat_info_ = threat_info; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info) +} + +// ------------------------------------------------------------------- + +// FindFullHashesResponse + +// repeated .mozilla.safebrowsing.ThreatMatch matches = 1; +inline int FindFullHashesResponse::_internal_matches_size() const { + return _impl_.matches_.size(); +} +inline int FindFullHashesResponse::matches_size() const { + return _internal_matches_size(); +} +inline void FindFullHashesResponse::clear_matches() { + _impl_.matches_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::mutable_matches(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.matches) + return _impl_.matches_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* +FindFullHashesResponse::mutable_matches() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesResponse.matches) + return &_impl_.matches_; +} +inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::_internal_matches(int index) const { + return _impl_.matches_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::matches(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.matches) + return _internal_matches(index); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::_internal_add_matches() { + return _impl_.matches_.Add(); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::add_matches() { + ::mozilla::safebrowsing::ThreatMatch* _add = _internal_add_matches(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesResponse.matches) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& +FindFullHashesResponse::matches() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesResponse.matches) + return _impl_.matches_; +} + +// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; +inline bool FindFullHashesResponse::_internal_has_minimum_wait_duration() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.minimum_wait_duration_ != nullptr); + return value; +} +inline bool FindFullHashesResponse::has_minimum_wait_duration() const { + return _internal_has_minimum_wait_duration(); +} +inline void FindFullHashesResponse::clear_minimum_wait_duration() { + if (_impl_.minimum_wait_duration_ != nullptr) _impl_.minimum_wait_duration_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::_internal_minimum_wait_duration() const { + const ::mozilla::safebrowsing::Duration* p = _impl_.minimum_wait_duration_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>( + ::mozilla::safebrowsing::_Duration_default_instance_); +} +inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::minimum_wait_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) + return _internal_minimum_wait_duration(); +} +inline void FindFullHashesResponse::unsafe_arena_set_allocated_minimum_wait_duration( + ::mozilla::safebrowsing::Duration* minimum_wait_duration) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.minimum_wait_duration_); + } + _impl_.minimum_wait_duration_ = minimum_wait_duration; + if (minimum_wait_duration) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_minimum_wait_duration() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::Duration* temp = _impl_.minimum_wait_duration_; + _impl_.minimum_wait_duration_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::unsafe_arena_release_minimum_wait_duration() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::Duration* temp = _impl_.minimum_wait_duration_; + _impl_.minimum_wait_duration_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::_internal_mutable_minimum_wait_duration() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.minimum_wait_duration_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation()); + _impl_.minimum_wait_duration_ = p; + } + return _impl_.minimum_wait_duration_; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_minimum_wait_duration() { + ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_minimum_wait_duration(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) + return _msg; +} +inline void FindFullHashesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.minimum_wait_duration_; + } + if (minimum_wait_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(minimum_wait_duration); + if (message_arena != submessage_arena) { + minimum_wait_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, minimum_wait_duration, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.minimum_wait_duration_ = minimum_wait_duration; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) +} + +// optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; +inline bool FindFullHashesResponse::_internal_has_negative_cache_duration() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.negative_cache_duration_ != nullptr); + return value; +} +inline bool FindFullHashesResponse::has_negative_cache_duration() const { + return _internal_has_negative_cache_duration(); +} +inline void FindFullHashesResponse::clear_negative_cache_duration() { + if (_impl_.negative_cache_duration_ != nullptr) _impl_.negative_cache_duration_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::_internal_negative_cache_duration() const { + const ::mozilla::safebrowsing::Duration* p = _impl_.negative_cache_duration_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>( + ::mozilla::safebrowsing::_Duration_default_instance_); +} +inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::negative_cache_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) + return _internal_negative_cache_duration(); +} +inline void FindFullHashesResponse::unsafe_arena_set_allocated_negative_cache_duration( + ::mozilla::safebrowsing::Duration* negative_cache_duration) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.negative_cache_duration_); + } + _impl_.negative_cache_duration_ = negative_cache_duration; + if (negative_cache_duration) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_negative_cache_duration() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::Duration* temp = _impl_.negative_cache_duration_; + _impl_.negative_cache_duration_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::unsafe_arena_release_negative_cache_duration() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::Duration* temp = _impl_.negative_cache_duration_; + _impl_.negative_cache_duration_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::_internal_mutable_negative_cache_duration() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.negative_cache_duration_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation()); + _impl_.negative_cache_duration_ = p; + } + return _impl_.negative_cache_duration_; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_negative_cache_duration() { + ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_negative_cache_duration(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) + return _msg; +} +inline void FindFullHashesResponse::set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.negative_cache_duration_; + } + if (negative_cache_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(negative_cache_duration); + if (message_arena != submessage_arena) { + negative_cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, negative_cache_duration, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.negative_cache_duration_ = negative_cache_duration; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) +} + +// ------------------------------------------------------------------- + +// ThreatHit_ThreatSource + +// optional string url = 1; +inline bool ThreatHit_ThreatSource::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ThreatHit_ThreatSource::has_url() const { + return _internal_has_url(); +} +inline void ThreatHit_ThreatSource::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ThreatHit_ThreatSource::url() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.url) + return _internal_url(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatHit_ThreatSource::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.url) +} +inline std::string* ThreatHit_ThreatSource::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.url) + return _s; +} +inline const std::string& ThreatHit_ThreatSource::_internal_url() const { + return _impl_.url_.Get(); +} +inline void ThreatHit_ThreatSource::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatHit_ThreatSource::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatHit_ThreatSource::release_url() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatHit_ThreatSource::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.url) +} + +// optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; +inline bool ThreatHit_ThreatSource::_internal_has_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ThreatHit_ThreatSource::has_type() const { + return _internal_has_type(); +} +inline void ThreatHit_ThreatSource::clear_type() { + _impl_.type_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::_internal_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(_impl_.type_); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.type) + return _internal_type(); +} +inline void ThreatHit_ThreatSource::_internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) { + assert(::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.type_ = value; +} +inline void ThreatHit_ThreatSource::set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.type) +} + +// optional string remote_ip = 3; +inline bool ThreatHit_ThreatSource::_internal_has_remote_ip() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ThreatHit_ThreatSource::has_remote_ip() const { + return _internal_has_remote_ip(); +} +inline void ThreatHit_ThreatSource::clear_remote_ip() { + _impl_.remote_ip_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ThreatHit_ThreatSource::remote_ip() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) + return _internal_remote_ip(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatHit_ThreatSource::set_remote_ip(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.remote_ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) +} +inline std::string* ThreatHit_ThreatSource::mutable_remote_ip() { + std::string* _s = _internal_mutable_remote_ip(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) + return _s; +} +inline const std::string& ThreatHit_ThreatSource::_internal_remote_ip() const { + return _impl_.remote_ip_.Get(); +} +inline void ThreatHit_ThreatSource::_internal_set_remote_ip(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.remote_ip_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatHit_ThreatSource::_internal_mutable_remote_ip() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.remote_ip_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatHit_ThreatSource::release_remote_ip() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) + if (!_internal_has_remote_ip()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.remote_ip_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remote_ip_.IsDefault()) { + _impl_.remote_ip_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatHit_ThreatSource::set_allocated_remote_ip(std::string* remote_ip) { + if (remote_ip != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.remote_ip_.SetAllocated(remote_ip, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remote_ip_.IsDefault()) { + _impl_.remote_ip_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) +} + +// optional string referrer = 4; +inline bool ThreatHit_ThreatSource::_internal_has_referrer() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ThreatHit_ThreatSource::has_referrer() const { + return _internal_has_referrer(); +} +inline void ThreatHit_ThreatSource::clear_referrer() { + _impl_.referrer_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ThreatHit_ThreatSource::referrer() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) + return _internal_referrer(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatHit_ThreatSource::set_referrer(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.referrer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) +} +inline std::string* ThreatHit_ThreatSource::mutable_referrer() { + std::string* _s = _internal_mutable_referrer(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) + return _s; +} +inline const std::string& ThreatHit_ThreatSource::_internal_referrer() const { + return _impl_.referrer_.Get(); +} +inline void ThreatHit_ThreatSource::_internal_set_referrer(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.referrer_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatHit_ThreatSource::_internal_mutable_referrer() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.referrer_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatHit_ThreatSource::release_referrer() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) + if (!_internal_has_referrer()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.referrer_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.referrer_.IsDefault()) { + _impl_.referrer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatHit_ThreatSource::set_allocated_referrer(std::string* referrer) { + if (referrer != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.referrer_.SetAllocated(referrer, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.referrer_.IsDefault()) { + _impl_.referrer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) +} + +// ------------------------------------------------------------------- + +// ThreatHit_UserInfo + +// optional string region_code = 1; +inline bool ThreatHit_UserInfo::_internal_has_region_code() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ThreatHit_UserInfo::has_region_code() const { + return _internal_has_region_code(); +} +inline void ThreatHit_UserInfo::clear_region_code() { + _impl_.region_code_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ThreatHit_UserInfo::region_code() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.UserInfo.region_code) + return _internal_region_code(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatHit_UserInfo::set_region_code(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.region_code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.UserInfo.region_code) +} +inline std::string* ThreatHit_UserInfo::mutable_region_code() { + std::string* _s = _internal_mutable_region_code(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.UserInfo.region_code) + return _s; +} +inline const std::string& ThreatHit_UserInfo::_internal_region_code() const { + return _impl_.region_code_.Get(); +} +inline void ThreatHit_UserInfo::_internal_set_region_code(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.region_code_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatHit_UserInfo::_internal_mutable_region_code() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.region_code_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatHit_UserInfo::release_region_code() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.UserInfo.region_code) + if (!_internal_has_region_code()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.region_code_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.region_code_.IsDefault()) { + _impl_.region_code_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatHit_UserInfo::set_allocated_region_code(std::string* region_code) { + if (region_code != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.region_code_.SetAllocated(region_code, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.region_code_.IsDefault()) { + _impl_.region_code_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.UserInfo.region_code) +} + +// optional bytes user_id = 2; +inline bool ThreatHit_UserInfo::_internal_has_user_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ThreatHit_UserInfo::has_user_id() const { + return _internal_has_user_id(); +} +inline void ThreatHit_UserInfo::clear_user_id() { + _impl_.user_id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ThreatHit_UserInfo::user_id() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.UserInfo.user_id) + return _internal_user_id(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatHit_UserInfo::set_user_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.user_id_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.UserInfo.user_id) +} +inline std::string* ThreatHit_UserInfo::mutable_user_id() { + std::string* _s = _internal_mutable_user_id(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.UserInfo.user_id) + return _s; +} +inline const std::string& ThreatHit_UserInfo::_internal_user_id() const { + return _impl_.user_id_.Get(); +} +inline void ThreatHit_UserInfo::_internal_set_user_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.user_id_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatHit_UserInfo::_internal_mutable_user_id() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.user_id_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatHit_UserInfo::release_user_id() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.UserInfo.user_id) + if (!_internal_has_user_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.user_id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.user_id_.IsDefault()) { + _impl_.user_id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatHit_UserInfo::set_allocated_user_id(std::string* user_id) { + if (user_id != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.user_id_.SetAllocated(user_id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.user_id_.IsDefault()) { + _impl_.user_id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.UserInfo.user_id) +} + +// ------------------------------------------------------------------- + +// ThreatHit + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool ThreatHit::_internal_has_threat_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ThreatHit::has_threat_type() const { + return _internal_has_threat_type(); +} +inline void ThreatHit::clear_threat_type() { + _impl_.threat_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::mozilla::safebrowsing::ThreatType ThreatHit::_internal_threat_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_); +} +inline ::mozilla::safebrowsing::ThreatType ThreatHit::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.threat_type) + return _internal_threat_type(); +} +inline void ThreatHit::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.threat_type_ = value; +} +inline void ThreatHit::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + _internal_set_threat_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool ThreatHit::_internal_has_platform_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ThreatHit::has_platform_type() const { + return _internal_has_platform_type(); +} +inline void ThreatHit::clear_platform_type() { + _impl_.platform_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::mozilla::safebrowsing::PlatformType ThreatHit::_internal_platform_type() const { + return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_); +} +inline ::mozilla::safebrowsing::PlatformType ThreatHit::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.platform_type) + return _internal_platform_type(); +} +inline void ThreatHit::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.platform_type_ = value; +} +inline void ThreatHit::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + _internal_set_platform_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntry entry = 3; +inline bool ThreatHit::_internal_has_entry() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.entry_ != nullptr); + return value; +} +inline bool ThreatHit::has_entry() const { + return _internal_has_entry(); +} +inline void ThreatHit::clear_entry() { + if (_impl_.entry_ != nullptr) _impl_.entry_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::_internal_entry() const { + const ::mozilla::safebrowsing::ThreatEntry* p = _impl_.entry_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntry&>( + ::mozilla::safebrowsing::_ThreatEntry_default_instance_); +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::entry() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.entry) + return _internal_entry(); +} +inline void ThreatHit::unsafe_arena_set_allocated_entry( + ::mozilla::safebrowsing::ThreatEntry* entry) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_); + } + _impl_.entry_ = entry; + if (entry) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatHit.entry) +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::release_entry() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.entry_; + _impl_.entry_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::unsafe_arena_release_entry() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.entry) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.entry_; + _impl_.entry_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::_internal_mutable_entry() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.entry_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(GetArenaForAllocation()); + _impl_.entry_ = p; + } + return _impl_.entry_; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::mutable_entry() { + ::mozilla::safebrowsing::ThreatEntry* _msg = _internal_mutable_entry(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.entry) + return _msg; +} +inline void ThreatHit::set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.entry_; + } + if (entry) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(entry); + if (message_arena != submessage_arena) { + entry = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entry, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.entry_ = entry; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.entry) +} + +// repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; +inline int ThreatHit::_internal_resources_size() const { + return _impl_.resources_.size(); +} +inline int ThreatHit::resources_size() const { + return _internal_resources_size(); +} +inline void ThreatHit::clear_resources() { + _impl_.resources_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::mutable_resources(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.resources) + return _impl_.resources_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >* +ThreatHit::mutable_resources() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatHit.resources) + return &_impl_.resources_; +} +inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::_internal_resources(int index) const { + return _impl_.resources_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::resources(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.resources) + return _internal_resources(index); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::_internal_add_resources() { + return _impl_.resources_.Add(); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::add_resources() { + ::mozilla::safebrowsing::ThreatHit_ThreatSource* _add = _internal_add_resources(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatHit.resources) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >& +ThreatHit::resources() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatHit.resources) + return _impl_.resources_; +} + +// optional .mozilla.safebrowsing.ClientInfo client_info = 5; +inline bool ThreatHit::_internal_has_client_info() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.client_info_ != nullptr); + return value; +} +inline bool ThreatHit::has_client_info() const { + return _internal_has_client_info(); +} +inline void ThreatHit::clear_client_info() { + if (_impl_.client_info_ != nullptr) _impl_.client_info_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::ClientInfo& ThreatHit::_internal_client_info() const { + const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_info_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>( + ::mozilla::safebrowsing::_ClientInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ClientInfo& ThreatHit::client_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.client_info) + return _internal_client_info(); +} +inline void ThreatHit::unsafe_arena_set_allocated_client_info( + ::mozilla::safebrowsing::ClientInfo* client_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_info_); + } + _impl_.client_info_ = client_info; + if (client_info) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatHit.client_info) +} +inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::release_client_info() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_info_; + _impl_.client_info_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::unsafe_arena_release_client_info() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.client_info) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_info_; + _impl_.client_info_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::_internal_mutable_client_info() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.client_info_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation()); + _impl_.client_info_ = p; + } + return _impl_.client_info_; +} +inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::mutable_client_info() { + ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client_info(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.client_info) + return _msg; +} +inline void ThreatHit::set_allocated_client_info(::mozilla::safebrowsing::ClientInfo* client_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.client_info_; + } + if (client_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client_info); + if (message_arena != submessage_arena) { + client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client_info, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.client_info_ = client_info; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.client_info) +} + +// optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6; +inline bool ThreatHit::_internal_has_user_info() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.user_info_ != nullptr); + return value; +} +inline bool ThreatHit::has_user_info() const { + return _internal_has_user_info(); +} +inline void ThreatHit::clear_user_info() { + if (_impl_.user_info_ != nullptr) _impl_.user_info_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::mozilla::safebrowsing::ThreatHit_UserInfo& ThreatHit::_internal_user_info() const { + const ::mozilla::safebrowsing::ThreatHit_UserInfo* p = _impl_.user_info_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatHit_UserInfo&>( + ::mozilla::safebrowsing::_ThreatHit_UserInfo_default_instance_); +} +inline const ::mozilla::safebrowsing::ThreatHit_UserInfo& ThreatHit::user_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.user_info) + return _internal_user_info(); +} +inline void ThreatHit::unsafe_arena_set_allocated_user_info( + ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_info_); + } + _impl_.user_info_ = user_info; + if (user_info) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatHit.user_info) +} +inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::release_user_info() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::mozilla::safebrowsing::ThreatHit_UserInfo* temp = _impl_.user_info_; + _impl_.user_info_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::unsafe_arena_release_user_info() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.user_info) + _impl_._has_bits_[0] &= ~0x00000004u; + ::mozilla::safebrowsing::ThreatHit_UserInfo* temp = _impl_.user_info_; + _impl_.user_info_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::_internal_mutable_user_info() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.user_info_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_UserInfo>(GetArenaForAllocation()); + _impl_.user_info_ = p; + } + return _impl_.user_info_; +} +inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::mutable_user_info() { + ::mozilla::safebrowsing::ThreatHit_UserInfo* _msg = _internal_mutable_user_info(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.user_info) + return _msg; +} +inline void ThreatHit::set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo* user_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.user_info_; + } + if (user_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_info); + if (message_arena != submessage_arena) { + user_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, user_info, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.user_info_ = user_info; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.user_info) +} + +// ------------------------------------------------------------------- + +// ClientInfo + +// optional string client_id = 1; +inline bool ClientInfo::_internal_has_client_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientInfo::has_client_id() const { + return _internal_has_client_id(); +} +inline void ClientInfo::clear_client_id() { + _impl_.client_id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientInfo::client_id() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_id) + return _internal_client_id(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ClientInfo::set_client_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.client_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_id) +} +inline std::string* ClientInfo::mutable_client_id() { + std::string* _s = _internal_mutable_client_id(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_id) + return _s; +} +inline const std::string& ClientInfo::_internal_client_id() const { + return _impl_.client_id_.Get(); +} +inline void ClientInfo::_internal_set_client_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.client_id_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientInfo::_internal_mutable_client_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.client_id_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientInfo::release_client_id() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ClientInfo.client_id) + if (!_internal_has_client_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.client_id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.client_id_.IsDefault()) { + _impl_.client_id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientInfo::set_allocated_client_id(std::string* client_id) { + if (client_id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.client_id_.SetAllocated(client_id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.client_id_.IsDefault()) { + _impl_.client_id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_id) +} + +// optional string client_version = 2; +inline bool ClientInfo::_internal_has_client_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientInfo::has_client_version() const { + return _internal_has_client_version(); +} +inline void ClientInfo::clear_client_version() { + _impl_.client_version_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ClientInfo::client_version() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_version) + return _internal_client_version(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ClientInfo::set_client_version(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.client_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_version) +} +inline std::string* ClientInfo::mutable_client_version() { + std::string* _s = _internal_mutable_client_version(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_version) + return _s; +} +inline const std::string& ClientInfo::_internal_client_version() const { + return _impl_.client_version_.Get(); +} +inline void ClientInfo::_internal_set_client_version(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.client_version_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientInfo::_internal_mutable_client_version() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.client_version_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientInfo::release_client_version() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ClientInfo.client_version) + if (!_internal_has_client_version()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.client_version_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.client_version_.IsDefault()) { + _impl_.client_version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientInfo::set_allocated_client_version(std::string* client_version) { + if (client_version != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.client_version_.SetAllocated(client_version, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.client_version_.IsDefault()) { + _impl_.client_version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_version) +} + +// ------------------------------------------------------------------- + +// ChromeClientInfo + +// optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1; +inline bool ChromeClientInfo::_internal_has_reporting_population() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ChromeClientInfo::has_reporting_population() const { + return _internal_has_reporting_population(); +} +inline void ChromeClientInfo::clear_reporting_population() { + _impl_.reporting_population_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::_internal_reporting_population() const { + return static_cast< ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation >(_impl_.reporting_population_); +} +inline ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::reporting_population() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ChromeClientInfo.reporting_population) + return _internal_reporting_population(); +} +inline void ChromeClientInfo::_internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value) { + assert(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.reporting_population_ = value; +} +inline void ChromeClientInfo::set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value) { + _internal_set_reporting_population(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ChromeClientInfo.reporting_population) +} + +// ------------------------------------------------------------------- + +// Checksum + +// optional bytes sha256 = 1; +inline bool Checksum::_internal_has_sha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Checksum::has_sha256() const { + return _internal_has_sha256(); +} +inline void Checksum::clear_sha256() { + _impl_.sha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Checksum::sha256() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Checksum.sha256) + return _internal_sha256(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void Checksum::set_sha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.sha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Checksum.sha256) +} +inline std::string* Checksum::mutable_sha256() { + std::string* _s = _internal_mutable_sha256(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.Checksum.sha256) + return _s; +} +inline const std::string& Checksum::_internal_sha256() const { + return _impl_.sha256_.Get(); +} +inline void Checksum::_internal_set_sha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.sha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Checksum::_internal_mutable_sha256() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.sha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Checksum::release_sha256() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.Checksum.sha256) + if (!_internal_has_sha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.sha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sha256_.IsDefault()) { + _impl_.sha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Checksum::set_allocated_sha256(std::string* sha256) { + if (sha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.sha256_.SetAllocated(sha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sha256_.IsDefault()) { + _impl_.sha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.Checksum.sha256) +} + +// ------------------------------------------------------------------- + +// ThreatEntry + +// optional bytes hash = 1; +inline bool ThreatEntry::_internal_has_hash() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ThreatEntry::has_hash() const { + return _internal_has_hash(); +} +inline void ThreatEntry::clear_hash() { + _impl_.hash_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ThreatEntry::hash() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.hash) + return _internal_hash(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatEntry::set_hash(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.hash) +} +inline std::string* ThreatEntry::mutable_hash() { + std::string* _s = _internal_mutable_hash(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.hash) + return _s; +} +inline const std::string& ThreatEntry::_internal_hash() const { + return _impl_.hash_.Get(); +} +inline void ThreatEntry::_internal_set_hash(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.hash_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatEntry::_internal_mutable_hash() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.hash_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatEntry::release_hash() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntry.hash) + if (!_internal_has_hash()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.hash_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hash_.IsDefault()) { + _impl_.hash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatEntry::set_allocated_hash(std::string* hash) { + if (hash != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.hash_.SetAllocated(hash, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hash_.IsDefault()) { + _impl_.hash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.hash) +} + +// optional string url = 2; +inline bool ThreatEntry::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ThreatEntry::has_url() const { + return _internal_has_url(); +} +inline void ThreatEntry::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ThreatEntry::url() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.url) + return _internal_url(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatEntry::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.url) +} +inline std::string* ThreatEntry::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.url) + return _s; +} +inline const std::string& ThreatEntry::_internal_url() const { + return _impl_.url_.Get(); +} +inline void ThreatEntry::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatEntry::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatEntry::release_url() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntry.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatEntry::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.url) +} + +// ------------------------------------------------------------------- + +// ThreatEntrySet + +// optional .mozilla.safebrowsing.CompressionType compression_type = 1; +inline bool ThreatEntrySet::_internal_has_compression_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ThreatEntrySet::has_compression_type() const { + return _internal_has_compression_type(); +} +inline void ThreatEntrySet::clear_compression_type() { + _impl_.compression_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::_internal_compression_type() const { + return static_cast< ::mozilla::safebrowsing::CompressionType >(_impl_.compression_type_); +} +inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::compression_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.compression_type) + return _internal_compression_type(); +} +inline void ThreatEntrySet::_internal_set_compression_type(::mozilla::safebrowsing::CompressionType value) { + assert(::mozilla::safebrowsing::CompressionType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.compression_type_ = value; +} +inline void ThreatEntrySet::set_compression_type(::mozilla::safebrowsing::CompressionType value) { + _internal_set_compression_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntrySet.compression_type) +} + +// optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; +inline bool ThreatEntrySet::_internal_has_raw_hashes() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.raw_hashes_ != nullptr); + return value; +} +inline bool ThreatEntrySet::has_raw_hashes() const { + return _internal_has_raw_hashes(); +} +inline void ThreatEntrySet::clear_raw_hashes() { + if (_impl_.raw_hashes_ != nullptr) _impl_.raw_hashes_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::_internal_raw_hashes() const { + const ::mozilla::safebrowsing::RawHashes* p = _impl_.raw_hashes_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RawHashes&>( + ::mozilla::safebrowsing::_RawHashes_default_instance_); +} +inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::raw_hashes() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) + return _internal_raw_hashes(); +} +inline void ThreatEntrySet::unsafe_arena_set_allocated_raw_hashes( + ::mozilla::safebrowsing::RawHashes* raw_hashes) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.raw_hashes_); + } + _impl_.raw_hashes_ = raw_hashes; + if (raw_hashes) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) +} +inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::release_raw_hashes() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::RawHashes* temp = _impl_.raw_hashes_; + _impl_.raw_hashes_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::unsafe_arena_release_raw_hashes() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::safebrowsing::RawHashes* temp = _impl_.raw_hashes_; + _impl_.raw_hashes_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::_internal_mutable_raw_hashes() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.raw_hashes_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RawHashes>(GetArenaForAllocation()); + _impl_.raw_hashes_ = p; + } + return _impl_.raw_hashes_; +} +inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::mutable_raw_hashes() { + ::mozilla::safebrowsing::RawHashes* _msg = _internal_mutable_raw_hashes(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) + return _msg; +} +inline void ThreatEntrySet::set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.raw_hashes_; + } + if (raw_hashes) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_hashes); + if (message_arena != submessage_arena) { + raw_hashes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, raw_hashes, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.raw_hashes_ = raw_hashes; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) +} + +// optional .mozilla.safebrowsing.RawIndices raw_indices = 3; +inline bool ThreatEntrySet::_internal_has_raw_indices() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.raw_indices_ != nullptr); + return value; +} +inline bool ThreatEntrySet::has_raw_indices() const { + return _internal_has_raw_indices(); +} +inline void ThreatEntrySet::clear_raw_indices() { + if (_impl_.raw_indices_ != nullptr) _impl_.raw_indices_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::_internal_raw_indices() const { + const ::mozilla::safebrowsing::RawIndices* p = _impl_.raw_indices_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RawIndices&>( + ::mozilla::safebrowsing::_RawIndices_default_instance_); +} +inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::raw_indices() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_indices) + return _internal_raw_indices(); +} +inline void ThreatEntrySet::unsafe_arena_set_allocated_raw_indices( + ::mozilla::safebrowsing::RawIndices* raw_indices) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.raw_indices_); + } + _impl_.raw_indices_ = raw_indices; + if (raw_indices) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices) +} +inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::release_raw_indices() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::RawIndices* temp = _impl_.raw_indices_; + _impl_.raw_indices_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::unsafe_arena_release_raw_indices() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.raw_indices) + _impl_._has_bits_[0] &= ~0x00000002u; + ::mozilla::safebrowsing::RawIndices* temp = _impl_.raw_indices_; + _impl_.raw_indices_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::_internal_mutable_raw_indices() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.raw_indices_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RawIndices>(GetArenaForAllocation()); + _impl_.raw_indices_ = p; + } + return _impl_.raw_indices_; +} +inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::mutable_raw_indices() { + ::mozilla::safebrowsing::RawIndices* _msg = _internal_mutable_raw_indices(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_indices) + return _msg; +} +inline void ThreatEntrySet::set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.raw_indices_; + } + if (raw_indices) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_indices); + if (message_arena != submessage_arena) { + raw_indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, raw_indices, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.raw_indices_ = raw_indices; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices) +} + +// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; +inline bool ThreatEntrySet::_internal_has_rice_hashes() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.rice_hashes_ != nullptr); + return value; +} +inline bool ThreatEntrySet::has_rice_hashes() const { + return _internal_has_rice_hashes(); +} +inline void ThreatEntrySet::clear_rice_hashes() { + if (_impl_.rice_hashes_ != nullptr) _impl_.rice_hashes_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::_internal_rice_hashes() const { + const ::mozilla::safebrowsing::RiceDeltaEncoding* p = _impl_.rice_hashes_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RiceDeltaEncoding&>( + ::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_); +} +inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_hashes() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) + return _internal_rice_hashes(); +} +inline void ThreatEntrySet::unsafe_arena_set_allocated_rice_hashes( + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rice_hashes_); + } + _impl_.rice_hashes_ = rice_hashes; + if (rice_hashes) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_hashes() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_hashes_; + _impl_.rice_hashes_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::unsafe_arena_release_rice_hashes() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) + _impl_._has_bits_[0] &= ~0x00000004u; + ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_hashes_; + _impl_.rice_hashes_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::_internal_mutable_rice_hashes() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.rice_hashes_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(GetArenaForAllocation()); + _impl_.rice_hashes_ = p; + } + return _impl_.rice_hashes_; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_hashes() { + ::mozilla::safebrowsing::RiceDeltaEncoding* _msg = _internal_mutable_rice_hashes(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) + return _msg; +} +inline void ThreatEntrySet::set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.rice_hashes_; + } + if (rice_hashes) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rice_hashes); + if (message_arena != submessage_arena) { + rice_hashes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, rice_hashes, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.rice_hashes_ = rice_hashes; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) +} + +// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; +inline bool ThreatEntrySet::_internal_has_rice_indices() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.rice_indices_ != nullptr); + return value; +} +inline bool ThreatEntrySet::has_rice_indices() const { + return _internal_has_rice_indices(); +} +inline void ThreatEntrySet::clear_rice_indices() { + if (_impl_.rice_indices_ != nullptr) _impl_.rice_indices_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::_internal_rice_indices() const { + const ::mozilla::safebrowsing::RiceDeltaEncoding* p = _impl_.rice_indices_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RiceDeltaEncoding&>( + ::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_); +} +inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_indices() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_indices) + return _internal_rice_indices(); +} +inline void ThreatEntrySet::unsafe_arena_set_allocated_rice_indices( + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rice_indices_); + } + _impl_.rice_indices_ = rice_indices; + if (rice_indices) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices) +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_indices() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_indices_; + _impl_.rice_indices_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::unsafe_arena_release_rice_indices() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.rice_indices) + _impl_._has_bits_[0] &= ~0x00000008u; + ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_indices_; + _impl_.rice_indices_ = nullptr; + return temp; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::_internal_mutable_rice_indices() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.rice_indices_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(GetArenaForAllocation()); + _impl_.rice_indices_ = p; + } + return _impl_.rice_indices_; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_indices() { + ::mozilla::safebrowsing::RiceDeltaEncoding* _msg = _internal_mutable_rice_indices(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_indices) + return _msg; +} +inline void ThreatEntrySet::set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.rice_indices_; + } + if (rice_indices) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rice_indices); + if (message_arena != submessage_arena) { + rice_indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, rice_indices, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.rice_indices_ = rice_indices; + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices) +} + +// ------------------------------------------------------------------- + +// RawIndices + +// repeated int32 indices = 1; +inline int RawIndices::_internal_indices_size() const { + return _impl_.indices_.size(); +} +inline int RawIndices::indices_size() const { + return _internal_indices_size(); +} +inline void RawIndices::clear_indices() { + _impl_.indices_.Clear(); +} +inline int32_t RawIndices::_internal_indices(int index) const { + return _impl_.indices_.Get(index); +} +inline int32_t RawIndices::indices(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawIndices.indices) + return _internal_indices(index); +} +inline void RawIndices::set_indices(int index, int32_t value) { + _impl_.indices_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawIndices.indices) +} +inline void RawIndices::_internal_add_indices(int32_t value) { + _impl_.indices_.Add(value); +} +inline void RawIndices::add_indices(int32_t value) { + _internal_add_indices(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.RawIndices.indices) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +RawIndices::_internal_indices() const { + return _impl_.indices_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +RawIndices::indices() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.RawIndices.indices) + return _internal_indices(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +RawIndices::_internal_mutable_indices() { + return &_impl_.indices_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +RawIndices::mutable_indices() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.RawIndices.indices) + return _internal_mutable_indices(); +} + +// ------------------------------------------------------------------- + +// RawHashes + +// optional int32 prefix_size = 1; +inline bool RawHashes::_internal_has_prefix_size() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool RawHashes::has_prefix_size() const { + return _internal_has_prefix_size(); +} +inline void RawHashes::clear_prefix_size() { + _impl_.prefix_size_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t RawHashes::_internal_prefix_size() const { + return _impl_.prefix_size_; +} +inline int32_t RawHashes::prefix_size() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.prefix_size) + return _internal_prefix_size(); +} +inline void RawHashes::_internal_set_prefix_size(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.prefix_size_ = value; +} +inline void RawHashes::set_prefix_size(int32_t value) { + _internal_set_prefix_size(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.prefix_size) +} + +// optional bytes raw_hashes = 2; +inline bool RawHashes::_internal_has_raw_hashes() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool RawHashes::has_raw_hashes() const { + return _internal_has_raw_hashes(); +} +inline void RawHashes::clear_raw_hashes() { + _impl_.raw_hashes_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& RawHashes::raw_hashes() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.raw_hashes) + return _internal_raw_hashes(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void RawHashes::set_raw_hashes(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.raw_hashes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.raw_hashes) +} +inline std::string* RawHashes::mutable_raw_hashes() { + std::string* _s = _internal_mutable_raw_hashes(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RawHashes.raw_hashes) + return _s; +} +inline const std::string& RawHashes::_internal_raw_hashes() const { + return _impl_.raw_hashes_.Get(); +} +inline void RawHashes::_internal_set_raw_hashes(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.raw_hashes_.Set(value, GetArenaForAllocation()); +} +inline std::string* RawHashes::_internal_mutable_raw_hashes() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.raw_hashes_.Mutable(GetArenaForAllocation()); +} +inline std::string* RawHashes::release_raw_hashes() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.RawHashes.raw_hashes) + if (!_internal_has_raw_hashes()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.raw_hashes_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.raw_hashes_.IsDefault()) { + _impl_.raw_hashes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void RawHashes::set_allocated_raw_hashes(std::string* raw_hashes) { + if (raw_hashes != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.raw_hashes_.SetAllocated(raw_hashes, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.raw_hashes_.IsDefault()) { + _impl_.raw_hashes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RawHashes.raw_hashes) +} + +// ------------------------------------------------------------------- + +// RiceDeltaEncoding + +// optional int64 first_value = 1; +inline bool RiceDeltaEncoding::_internal_has_first_value() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool RiceDeltaEncoding::has_first_value() const { + return _internal_has_first_value(); +} +inline void RiceDeltaEncoding::clear_first_value() { + _impl_.first_value_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t RiceDeltaEncoding::_internal_first_value() const { + return _impl_.first_value_; +} +inline int64_t RiceDeltaEncoding::first_value() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.first_value) + return _internal_first_value(); +} +inline void RiceDeltaEncoding::_internal_set_first_value(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.first_value_ = value; +} +inline void RiceDeltaEncoding::set_first_value(int64_t value) { + _internal_set_first_value(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.first_value) +} + +// optional int32 rice_parameter = 2; +inline bool RiceDeltaEncoding::_internal_has_rice_parameter() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool RiceDeltaEncoding::has_rice_parameter() const { + return _internal_has_rice_parameter(); +} +inline void RiceDeltaEncoding::clear_rice_parameter() { + _impl_.rice_parameter_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t RiceDeltaEncoding::_internal_rice_parameter() const { + return _impl_.rice_parameter_; +} +inline int32_t RiceDeltaEncoding::rice_parameter() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter) + return _internal_rice_parameter(); +} +inline void RiceDeltaEncoding::_internal_set_rice_parameter(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.rice_parameter_ = value; +} +inline void RiceDeltaEncoding::set_rice_parameter(int32_t value) { + _internal_set_rice_parameter(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter) +} + +// optional int32 num_entries = 3; +inline bool RiceDeltaEncoding::_internal_has_num_entries() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool RiceDeltaEncoding::has_num_entries() const { + return _internal_has_num_entries(); +} +inline void RiceDeltaEncoding::clear_num_entries() { + _impl_.num_entries_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int32_t RiceDeltaEncoding::_internal_num_entries() const { + return _impl_.num_entries_; +} +inline int32_t RiceDeltaEncoding::num_entries() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.num_entries) + return _internal_num_entries(); +} +inline void RiceDeltaEncoding::_internal_set_num_entries(int32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.num_entries_ = value; +} +inline void RiceDeltaEncoding::set_num_entries(int32_t value) { + _internal_set_num_entries(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.num_entries) +} + +// optional bytes encoded_data = 4; +inline bool RiceDeltaEncoding::_internal_has_encoded_data() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool RiceDeltaEncoding::has_encoded_data() const { + return _internal_has_encoded_data(); +} +inline void RiceDeltaEncoding::clear_encoded_data() { + _impl_.encoded_data_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& RiceDeltaEncoding::encoded_data() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) + return _internal_encoded_data(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void RiceDeltaEncoding::set_encoded_data(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) +} +inline std::string* RiceDeltaEncoding::mutable_encoded_data() { + std::string* _s = _internal_mutable_encoded_data(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) + return _s; +} +inline const std::string& RiceDeltaEncoding::_internal_encoded_data() const { + return _impl_.encoded_data_.Get(); +} +inline void RiceDeltaEncoding::_internal_set_encoded_data(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.encoded_data_.Set(value, GetArenaForAllocation()); +} +inline std::string* RiceDeltaEncoding::_internal_mutable_encoded_data() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.encoded_data_.Mutable(GetArenaForAllocation()); +} +inline std::string* RiceDeltaEncoding::release_encoded_data() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) + if (!_internal_has_encoded_data()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.encoded_data_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.encoded_data_.IsDefault()) { + _impl_.encoded_data_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void RiceDeltaEncoding::set_allocated_encoded_data(std::string* encoded_data) { + if (encoded_data != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.encoded_data_.IsDefault()) { + _impl_.encoded_data_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) +} + +// ------------------------------------------------------------------- + +// ThreatEntryMetadata_MetadataEntry + +// optional bytes key = 1; +inline bool ThreatEntryMetadata_MetadataEntry::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ThreatEntryMetadata_MetadataEntry::has_key() const { + return _internal_has_key(); +} +inline void ThreatEntryMetadata_MetadataEntry::clear_key() { + _impl_.key_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ThreatEntryMetadata_MetadataEntry::key() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) + return _internal_key(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatEntryMetadata_MetadataEntry::set_key(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) +} +inline std::string* ThreatEntryMetadata_MetadataEntry::mutable_key() { + std::string* _s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) + return _s; +} +inline const std::string& ThreatEntryMetadata_MetadataEntry::_internal_key() const { + return _impl_.key_.Get(); +} +inline void ThreatEntryMetadata_MetadataEntry::_internal_set_key(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.key_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatEntryMetadata_MetadataEntry::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.key_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatEntryMetadata_MetadataEntry::release_key() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) + if (!_internal_has_key()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.key_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatEntryMetadata_MetadataEntry::set_allocated_key(std::string* key) { + if (key != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_.SetAllocated(key, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) +} + +// optional bytes value = 2; +inline bool ThreatEntryMetadata_MetadataEntry::_internal_has_value() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ThreatEntryMetadata_MetadataEntry::has_value() const { + return _internal_has_value(); +} +inline void ThreatEntryMetadata_MetadataEntry::clear_value() { + _impl_.value_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ThreatEntryMetadata_MetadataEntry::value() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) + return _internal_value(); +} +template <typename ArgT0, typename... ArgT> +inline PROTOBUF_ALWAYS_INLINE +void ThreatEntryMetadata_MetadataEntry::set_value(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) +} +inline std::string* ThreatEntryMetadata_MetadataEntry::mutable_value() { + std::string* _s = _internal_mutable_value(); + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) + return _s; +} +inline const std::string& ThreatEntryMetadata_MetadataEntry::_internal_value() const { + return _impl_.value_.Get(); +} +inline void ThreatEntryMetadata_MetadataEntry::_internal_set_value(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.value_.Set(value, GetArenaForAllocation()); +} +inline std::string* ThreatEntryMetadata_MetadataEntry::_internal_mutable_value() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.value_.Mutable(GetArenaForAllocation()); +} +inline std::string* ThreatEntryMetadata_MetadataEntry::release_value() { + // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) + if (!_internal_has_value()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.value_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.value_.IsDefault()) { + _impl_.value_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ThreatEntryMetadata_MetadataEntry::set_allocated_value(std::string* value) { + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.value_.SetAllocated(value, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.value_.IsDefault()) { + _impl_.value_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) +} + +// ------------------------------------------------------------------- + +// ThreatEntryMetadata + +// repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; +inline int ThreatEntryMetadata::_internal_entries_size() const { + return _impl_.entries_.size(); +} +inline int ThreatEntryMetadata::entries_size() const { + return _internal_entries_size(); +} +inline void ThreatEntryMetadata::clear_entries() { + _impl_.entries_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::mutable_entries(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return _impl_.entries_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >* +ThreatEntryMetadata::mutable_entries() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return &_impl_.entries_; +} +inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::_internal_entries(int index) const { + return _impl_.entries_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::entries(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return _internal_entries(index); +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::_internal_add_entries() { + return _impl_.entries_.Add(); +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::add_entries() { + ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* _add = _internal_add_entries(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >& +ThreatEntryMetadata::entries() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return _impl_.entries_; +} + +// ------------------------------------------------------------------- + +// ThreatListDescriptor + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool ThreatListDescriptor::_internal_has_threat_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ThreatListDescriptor::has_threat_type() const { + return _internal_has_threat_type(); +} +inline void ThreatListDescriptor::clear_threat_type() { + _impl_.threat_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::_internal_threat_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_); +} +inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_type) + return _internal_threat_type(); +} +inline void ThreatListDescriptor::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.threat_type_ = value; +} +inline void ThreatListDescriptor::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + _internal_set_threat_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool ThreatListDescriptor::_internal_has_platform_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ThreatListDescriptor::has_platform_type() const { + return _internal_has_platform_type(); +} +inline void ThreatListDescriptor::clear_platform_type() { + _impl_.platform_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::_internal_platform_type() const { + return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_); +} +inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.platform_type) + return _internal_platform_type(); +} +inline void ThreatListDescriptor::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.platform_type_ = value; +} +inline void ThreatListDescriptor::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + _internal_set_platform_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; +inline bool ThreatListDescriptor::_internal_has_threat_entry_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ThreatListDescriptor::has_threat_entry_type() const { + return _internal_has_threat_entry_type(); +} +inline void ThreatListDescriptor::clear_threat_entry_type() { + _impl_.threat_entry_type_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::_internal_threat_entry_type() const { + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type) + return _internal_threat_entry_type(); +} +inline void ThreatListDescriptor::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.threat_entry_type_ = value; +} +inline void ThreatListDescriptor::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + _internal_set_threat_entry_type(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type) +} + +// ------------------------------------------------------------------- + +// ListThreatListsResponse + +// repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; +inline int ListThreatListsResponse::_internal_threat_lists_size() const { + return _impl_.threat_lists_.size(); +} +inline int ListThreatListsResponse::threat_lists_size() const { + return _internal_threat_lists_size(); +} +inline void ListThreatListsResponse::clear_threat_lists() { + _impl_.threat_lists_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::mutable_threat_lists(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return _impl_.threat_lists_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >* +ListThreatListsResponse::mutable_threat_lists() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return &_impl_.threat_lists_; +} +inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::_internal_threat_lists(int index) const { + return _impl_.threat_lists_.Get(index); +} +inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::threat_lists(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return _internal_threat_lists(index); +} +inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::_internal_add_threat_lists() { + return _impl_.threat_lists_.Add(); +} +inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::add_threat_lists() { + ::mozilla::safebrowsing::ThreatListDescriptor* _add = _internal_add_threat_lists(); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >& +ListThreatListsResponse::threat_lists() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return _impl_.threat_lists_; +} + +// ------------------------------------------------------------------- + +// Duration + +// optional int64 seconds = 1; +inline bool Duration::_internal_has_seconds() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Duration::has_seconds() const { + return _internal_has_seconds(); +} +inline void Duration::clear_seconds() { + _impl_.seconds_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t Duration::_internal_seconds() const { + return _impl_.seconds_; +} +inline int64_t Duration::seconds() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.seconds) + return _internal_seconds(); +} +inline void Duration::_internal_set_seconds(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.seconds_ = value; +} +inline void Duration::set_seconds(int64_t value) { + _internal_set_seconds(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.seconds) +} + +// optional int32 nanos = 2; +inline bool Duration::_internal_has_nanos() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Duration::has_nanos() const { + return _internal_has_nanos(); +} +inline void Duration::clear_nanos() { + _impl_.nanos_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t Duration::_internal_nanos() const { + return _impl_.nanos_; +} +inline int32_t Duration::nanos() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.nanos) + return _internal_nanos(); +} +inline void Duration::_internal_set_nanos(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.nanos_ = value; +} +inline void Duration::set_nanos(int32_t value) { + _internal_set_nanos(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.nanos) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace safebrowsing +} // namespace mozilla + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType> : ::std::true_type {}; +template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType> : ::std::true_type {}; +template <> struct is_proto_enum< ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation> : ::std::true_type {}; +template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatType> : ::std::true_type {}; +template <> struct is_proto_enum< ::mozilla::safebrowsing::PlatformType> : ::std::true_type {}; +template <> struct is_proto_enum< ::mozilla::safebrowsing::CompressionType> : ::std::true_type {}; +template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatEntryType> : ::std::true_type {}; + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include <google/protobuf/port_undef.inc> +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto |