diff options
Diffstat (limited to 'toolkit/components/url-classifier/chromium/safebrowsing.pb.cc')
| -rw-r--r-- | toolkit/components/url-classifier/chromium/safebrowsing.pb.cc | 8925 |
1 files changed, 8925 insertions, 0 deletions
diff --git a/toolkit/components/url-classifier/chromium/safebrowsing.pb.cc b/toolkit/components/url-classifier/chromium/safebrowsing.pb.cc new file mode 100644 index 0000000000..ec0994bfd6 --- /dev/null +++ b/toolkit/components/url-classifier/chromium/safebrowsing.pb.cc @@ -0,0 +1,8925 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: safebrowsing.proto + +#include "safebrowsing.pb.h" + +#include <algorithm> + +#include <google/protobuf/io/coded_stream.h> +#include <google/protobuf/extension_set.h> +#include <google/protobuf/wire_format_lite.h> +#include <google/protobuf/io/zero_copy_stream_impl_lite.h> +// @@protoc_insertion_point(includes) +#include <google/protobuf/port_def.inc> + +PROTOBUF_PRAGMA_INIT_SEG + +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = _pb::internal; + +namespace mozilla { +namespace safebrowsing { +PROTOBUF_CONSTEXPR ThreatInfo::ThreatInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.threat_types_)*/{} + , /*decltype(_impl_.platform_types_)*/{} + , /*decltype(_impl_.threat_entries_)*/{} + , /*decltype(_impl_.threat_entry_types_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ThreatInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatInfoDefaultTypeInternal() {} + union { + ThreatInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatInfoDefaultTypeInternal _ThreatInfo_default_instance_; +PROTOBUF_CONSTEXPR ThreatMatch::ThreatMatch( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.threat_)*/nullptr + , /*decltype(_impl_.threat_entry_metadata_)*/nullptr + , /*decltype(_impl_.cache_duration_)*/nullptr + , /*decltype(_impl_.threat_type_)*/0 + , /*decltype(_impl_.platform_type_)*/0 + , /*decltype(_impl_.threat_entry_type_)*/0} {} +struct ThreatMatchDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatMatchDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatMatchDefaultTypeInternal() {} + union { + ThreatMatch _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatMatchDefaultTypeInternal _ThreatMatch_default_instance_; +PROTOBUF_CONSTEXPR FindThreatMatchesRequest::FindThreatMatchesRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.client_)*/nullptr + , /*decltype(_impl_.threat_info_)*/nullptr} {} +struct FindThreatMatchesRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR FindThreatMatchesRequestDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FindThreatMatchesRequestDefaultTypeInternal() {} + union { + FindThreatMatchesRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FindThreatMatchesRequestDefaultTypeInternal _FindThreatMatchesRequest_default_instance_; +PROTOBUF_CONSTEXPR FindThreatMatchesResponse::FindThreatMatchesResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.matches_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct FindThreatMatchesResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR FindThreatMatchesResponseDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FindThreatMatchesResponseDefaultTypeInternal() {} + union { + FindThreatMatchesResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FindThreatMatchesResponseDefaultTypeInternal _FindThreatMatchesResponse_default_instance_; +PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.supported_compressions_)*/{} + , /*decltype(_impl_.region_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.max_update_entries_)*/0 + , /*decltype(_impl_.max_database_entries_)*/0} {} +struct FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal { + PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal() {} + union { + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_; +PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.state_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.constraints_)*/nullptr + , /*decltype(_impl_.threat_type_)*/0 + , /*decltype(_impl_.platform_type_)*/0 + , /*decltype(_impl_.threat_entry_type_)*/0} {} +struct FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal() {} + union { + FetchThreatListUpdatesRequest_ListUpdateRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_; +PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.list_update_requests_)*/{} + , /*decltype(_impl_.client_)*/nullptr + , /*decltype(_impl_.chrome_client_info_)*/nullptr} {} +struct FetchThreatListUpdatesRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequestDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FetchThreatListUpdatesRequestDefaultTypeInternal() {} + union { + FetchThreatListUpdatesRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FetchThreatListUpdatesRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_default_instance_; +PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.additions_)*/{} + , /*decltype(_impl_.removals_)*/{} + , /*decltype(_impl_.new_client_state_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.checksum_)*/nullptr + , /*decltype(_impl_.threat_type_)*/0 + , /*decltype(_impl_.threat_entry_type_)*/0 + , /*decltype(_impl_.platform_type_)*/0 + , /*decltype(_impl_.response_type_)*/0} {} +struct FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal() {} + union { + FetchThreatListUpdatesResponse_ListUpdateResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_; +PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.list_update_responses_)*/{} + , /*decltype(_impl_.minimum_wait_duration_)*/nullptr} {} +struct FetchThreatListUpdatesResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponseDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FetchThreatListUpdatesResponseDefaultTypeInternal() {} + union { + FetchThreatListUpdatesResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FetchThreatListUpdatesResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_default_instance_; +PROTOBUF_CONSTEXPR FindFullHashesRequest::FindFullHashesRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.client_states_)*/{} + , /*decltype(_impl_.client_)*/nullptr + , /*decltype(_impl_.threat_info_)*/nullptr} {} +struct FindFullHashesRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR FindFullHashesRequestDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FindFullHashesRequestDefaultTypeInternal() {} + union { + FindFullHashesRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FindFullHashesRequestDefaultTypeInternal _FindFullHashesRequest_default_instance_; +PROTOBUF_CONSTEXPR FindFullHashesResponse::FindFullHashesResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.matches_)*/{} + , /*decltype(_impl_.minimum_wait_duration_)*/nullptr + , /*decltype(_impl_.negative_cache_duration_)*/nullptr} {} +struct FindFullHashesResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR FindFullHashesResponseDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FindFullHashesResponseDefaultTypeInternal() {} + union { + FindFullHashesResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FindFullHashesResponseDefaultTypeInternal _FindFullHashesResponse_default_instance_; +PROTOBUF_CONSTEXPR ThreatHit_ThreatSource::ThreatHit_ThreatSource( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.remote_ip_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.referrer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.type_)*/0} {} +struct ThreatHit_ThreatSourceDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatHit_ThreatSourceDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatHit_ThreatSourceDefaultTypeInternal() {} + union { + ThreatHit_ThreatSource _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatHit_ThreatSourceDefaultTypeInternal _ThreatHit_ThreatSource_default_instance_; +PROTOBUF_CONSTEXPR ThreatHit_UserInfo::ThreatHit_UserInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.region_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.user_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ThreatHit_UserInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatHit_UserInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatHit_UserInfoDefaultTypeInternal() {} + union { + ThreatHit_UserInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatHit_UserInfoDefaultTypeInternal _ThreatHit_UserInfo_default_instance_; +PROTOBUF_CONSTEXPR ThreatHit::ThreatHit( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.resources_)*/{} + , /*decltype(_impl_.entry_)*/nullptr + , /*decltype(_impl_.client_info_)*/nullptr + , /*decltype(_impl_.user_info_)*/nullptr + , /*decltype(_impl_.threat_type_)*/0 + , /*decltype(_impl_.platform_type_)*/0} {} +struct ThreatHitDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatHitDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatHitDefaultTypeInternal() {} + union { + ThreatHit _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatHitDefaultTypeInternal _ThreatHit_default_instance_; +PROTOBUF_CONSTEXPR ClientInfo::ClientInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.client_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.client_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ClientInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientInfoDefaultTypeInternal() {} + union { + ClientInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientInfoDefaultTypeInternal _ClientInfo_default_instance_; +PROTOBUF_CONSTEXPR ChromeClientInfo::ChromeClientInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.reporting_population_)*/0} {} +struct ChromeClientInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChromeClientInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ChromeClientInfoDefaultTypeInternal() {} + union { + ChromeClientInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeClientInfoDefaultTypeInternal _ChromeClientInfo_default_instance_; +PROTOBUF_CONSTEXPR Checksum::Checksum( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.sha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ChecksumDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChecksumDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ChecksumDefaultTypeInternal() {} + union { + Checksum _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChecksumDefaultTypeInternal _Checksum_default_instance_; +PROTOBUF_CONSTEXPR ThreatEntry::ThreatEntry( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ThreatEntryDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatEntryDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatEntryDefaultTypeInternal() {} + union { + ThreatEntry _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatEntryDefaultTypeInternal _ThreatEntry_default_instance_; +PROTOBUF_CONSTEXPR ThreatEntrySet::ThreatEntrySet( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.raw_hashes_)*/nullptr + , /*decltype(_impl_.raw_indices_)*/nullptr + , /*decltype(_impl_.rice_hashes_)*/nullptr + , /*decltype(_impl_.rice_indices_)*/nullptr + , /*decltype(_impl_.compression_type_)*/0} {} +struct ThreatEntrySetDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatEntrySetDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatEntrySetDefaultTypeInternal() {} + union { + ThreatEntrySet _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatEntrySetDefaultTypeInternal _ThreatEntrySet_default_instance_; +PROTOBUF_CONSTEXPR RawIndices::RawIndices( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.indices_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct RawIndicesDefaultTypeInternal { + PROTOBUF_CONSTEXPR RawIndicesDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~RawIndicesDefaultTypeInternal() {} + union { + RawIndices _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RawIndicesDefaultTypeInternal _RawIndices_default_instance_; +PROTOBUF_CONSTEXPR RawHashes::RawHashes( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.raw_hashes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.prefix_size_)*/0} {} +struct RawHashesDefaultTypeInternal { + PROTOBUF_CONSTEXPR RawHashesDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~RawHashesDefaultTypeInternal() {} + union { + RawHashes _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RawHashesDefaultTypeInternal _RawHashes_default_instance_; +PROTOBUF_CONSTEXPR RiceDeltaEncoding::RiceDeltaEncoding( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.encoded_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.first_value_)*/int64_t{0} + , /*decltype(_impl_.rice_parameter_)*/0 + , /*decltype(_impl_.num_entries_)*/0} {} +struct RiceDeltaEncodingDefaultTypeInternal { + PROTOBUF_CONSTEXPR RiceDeltaEncodingDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~RiceDeltaEncodingDefaultTypeInternal() {} + union { + RiceDeltaEncoding _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RiceDeltaEncodingDefaultTypeInternal _RiceDeltaEncoding_default_instance_; +PROTOBUF_CONSTEXPR ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ThreatEntryMetadata_MetadataEntryDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatEntryMetadata_MetadataEntryDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatEntryMetadata_MetadataEntryDefaultTypeInternal() {} + union { + ThreatEntryMetadata_MetadataEntry _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatEntryMetadata_MetadataEntryDefaultTypeInternal _ThreatEntryMetadata_MetadataEntry_default_instance_; +PROTOBUF_CONSTEXPR ThreatEntryMetadata::ThreatEntryMetadata( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.entries_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ThreatEntryMetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatEntryMetadataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatEntryMetadataDefaultTypeInternal() {} + union { + ThreatEntryMetadata _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatEntryMetadataDefaultTypeInternal _ThreatEntryMetadata_default_instance_; +PROTOBUF_CONSTEXPR ThreatListDescriptor::ThreatListDescriptor( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.threat_type_)*/0 + , /*decltype(_impl_.platform_type_)*/0 + , /*decltype(_impl_.threat_entry_type_)*/0} {} +struct ThreatListDescriptorDefaultTypeInternal { + PROTOBUF_CONSTEXPR ThreatListDescriptorDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ThreatListDescriptorDefaultTypeInternal() {} + union { + ThreatListDescriptor _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThreatListDescriptorDefaultTypeInternal _ThreatListDescriptor_default_instance_; +PROTOBUF_CONSTEXPR ListThreatListsResponse::ListThreatListsResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.threat_lists_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ListThreatListsResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ListThreatListsResponseDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ListThreatListsResponseDefaultTypeInternal() {} + union { + ListThreatListsResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ListThreatListsResponseDefaultTypeInternal _ListThreatListsResponse_default_instance_; +PROTOBUF_CONSTEXPR Duration::Duration( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.seconds_)*/int64_t{0} + , /*decltype(_impl_.nanos_)*/0} {} +struct DurationDefaultTypeInternal { + PROTOBUF_CONSTEXPR DurationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~DurationDefaultTypeInternal() {} + union { + Duration _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DurationDefaultTypeInternal _Duration_default_instance_; +} // namespace safebrowsing +} // namespace mozilla +namespace mozilla { +namespace safebrowsing { +bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_strings[3] = {}; + +static const char FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_names[] = + "FULL_UPDATE" + "PARTIAL_UPDATE" + "RESPONSE_TYPE_UNSPECIFIED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries[] = { + { {FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_names + 0, 11}, 2 }, + { {FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_names + 11, 14}, 1 }, + { {FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_names + 25, 25}, 0 }, +}; + +static const int FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries_by_number[] = { + 2, // 0 -> RESPONSE_TYPE_UNSPECIFIED + 1, // 1 -> PARTIAL_UPDATE + 0, // 2 -> FULL_UPDATE +}; + +const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name( + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries, + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries_by_number, + 3, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries, + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_strings[idx].get(); +} +bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_entries, 3, name, &int_value); + if (success) { + *value = static_cast<FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::RESPONSE_TYPE_UNSPECIFIED; +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::PARTIAL_UPDATE; +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::FULL_UPDATE; +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_MIN; +constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_MAX; +constexpr int FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool ThreatHit_ThreatSourceType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ThreatHit_ThreatSourceType_strings[5] = {}; + +static const char ThreatHit_ThreatSourceType_names[] = + "MATCHING_URL" + "TAB_REDIRECT" + "TAB_RESOURCE" + "TAB_URL" + "THREAT_SOURCE_TYPE_UNSPECIFIED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ThreatHit_ThreatSourceType_entries[] = { + { {ThreatHit_ThreatSourceType_names + 0, 12}, 1 }, + { {ThreatHit_ThreatSourceType_names + 12, 12}, 3 }, + { {ThreatHit_ThreatSourceType_names + 24, 12}, 4 }, + { {ThreatHit_ThreatSourceType_names + 36, 7}, 2 }, + { {ThreatHit_ThreatSourceType_names + 43, 30}, 0 }, +}; + +static const int ThreatHit_ThreatSourceType_entries_by_number[] = { + 4, // 0 -> THREAT_SOURCE_TYPE_UNSPECIFIED + 0, // 1 -> MATCHING_URL + 3, // 2 -> TAB_URL + 1, // 3 -> TAB_REDIRECT + 2, // 4 -> TAB_RESOURCE +}; + +const std::string& ThreatHit_ThreatSourceType_Name( + ThreatHit_ThreatSourceType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ThreatHit_ThreatSourceType_entries, + ThreatHit_ThreatSourceType_entries_by_number, + 5, ThreatHit_ThreatSourceType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ThreatHit_ThreatSourceType_entries, + ThreatHit_ThreatSourceType_entries_by_number, + 5, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ThreatHit_ThreatSourceType_strings[idx].get(); +} +bool ThreatHit_ThreatSourceType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatHit_ThreatSourceType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ThreatHit_ThreatSourceType_entries, 5, name, &int_value); + if (success) { + *value = static_cast<ThreatHit_ThreatSourceType>(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ThreatHit_ThreatSourceType ThreatHit::THREAT_SOURCE_TYPE_UNSPECIFIED; +constexpr ThreatHit_ThreatSourceType ThreatHit::MATCHING_URL; +constexpr ThreatHit_ThreatSourceType ThreatHit::TAB_URL; +constexpr ThreatHit_ThreatSourceType ThreatHit::TAB_REDIRECT; +constexpr ThreatHit_ThreatSourceType ThreatHit::TAB_RESOURCE; +constexpr ThreatHit_ThreatSourceType ThreatHit::ThreatSourceType_MIN; +constexpr ThreatHit_ThreatSourceType ThreatHit::ThreatSourceType_MAX; +constexpr int ThreatHit::ThreatSourceType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeClientInfo_SafeBrowsingReportingPopulation_strings[4] = {}; + +static const char ChromeClientInfo_SafeBrowsingReportingPopulation_names[] = + "EXTENDED" + "OPT_OUT" + "SCOUT" + "UNSPECIFIED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeClientInfo_SafeBrowsingReportingPopulation_entries[] = { + { {ChromeClientInfo_SafeBrowsingReportingPopulation_names + 0, 8}, 2 }, + { {ChromeClientInfo_SafeBrowsingReportingPopulation_names + 8, 7}, 1 }, + { {ChromeClientInfo_SafeBrowsingReportingPopulation_names + 15, 5}, 3 }, + { {ChromeClientInfo_SafeBrowsingReportingPopulation_names + 20, 11}, 0 }, +}; + +static const int ChromeClientInfo_SafeBrowsingReportingPopulation_entries_by_number[] = { + 3, // 0 -> UNSPECIFIED + 1, // 1 -> OPT_OUT + 0, // 2 -> EXTENDED + 2, // 3 -> SCOUT +}; + +const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name( + ChromeClientInfo_SafeBrowsingReportingPopulation value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ChromeClientInfo_SafeBrowsingReportingPopulation_entries, + ChromeClientInfo_SafeBrowsingReportingPopulation_entries_by_number, + 4, ChromeClientInfo_SafeBrowsingReportingPopulation_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ChromeClientInfo_SafeBrowsingReportingPopulation_entries, + ChromeClientInfo_SafeBrowsingReportingPopulation_entries_by_number, + 4, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ChromeClientInfo_SafeBrowsingReportingPopulation_strings[idx].get(); +} +bool ChromeClientInfo_SafeBrowsingReportingPopulation_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeClientInfo_SafeBrowsingReportingPopulation* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ChromeClientInfo_SafeBrowsingReportingPopulation_entries, 4, name, &int_value); + if (success) { + *value = static_cast<ChromeClientInfo_SafeBrowsingReportingPopulation>(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::UNSPECIFIED; +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::OPT_OUT; +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::EXTENDED; +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::SCOUT; +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::SafeBrowsingReportingPopulation_MIN; +constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::SafeBrowsingReportingPopulation_MAX; +constexpr int ChromeClientInfo::SafeBrowsingReportingPopulation_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool ThreatType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 13: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ThreatType_strings[12] = {}; + +static const char ThreatType_names[] = + "API_ABUSE" + "CLIENT_INCIDENT" + "CSD_DOWNLOAD_WHITELIST" + "CSD_WHITELIST" + "MALICIOUS_BINARY" + "MALWARE_THREAT" + "POTENTIALLY_HARMFUL_APPLICATION" + "SOCIAL_ENGINEERING" + "SOCIAL_ENGINEERING_PUBLIC" + "SUBRESOURCE_FILTER" + "THREAT_TYPE_UNSPECIFIED" + "UNWANTED_SOFTWARE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ThreatType_entries[] = { + { {ThreatType_names + 0, 9}, 6 }, + { {ThreatType_names + 9, 15}, 10 }, + { {ThreatType_names + 24, 22}, 9 }, + { {ThreatType_names + 46, 13}, 8 }, + { {ThreatType_names + 59, 16}, 7 }, + { {ThreatType_names + 75, 14}, 1 }, + { {ThreatType_names + 89, 31}, 4 }, + { {ThreatType_names + 120, 18}, 5 }, + { {ThreatType_names + 138, 25}, 2 }, + { {ThreatType_names + 163, 18}, 13 }, + { {ThreatType_names + 181, 23}, 0 }, + { {ThreatType_names + 204, 17}, 3 }, +}; + +static const int ThreatType_entries_by_number[] = { + 10, // 0 -> THREAT_TYPE_UNSPECIFIED + 5, // 1 -> MALWARE_THREAT + 8, // 2 -> SOCIAL_ENGINEERING_PUBLIC + 11, // 3 -> UNWANTED_SOFTWARE + 6, // 4 -> POTENTIALLY_HARMFUL_APPLICATION + 7, // 5 -> SOCIAL_ENGINEERING + 0, // 6 -> API_ABUSE + 4, // 7 -> MALICIOUS_BINARY + 3, // 8 -> CSD_WHITELIST + 2, // 9 -> CSD_DOWNLOAD_WHITELIST + 1, // 10 -> CLIENT_INCIDENT + 9, // 13 -> SUBRESOURCE_FILTER +}; + +const std::string& ThreatType_Name( + ThreatType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ThreatType_entries, + ThreatType_entries_by_number, + 12, ThreatType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ThreatType_entries, + ThreatType_entries_by_number, + 12, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ThreatType_strings[idx].get(); +} +bool ThreatType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ThreatType_entries, 12, name, &int_value); + if (success) { + *value = static_cast<ThreatType>(int_value); + } + return success; +} +bool PlatformType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PlatformType_strings[9] = {}; + +static const char PlatformType_names[] = + "ALL_PLATFORMS" + "ANDROID_PLATFORM" + "ANY_PLATFORM" + "CHROME_PLATFORM" + "IOS_PLATFORM" + "LINUX_PLATFORM" + "OSX_PLATFORM" + "PLATFORM_TYPE_UNSPECIFIED" + "WINDOWS_PLATFORM"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PlatformType_entries[] = { + { {PlatformType_names + 0, 13}, 7 }, + { {PlatformType_names + 13, 16}, 3 }, + { {PlatformType_names + 29, 12}, 6 }, + { {PlatformType_names + 41, 15}, 8 }, + { {PlatformType_names + 56, 12}, 5 }, + { {PlatformType_names + 68, 14}, 2 }, + { {PlatformType_names + 82, 12}, 4 }, + { {PlatformType_names + 94, 25}, 0 }, + { {PlatformType_names + 119, 16}, 1 }, +}; + +static const int PlatformType_entries_by_number[] = { + 7, // 0 -> PLATFORM_TYPE_UNSPECIFIED + 8, // 1 -> WINDOWS_PLATFORM + 5, // 2 -> LINUX_PLATFORM + 1, // 3 -> ANDROID_PLATFORM + 6, // 4 -> OSX_PLATFORM + 4, // 5 -> IOS_PLATFORM + 2, // 6 -> ANY_PLATFORM + 0, // 7 -> ALL_PLATFORMS + 3, // 8 -> CHROME_PLATFORM +}; + +const std::string& PlatformType_Name( + PlatformType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + PlatformType_entries, + PlatformType_entries_by_number, + 9, PlatformType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + PlatformType_entries, + PlatformType_entries_by_number, + 9, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + PlatformType_strings[idx].get(); +} +bool PlatformType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlatformType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + PlatformType_entries, 9, name, &int_value); + if (success) { + *value = static_cast<PlatformType>(int_value); + } + return success; +} +bool CompressionType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CompressionType_strings[3] = {}; + +static const char CompressionType_names[] = + "COMPRESSION_TYPE_UNSPECIFIED" + "RAW" + "RICE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CompressionType_entries[] = { + { {CompressionType_names + 0, 28}, 0 }, + { {CompressionType_names + 28, 3}, 1 }, + { {CompressionType_names + 31, 4}, 2 }, +}; + +static const int CompressionType_entries_by_number[] = { + 0, // 0 -> COMPRESSION_TYPE_UNSPECIFIED + 1, // 1 -> RAW + 2, // 2 -> RICE +}; + +const std::string& CompressionType_Name( + CompressionType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + CompressionType_entries, + CompressionType_entries_by_number, + 3, CompressionType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + CompressionType_entries, + CompressionType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + CompressionType_strings[idx].get(); +} +bool CompressionType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressionType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + CompressionType_entries, 3, name, &int_value); + if (success) { + *value = static_cast<CompressionType>(int_value); + } + return success; +} +bool ThreatEntryType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ThreatEntryType_strings[7] = {}; + +static const char ThreatEntryType_names[] = + "CERT" + "CHROME_EXTENSION" + "EXECUTABLE" + "FILENAME" + "IP_RANGE" + "THREAT_ENTRY_TYPE_UNSPECIFIED" + "URL"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ThreatEntryType_entries[] = { + { {ThreatEntryType_names + 0, 4}, 6 }, + { {ThreatEntryType_names + 4, 16}, 4 }, + { {ThreatEntryType_names + 20, 10}, 2 }, + { {ThreatEntryType_names + 30, 8}, 5 }, + { {ThreatEntryType_names + 38, 8}, 3 }, + { {ThreatEntryType_names + 46, 29}, 0 }, + { {ThreatEntryType_names + 75, 3}, 1 }, +}; + +static const int ThreatEntryType_entries_by_number[] = { + 5, // 0 -> THREAT_ENTRY_TYPE_UNSPECIFIED + 6, // 1 -> URL + 2, // 2 -> EXECUTABLE + 4, // 3 -> IP_RANGE + 1, // 4 -> CHROME_EXTENSION + 3, // 5 -> FILENAME + 0, // 6 -> CERT +}; + +const std::string& ThreatEntryType_Name( + ThreatEntryType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ThreatEntryType_entries, + ThreatEntryType_entries_by_number, + 7, ThreatEntryType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ThreatEntryType_entries, + ThreatEntryType_entries_by_number, + 7, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ThreatEntryType_strings[idx].get(); +} +bool ThreatEntryType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatEntryType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ThreatEntryType_entries, 7, name, &int_value); + if (success) { + *value = static_cast<ThreatEntryType>(int_value); + } + return success; +} + +// =================================================================== + +class ThreatInfo::_Internal { + public: +}; + +ThreatInfo::ThreatInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatInfo) +} +ThreatInfo::ThreatInfo(const ThreatInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.threat_types_){from._impl_.threat_types_} + , decltype(_impl_.platform_types_){from._impl_.platform_types_} + , decltype(_impl_.threat_entries_){from._impl_.threat_entries_} + , decltype(_impl_.threat_entry_types_){from._impl_.threat_entry_types_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatInfo) +} + +inline void ThreatInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.threat_types_){arena} + , decltype(_impl_.platform_types_){arena} + , decltype(_impl_.threat_entries_){arena} + , decltype(_impl_.threat_entry_types_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ThreatInfo::~ThreatInfo() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.threat_types_.~RepeatedField(); + _impl_.platform_types_.~RepeatedField(); + _impl_.threat_entries_.~RepeatedPtrField(); + _impl_.threat_entry_types_.~RepeatedField(); +} + +void ThreatInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.threat_types_.Clear(); + _impl_.platform_types_.Clear(); + _impl_.threat_entries_.Clear(); + _impl_.threat_entry_types_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatType_IsValid(val))) { + _internal_add_threat_types(static_cast<::mozilla::safebrowsing::ThreatType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast<uint8_t>(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_threat_types(), ptr, ctx, ::mozilla::safebrowsing::ThreatType_IsValid, &_internal_metadata_, 1); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + ptr -= 1; + do { + ptr += 1; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::PlatformType_IsValid(val))) { + _internal_add_platform_types(static_cast<::mozilla::safebrowsing::PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); + } else if (static_cast<uint8_t>(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_platform_types(), ptr, ctx, ::mozilla::safebrowsing::PlatformType_IsValid, &_internal_metadata_, 2); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_threat_entries(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatEntryType_IsValid(val))) { + _internal_add_threat_entry_types(static_cast<::mozilla::safebrowsing::ThreatEntryType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast<uint8_t>(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_threat_entry_types(), ptr, ctx, ::mozilla::safebrowsing::ThreatEntryType_IsValid, &_internal_metadata_, 4); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + for (int i = 0, n = this->_internal_threat_types_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_threat_types(i), target); + } + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + for (int i = 0, n = this->_internal_platform_types_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_platform_types(i), target); + } + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_threat_entries_size()); i < n; i++) { + const auto& repfield = this->_internal_threat_entries(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + for (int i = 0, n = this->_internal_threat_entry_types_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_threat_entry_types(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatInfo) + return target; +} + +size_t ThreatInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + { + size_t data_size = 0; + unsigned int count = static_cast<unsigned int>(this->_internal_threat_types_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_threat_types(static_cast<int>(i))); + } + total_size += (1UL * count) + data_size; + } + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + { + size_t data_size = 0; + unsigned int count = static_cast<unsigned int>(this->_internal_platform_types_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_platform_types(static_cast<int>(i))); + } + total_size += (1UL * count) + data_size; + } + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + total_size += 1UL * this->_internal_threat_entries_size(); + for (const auto& msg : this->_impl_.threat_entries_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + { + size_t data_size = 0; + unsigned int count = static_cast<unsigned int>(this->_internal_threat_entry_types_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_threat_entry_types(static_cast<int>(i))); + } + total_size += (1UL * count) + data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatInfo*>( + &from)); +} + +void ThreatInfo::MergeFrom(const ThreatInfo& from) { + ThreatInfo* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.threat_types_.MergeFrom(from._impl_.threat_types_); + _this->_impl_.platform_types_.MergeFrom(from._impl_.platform_types_); + _this->_impl_.threat_entries_.MergeFrom(from._impl_.threat_entries_); + _this->_impl_.threat_entry_types_.MergeFrom(from._impl_.threat_entry_types_); + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatInfo::CopyFrom(const ThreatInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatInfo::IsInitialized() const { + return true; +} + +void ThreatInfo::InternalSwap(ThreatInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.threat_types_.InternalSwap(&other->_impl_.threat_types_); + _impl_.platform_types_.InternalSwap(&other->_impl_.platform_types_); + _impl_.threat_entries_.InternalSwap(&other->_impl_.threat_entries_); + _impl_.threat_entry_types_.InternalSwap(&other->_impl_.threat_entry_types_); +} + +std::string ThreatInfo::GetTypeName() const { + return "mozilla.safebrowsing.ThreatInfo"; +} + + +// =================================================================== + +class ThreatMatch::_Internal { + public: + using HasBits = decltype(std::declval<ThreatMatch>()._impl_._has_bits_); + static void set_has_threat_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_platform_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_threat_entry_type(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::mozilla::safebrowsing::ThreatEntry& threat(const ThreatMatch* msg); + static void set_has_threat(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::ThreatEntryMetadata& threat_entry_metadata(const ThreatMatch* msg); + static void set_has_threat_entry_metadata(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::mozilla::safebrowsing::Duration& cache_duration(const ThreatMatch* msg); + static void set_has_cache_duration(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::mozilla::safebrowsing::ThreatEntry& +ThreatMatch::_Internal::threat(const ThreatMatch* msg) { + return *msg->_impl_.threat_; +} +const ::mozilla::safebrowsing::ThreatEntryMetadata& +ThreatMatch::_Internal::threat_entry_metadata(const ThreatMatch* msg) { + return *msg->_impl_.threat_entry_metadata_; +} +const ::mozilla::safebrowsing::Duration& +ThreatMatch::_Internal::cache_duration(const ThreatMatch* msg) { + return *msg->_impl_.cache_duration_; +} +ThreatMatch::ThreatMatch(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatMatch) +} +ThreatMatch::ThreatMatch(const ThreatMatch& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatMatch* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.threat_){nullptr} + , decltype(_impl_.threat_entry_metadata_){nullptr} + , decltype(_impl_.cache_duration_){nullptr} + , decltype(_impl_.threat_type_){} + , decltype(_impl_.platform_type_){} + , decltype(_impl_.threat_entry_type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_threat()) { + _this->_impl_.threat_ = new ::mozilla::safebrowsing::ThreatEntry(*from._impl_.threat_); + } + if (from._internal_has_threat_entry_metadata()) { + _this->_impl_.threat_entry_metadata_ = new ::mozilla::safebrowsing::ThreatEntryMetadata(*from._impl_.threat_entry_metadata_); + } + if (from._internal_has_cache_duration()) { + _this->_impl_.cache_duration_ = new ::mozilla::safebrowsing::Duration(*from._impl_.cache_duration_); + } + ::memcpy(&_impl_.threat_type_, &from._impl_.threat_type_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.threat_entry_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.threat_entry_type_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatMatch) +} + +inline void ThreatMatch::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.threat_){nullptr} + , decltype(_impl_.threat_entry_metadata_){nullptr} + , decltype(_impl_.cache_duration_){nullptr} + , decltype(_impl_.threat_type_){0} + , decltype(_impl_.platform_type_){0} + , decltype(_impl_.threat_entry_type_){0} + }; +} + +ThreatMatch::~ThreatMatch() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatMatch) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatMatch::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.threat_; + if (this != internal_default_instance()) delete _impl_.threat_entry_metadata_; + if (this != internal_default_instance()) delete _impl_.cache_duration_; +} + +void ThreatMatch::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatMatch::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatMatch) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.threat_ != nullptr); + _impl_.threat_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.threat_entry_metadata_ != nullptr); + _impl_.threat_entry_metadata_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.cache_duration_ != nullptr); + _impl_.cache_duration_->Clear(); + } + } + if (cached_has_bits & 0x00000038u) { + ::memset(&_impl_.threat_type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.threat_entry_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.threat_entry_type_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatMatch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatType_IsValid(val))) { + _internal_set_threat_type(static_cast<::mozilla::safebrowsing::ThreatType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::PlatformType_IsValid(val))) { + _internal_set_platform_type(static_cast<::mozilla::safebrowsing::PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_threat(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_threat_entry_metadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_cache_duration(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatEntryType_IsValid(val))) { + _internal_set_threat_entry_type(static_cast<::mozilla::safebrowsing::ThreatEntryType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatMatch::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatMatch) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_threat_type(), target); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_platform_type(), target); + } + + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::threat(this), + _Internal::threat(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::threat_entry_metadata(this), + _Internal::threat_entry_metadata(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::cache_duration(this), + _Internal::cache_duration(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 6, this->_internal_threat_entry_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatMatch) + return target; +} + +size_t ThreatMatch::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatMatch) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.threat_); + } + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.threat_entry_metadata_); + } + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.cache_duration_); + } + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_entry_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatMatch::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatMatch*>( + &from)); +} + +void ThreatMatch::MergeFrom(const ThreatMatch& from) { + ThreatMatch* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatMatch) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_threat()->::mozilla::safebrowsing::ThreatEntry::MergeFrom( + from._internal_threat()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_threat_entry_metadata()->::mozilla::safebrowsing::ThreatEntryMetadata::MergeFrom( + from._internal_threat_entry_metadata()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom( + from._internal_cache_duration()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.threat_type_ = from._impl_.threat_type_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.platform_type_ = from._impl_.platform_type_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.threat_entry_type_ = from._impl_.threat_entry_type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatMatch::CopyFrom(const ThreatMatch& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatMatch) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatMatch::IsInitialized() const { + return true; +} + +void ThreatMatch::InternalSwap(ThreatMatch* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ThreatMatch, _impl_.threat_entry_type_) + + sizeof(ThreatMatch::_impl_.threat_entry_type_) + - PROTOBUF_FIELD_OFFSET(ThreatMatch, _impl_.threat_)>( + reinterpret_cast<char*>(&_impl_.threat_), + reinterpret_cast<char*>(&other->_impl_.threat_)); +} + +std::string ThreatMatch::GetTypeName() const { + return "mozilla.safebrowsing.ThreatMatch"; +} + + +// =================================================================== + +class FindThreatMatchesRequest::_Internal { + public: + using HasBits = decltype(std::declval<FindThreatMatchesRequest>()._impl_._has_bits_); + static const ::mozilla::safebrowsing::ClientInfo& client(const FindThreatMatchesRequest* msg); + static void set_has_client(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::ThreatInfo& threat_info(const FindThreatMatchesRequest* msg); + static void set_has_threat_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::mozilla::safebrowsing::ClientInfo& +FindThreatMatchesRequest::_Internal::client(const FindThreatMatchesRequest* msg) { + return *msg->_impl_.client_; +} +const ::mozilla::safebrowsing::ThreatInfo& +FindThreatMatchesRequest::_Internal::threat_info(const FindThreatMatchesRequest* msg) { + return *msg->_impl_.threat_info_; +} +FindThreatMatchesRequest::FindThreatMatchesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FindThreatMatchesRequest) +} +FindThreatMatchesRequest::FindThreatMatchesRequest(const FindThreatMatchesRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FindThreatMatchesRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.client_){nullptr} + , decltype(_impl_.threat_info_){nullptr}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_client()) { + _this->_impl_.client_ = new ::mozilla::safebrowsing::ClientInfo(*from._impl_.client_); + } + if (from._internal_has_threat_info()) { + _this->_impl_.threat_info_ = new ::mozilla::safebrowsing::ThreatInfo(*from._impl_.threat_info_); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesRequest) +} + +inline void FindThreatMatchesRequest::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.client_){nullptr} + , decltype(_impl_.threat_info_){nullptr} + }; +} + +FindThreatMatchesRequest::~FindThreatMatchesRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FindThreatMatchesRequest::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.client_; + if (this != internal_default_instance()) delete _impl_.threat_info_; +} + +void FindThreatMatchesRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FindThreatMatchesRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindThreatMatchesRequest) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.client_ != nullptr); + _impl_.client_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.threat_info_ != nullptr); + _impl_.threat_info_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FindThreatMatchesRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_client(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_threat_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FindThreatMatchesRequest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindThreatMatchesRequest) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::client(this), + _Internal::client(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::threat_info(this), + _Internal::threat_info(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FindThreatMatchesRequest) + return target; +} + +size_t FindThreatMatchesRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FindThreatMatchesRequest) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.client_); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.threat_info_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FindThreatMatchesRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FindThreatMatchesRequest*>( + &from)); +} + +void FindThreatMatchesRequest::MergeFrom(const FindThreatMatchesRequest& from) { + FindThreatMatchesRequest* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindThreatMatchesRequest) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom( + from._internal_client()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom( + from._internal_threat_info()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FindThreatMatchesRequest::CopyFrom(const FindThreatMatchesRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FindThreatMatchesRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindThreatMatchesRequest::IsInitialized() const { + return true; +} + +void FindThreatMatchesRequest::InternalSwap(FindThreatMatchesRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FindThreatMatchesRequest, _impl_.threat_info_) + + sizeof(FindThreatMatchesRequest::_impl_.threat_info_) + - PROTOBUF_FIELD_OFFSET(FindThreatMatchesRequest, _impl_.client_)>( + reinterpret_cast<char*>(&_impl_.client_), + reinterpret_cast<char*>(&other->_impl_.client_)); +} + +std::string FindThreatMatchesRequest::GetTypeName() const { + return "mozilla.safebrowsing.FindThreatMatchesRequest"; +} + + +// =================================================================== + +class FindThreatMatchesResponse::_Internal { + public: +}; + +FindThreatMatchesResponse::FindThreatMatchesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FindThreatMatchesResponse) +} +FindThreatMatchesResponse::FindThreatMatchesResponse(const FindThreatMatchesResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FindThreatMatchesResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.matches_){from._impl_.matches_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesResponse) +} + +inline void FindThreatMatchesResponse::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.matches_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +FindThreatMatchesResponse::~FindThreatMatchesResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FindThreatMatchesResponse::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.matches_.~RepeatedPtrField(); +} + +void FindThreatMatchesResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FindThreatMatchesResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindThreatMatchesResponse) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.matches_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FindThreatMatchesResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_matches(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FindThreatMatchesResponse::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindThreatMatchesResponse) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_matches_size()); i < n; i++) { + const auto& repfield = this->_internal_matches(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FindThreatMatchesResponse) + return target; +} + +size_t FindThreatMatchesResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FindThreatMatchesResponse) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + total_size += 1UL * this->_internal_matches_size(); + for (const auto& msg : this->_impl_.matches_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FindThreatMatchesResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FindThreatMatchesResponse*>( + &from)); +} + +void FindThreatMatchesResponse::MergeFrom(const FindThreatMatchesResponse& from) { + FindThreatMatchesResponse* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindThreatMatchesResponse) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.matches_.MergeFrom(from._impl_.matches_); + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FindThreatMatchesResponse::CopyFrom(const FindThreatMatchesResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FindThreatMatchesResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindThreatMatchesResponse::IsInitialized() const { + return true; +} + +void FindThreatMatchesResponse::InternalSwap(FindThreatMatchesResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.matches_.InternalSwap(&other->_impl_.matches_); +} + +std::string FindThreatMatchesResponse::GetTypeName() const { + return "mozilla.safebrowsing.FindThreatMatchesResponse"; +} + + +// =================================================================== + +class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_Internal { + public: + using HasBits = decltype(std::declval<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>()._impl_._has_bits_); + static void set_has_max_update_entries(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_max_database_entries(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_region(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) +} +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.supported_compressions_){from._impl_.supported_compressions_} + , decltype(_impl_.region_){} + , decltype(_impl_.max_update_entries_){} + , decltype(_impl_.max_database_entries_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.region_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.region_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_region()) { + _this->_impl_.region_.Set(from._internal_region(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.max_update_entries_, &from._impl_.max_update_entries_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.max_database_entries_) - + reinterpret_cast<char*>(&_impl_.max_update_entries_)) + sizeof(_impl_.max_database_entries_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) +} + +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.supported_compressions_){arena} + , decltype(_impl_.region_){} + , decltype(_impl_.max_update_entries_){0} + , decltype(_impl_.max_database_entries_){0} + }; + _impl_.region_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.region_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.supported_compressions_.~RepeatedField(); + _impl_.region_.Destroy(); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.supported_compressions_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.region_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.max_update_entries_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.max_database_entries_) - + reinterpret_cast<char*>(&_impl_.max_update_entries_)) + sizeof(_impl_.max_database_entries_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 max_update_entries = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + _Internal::set_has_max_update_entries(&has_bits); + _impl_.max_update_entries_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 max_database_entries = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + _Internal::set_has_max_database_entries(&has_bits); + _impl_.max_database_entries_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string region = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + auto str = _internal_mutable_region(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::CompressionType_IsValid(val))) { + _internal_add_supported_compressions(static_cast<::mozilla::safebrowsing::CompressionType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast<uint8_t>(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_supported_compressions(), ptr, ctx, ::mozilla::safebrowsing::CompressionType_IsValid, &_internal_metadata_, 4); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int32 max_update_entries = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_max_update_entries(), target); + } + + // optional int32 max_database_entries = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_max_database_entries(), target); + } + + // optional string region = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 3, this->_internal_region(), target); + } + + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + for (int i = 0, n = this->_internal_supported_compressions_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_supported_compressions(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + return target; +} + +size_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + { + size_t data_size = 0; + unsigned int count = static_cast<unsigned int>(this->_internal_supported_compressions_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_supported_compressions(static_cast<int>(i))); + } + total_size += (1UL * count) + data_size; + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string region = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_region()); + } + + // optional int32 max_update_entries = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_max_update_entries()); + } + + // optional int32 max_database_entries = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_max_database_entries()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>( + &from)); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) { + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.supported_compressions_.MergeFrom(from._impl_.supported_compressions_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_region(from._internal_region()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.max_update_entries_ = from._impl_.max_update_entries_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.max_database_entries_ = from._impl_.max_database_entries_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::IsInitialized() const { + return true; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::InternalSwap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.supported_compressions_.InternalSwap(&other->_impl_.supported_compressions_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.region_, lhs_arena, + &other->_impl_.region_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints, _impl_.max_database_entries_) + + sizeof(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_impl_.max_database_entries_) + - PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints, _impl_.max_update_entries_)>( + reinterpret_cast<char*>(&_impl_.max_update_entries_), + reinterpret_cast<char*>(&other->_impl_.max_update_entries_)); +} + +std::string FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints"; +} + + +// =================================================================== + +class FetchThreatListUpdatesRequest_ListUpdateRequest::_Internal { + public: + using HasBits = decltype(std::declval<FetchThreatListUpdatesRequest_ListUpdateRequest>()._impl_._has_bits_); + static void set_has_threat_type(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_platform_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_threat_entry_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_state(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest* msg); + static void set_has_constraints(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& +FetchThreatListUpdatesRequest_ListUpdateRequest::_Internal::constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest* msg) { + return *msg->_impl_.constraints_; +} +FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) +} +FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FetchThreatListUpdatesRequest_ListUpdateRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.state_){} + , decltype(_impl_.constraints_){nullptr} + , decltype(_impl_.threat_type_){} + , decltype(_impl_.platform_type_){} + , decltype(_impl_.threat_entry_type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.state_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.state_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_state()) { + _this->_impl_.state_.Set(from._internal_state(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_constraints()) { + _this->_impl_.constraints_ = new ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(*from._impl_.constraints_); + } + ::memcpy(&_impl_.threat_type_, &from._impl_.threat_type_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.threat_entry_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.threat_entry_type_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) +} + +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.state_){} + , decltype(_impl_.constraints_){nullptr} + , decltype(_impl_.threat_type_){0} + , decltype(_impl_.platform_type_){0} + , decltype(_impl_.threat_entry_type_){0} + }; + _impl_.state_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.state_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +FetchThreatListUpdatesRequest_ListUpdateRequest::~FetchThreatListUpdatesRequest_ListUpdateRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.state_.Destroy(); + if (this != internal_default_instance()) delete _impl_.constraints_; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.state_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.constraints_ != nullptr); + _impl_.constraints_->Clear(); + } + } + if (cached_has_bits & 0x0000001cu) { + ::memset(&_impl_.threat_type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.threat_entry_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.threat_entry_type_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FetchThreatListUpdatesRequest_ListUpdateRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatType_IsValid(val))) { + _internal_set_threat_type(static_cast<::mozilla::safebrowsing::ThreatType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::PlatformType_IsValid(val))) { + _internal_set_platform_type(static_cast<::mozilla::safebrowsing::PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bytes state = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + auto str = _internal_mutable_state(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_constraints(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatEntryType_IsValid(val))) { + _internal_set_threat_entry_type(static_cast<::mozilla::safebrowsing::ThreatEntryType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FetchThreatListUpdatesRequest_ListUpdateRequest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_threat_type(), target); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_platform_type(), target); + } + + // optional bytes state = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_state(), target); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::constraints(this), + _Internal::constraints(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 5, this->_internal_threat_entry_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + return target; +} + +size_t FetchThreatListUpdatesRequest_ListUpdateRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional bytes state = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_state()); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.constraints_); + } + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_entry_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>( + &from)); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) { + FetchThreatListUpdatesRequest_ListUpdateRequest* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_state(from._internal_state()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_constraints()->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom( + from._internal_constraints()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.threat_type_ = from._impl_.threat_type_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.platform_type_ = from._impl_.platform_type_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.threat_entry_type_ = from._impl_.threat_entry_type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesRequest_ListUpdateRequest::IsInitialized() const { + return true; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::InternalSwap(FetchThreatListUpdatesRequest_ListUpdateRequest* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.state_, lhs_arena, + &other->_impl_.state_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesRequest_ListUpdateRequest, _impl_.threat_entry_type_) + + sizeof(FetchThreatListUpdatesRequest_ListUpdateRequest::_impl_.threat_entry_type_) + - PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesRequest_ListUpdateRequest, _impl_.constraints_)>( + reinterpret_cast<char*>(&_impl_.constraints_), + reinterpret_cast<char*>(&other->_impl_.constraints_)); +} + +std::string FetchThreatListUpdatesRequest_ListUpdateRequest::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest"; +} + + +// =================================================================== + +class FetchThreatListUpdatesRequest::_Internal { + public: + using HasBits = decltype(std::declval<FetchThreatListUpdatesRequest>()._impl_._has_bits_); + static const ::mozilla::safebrowsing::ClientInfo& client(const FetchThreatListUpdatesRequest* msg); + static void set_has_client(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::ChromeClientInfo& chrome_client_info(const FetchThreatListUpdatesRequest* msg); + static void set_has_chrome_client_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::mozilla::safebrowsing::ClientInfo& +FetchThreatListUpdatesRequest::_Internal::client(const FetchThreatListUpdatesRequest* msg) { + return *msg->_impl_.client_; +} +const ::mozilla::safebrowsing::ChromeClientInfo& +FetchThreatListUpdatesRequest::_Internal::chrome_client_info(const FetchThreatListUpdatesRequest* msg) { + return *msg->_impl_.chrome_client_info_; +} +FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest) +} +FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FetchThreatListUpdatesRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.list_update_requests_){from._impl_.list_update_requests_} + , decltype(_impl_.client_){nullptr} + , decltype(_impl_.chrome_client_info_){nullptr}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_client()) { + _this->_impl_.client_ = new ::mozilla::safebrowsing::ClientInfo(*from._impl_.client_); + } + if (from._internal_has_chrome_client_info()) { + _this->_impl_.chrome_client_info_ = new ::mozilla::safebrowsing::ChromeClientInfo(*from._impl_.chrome_client_info_); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest) +} + +inline void FetchThreatListUpdatesRequest::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.list_update_requests_){arena} + , decltype(_impl_.client_){nullptr} + , decltype(_impl_.chrome_client_info_){nullptr} + }; +} + +FetchThreatListUpdatesRequest::~FetchThreatListUpdatesRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FetchThreatListUpdatesRequest::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.list_update_requests_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.client_; + if (this != internal_default_instance()) delete _impl_.chrome_client_info_; +} + +void FetchThreatListUpdatesRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FetchThreatListUpdatesRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.list_update_requests_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.client_ != nullptr); + _impl_.client_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.chrome_client_info_ != nullptr); + _impl_.chrome_client_info_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FetchThreatListUpdatesRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_client(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_list_update_requests(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_chrome_client_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FetchThreatListUpdatesRequest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::client(this), + _Internal::client(this).GetCachedSize(), target, stream); + } + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_list_update_requests_size()); i < n; i++) { + const auto& repfield = this->_internal_list_update_requests(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::chrome_client_info(this), + _Internal::chrome_client_info(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + return target; +} + +size_t FetchThreatListUpdatesRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + total_size += 1UL * this->_internal_list_update_requests_size(); + for (const auto& msg : this->_impl_.list_update_requests_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.client_); + } + + // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.chrome_client_info_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FetchThreatListUpdatesRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FetchThreatListUpdatesRequest*>( + &from)); +} + +void FetchThreatListUpdatesRequest::MergeFrom(const FetchThreatListUpdatesRequest& from) { + FetchThreatListUpdatesRequest* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.list_update_requests_.MergeFrom(from._impl_.list_update_requests_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom( + from._internal_client()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_chrome_client_info()->::mozilla::safebrowsing::ChromeClientInfo::MergeFrom( + from._internal_chrome_client_info()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FetchThreatListUpdatesRequest::CopyFrom(const FetchThreatListUpdatesRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesRequest::IsInitialized() const { + return true; +} + +void FetchThreatListUpdatesRequest::InternalSwap(FetchThreatListUpdatesRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.list_update_requests_.InternalSwap(&other->_impl_.list_update_requests_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesRequest, _impl_.chrome_client_info_) + + sizeof(FetchThreatListUpdatesRequest::_impl_.chrome_client_info_) + - PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesRequest, _impl_.client_)>( + reinterpret_cast<char*>(&_impl_.client_), + reinterpret_cast<char*>(&other->_impl_.client_)); +} + +std::string FetchThreatListUpdatesRequest::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest"; +} + + +// =================================================================== + +class FetchThreatListUpdatesResponse_ListUpdateResponse::_Internal { + public: + using HasBits = decltype(std::declval<FetchThreatListUpdatesResponse_ListUpdateResponse>()._impl_._has_bits_); + static void set_has_threat_type(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_threat_entry_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_platform_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_response_type(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_new_client_state(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::Checksum& checksum(const FetchThreatListUpdatesResponse_ListUpdateResponse* msg); + static void set_has_checksum(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::mozilla::safebrowsing::Checksum& +FetchThreatListUpdatesResponse_ListUpdateResponse::_Internal::checksum(const FetchThreatListUpdatesResponse_ListUpdateResponse* msg) { + return *msg->_impl_.checksum_; +} +FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) +} +FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FetchThreatListUpdatesResponse_ListUpdateResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.additions_){from._impl_.additions_} + , decltype(_impl_.removals_){from._impl_.removals_} + , decltype(_impl_.new_client_state_){} + , decltype(_impl_.checksum_){nullptr} + , decltype(_impl_.threat_type_){} + , decltype(_impl_.threat_entry_type_){} + , decltype(_impl_.platform_type_){} + , decltype(_impl_.response_type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.new_client_state_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.new_client_state_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_new_client_state()) { + _this->_impl_.new_client_state_.Set(from._internal_new_client_state(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_checksum()) { + _this->_impl_.checksum_ = new ::mozilla::safebrowsing::Checksum(*from._impl_.checksum_); + } + ::memcpy(&_impl_.threat_type_, &from._impl_.threat_type_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.response_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.response_type_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) +} + +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.additions_){arena} + , decltype(_impl_.removals_){arena} + , decltype(_impl_.new_client_state_){} + , decltype(_impl_.checksum_){nullptr} + , decltype(_impl_.threat_type_){0} + , decltype(_impl_.threat_entry_type_){0} + , decltype(_impl_.platform_type_){0} + , decltype(_impl_.response_type_){0} + }; + _impl_.new_client_state_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.new_client_state_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +FetchThreatListUpdatesResponse_ListUpdateResponse::~FetchThreatListUpdatesResponse_ListUpdateResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.additions_.~RepeatedPtrField(); + _impl_.removals_.~RepeatedPtrField(); + _impl_.new_client_state_.Destroy(); + if (this != internal_default_instance()) delete _impl_.checksum_; +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.additions_.Clear(); + _impl_.removals_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.new_client_state_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.checksum_ != nullptr); + _impl_.checksum_->Clear(); + } + } + if (cached_has_bits & 0x0000003cu) { + ::memset(&_impl_.threat_type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.response_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.response_type_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FetchThreatListUpdatesResponse_ListUpdateResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatType_IsValid(val))) { + _internal_set_threat_type(static_cast<::mozilla::safebrowsing::ThreatType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatEntryType_IsValid(val))) { + _internal_set_threat_entry_type(static_cast<::mozilla::safebrowsing::ThreatEntryType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::PlatformType_IsValid(val))) { + _internal_set_platform_type(static_cast<::mozilla::safebrowsing::PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(val))) { + _internal_set_response_type(static_cast<::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_additions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_removals(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // optional bytes new_client_state = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) { + auto str = _internal_mutable_new_client_state(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.Checksum checksum = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_checksum(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FetchThreatListUpdatesResponse_ListUpdateResponse::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_threat_type(), target); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_threat_entry_type(), target); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_platform_type(), target); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_response_type(), target); + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_additions_size()); i < n; i++) { + const auto& repfield = this->_internal_additions(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_removals_size()); i < n; i++) { + const auto& repfield = this->_internal_removals(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional bytes new_client_state = 7; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 7, this->_internal_new_client_state(), target); + } + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::checksum(this), + _Internal::checksum(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + return target; +} + +size_t FetchThreatListUpdatesResponse_ListUpdateResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + total_size += 1UL * this->_internal_additions_size(); + for (const auto& msg : this->_impl_.additions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + total_size += 1UL * this->_internal_removals_size(); + for (const auto& msg : this->_impl_.removals_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional bytes new_client_state = 7; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_new_client_state()); + } + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.checksum_); + } + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_entry_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platform_type()); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_response_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>( + &from)); +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) { + FetchThreatListUpdatesResponse_ListUpdateResponse* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.additions_.MergeFrom(from._impl_.additions_); + _this->_impl_.removals_.MergeFrom(from._impl_.removals_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_new_client_state(from._internal_new_client_state()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_checksum()->::mozilla::safebrowsing::Checksum::MergeFrom( + from._internal_checksum()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.threat_type_ = from._impl_.threat_type_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.threat_entry_type_ = from._impl_.threat_entry_type_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.platform_type_ = from._impl_.platform_type_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.response_type_ = from._impl_.response_type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesResponse_ListUpdateResponse::IsInitialized() const { + return true; +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::InternalSwap(FetchThreatListUpdatesResponse_ListUpdateResponse* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.additions_.InternalSwap(&other->_impl_.additions_); + _impl_.removals_.InternalSwap(&other->_impl_.removals_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.new_client_state_, lhs_arena, + &other->_impl_.new_client_state_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesResponse_ListUpdateResponse, _impl_.response_type_) + + sizeof(FetchThreatListUpdatesResponse_ListUpdateResponse::_impl_.response_type_) + - PROTOBUF_FIELD_OFFSET(FetchThreatListUpdatesResponse_ListUpdateResponse, _impl_.checksum_)>( + reinterpret_cast<char*>(&_impl_.checksum_), + reinterpret_cast<char*>(&other->_impl_.checksum_)); +} + +std::string FetchThreatListUpdatesResponse_ListUpdateResponse::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse"; +} + + +// =================================================================== + +class FetchThreatListUpdatesResponse::_Internal { + public: + using HasBits = decltype(std::declval<FetchThreatListUpdatesResponse>()._impl_._has_bits_); + static const ::mozilla::safebrowsing::Duration& minimum_wait_duration(const FetchThreatListUpdatesResponse* msg); + static void set_has_minimum_wait_duration(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::mozilla::safebrowsing::Duration& +FetchThreatListUpdatesResponse::_Internal::minimum_wait_duration(const FetchThreatListUpdatesResponse* msg) { + return *msg->_impl_.minimum_wait_duration_; +} +FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse) +} +FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FetchThreatListUpdatesResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.list_update_responses_){from._impl_.list_update_responses_} + , decltype(_impl_.minimum_wait_duration_){nullptr}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_minimum_wait_duration()) { + _this->_impl_.minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration(*from._impl_.minimum_wait_duration_); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse) +} + +inline void FetchThreatListUpdatesResponse::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.list_update_responses_){arena} + , decltype(_impl_.minimum_wait_duration_){nullptr} + }; +} + +FetchThreatListUpdatesResponse::~FetchThreatListUpdatesResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FetchThreatListUpdatesResponse::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.list_update_responses_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.minimum_wait_duration_; +} + +void FetchThreatListUpdatesResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FetchThreatListUpdatesResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.list_update_responses_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.minimum_wait_duration_ != nullptr); + _impl_.minimum_wait_duration_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FetchThreatListUpdatesResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_list_update_responses(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_minimum_wait_duration(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FetchThreatListUpdatesResponse::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_list_update_responses_size()); i < n; i++) { + const auto& repfield = this->_internal_list_update_responses(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::minimum_wait_duration(this), + _Internal::minimum_wait_duration(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + return target; +} + +size_t FetchThreatListUpdatesResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + total_size += 1UL * this->_internal_list_update_responses_size(); + for (const auto& msg : this->_impl_.list_update_responses_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.minimum_wait_duration_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FetchThreatListUpdatesResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FetchThreatListUpdatesResponse*>( + &from)); +} + +void FetchThreatListUpdatesResponse::MergeFrom(const FetchThreatListUpdatesResponse& from) { + FetchThreatListUpdatesResponse* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.list_update_responses_.MergeFrom(from._impl_.list_update_responses_); + if (from._internal_has_minimum_wait_duration()) { + _this->_internal_mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom( + from._internal_minimum_wait_duration()); + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FetchThreatListUpdatesResponse::CopyFrom(const FetchThreatListUpdatesResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesResponse::IsInitialized() const { + return true; +} + +void FetchThreatListUpdatesResponse::InternalSwap(FetchThreatListUpdatesResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.list_update_responses_.InternalSwap(&other->_impl_.list_update_responses_); + swap(_impl_.minimum_wait_duration_, other->_impl_.minimum_wait_duration_); +} + +std::string FetchThreatListUpdatesResponse::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesResponse"; +} + + +// =================================================================== + +class FindFullHashesRequest::_Internal { + public: + using HasBits = decltype(std::declval<FindFullHashesRequest>()._impl_._has_bits_); + static const ::mozilla::safebrowsing::ClientInfo& client(const FindFullHashesRequest* msg); + static void set_has_client(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::ThreatInfo& threat_info(const FindFullHashesRequest* msg); + static void set_has_threat_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::mozilla::safebrowsing::ClientInfo& +FindFullHashesRequest::_Internal::client(const FindFullHashesRequest* msg) { + return *msg->_impl_.client_; +} +const ::mozilla::safebrowsing::ThreatInfo& +FindFullHashesRequest::_Internal::threat_info(const FindFullHashesRequest* msg) { + return *msg->_impl_.threat_info_; +} +FindFullHashesRequest::FindFullHashesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FindFullHashesRequest) +} +FindFullHashesRequest::FindFullHashesRequest(const FindFullHashesRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FindFullHashesRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.client_states_){from._impl_.client_states_} + , decltype(_impl_.client_){nullptr} + , decltype(_impl_.threat_info_){nullptr}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_client()) { + _this->_impl_.client_ = new ::mozilla::safebrowsing::ClientInfo(*from._impl_.client_); + } + if (from._internal_has_threat_info()) { + _this->_impl_.threat_info_ = new ::mozilla::safebrowsing::ThreatInfo(*from._impl_.threat_info_); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesRequest) +} + +inline void FindFullHashesRequest::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.client_states_){arena} + , decltype(_impl_.client_){nullptr} + , decltype(_impl_.threat_info_){nullptr} + }; +} + +FindFullHashesRequest::~FindFullHashesRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FindFullHashesRequest::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.client_states_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.client_; + if (this != internal_default_instance()) delete _impl_.threat_info_; +} + +void FindFullHashesRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FindFullHashesRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindFullHashesRequest) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.client_states_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.client_ != nullptr); + _impl_.client_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.threat_info_ != nullptr); + _impl_.threat_info_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FindFullHashesRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_client(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated bytes client_states = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_client_states(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_threat_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FindFullHashesRequest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindFullHashesRequest) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::client(this), + _Internal::client(this).GetCachedSize(), target, stream); + } + + // repeated bytes client_states = 2; + for (int i = 0, n = this->_internal_client_states_size(); i < n; i++) { + const auto& s = this->_internal_client_states(i); + target = stream->WriteBytes(2, s, target); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::threat_info(this), + _Internal::threat_info(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FindFullHashesRequest) + return target; +} + +size_t FindFullHashesRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FindFullHashesRequest) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated bytes client_states = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.client_states_.size()); + for (int i = 0, n = _impl_.client_states_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + _impl_.client_states_.Get(i)); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.client_); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.threat_info_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FindFullHashesRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FindFullHashesRequest*>( + &from)); +} + +void FindFullHashesRequest::MergeFrom(const FindFullHashesRequest& from) { + FindFullHashesRequest* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindFullHashesRequest) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.client_states_.MergeFrom(from._impl_.client_states_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom( + from._internal_client()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom( + from._internal_threat_info()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FindFullHashesRequest::CopyFrom(const FindFullHashesRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FindFullHashesRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindFullHashesRequest::IsInitialized() const { + return true; +} + +void FindFullHashesRequest::InternalSwap(FindFullHashesRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.client_states_.InternalSwap(&other->_impl_.client_states_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FindFullHashesRequest, _impl_.threat_info_) + + sizeof(FindFullHashesRequest::_impl_.threat_info_) + - PROTOBUF_FIELD_OFFSET(FindFullHashesRequest, _impl_.client_)>( + reinterpret_cast<char*>(&_impl_.client_), + reinterpret_cast<char*>(&other->_impl_.client_)); +} + +std::string FindFullHashesRequest::GetTypeName() const { + return "mozilla.safebrowsing.FindFullHashesRequest"; +} + + +// =================================================================== + +class FindFullHashesResponse::_Internal { + public: + using HasBits = decltype(std::declval<FindFullHashesResponse>()._impl_._has_bits_); + static const ::mozilla::safebrowsing::Duration& minimum_wait_duration(const FindFullHashesResponse* msg); + static void set_has_minimum_wait_duration(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::Duration& negative_cache_duration(const FindFullHashesResponse* msg); + static void set_has_negative_cache_duration(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::mozilla::safebrowsing::Duration& +FindFullHashesResponse::_Internal::minimum_wait_duration(const FindFullHashesResponse* msg) { + return *msg->_impl_.minimum_wait_duration_; +} +const ::mozilla::safebrowsing::Duration& +FindFullHashesResponse::_Internal::negative_cache_duration(const FindFullHashesResponse* msg) { + return *msg->_impl_.negative_cache_duration_; +} +FindFullHashesResponse::FindFullHashesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.FindFullHashesResponse) +} +FindFullHashesResponse::FindFullHashesResponse(const FindFullHashesResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + FindFullHashesResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.matches_){from._impl_.matches_} + , decltype(_impl_.minimum_wait_duration_){nullptr} + , decltype(_impl_.negative_cache_duration_){nullptr}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_minimum_wait_duration()) { + _this->_impl_.minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration(*from._impl_.minimum_wait_duration_); + } + if (from._internal_has_negative_cache_duration()) { + _this->_impl_.negative_cache_duration_ = new ::mozilla::safebrowsing::Duration(*from._impl_.negative_cache_duration_); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesResponse) +} + +inline void FindFullHashesResponse::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.matches_){arena} + , decltype(_impl_.minimum_wait_duration_){nullptr} + , decltype(_impl_.negative_cache_duration_){nullptr} + }; +} + +FindFullHashesResponse::~FindFullHashesResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FindFullHashesResponse::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.matches_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.minimum_wait_duration_; + if (this != internal_default_instance()) delete _impl_.negative_cache_duration_; +} + +void FindFullHashesResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FindFullHashesResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindFullHashesResponse) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.matches_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.minimum_wait_duration_ != nullptr); + _impl_.minimum_wait_duration_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.negative_cache_duration_ != nullptr); + _impl_.negative_cache_duration_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* FindFullHashesResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_matches(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_minimum_wait_duration(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_negative_cache_duration(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FindFullHashesResponse::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindFullHashesResponse) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_matches_size()); i < n; i++) { + const auto& repfield = this->_internal_matches(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::minimum_wait_duration(this), + _Internal::minimum_wait_duration(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::negative_cache_duration(this), + _Internal::negative_cache_duration(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.FindFullHashesResponse) + return target; +} + +size_t FindFullHashesResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.FindFullHashesResponse) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + total_size += 1UL * this->_internal_matches_size(); + for (const auto& msg : this->_impl_.matches_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.minimum_wait_duration_); + } + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.negative_cache_duration_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FindFullHashesResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const FindFullHashesResponse*>( + &from)); +} + +void FindFullHashesResponse::MergeFrom(const FindFullHashesResponse& from) { + FindFullHashesResponse* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindFullHashesResponse) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.matches_.MergeFrom(from._impl_.matches_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom( + from._internal_minimum_wait_duration()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_negative_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom( + from._internal_negative_cache_duration()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void FindFullHashesResponse::CopyFrom(const FindFullHashesResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.FindFullHashesResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindFullHashesResponse::IsInitialized() const { + return true; +} + +void FindFullHashesResponse::InternalSwap(FindFullHashesResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.matches_.InternalSwap(&other->_impl_.matches_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FindFullHashesResponse, _impl_.negative_cache_duration_) + + sizeof(FindFullHashesResponse::_impl_.negative_cache_duration_) + - PROTOBUF_FIELD_OFFSET(FindFullHashesResponse, _impl_.minimum_wait_duration_)>( + reinterpret_cast<char*>(&_impl_.minimum_wait_duration_), + reinterpret_cast<char*>(&other->_impl_.minimum_wait_duration_)); +} + +std::string FindFullHashesResponse::GetTypeName() const { + return "mozilla.safebrowsing.FindFullHashesResponse"; +} + + +// =================================================================== + +class ThreatHit_ThreatSource::_Internal { + public: + using HasBits = decltype(std::declval<ThreatHit_ThreatSource>()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_remote_ip(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_referrer(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ThreatHit_ThreatSource::ThreatHit_ThreatSource(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatHit.ThreatSource) +} +ThreatHit_ThreatSource::ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatHit_ThreatSource* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.remote_ip_){} + , decltype(_impl_.referrer_){} + , decltype(_impl_.type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.remote_ip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remote_ip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_remote_ip()) { + _this->_impl_.remote_ip_.Set(from._internal_remote_ip(), + _this->GetArenaForAllocation()); + } + _impl_.referrer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.referrer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_referrer()) { + _this->_impl_.referrer_.Set(from._internal_referrer(), + _this->GetArenaForAllocation()); + } + _this->_impl_.type_ = from._impl_.type_; + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit.ThreatSource) +} + +inline void ThreatHit_ThreatSource::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.remote_ip_){} + , decltype(_impl_.referrer_){} + , decltype(_impl_.type_){0} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remote_ip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remote_ip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.referrer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.referrer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ThreatHit_ThreatSource::~ThreatHit_ThreatSource() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit.ThreatSource) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatHit_ThreatSource::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.remote_ip_.Destroy(); + _impl_.referrer_.Destroy(); +} + +void ThreatHit_ThreatSource::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatHit_ThreatSource::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.remote_ip_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.referrer_.ClearNonDefaultToEmpty(); + } + } + _impl_.type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatHit_ThreatSource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(val))) { + _internal_set_type(static_cast<::mozilla::safebrowsing::ThreatHit_ThreatSourceType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string remote_ip = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + auto str = _internal_mutable_remote_ip(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string referrer = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + auto str = _internal_mutable_referrer(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatHit_ThreatSource::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_type(), target); + } + + // optional string remote_ip = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 3, this->_internal_remote_ip(), target); + } + + // optional string referrer = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteStringMaybeAliased( + 4, this->_internal_referrer(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatHit.ThreatSource) + return target; +} + +size_t ThreatHit_ThreatSource::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string remote_ip = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_remote_ip()); + } + + // optional string referrer = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_referrer()); + } + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatHit_ThreatSource::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatHit_ThreatSource*>( + &from)); +} + +void ThreatHit_ThreatSource::MergeFrom(const ThreatHit_ThreatSource& from) { + ThreatHit_ThreatSource* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_remote_ip(from._internal_remote_ip()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_referrer(from._internal_referrer()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.type_ = from._impl_.type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatHit_ThreatSource::CopyFrom(const ThreatHit_ThreatSource& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatHit_ThreatSource::IsInitialized() const { + return true; +} + +void ThreatHit_ThreatSource::InternalSwap(ThreatHit_ThreatSource* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.remote_ip_, lhs_arena, + &other->_impl_.remote_ip_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.referrer_, lhs_arena, + &other->_impl_.referrer_, rhs_arena + ); + swap(_impl_.type_, other->_impl_.type_); +} + +std::string ThreatHit_ThreatSource::GetTypeName() const { + return "mozilla.safebrowsing.ThreatHit.ThreatSource"; +} + + +// =================================================================== + +class ThreatHit_UserInfo::_Internal { + public: + using HasBits = decltype(std::declval<ThreatHit_UserInfo>()._impl_._has_bits_); + static void set_has_region_code(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_user_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ThreatHit_UserInfo::ThreatHit_UserInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatHit.UserInfo) +} +ThreatHit_UserInfo::ThreatHit_UserInfo(const ThreatHit_UserInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatHit_UserInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.region_code_){} + , decltype(_impl_.user_id_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.region_code_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.region_code_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_region_code()) { + _this->_impl_.region_code_.Set(from._internal_region_code(), + _this->GetArenaForAllocation()); + } + _impl_.user_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.user_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_user_id()) { + _this->_impl_.user_id_.Set(from._internal_user_id(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit.UserInfo) +} + +inline void ThreatHit_UserInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.region_code_){} + , decltype(_impl_.user_id_){} + }; + _impl_.region_code_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.region_code_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.user_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.user_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ThreatHit_UserInfo::~ThreatHit_UserInfo() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit.UserInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatHit_UserInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.region_code_.Destroy(); + _impl_.user_id_.Destroy(); +} + +void ThreatHit_UserInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatHit_UserInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatHit.UserInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.region_code_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.user_id_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatHit_UserInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string region_code = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + auto str = _internal_mutable_region_code(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes user_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + auto str = _internal_mutable_user_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatHit_UserInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatHit.UserInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string region_code = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_region_code(), target); + } + + // optional bytes user_id = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_user_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatHit.UserInfo) + return target; +} + +size_t ThreatHit_UserInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatHit.UserInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string region_code = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_region_code()); + } + + // optional bytes user_id = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_user_id()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatHit_UserInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatHit_UserInfo*>( + &from)); +} + +void ThreatHit_UserInfo::MergeFrom(const ThreatHit_UserInfo& from) { + ThreatHit_UserInfo* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatHit.UserInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_region_code(from._internal_region_code()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_user_id(from._internal_user_id()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatHit_UserInfo::CopyFrom(const ThreatHit_UserInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatHit.UserInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatHit_UserInfo::IsInitialized() const { + return true; +} + +void ThreatHit_UserInfo::InternalSwap(ThreatHit_UserInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.region_code_, lhs_arena, + &other->_impl_.region_code_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.user_id_, lhs_arena, + &other->_impl_.user_id_, rhs_arena + ); +} + +std::string ThreatHit_UserInfo::GetTypeName() const { + return "mozilla.safebrowsing.ThreatHit.UserInfo"; +} + + +// =================================================================== + +class ThreatHit::_Internal { + public: + using HasBits = decltype(std::declval<ThreatHit>()._impl_._has_bits_); + static void set_has_threat_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_platform_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::mozilla::safebrowsing::ThreatEntry& entry(const ThreatHit* msg); + static void set_has_entry(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::ClientInfo& client_info(const ThreatHit* msg); + static void set_has_client_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::mozilla::safebrowsing::ThreatHit_UserInfo& user_info(const ThreatHit* msg); + static void set_has_user_info(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::mozilla::safebrowsing::ThreatEntry& +ThreatHit::_Internal::entry(const ThreatHit* msg) { + return *msg->_impl_.entry_; +} +const ::mozilla::safebrowsing::ClientInfo& +ThreatHit::_Internal::client_info(const ThreatHit* msg) { + return *msg->_impl_.client_info_; +} +const ::mozilla::safebrowsing::ThreatHit_UserInfo& +ThreatHit::_Internal::user_info(const ThreatHit* msg) { + return *msg->_impl_.user_info_; +} +ThreatHit::ThreatHit(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatHit) +} +ThreatHit::ThreatHit(const ThreatHit& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatHit* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.resources_){from._impl_.resources_} + , decltype(_impl_.entry_){nullptr} + , decltype(_impl_.client_info_){nullptr} + , decltype(_impl_.user_info_){nullptr} + , decltype(_impl_.threat_type_){} + , decltype(_impl_.platform_type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_entry()) { + _this->_impl_.entry_ = new ::mozilla::safebrowsing::ThreatEntry(*from._impl_.entry_); + } + if (from._internal_has_client_info()) { + _this->_impl_.client_info_ = new ::mozilla::safebrowsing::ClientInfo(*from._impl_.client_info_); + } + if (from._internal_has_user_info()) { + _this->_impl_.user_info_ = new ::mozilla::safebrowsing::ThreatHit_UserInfo(*from._impl_.user_info_); + } + ::memcpy(&_impl_.threat_type_, &from._impl_.threat_type_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.platform_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.platform_type_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit) +} + +inline void ThreatHit::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.resources_){arena} + , decltype(_impl_.entry_){nullptr} + , decltype(_impl_.client_info_){nullptr} + , decltype(_impl_.user_info_){nullptr} + , decltype(_impl_.threat_type_){0} + , decltype(_impl_.platform_type_){0} + }; +} + +ThreatHit::~ThreatHit() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatHit::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.resources_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.entry_; + if (this != internal_default_instance()) delete _impl_.client_info_; + if (this != internal_default_instance()) delete _impl_.user_info_; +} + +void ThreatHit::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatHit::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatHit) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.resources_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.entry_ != nullptr); + _impl_.entry_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.client_info_ != nullptr); + _impl_.client_info_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.user_info_ != nullptr); + _impl_.user_info_->Clear(); + } + } + if (cached_has_bits & 0x00000018u) { + ::memset(&_impl_.threat_type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.platform_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.platform_type_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatHit::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatType_IsValid(val))) { + _internal_set_threat_type(static_cast<::mozilla::safebrowsing::ThreatType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::PlatformType_IsValid(val))) { + _internal_set_platform_type(static_cast<::mozilla::safebrowsing::PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_entry(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_resources(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ClientInfo client_info = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_client_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_user_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatHit::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatHit) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_threat_type(), target); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_platform_type(), target); + } + + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::entry(this), + _Internal::entry(this).GetCachedSize(), target, stream); + } + + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_resources_size()); i < n; i++) { + const auto& repfield = this->_internal_resources(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ClientInfo client_info = 5; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::client_info(this), + _Internal::client_info(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::user_info(this), + _Internal::user_info(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatHit) + return target; +} + +size_t ThreatHit::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatHit) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + total_size += 1UL * this->_internal_resources_size(); + for (const auto& msg : this->_impl_.resources_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.entry_); + } + + // optional .mozilla.safebrowsing.ClientInfo client_info = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.client_info_); + } + + // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.user_info_); + } + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platform_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatHit::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatHit*>( + &from)); +} + +void ThreatHit::MergeFrom(const ThreatHit& from) { + ThreatHit* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatHit) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.resources_.MergeFrom(from._impl_.resources_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_entry()->::mozilla::safebrowsing::ThreatEntry::MergeFrom( + from._internal_entry()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_client_info()->::mozilla::safebrowsing::ClientInfo::MergeFrom( + from._internal_client_info()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_user_info()->::mozilla::safebrowsing::ThreatHit_UserInfo::MergeFrom( + from._internal_user_info()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.threat_type_ = from._impl_.threat_type_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.platform_type_ = from._impl_.platform_type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatHit::CopyFrom(const ThreatHit& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatHit) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatHit::IsInitialized() const { + return true; +} + +void ThreatHit::InternalSwap(ThreatHit* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.resources_.InternalSwap(&other->_impl_.resources_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ThreatHit, _impl_.platform_type_) + + sizeof(ThreatHit::_impl_.platform_type_) + - PROTOBUF_FIELD_OFFSET(ThreatHit, _impl_.entry_)>( + reinterpret_cast<char*>(&_impl_.entry_), + reinterpret_cast<char*>(&other->_impl_.entry_)); +} + +std::string ThreatHit::GetTypeName() const { + return "mozilla.safebrowsing.ThreatHit"; +} + + +// =================================================================== + +class ClientInfo::_Internal { + public: + using HasBits = decltype(std::declval<ClientInfo>()._impl_._has_bits_); + static void set_has_client_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_client_version(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ClientInfo::ClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ClientInfo) +} +ClientInfo::ClientInfo(const ClientInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ClientInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.client_id_){} + , decltype(_impl_.client_version_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.client_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.client_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_client_id()) { + _this->_impl_.client_id_.Set(from._internal_client_id(), + _this->GetArenaForAllocation()); + } + _impl_.client_version_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.client_version_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_client_version()) { + _this->_impl_.client_version_.Set(from._internal_client_version(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ClientInfo) +} + +inline void ClientInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.client_id_){} + , decltype(_impl_.client_version_){} + }; + _impl_.client_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.client_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.client_version_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.client_version_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientInfo::~ClientInfo() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ClientInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.client_id_.Destroy(); + _impl_.client_version_.Destroy(); +} + +void ClientInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ClientInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.client_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.client_version_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ClientInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string client_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + auto str = _internal_mutable_client_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string client_version = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + auto str = _internal_mutable_client_version(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ClientInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string client_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_client_id(), target); + } + + // optional string client_version = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_client_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ClientInfo) + return target; +} + +size_t ClientInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ClientInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string client_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_client_id()); + } + + // optional string client_version = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_client_version()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ClientInfo*>( + &from)); +} + +void ClientInfo::MergeFrom(const ClientInfo& from) { + ClientInfo* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ClientInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_client_id(from._internal_client_id()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_client_version(from._internal_client_version()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ClientInfo::CopyFrom(const ClientInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ClientInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientInfo::IsInitialized() const { + return true; +} + +void ClientInfo::InternalSwap(ClientInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.client_id_, lhs_arena, + &other->_impl_.client_id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.client_version_, lhs_arena, + &other->_impl_.client_version_, rhs_arena + ); +} + +std::string ClientInfo::GetTypeName() const { + return "mozilla.safebrowsing.ClientInfo"; +} + + +// =================================================================== + +class ChromeClientInfo::_Internal { + public: + using HasBits = decltype(std::declval<ChromeClientInfo>()._impl_._has_bits_); + static void set_has_reporting_population(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ChromeClientInfo::ChromeClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ChromeClientInfo) +} +ChromeClientInfo::ChromeClientInfo(const ChromeClientInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ChromeClientInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.reporting_population_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _this->_impl_.reporting_population_ = from._impl_.reporting_population_; + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ChromeClientInfo) +} + +inline void ChromeClientInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.reporting_population_){0} + }; +} + +ChromeClientInfo::~ChromeClientInfo() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ChromeClientInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ChromeClientInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ChromeClientInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ChromeClientInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ChromeClientInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.reporting_population_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ChromeClientInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(val))) { + _internal_set_reporting_population(static_cast<::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ChromeClientInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ChromeClientInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_reporting_population(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ChromeClientInfo) + return target; +} + +size_t ChromeClientInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ChromeClientInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_reporting_population()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ChromeClientInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ChromeClientInfo*>( + &from)); +} + +void ChromeClientInfo::MergeFrom(const ChromeClientInfo& from) { + ChromeClientInfo* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ChromeClientInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_reporting_population()) { + _this->_internal_set_reporting_population(from._internal_reporting_population()); + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ChromeClientInfo::CopyFrom(const ChromeClientInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ChromeClientInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChromeClientInfo::IsInitialized() const { + return true; +} + +void ChromeClientInfo::InternalSwap(ChromeClientInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.reporting_population_, other->_impl_.reporting_population_); +} + +std::string ChromeClientInfo::GetTypeName() const { + return "mozilla.safebrowsing.ChromeClientInfo"; +} + + +// =================================================================== + +class Checksum::_Internal { + public: + using HasBits = decltype(std::declval<Checksum>()._impl_._has_bits_); + static void set_has_sha256(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Checksum::Checksum(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.Checksum) +} +Checksum::Checksum(const Checksum& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + Checksum* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.sha256_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.sha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_sha256()) { + _this->_impl_.sha256_.Set(from._internal_sha256(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Checksum) +} + +inline void Checksum::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.sha256_){} + }; + _impl_.sha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Checksum::~Checksum() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.Checksum) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Checksum::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.sha256_.Destroy(); +} + +void Checksum::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Checksum::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.Checksum) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.sha256_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* Checksum::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes sha256 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + auto str = _internal_mutable_sha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Checksum::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.Checksum) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes sha256 = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_sha256(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.Checksum) + return target; +} + +size_t Checksum::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.Checksum) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes sha256 = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_sha256()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Checksum::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const Checksum*>( + &from)); +} + +void Checksum::MergeFrom(const Checksum& from) { + Checksum* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.Checksum) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_sha256()) { + _this->_internal_set_sha256(from._internal_sha256()); + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void Checksum::CopyFrom(const Checksum& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.Checksum) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Checksum::IsInitialized() const { + return true; +} + +void Checksum::InternalSwap(Checksum* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.sha256_, lhs_arena, + &other->_impl_.sha256_, rhs_arena + ); +} + +std::string Checksum::GetTypeName() const { + return "mozilla.safebrowsing.Checksum"; +} + + +// =================================================================== + +class ThreatEntry::_Internal { + public: + using HasBits = decltype(std::declval<ThreatEntry>()._impl_._has_bits_); + static void set_has_hash(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ThreatEntry::ThreatEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatEntry) +} +ThreatEntry::ThreatEntry(const ThreatEntry& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatEntry* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.hash_){} + , decltype(_impl_.url_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.hash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_hash()) { + _this->_impl_.hash_.Set(from._internal_hash(), + _this->GetArenaForAllocation()); + } + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntry) +} + +inline void ThreatEntry::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.hash_){} + , decltype(_impl_.url_){} + }; + _impl_.hash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ThreatEntry::~ThreatEntry() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntry) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatEntry::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.hash_.Destroy(); + _impl_.url_.Destroy(); +} + +void ThreatEntry::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatEntry::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntry) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.hash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatEntry::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes hash = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + auto str = _internal_mutable_hash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatEntry::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntry) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes hash = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_hash(), target); + } + + // optional string url = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_url(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatEntry) + return target; +} + +size_t ThreatEntry::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatEntry) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes hash = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_hash()); + } + + // optional string url = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatEntry::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatEntry*>( + &from)); +} + +void ThreatEntry::MergeFrom(const ThreatEntry& from) { + ThreatEntry* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntry) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_hash(from._internal_hash()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_url(from._internal_url()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatEntry::CopyFrom(const ThreatEntry& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatEntry) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntry::IsInitialized() const { + return true; +} + +void ThreatEntry::InternalSwap(ThreatEntry* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.hash_, lhs_arena, + &other->_impl_.hash_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); +} + +std::string ThreatEntry::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntry"; +} + + +// =================================================================== + +class ThreatEntrySet::_Internal { + public: + using HasBits = decltype(std::declval<ThreatEntrySet>()._impl_._has_bits_); + static void set_has_compression_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::mozilla::safebrowsing::RawHashes& raw_hashes(const ThreatEntrySet* msg); + static void set_has_raw_hashes(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::mozilla::safebrowsing::RawIndices& raw_indices(const ThreatEntrySet* msg); + static void set_has_raw_indices(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_hashes(const ThreatEntrySet* msg); + static void set_has_rice_hashes(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_indices(const ThreatEntrySet* msg); + static void set_has_rice_indices(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::mozilla::safebrowsing::RawHashes& +ThreatEntrySet::_Internal::raw_hashes(const ThreatEntrySet* msg) { + return *msg->_impl_.raw_hashes_; +} +const ::mozilla::safebrowsing::RawIndices& +ThreatEntrySet::_Internal::raw_indices(const ThreatEntrySet* msg) { + return *msg->_impl_.raw_indices_; +} +const ::mozilla::safebrowsing::RiceDeltaEncoding& +ThreatEntrySet::_Internal::rice_hashes(const ThreatEntrySet* msg) { + return *msg->_impl_.rice_hashes_; +} +const ::mozilla::safebrowsing::RiceDeltaEncoding& +ThreatEntrySet::_Internal::rice_indices(const ThreatEntrySet* msg) { + return *msg->_impl_.rice_indices_; +} +ThreatEntrySet::ThreatEntrySet(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatEntrySet) +} +ThreatEntrySet::ThreatEntrySet(const ThreatEntrySet& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatEntrySet* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.raw_hashes_){nullptr} + , decltype(_impl_.raw_indices_){nullptr} + , decltype(_impl_.rice_hashes_){nullptr} + , decltype(_impl_.rice_indices_){nullptr} + , decltype(_impl_.compression_type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + if (from._internal_has_raw_hashes()) { + _this->_impl_.raw_hashes_ = new ::mozilla::safebrowsing::RawHashes(*from._impl_.raw_hashes_); + } + if (from._internal_has_raw_indices()) { + _this->_impl_.raw_indices_ = new ::mozilla::safebrowsing::RawIndices(*from._impl_.raw_indices_); + } + if (from._internal_has_rice_hashes()) { + _this->_impl_.rice_hashes_ = new ::mozilla::safebrowsing::RiceDeltaEncoding(*from._impl_.rice_hashes_); + } + if (from._internal_has_rice_indices()) { + _this->_impl_.rice_indices_ = new ::mozilla::safebrowsing::RiceDeltaEncoding(*from._impl_.rice_indices_); + } + _this->_impl_.compression_type_ = from._impl_.compression_type_; + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntrySet) +} + +inline void ThreatEntrySet::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.raw_hashes_){nullptr} + , decltype(_impl_.raw_indices_){nullptr} + , decltype(_impl_.rice_hashes_){nullptr} + , decltype(_impl_.rice_indices_){nullptr} + , decltype(_impl_.compression_type_){0} + }; +} + +ThreatEntrySet::~ThreatEntrySet() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntrySet) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatEntrySet::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.raw_hashes_; + if (this != internal_default_instance()) delete _impl_.raw_indices_; + if (this != internal_default_instance()) delete _impl_.rice_hashes_; + if (this != internal_default_instance()) delete _impl_.rice_indices_; +} + +void ThreatEntrySet::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatEntrySet::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntrySet) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.raw_hashes_ != nullptr); + _impl_.raw_hashes_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.raw_indices_ != nullptr); + _impl_.raw_indices_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.rice_hashes_ != nullptr); + _impl_.rice_hashes_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.rice_indices_ != nullptr); + _impl_.rice_indices_->Clear(); + } + } + _impl_.compression_type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatEntrySet::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::CompressionType_IsValid(val))) { + _internal_set_compression_type(static_cast<::mozilla::safebrowsing::CompressionType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_raw_hashes(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_raw_indices(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_rice_hashes(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_rice_indices(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatEntrySet::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntrySet) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_compression_type(), target); + } + + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::raw_hashes(this), + _Internal::raw_hashes(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::raw_indices(this), + _Internal::raw_indices(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::rice_hashes(this), + _Internal::rice_hashes(this).GetCachedSize(), target, stream); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::rice_indices(this), + _Internal::rice_indices(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatEntrySet) + return target; +} + +size_t ThreatEntrySet::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatEntrySet) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.raw_hashes_); + } + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.raw_indices_); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.rice_hashes_); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.rice_indices_); + } + + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_compression_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatEntrySet::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatEntrySet*>( + &from)); +} + +void ThreatEntrySet::MergeFrom(const ThreatEntrySet& from) { + ThreatEntrySet* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntrySet) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_raw_hashes()->::mozilla::safebrowsing::RawHashes::MergeFrom( + from._internal_raw_hashes()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_raw_indices()->::mozilla::safebrowsing::RawIndices::MergeFrom( + from._internal_raw_indices()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_rice_hashes()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom( + from._internal_rice_hashes()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_rice_indices()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom( + from._internal_rice_indices()); + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.compression_type_ = from._impl_.compression_type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatEntrySet::CopyFrom(const ThreatEntrySet& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatEntrySet) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntrySet::IsInitialized() const { + return true; +} + +void ThreatEntrySet::InternalSwap(ThreatEntrySet* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ThreatEntrySet, _impl_.compression_type_) + + sizeof(ThreatEntrySet::_impl_.compression_type_) + - PROTOBUF_FIELD_OFFSET(ThreatEntrySet, _impl_.raw_hashes_)>( + reinterpret_cast<char*>(&_impl_.raw_hashes_), + reinterpret_cast<char*>(&other->_impl_.raw_hashes_)); +} + +std::string ThreatEntrySet::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntrySet"; +} + + +// =================================================================== + +class RawIndices::_Internal { + public: +}; + +RawIndices::RawIndices(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.RawIndices) +} +RawIndices::RawIndices(const RawIndices& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + RawIndices* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.indices_){from._impl_.indices_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawIndices) +} + +inline void RawIndices::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.indices_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +RawIndices::~RawIndices() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawIndices) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void RawIndices::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.indices_.~RepeatedField(); +} + +void RawIndices::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void RawIndices::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.RawIndices) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.indices_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* RawIndices::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 indices = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_indices(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast<uint8_t>(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_indices(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* RawIndices::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.RawIndices) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 indices = 1; + for (int i = 0, n = this->_internal_indices_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_indices(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.RawIndices) + return target; +} + +size_t RawIndices::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.RawIndices) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 indices = 1; + { + size_t data_size = ::_pbi::WireFormatLite:: + Int32Size(this->_impl_.indices_); + total_size += 1 * + ::_pbi::FromIntSize(this->_internal_indices_size()); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RawIndices::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const RawIndices*>( + &from)); +} + +void RawIndices::MergeFrom(const RawIndices& from) { + RawIndices* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.RawIndices) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.indices_.MergeFrom(from._impl_.indices_); + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void RawIndices::CopyFrom(const RawIndices& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.RawIndices) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RawIndices::IsInitialized() const { + return true; +} + +void RawIndices::InternalSwap(RawIndices* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.indices_.InternalSwap(&other->_impl_.indices_); +} + +std::string RawIndices::GetTypeName() const { + return "mozilla.safebrowsing.RawIndices"; +} + + +// =================================================================== + +class RawHashes::_Internal { + public: + using HasBits = decltype(std::declval<RawHashes>()._impl_._has_bits_); + static void set_has_prefix_size(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_raw_hashes(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +RawHashes::RawHashes(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.RawHashes) +} +RawHashes::RawHashes(const RawHashes& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + RawHashes* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.raw_hashes_){} + , decltype(_impl_.prefix_size_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.raw_hashes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.raw_hashes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_raw_hashes()) { + _this->_impl_.raw_hashes_.Set(from._internal_raw_hashes(), + _this->GetArenaForAllocation()); + } + _this->_impl_.prefix_size_ = from._impl_.prefix_size_; + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawHashes) +} + +inline void RawHashes::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.raw_hashes_){} + , decltype(_impl_.prefix_size_){0} + }; + _impl_.raw_hashes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.raw_hashes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +RawHashes::~RawHashes() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawHashes) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void RawHashes::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.raw_hashes_.Destroy(); +} + +void RawHashes::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void RawHashes::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.RawHashes) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.raw_hashes_.ClearNonDefaultToEmpty(); + } + _impl_.prefix_size_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* RawHashes::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 prefix_size = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + _Internal::set_has_prefix_size(&has_bits); + _impl_.prefix_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes raw_hashes = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + auto str = _internal_mutable_raw_hashes(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* RawHashes::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.RawHashes) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int32 prefix_size = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_prefix_size(), target); + } + + // optional bytes raw_hashes = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_raw_hashes(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.RawHashes) + return target; +} + +size_t RawHashes::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.RawHashes) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes raw_hashes = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_raw_hashes()); + } + + // optional int32 prefix_size = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prefix_size()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RawHashes::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const RawHashes*>( + &from)); +} + +void RawHashes::MergeFrom(const RawHashes& from) { + RawHashes* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.RawHashes) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_raw_hashes(from._internal_raw_hashes()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.prefix_size_ = from._impl_.prefix_size_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void RawHashes::CopyFrom(const RawHashes& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.RawHashes) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RawHashes::IsInitialized() const { + return true; +} + +void RawHashes::InternalSwap(RawHashes* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.raw_hashes_, lhs_arena, + &other->_impl_.raw_hashes_, rhs_arena + ); + swap(_impl_.prefix_size_, other->_impl_.prefix_size_); +} + +std::string RawHashes::GetTypeName() const { + return "mozilla.safebrowsing.RawHashes"; +} + + +// =================================================================== + +class RiceDeltaEncoding::_Internal { + public: + using HasBits = decltype(std::declval<RiceDeltaEncoding>()._impl_._has_bits_); + static void set_has_first_value(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_rice_parameter(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_num_entries(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_encoded_data(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +RiceDeltaEncoding::RiceDeltaEncoding(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.RiceDeltaEncoding) +} +RiceDeltaEncoding::RiceDeltaEncoding(const RiceDeltaEncoding& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + RiceDeltaEncoding* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.encoded_data_){} + , decltype(_impl_.first_value_){} + , decltype(_impl_.rice_parameter_){} + , decltype(_impl_.num_entries_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.encoded_data_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.encoded_data_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_encoded_data()) { + _this->_impl_.encoded_data_.Set(from._internal_encoded_data(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.first_value_, &from._impl_.first_value_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.num_entries_) - + reinterpret_cast<char*>(&_impl_.first_value_)) + sizeof(_impl_.num_entries_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RiceDeltaEncoding) +} + +inline void RiceDeltaEncoding::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.encoded_data_){} + , decltype(_impl_.first_value_){int64_t{0}} + , decltype(_impl_.rice_parameter_){0} + , decltype(_impl_.num_entries_){0} + }; + _impl_.encoded_data_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.encoded_data_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +RiceDeltaEncoding::~RiceDeltaEncoding() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RiceDeltaEncoding) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void RiceDeltaEncoding::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.encoded_data_.Destroy(); +} + +void RiceDeltaEncoding::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void RiceDeltaEncoding::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.RiceDeltaEncoding) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.encoded_data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&_impl_.first_value_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.num_entries_) - + reinterpret_cast<char*>(&_impl_.first_value_)) + sizeof(_impl_.num_entries_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* RiceDeltaEncoding::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 first_value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + _Internal::set_has_first_value(&has_bits); + _impl_.first_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 rice_parameter = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + _Internal::set_has_rice_parameter(&has_bits); + _impl_.rice_parameter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 num_entries = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) { + _Internal::set_has_num_entries(&has_bits); + _impl_.num_entries_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes encoded_data = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) { + auto str = _internal_mutable_encoded_data(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* RiceDeltaEncoding::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.RiceDeltaEncoding) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 first_value = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_first_value(), target); + } + + // optional int32 rice_parameter = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_rice_parameter(), target); + } + + // optional int32 num_entries = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_num_entries(), target); + } + + // optional bytes encoded_data = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_encoded_data(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.RiceDeltaEncoding) + return target; +} + +size_t RiceDeltaEncoding::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.RiceDeltaEncoding) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes encoded_data = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_encoded_data()); + } + + // optional int64 first_value = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_first_value()); + } + + // optional int32 rice_parameter = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_rice_parameter()); + } + + // optional int32 num_entries = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_entries()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RiceDeltaEncoding::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const RiceDeltaEncoding*>( + &from)); +} + +void RiceDeltaEncoding::MergeFrom(const RiceDeltaEncoding& from) { + RiceDeltaEncoding* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.RiceDeltaEncoding) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_encoded_data(from._internal_encoded_data()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.first_value_ = from._impl_.first_value_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.rice_parameter_ = from._impl_.rice_parameter_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.num_entries_ = from._impl_.num_entries_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void RiceDeltaEncoding::CopyFrom(const RiceDeltaEncoding& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.RiceDeltaEncoding) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RiceDeltaEncoding::IsInitialized() const { + return true; +} + +void RiceDeltaEncoding::InternalSwap(RiceDeltaEncoding* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.encoded_data_, lhs_arena, + &other->_impl_.encoded_data_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(RiceDeltaEncoding, _impl_.num_entries_) + + sizeof(RiceDeltaEncoding::_impl_.num_entries_) + - PROTOBUF_FIELD_OFFSET(RiceDeltaEncoding, _impl_.first_value_)>( + reinterpret_cast<char*>(&_impl_.first_value_), + reinterpret_cast<char*>(&other->_impl_.first_value_)); +} + +std::string RiceDeltaEncoding::GetTypeName() const { + return "mozilla.safebrowsing.RiceDeltaEncoding"; +} + + +// =================================================================== + +class ThreatEntryMetadata_MetadataEntry::_Internal { + public: + using HasBits = decltype(std::declval<ThreatEntryMetadata_MetadataEntry>()._impl_._has_bits_); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_value(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) +} +ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatEntryMetadata_MetadataEntry* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){} + , decltype(_impl_.value_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_key()) { + _this->_impl_.key_.Set(from._internal_key(), + _this->GetArenaForAllocation()); + } + _impl_.value_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.value_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_value()) { + _this->_impl_.value_.Set(from._internal_value(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) +} + +inline void ThreatEntryMetadata_MetadataEntry::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){} + , decltype(_impl_.value_){} + }; + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.value_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.value_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ThreatEntryMetadata_MetadataEntry::~ThreatEntryMetadata_MetadataEntry() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatEntryMetadata_MetadataEntry::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.key_.Destroy(); + _impl_.value_.Destroy(); +} + +void ThreatEntryMetadata_MetadataEntry::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatEntryMetadata_MetadataEntry::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.key_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.value_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatEntryMetadata_MetadataEntry::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatEntryMetadata_MetadataEntry::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes key = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_key(), target); + } + + // optional bytes value = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + return target; +} + +size_t ThreatEntryMetadata_MetadataEntry::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes key = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_key()); + } + + // optional bytes value = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_value()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatEntryMetadata_MetadataEntry::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatEntryMetadata_MetadataEntry*>( + &from)); +} + +void ThreatEntryMetadata_MetadataEntry::MergeFrom(const ThreatEntryMetadata_MetadataEntry& from) { + ThreatEntryMetadata_MetadataEntry* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_key(from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_value(from._internal_value()); + } + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatEntryMetadata_MetadataEntry::CopyFrom(const ThreatEntryMetadata_MetadataEntry& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntryMetadata_MetadataEntry::IsInitialized() const { + return true; +} + +void ThreatEntryMetadata_MetadataEntry::InternalSwap(ThreatEntryMetadata_MetadataEntry* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.key_, lhs_arena, + &other->_impl_.key_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.value_, lhs_arena, + &other->_impl_.value_, rhs_arena + ); +} + +std::string ThreatEntryMetadata_MetadataEntry::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry"; +} + + +// =================================================================== + +class ThreatEntryMetadata::_Internal { + public: +}; + +ThreatEntryMetadata::ThreatEntryMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatEntryMetadata) +} +ThreatEntryMetadata::ThreatEntryMetadata(const ThreatEntryMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatEntryMetadata* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.entries_){from._impl_.entries_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata) +} + +inline void ThreatEntryMetadata::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.entries_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ThreatEntryMetadata::~ThreatEntryMetadata() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatEntryMetadata::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.entries_.~RepeatedPtrField(); +} + +void ThreatEntryMetadata::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatEntryMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntryMetadata) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.entries_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatEntryMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_entries(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatEntryMetadata::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntryMetadata) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_entries_size()); i < n; i++) { + const auto& repfield = this->_internal_entries(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatEntryMetadata) + return target; +} + +size_t ThreatEntryMetadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatEntryMetadata) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + total_size += 1UL * this->_internal_entries_size(); + for (const auto& msg : this->_impl_.entries_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatEntryMetadata::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatEntryMetadata*>( + &from)); +} + +void ThreatEntryMetadata::MergeFrom(const ThreatEntryMetadata& from) { + ThreatEntryMetadata* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntryMetadata) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.entries_.MergeFrom(from._impl_.entries_); + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatEntryMetadata::CopyFrom(const ThreatEntryMetadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatEntryMetadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntryMetadata::IsInitialized() const { + return true; +} + +void ThreatEntryMetadata::InternalSwap(ThreatEntryMetadata* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.entries_.InternalSwap(&other->_impl_.entries_); +} + +std::string ThreatEntryMetadata::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntryMetadata"; +} + + +// =================================================================== + +class ThreatListDescriptor::_Internal { + public: + using HasBits = decltype(std::declval<ThreatListDescriptor>()._impl_._has_bits_); + static void set_has_threat_type(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_platform_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_threat_entry_type(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ThreatListDescriptor::ThreatListDescriptor(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ThreatListDescriptor) +} +ThreatListDescriptor::ThreatListDescriptor(const ThreatListDescriptor& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ThreatListDescriptor* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.threat_type_){} + , decltype(_impl_.platform_type_){} + , decltype(_impl_.threat_entry_type_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + ::memcpy(&_impl_.threat_type_, &from._impl_.threat_type_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.threat_entry_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.threat_entry_type_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatListDescriptor) +} + +inline void ThreatListDescriptor::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.threat_type_){0} + , decltype(_impl_.platform_type_){0} + , decltype(_impl_.threat_entry_type_){0} + }; +} + +ThreatListDescriptor::~ThreatListDescriptor() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatListDescriptor) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ThreatListDescriptor::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ThreatListDescriptor::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ThreatListDescriptor::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatListDescriptor) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&_impl_.threat_type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.threat_entry_type_) - + reinterpret_cast<char*>(&_impl_.threat_type_)) + sizeof(_impl_.threat_entry_type_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ThreatListDescriptor::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatType_IsValid(val))) { + _internal_set_threat_type(static_cast<::mozilla::safebrowsing::ThreatType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::PlatformType_IsValid(val))) { + _internal_set_platform_type(static_cast<::mozilla::safebrowsing::PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::mozilla::safebrowsing::ThreatEntryType_IsValid(val))) { + _internal_set_threat_entry_type(static_cast<::mozilla::safebrowsing::ThreatEntryType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ThreatListDescriptor::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatListDescriptor) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_threat_type(), target); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_platform_type(), target); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_threat_entry_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ThreatListDescriptor) + return target; +} + +size_t ThreatListDescriptor::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ThreatListDescriptor) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_threat_entry_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ThreatListDescriptor::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ThreatListDescriptor*>( + &from)); +} + +void ThreatListDescriptor::MergeFrom(const ThreatListDescriptor& from) { + ThreatListDescriptor* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatListDescriptor) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.threat_type_ = from._impl_.threat_type_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.platform_type_ = from._impl_.platform_type_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.threat_entry_type_ = from._impl_.threat_entry_type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ThreatListDescriptor::CopyFrom(const ThreatListDescriptor& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ThreatListDescriptor) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatListDescriptor::IsInitialized() const { + return true; +} + +void ThreatListDescriptor::InternalSwap(ThreatListDescriptor* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ThreatListDescriptor, _impl_.threat_entry_type_) + + sizeof(ThreatListDescriptor::_impl_.threat_entry_type_) + - PROTOBUF_FIELD_OFFSET(ThreatListDescriptor, _impl_.threat_type_)>( + reinterpret_cast<char*>(&_impl_.threat_type_), + reinterpret_cast<char*>(&other->_impl_.threat_type_)); +} + +std::string ThreatListDescriptor::GetTypeName() const { + return "mozilla.safebrowsing.ThreatListDescriptor"; +} + + +// =================================================================== + +class ListThreatListsResponse::_Internal { + public: +}; + +ListThreatListsResponse::ListThreatListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.ListThreatListsResponse) +} +ListThreatListsResponse::ListThreatListsResponse(const ListThreatListsResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + ListThreatListsResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.threat_lists_){from._impl_.threat_lists_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ListThreatListsResponse) +} + +inline void ListThreatListsResponse::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.threat_lists_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ListThreatListsResponse::~ListThreatListsResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ListThreatListsResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ListThreatListsResponse::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.threat_lists_.~RepeatedPtrField(); +} + +void ListThreatListsResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ListThreatListsResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ListThreatListsResponse) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.threat_lists_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* ListThreatListsResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_threat_lists(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ListThreatListsResponse::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ListThreatListsResponse) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + for (unsigned i = 0, + n = static_cast<unsigned>(this->_internal_threat_lists_size()); i < n; i++) { + const auto& repfield = this->_internal_threat_lists(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.ListThreatListsResponse) + return target; +} + +size_t ListThreatListsResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.ListThreatListsResponse) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + total_size += 1UL * this->_internal_threat_lists_size(); + for (const auto& msg : this->_impl_.threat_lists_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ListThreatListsResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const ListThreatListsResponse*>( + &from)); +} + +void ListThreatListsResponse::MergeFrom(const ListThreatListsResponse& from) { + ListThreatListsResponse* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ListThreatListsResponse) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.threat_lists_.MergeFrom(from._impl_.threat_lists_); + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void ListThreatListsResponse::CopyFrom(const ListThreatListsResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.ListThreatListsResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ListThreatListsResponse::IsInitialized() const { + return true; +} + +void ListThreatListsResponse::InternalSwap(ListThreatListsResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.threat_lists_.InternalSwap(&other->_impl_.threat_lists_); +} + +std::string ListThreatListsResponse::GetTypeName() const { + return "mozilla.safebrowsing.ListThreatListsResponse"; +} + + +// =================================================================== + +class Duration::_Internal { + public: + using HasBits = decltype(std::declval<Duration>()._impl_._has_bits_); + static void set_has_seconds(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_nanos(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Duration::Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:mozilla.safebrowsing.Duration) +} +Duration::Duration(const Duration& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + Duration* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.seconds_){} + , decltype(_impl_.nanos_){}}; + + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + ::memcpy(&_impl_.seconds_, &from._impl_.seconds_, + static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nanos_) - + reinterpret_cast<char*>(&_impl_.seconds_)) + sizeof(_impl_.nanos_)); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Duration) +} + +inline void Duration::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.seconds_){int64_t{0}} + , decltype(_impl_.nanos_){0} + }; +} + +Duration::~Duration() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.Duration) + if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Duration::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Duration::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Duration::Clear() { +// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.Duration) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.seconds_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&_impl_.nanos_) - + reinterpret_cast<char*>(&_impl_.seconds_)) + sizeof(_impl_.nanos_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* Duration::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 seconds = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) { + _Internal::set_has_seconds(&has_bits); + _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 nanos = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) { + _Internal::set_has_nanos(&has_bits); + _impl_.nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<std::string>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Duration::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.Duration) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 seconds = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_seconds(), target); + } + + // optional int32 nanos = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_nanos(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:mozilla.safebrowsing.Duration) + return target; +} + +size_t Duration::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:mozilla.safebrowsing.Duration) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int64 seconds = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_seconds()); + } + + // optional int32 nanos = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nanos()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Duration::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::_pbi::DownCast<const Duration*>( + &from)); +} + +void Duration::MergeFrom(const Duration& from) { + Duration* const _this = this; + // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.Duration) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.seconds_ = from._impl_.seconds_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.nanos_ = from._impl_.nanos_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void Duration::CopyFrom(const Duration& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.safebrowsing.Duration) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Duration::IsInitialized() const { + return true; +} + +void Duration::InternalSwap(Duration* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Duration, _impl_.nanos_) + + sizeof(Duration::_impl_.nanos_) + - PROTOBUF_FIELD_OFFSET(Duration, _impl_.seconds_)>( + reinterpret_cast<char*>(&_impl_.seconds_), + reinterpret_cast<char*>(&other->_impl_.seconds_)); +} + +std::string Duration::GetTypeName() const { + return "mozilla.safebrowsing.Duration"; +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace safebrowsing +} // namespace mozilla +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatInfo* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatMatch* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatMatch >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatMatch >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindThreatMatchesRequest* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindThreatMatchesRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FindThreatMatchesRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindThreatMatchesResponse* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindThreatMatchesResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FindThreatMatchesResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesRequest* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesResponse* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindFullHashesRequest* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindFullHashesRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FindFullHashesRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindFullHashesResponse* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindFullHashesResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::FindFullHashesResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatHit_ThreatSource* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatHit_ThreatSource >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatHit_ThreatSource >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatHit_UserInfo* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatHit_UserInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatHit_UserInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatHit* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatHit >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatHit >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ClientInfo* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ClientInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ClientInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ChromeClientInfo* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ChromeClientInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ChromeClientInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::Checksum* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::Checksum >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::Checksum >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntry* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntry >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatEntry >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntrySet* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntrySet >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatEntrySet >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::RawIndices* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::RawIndices >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::RawIndices >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::RawHashes* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::RawHashes >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::RawHashes >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::RiceDeltaEncoding* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::RiceDeltaEncoding >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::RiceDeltaEncoding >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntryMetadata* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntryMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatEntryMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatListDescriptor* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatListDescriptor >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ThreatListDescriptor >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ListThreatListsResponse* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ListThreatListsResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::ListThreatListsResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::Duration* +Arena::CreateMaybeMessage< ::mozilla::safebrowsing::Duration >(Arena* arena) { + return Arena::CreateMessageInternal< ::mozilla::safebrowsing::Duration >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include <google/protobuf/port_undef.inc> |