8925 lines
332 KiB
C++
8925 lines
332 KiB
C++
// 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>
|