forked from mirrors/gecko-dev
8442a065cf
Differential Revision: https://phabricator.services.mozilla.com/D69707 --HG-- extra : moz-landing-system : lando
8433 lines
327 KiB
C++
8433 lines
327 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>
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Checksum_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChromeClientInfo_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientInfo_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Duration_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RawHashes_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RawIndices_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RiceDeltaEncoding_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatEntry_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ThreatEntryMetadata_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ThreatEntrySet_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatHit_ThreatSource_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatHit_UserInfo_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ThreatInfo_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatListDescriptor_safebrowsing_2eproto;
|
|
extern PROTOBUF_INTERNAL_EXPORT_safebrowsing_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ThreatMatch_safebrowsing_2eproto;
|
|
namespace mozilla {
|
|
namespace safebrowsing {
|
|
class ThreatInfoDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatInfo> _instance;
|
|
} _ThreatInfo_default_instance_;
|
|
class ThreatMatchDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatMatch> _instance;
|
|
} _ThreatMatch_default_instance_;
|
|
class FindThreatMatchesRequestDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FindThreatMatchesRequest> _instance;
|
|
} _FindThreatMatchesRequest_default_instance_;
|
|
class FindThreatMatchesResponseDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FindThreatMatchesResponse> _instance;
|
|
} _FindThreatMatchesResponse_default_instance_;
|
|
class FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints> _instance;
|
|
} _FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_;
|
|
class FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FetchThreatListUpdatesRequest_ListUpdateRequest> _instance;
|
|
} _FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_;
|
|
class FetchThreatListUpdatesRequestDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FetchThreatListUpdatesRequest> _instance;
|
|
} _FetchThreatListUpdatesRequest_default_instance_;
|
|
class FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FetchThreatListUpdatesResponse_ListUpdateResponse> _instance;
|
|
} _FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_;
|
|
class FetchThreatListUpdatesResponseDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FetchThreatListUpdatesResponse> _instance;
|
|
} _FetchThreatListUpdatesResponse_default_instance_;
|
|
class FindFullHashesRequestDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FindFullHashesRequest> _instance;
|
|
} _FindFullHashesRequest_default_instance_;
|
|
class FindFullHashesResponseDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FindFullHashesResponse> _instance;
|
|
} _FindFullHashesResponse_default_instance_;
|
|
class ThreatHit_ThreatSourceDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatHit_ThreatSource> _instance;
|
|
} _ThreatHit_ThreatSource_default_instance_;
|
|
class ThreatHit_UserInfoDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatHit_UserInfo> _instance;
|
|
} _ThreatHit_UserInfo_default_instance_;
|
|
class ThreatHitDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatHit> _instance;
|
|
} _ThreatHit_default_instance_;
|
|
class ClientInfoDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientInfo> _instance;
|
|
} _ClientInfo_default_instance_;
|
|
class ChromeClientInfoDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ChromeClientInfo> _instance;
|
|
} _ChromeClientInfo_default_instance_;
|
|
class ChecksumDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Checksum> _instance;
|
|
} _Checksum_default_instance_;
|
|
class ThreatEntryDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatEntry> _instance;
|
|
} _ThreatEntry_default_instance_;
|
|
class ThreatEntrySetDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatEntrySet> _instance;
|
|
} _ThreatEntrySet_default_instance_;
|
|
class RawIndicesDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RawIndices> _instance;
|
|
} _RawIndices_default_instance_;
|
|
class RawHashesDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RawHashes> _instance;
|
|
} _RawHashes_default_instance_;
|
|
class RiceDeltaEncodingDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RiceDeltaEncoding> _instance;
|
|
} _RiceDeltaEncoding_default_instance_;
|
|
class ThreatEntryMetadata_MetadataEntryDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatEntryMetadata_MetadataEntry> _instance;
|
|
} _ThreatEntryMetadata_MetadataEntry_default_instance_;
|
|
class ThreatEntryMetadataDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatEntryMetadata> _instance;
|
|
} _ThreatEntryMetadata_default_instance_;
|
|
class ThreatListDescriptorDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThreatListDescriptor> _instance;
|
|
} _ThreatListDescriptor_default_instance_;
|
|
class ListThreatListsResponseDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ListThreatListsResponse> _instance;
|
|
} _ListThreatListsResponse_default_instance_;
|
|
class DurationDefaultTypeInternal {
|
|
public:
|
|
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Duration> _instance;
|
|
} _Duration_default_instance_;
|
|
} // namespace safebrowsing
|
|
} // namespace mozilla
|
|
static void InitDefaultsscc_info_Checksum_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_Checksum_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::Checksum();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::Checksum::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Checksum_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Checksum_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ChromeClientInfo_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ChromeClientInfo_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ChromeClientInfo();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ChromeClientInfo::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChromeClientInfo_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ChromeClientInfo_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ClientInfo_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ClientInfo_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ClientInfo();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ClientInfo::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientInfo_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientInfo_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_Duration_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_Duration_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::Duration();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::Duration::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Duration_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Duration_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_FetchThreatListUpdatesRequest_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FetchThreatListUpdatesRequest();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FetchThreatListUpdatesRequest::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_FetchThreatListUpdatesRequest_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_FetchThreatListUpdatesRequest_safebrowsing_2eproto}, {
|
|
&scc_info_ClientInfo_safebrowsing_2eproto.base,
|
|
&scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto.base,
|
|
&scc_info_ChromeClientInfo_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto}, {
|
|
&scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_FetchThreatListUpdatesResponse_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FetchThreatListUpdatesResponse_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FetchThreatListUpdatesResponse();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FetchThreatListUpdatesResponse::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FetchThreatListUpdatesResponse_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_FetchThreatListUpdatesResponse_safebrowsing_2eproto}, {
|
|
&scc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto.base,
|
|
&scc_info_Duration_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatEntrySet_safebrowsing_2eproto.base,
|
|
&scc_info_Checksum_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FindFullHashesRequest_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FindFullHashesRequest_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FindFullHashesRequest();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FindFullHashesRequest::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FindFullHashesRequest_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_FindFullHashesRequest_safebrowsing_2eproto}, {
|
|
&scc_info_ClientInfo_safebrowsing_2eproto.base,
|
|
&scc_info_ThreatInfo_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FindFullHashesResponse_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FindFullHashesResponse_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FindFullHashesResponse();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FindFullHashesResponse::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FindFullHashesResponse_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_FindFullHashesResponse_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatMatch_safebrowsing_2eproto.base,
|
|
&scc_info_Duration_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FindThreatMatchesRequest_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FindThreatMatchesRequest_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FindThreatMatchesRequest();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FindThreatMatchesRequest::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FindThreatMatchesRequest_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_FindThreatMatchesRequest_safebrowsing_2eproto}, {
|
|
&scc_info_ClientInfo_safebrowsing_2eproto.base,
|
|
&scc_info_ThreatInfo_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_FindThreatMatchesResponse_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_FindThreatMatchesResponse_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::FindThreatMatchesResponse();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::FindThreatMatchesResponse::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FindThreatMatchesResponse_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_FindThreatMatchesResponse_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatMatch_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_ListThreatListsResponse_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ListThreatListsResponse_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ListThreatListsResponse();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ListThreatListsResponse::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ListThreatListsResponse_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ListThreatListsResponse_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatListDescriptor_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_RawHashes_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_RawHashes_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::RawHashes();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::RawHashes::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RawHashes_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RawHashes_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_RawIndices_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_RawIndices_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::RawIndices();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::RawIndices::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RawIndices_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RawIndices_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_RiceDeltaEncoding_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::RiceDeltaEncoding();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::RiceDeltaEncoding::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RiceDeltaEncoding_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RiceDeltaEncoding_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ThreatEntry_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatEntry_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatEntry();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatEntry::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatEntry_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ThreatEntry_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ThreatEntryMetadata_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatEntryMetadata_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatEntryMetadata();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatEntryMetadata::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ThreatEntryMetadata_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ThreatEntryMetadata_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatEntryMetadata_MetadataEntry_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ThreatEntrySet_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatEntrySet_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatEntrySet();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatEntrySet::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ThreatEntrySet_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ThreatEntrySet_safebrowsing_2eproto}, {
|
|
&scc_info_RawHashes_safebrowsing_2eproto.base,
|
|
&scc_info_RawIndices_safebrowsing_2eproto.base,
|
|
&scc_info_RiceDeltaEncoding_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_ThreatHit_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatHit_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatHit();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatHit::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ThreatHit_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_ThreatHit_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatEntry_safebrowsing_2eproto.base,
|
|
&scc_info_ThreatHit_ThreatSource_safebrowsing_2eproto.base,
|
|
&scc_info_ClientInfo_safebrowsing_2eproto.base,
|
|
&scc_info_ThreatHit_UserInfo_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_ThreatHit_ThreatSource_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatHit_ThreatSource_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatHit_ThreatSource();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatHit_ThreatSource::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatHit_ThreatSource_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ThreatHit_ThreatSource_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ThreatHit_UserInfo_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatHit_UserInfo_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatHit_UserInfo();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatHit_UserInfo::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatHit_UserInfo_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ThreatHit_UserInfo_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ThreatInfo_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatInfo_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatInfo();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatInfo::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ThreatInfo_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ThreatInfo_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatEntry_safebrowsing_2eproto.base,}};
|
|
|
|
static void InitDefaultsscc_info_ThreatListDescriptor_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatListDescriptor_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatListDescriptor();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatListDescriptor::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThreatListDescriptor_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ThreatListDescriptor_safebrowsing_2eproto}, {}};
|
|
|
|
static void InitDefaultsscc_info_ThreatMatch_safebrowsing_2eproto() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
{
|
|
void* ptr = &::mozilla::safebrowsing::_ThreatMatch_default_instance_;
|
|
new (ptr) ::mozilla::safebrowsing::ThreatMatch();
|
|
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
|
|
}
|
|
::mozilla::safebrowsing::ThreatMatch::InitAsDefaultInstance();
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ThreatMatch_safebrowsing_2eproto =
|
|
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ThreatMatch_safebrowsing_2eproto}, {
|
|
&scc_info_ThreatEntry_safebrowsing_2eproto.base,
|
|
&scc_info_ThreatEntryMetadata_safebrowsing_2eproto.base,
|
|
&scc_info_Duration_safebrowsing_2eproto.base,}};
|
|
|
|
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(
|
|
const std::string& 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)
|
|
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)
|
|
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(
|
|
const std::string& 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)
|
|
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)
|
|
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(
|
|
const std::string& 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)
|
|
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)
|
|
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(
|
|
const std::string& 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(
|
|
const std::string& 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(
|
|
const std::string& 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(
|
|
const std::string& 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;
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatInfo::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatInfo::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatInfo>()._has_bits_);
|
|
};
|
|
|
|
ThreatInfo::ThreatInfo()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatInfo)
|
|
}
|
|
ThreatInfo::ThreatInfo(const ThreatInfo& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
threat_types_(from.threat_types_),
|
|
platform_types_(from.platform_types_),
|
|
threat_entries_(from.threat_entries_),
|
|
threat_entry_types_(from.threat_entry_types_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatInfo)
|
|
}
|
|
|
|
void ThreatInfo::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatInfo_safebrowsing_2eproto.base);
|
|
}
|
|
|
|
ThreatInfo::~ThreatInfo() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatInfo)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatInfo::SharedDtor() {
|
|
}
|
|
|
|
void ThreatInfo::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatInfo& ThreatInfo::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatInfo_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatInfo::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
threat_types_.Clear();
|
|
platform_types_.Clear();
|
|
threat_entries_.Clear();
|
|
threat_entry_types_.Clear();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
ptr -= 1;
|
|
do {
|
|
ptr += 1;
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
ptr -= 1;
|
|
do {
|
|
ptr += 1;
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
|
|
ptr -= 1;
|
|
do {
|
|
ptr += 1;
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) {
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_threat_entry_types(), ptr, ctx, ::mozilla::safebrowsing::ThreatEntryType_IsValid, &_internal_metadata_, 4);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatInfo::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
2, this->_internal_platform_types(i), target);
|
|
}
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_threat_entries_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(3, this->_internal_threat_entries(i), 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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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 += ::PROTOBUF_NAMESPACE_ID::internal::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 += ::PROTOBUF_NAMESPACE_ID::internal::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->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 += ::PROTOBUF_NAMESPACE_ID::internal::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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatInfo::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatInfo*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatInfo::MergeFrom(const ThreatInfo& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatInfo)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
threat_types_.MergeFrom(from.threat_types_);
|
|
platform_types_.MergeFrom(from.platform_types_);
|
|
threat_entries_.MergeFrom(from.threat_entries_);
|
|
threat_entry_types_.MergeFrom(from.threat_entry_types_);
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
threat_types_.InternalSwap(&other->threat_types_);
|
|
platform_types_.InternalSwap(&other->platform_types_);
|
|
threat_entries_.InternalSwap(&other->threat_entries_);
|
|
threat_entry_types_.InternalSwap(&other->threat_entry_types_);
|
|
}
|
|
|
|
std::string ThreatInfo::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatInfo";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatMatch::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_ThreatMatch_default_instance_._instance.get_mutable()->threat_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(
|
|
::mozilla::safebrowsing::ThreatEntry::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatMatch_default_instance_._instance.get_mutable()->threat_entry_metadata_ = const_cast< ::mozilla::safebrowsing::ThreatEntryMetadata*>(
|
|
::mozilla::safebrowsing::ThreatEntryMetadata::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatMatch_default_instance_._instance.get_mutable()->cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
|
|
::mozilla::safebrowsing::Duration::internal_default_instance());
|
|
}
|
|
class ThreatMatch::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatMatch>()._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->threat_;
|
|
}
|
|
const ::mozilla::safebrowsing::ThreatEntryMetadata&
|
|
ThreatMatch::_Internal::threat_entry_metadata(const ThreatMatch* msg) {
|
|
return *msg->threat_entry_metadata_;
|
|
}
|
|
const ::mozilla::safebrowsing::Duration&
|
|
ThreatMatch::_Internal::cache_duration(const ThreatMatch* msg) {
|
|
return *msg->cache_duration_;
|
|
}
|
|
ThreatMatch::ThreatMatch()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatMatch)
|
|
}
|
|
ThreatMatch::ThreatMatch(const ThreatMatch& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_threat()) {
|
|
threat_ = new ::mozilla::safebrowsing::ThreatEntry(*from.threat_);
|
|
} else {
|
|
threat_ = nullptr;
|
|
}
|
|
if (from._internal_has_threat_entry_metadata()) {
|
|
threat_entry_metadata_ = new ::mozilla::safebrowsing::ThreatEntryMetadata(*from.threat_entry_metadata_);
|
|
} else {
|
|
threat_entry_metadata_ = nullptr;
|
|
}
|
|
if (from._internal_has_cache_duration()) {
|
|
cache_duration_ = new ::mozilla::safebrowsing::Duration(*from.cache_duration_);
|
|
} else {
|
|
cache_duration_ = nullptr;
|
|
}
|
|
::memcpy(&threat_type_, &from.threat_type_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatMatch)
|
|
}
|
|
|
|
void ThreatMatch::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatMatch_safebrowsing_2eproto.base);
|
|
::memset(&threat_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_)) + sizeof(threat_entry_type_));
|
|
}
|
|
|
|
ThreatMatch::~ThreatMatch() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatMatch)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatMatch::SharedDtor() {
|
|
if (this != internal_default_instance()) delete threat_;
|
|
if (this != internal_default_instance()) delete threat_entry_metadata_;
|
|
if (this != internal_default_instance()) delete cache_duration_;
|
|
}
|
|
|
|
void ThreatMatch::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatMatch& ThreatMatch::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatMatch_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatMatch::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatMatch)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(threat_ != nullptr);
|
|
threat_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(threat_entry_metadata_ != nullptr);
|
|
threat_entry_metadata_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
GOOGLE_DCHECK(cache_duration_ != nullptr);
|
|
cache_duration_->Clear();
|
|
}
|
|
}
|
|
if (cached_has_bits & 0x00000038u) {
|
|
::memset(&threat_type_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatMatch::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatMatch::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatMatch)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
2, this->_internal_platform_type(), target);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntry threat = 3;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::threat(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
4, _Internal::threat_entry_metadata(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.Duration cache_duration = 5;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
5, _Internal::cache_duration(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
|
|
if (cached_has_bits & 0x00000020u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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(
|
|
*threat_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*threat_entry_metadata_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.Duration cache_duration = 5;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*cache_duration_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_platform_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
|
|
if (cached_has_bits & 0x00000020u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_entry_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatMatch::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatMatch*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatMatch::MergeFrom(const ThreatMatch& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatMatch)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000003fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_threat()->::mozilla::safebrowsing::ThreatEntry::MergeFrom(from._internal_threat());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_threat_entry_metadata()->::mozilla::safebrowsing::ThreatEntryMetadata::MergeFrom(from._internal_threat_entry_metadata());
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
_internal_mutable_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from._internal_cache_duration());
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
threat_type_ = from.threat_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000010u) {
|
|
platform_type_ = from.platform_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000020u) {
|
|
threat_entry_type_ = from.threat_entry_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(threat_, other->threat_);
|
|
swap(threat_entry_metadata_, other->threat_entry_metadata_);
|
|
swap(cache_duration_, other->cache_duration_);
|
|
swap(threat_type_, other->threat_type_);
|
|
swap(platform_type_, other->platform_type_);
|
|
swap(threat_entry_type_, other->threat_entry_type_);
|
|
}
|
|
|
|
std::string ThreatMatch::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatMatch";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FindThreatMatchesRequest::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FindThreatMatchesRequest_default_instance_._instance.get_mutable()->client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
|
|
::mozilla::safebrowsing::ClientInfo::internal_default_instance());
|
|
::mozilla::safebrowsing::_FindThreatMatchesRequest_default_instance_._instance.get_mutable()->threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(
|
|
::mozilla::safebrowsing::ThreatInfo::internal_default_instance());
|
|
}
|
|
class FindThreatMatchesRequest::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FindThreatMatchesRequest>()._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->client_;
|
|
}
|
|
const ::mozilla::safebrowsing::ThreatInfo&
|
|
FindThreatMatchesRequest::_Internal::threat_info(const FindThreatMatchesRequest* msg) {
|
|
return *msg->threat_info_;
|
|
}
|
|
FindThreatMatchesRequest::FindThreatMatchesRequest()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindThreatMatchesRequest)
|
|
}
|
|
FindThreatMatchesRequest::FindThreatMatchesRequest(const FindThreatMatchesRequest& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_client()) {
|
|
client_ = new ::mozilla::safebrowsing::ClientInfo(*from.client_);
|
|
} else {
|
|
client_ = nullptr;
|
|
}
|
|
if (from._internal_has_threat_info()) {
|
|
threat_info_ = new ::mozilla::safebrowsing::ThreatInfo(*from.threat_info_);
|
|
} else {
|
|
threat_info_ = nullptr;
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesRequest)
|
|
}
|
|
|
|
void FindThreatMatchesRequest::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FindThreatMatchesRequest_safebrowsing_2eproto.base);
|
|
::memset(&client_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_info_) -
|
|
reinterpret_cast<char*>(&client_)) + sizeof(threat_info_));
|
|
}
|
|
|
|
FindThreatMatchesRequest::~FindThreatMatchesRequest() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesRequest)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FindThreatMatchesRequest::SharedDtor() {
|
|
if (this != internal_default_instance()) delete client_;
|
|
if (this != internal_default_instance()) delete threat_info_;
|
|
}
|
|
|
|
void FindThreatMatchesRequest::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FindThreatMatchesRequest& FindThreatMatchesRequest::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FindThreatMatchesRequest_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FindThreatMatchesRequest::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindThreatMatchesRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(client_ != nullptr);
|
|
client_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(threat_info_ != nullptr);
|
|
threat_info_->Clear();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FindThreatMatchesRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ClientInfo client = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_threat_info(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FindThreatMatchesRequest::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindThreatMatchesRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ClientInfo client = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
1, _Internal::client(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
2, _Internal::threat_info(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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(
|
|
*client_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*threat_info_);
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FindThreatMatchesRequest::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FindThreatMatchesRequest*>(
|
|
&from));
|
|
}
|
|
|
|
void FindThreatMatchesRequest::MergeFrom(const FindThreatMatchesRequest& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindThreatMatchesRequest)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from._internal_client());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom(from._internal_threat_info());
|
|
}
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(client_, other->client_);
|
|
swap(threat_info_, other->threat_info_);
|
|
}
|
|
|
|
std::string FindThreatMatchesRequest::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FindThreatMatchesRequest";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FindThreatMatchesResponse::InitAsDefaultInstance() {
|
|
}
|
|
class FindThreatMatchesResponse::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FindThreatMatchesResponse>()._has_bits_);
|
|
};
|
|
|
|
FindThreatMatchesResponse::FindThreatMatchesResponse()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindThreatMatchesResponse)
|
|
}
|
|
FindThreatMatchesResponse::FindThreatMatchesResponse(const FindThreatMatchesResponse& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
matches_(from.matches_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesResponse)
|
|
}
|
|
|
|
void FindThreatMatchesResponse::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FindThreatMatchesResponse_safebrowsing_2eproto.base);
|
|
}
|
|
|
|
FindThreatMatchesResponse::~FindThreatMatchesResponse() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesResponse)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FindThreatMatchesResponse::SharedDtor() {
|
|
}
|
|
|
|
void FindThreatMatchesResponse::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FindThreatMatchesResponse& FindThreatMatchesResponse::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FindThreatMatchesResponse_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FindThreatMatchesResponse::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindThreatMatchesResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
matches_.Clear();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FindThreatMatchesResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FindThreatMatchesResponse::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindThreatMatchesResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_matches_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(1, this->_internal_matches(i), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FindThreatMatchesResponse::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FindThreatMatchesResponse*>(
|
|
&from));
|
|
}
|
|
|
|
void FindThreatMatchesResponse::MergeFrom(const FindThreatMatchesResponse& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindThreatMatchesResponse)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
matches_.MergeFrom(from.matches_);
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
matches_.InternalSwap(&other->matches_);
|
|
}
|
|
|
|
std::string FindThreatMatchesResponse::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FindThreatMatchesResponse";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::InitAsDefaultInstance() {
|
|
}
|
|
class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
|
|
}
|
|
FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
supported_compressions_(from.supported_compressions_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
region_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_region()) {
|
|
region_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.region_);
|
|
}
|
|
::memcpy(&max_update_entries_, &from.max_update_entries_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&max_database_entries_) -
|
|
reinterpret_cast<char*>(&max_update_entries_)) + sizeof(max_database_entries_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto.base);
|
|
region_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
::memset(&max_update_entries_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&max_database_entries_) -
|
|
reinterpret_cast<char*>(&max_update_entries_)) + sizeof(max_database_entries_));
|
|
}
|
|
|
|
FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedDtor() {
|
|
region_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
supported_compressions_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
region_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000006u) {
|
|
::memset(&max_update_entries_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&max_database_entries_) -
|
|
reinterpret_cast<char*>(&max_update_entries_)) + sizeof(max_database_entries_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional int32 max_update_entries = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
_Internal::set_has_max_update_entries(&has_bits);
|
|
max_update_entries_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional int32 max_database_entries = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
_Internal::set_has_max_database_entries(&has_bits);
|
|
max_database_entries_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional string region = 3;
|
|
case 3:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
|
|
auto str = _internal_mutable_region();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
|
|
ptr -= 1;
|
|
do {
|
|
ptr += 1;
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) {
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_supported_compressions(), ptr, ctx, ::mozilla::safebrowsing::CompressionType_IsValid, &_internal_metadata_, 4);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional int32 max_update_entries = 1;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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 += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
|
|
this->_internal_supported_compressions(static_cast<int>(i)));
|
|
}
|
|
total_size += (1UL * count) + data_size;
|
|
}
|
|
|
|
cached_has_bits = _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 += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
|
|
this->_internal_max_update_entries());
|
|
}
|
|
|
|
// optional int32 max_database_entries = 2;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
|
|
this->_internal_max_database_entries());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(
|
|
&from));
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
supported_compressions_.MergeFrom(from.supported_compressions_);
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
region_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.region_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
max_update_entries_ = from.max_update_entries_;
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
max_database_entries_ = from.max_database_entries_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
supported_compressions_.InternalSwap(&other->supported_compressions_);
|
|
region_.Swap(&other->region_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
swap(max_update_entries_, other->max_update_entries_);
|
|
swap(max_database_entries_, other->max_database_entries_);
|
|
}
|
|
|
|
std::string FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_._instance.get_mutable()->constraints_ = const_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(
|
|
::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::internal_default_instance());
|
|
}
|
|
class FetchThreatListUpdatesRequest_ListUpdateRequest::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FetchThreatListUpdatesRequest_ListUpdateRequest>()._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->constraints_;
|
|
}
|
|
FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
|
|
}
|
|
FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
state_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_state()) {
|
|
state_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.state_);
|
|
}
|
|
if (from._internal_has_constraints()) {
|
|
constraints_ = new ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(*from.constraints_);
|
|
} else {
|
|
constraints_ = nullptr;
|
|
}
|
|
::memcpy(&threat_type_, &from.threat_type_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto.base);
|
|
state_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
::memset(&constraints_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&constraints_)) + sizeof(threat_entry_type_));
|
|
}
|
|
|
|
FetchThreatListUpdatesRequest_ListUpdateRequest::~FetchThreatListUpdatesRequest_ListUpdateRequest() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedDtor() {
|
|
state_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (this != internal_default_instance()) delete constraints_;
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FetchThreatListUpdatesRequest_ListUpdateRequest_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
state_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(constraints_ != nullptr);
|
|
constraints_->Clear();
|
|
}
|
|
}
|
|
if (cached_has_bits & 0x0000001cu) {
|
|
::memset(&threat_type_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FetchThreatListUpdatesRequest_ListUpdateRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
|
|
auto str = _internal_mutable_state();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FetchThreatListUpdatesRequest_ListUpdateRequest::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
4, _Internal::constraints(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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(
|
|
*constraints_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_platform_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_entry_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>(
|
|
&from));
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest_ListUpdateRequest::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000001fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
state_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.state_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_constraints()->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(from._internal_constraints());
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
threat_type_ = from.threat_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
platform_type_ = from.platform_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000010u) {
|
|
threat_entry_type_ = from.threat_entry_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
state_.Swap(&other->state_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
swap(constraints_, other->constraints_);
|
|
swap(threat_type_, other->threat_type_);
|
|
swap(platform_type_, other->platform_type_);
|
|
swap(threat_entry_type_, other->threat_entry_type_);
|
|
}
|
|
|
|
std::string FetchThreatListUpdatesRequest_ListUpdateRequest::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FetchThreatListUpdatesRequest::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_default_instance_._instance.get_mutable()->client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
|
|
::mozilla::safebrowsing::ClientInfo::internal_default_instance());
|
|
::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_default_instance_._instance.get_mutable()->chrome_client_info_ = const_cast< ::mozilla::safebrowsing::ChromeClientInfo*>(
|
|
::mozilla::safebrowsing::ChromeClientInfo::internal_default_instance());
|
|
}
|
|
class FetchThreatListUpdatesRequest::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FetchThreatListUpdatesRequest>()._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->client_;
|
|
}
|
|
const ::mozilla::safebrowsing::ChromeClientInfo&
|
|
FetchThreatListUpdatesRequest::_Internal::chrome_client_info(const FetchThreatListUpdatesRequest* msg) {
|
|
return *msg->chrome_client_info_;
|
|
}
|
|
FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
|
|
}
|
|
FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
list_update_requests_(from.list_update_requests_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_client()) {
|
|
client_ = new ::mozilla::safebrowsing::ClientInfo(*from.client_);
|
|
} else {
|
|
client_ = nullptr;
|
|
}
|
|
if (from._internal_has_chrome_client_info()) {
|
|
chrome_client_info_ = new ::mozilla::safebrowsing::ChromeClientInfo(*from.chrome_client_info_);
|
|
} else {
|
|
chrome_client_info_ = nullptr;
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FetchThreatListUpdatesRequest_safebrowsing_2eproto.base);
|
|
::memset(&client_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&chrome_client_info_) -
|
|
reinterpret_cast<char*>(&client_)) + sizeof(chrome_client_info_));
|
|
}
|
|
|
|
FetchThreatListUpdatesRequest::~FetchThreatListUpdatesRequest() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest::SharedDtor() {
|
|
if (this != internal_default_instance()) delete client_;
|
|
if (this != internal_default_instance()) delete chrome_client_info_;
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FetchThreatListUpdatesRequest& FetchThreatListUpdatesRequest::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FetchThreatListUpdatesRequest_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FetchThreatListUpdatesRequest::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
list_update_requests_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(client_ != nullptr);
|
|
client_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(chrome_client_info_ != nullptr);
|
|
chrome_client_info_->Clear();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FetchThreatListUpdatesRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ClientInfo client = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_chrome_client_info(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FetchThreatListUpdatesRequest::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ClientInfo client = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
1, _Internal::client(this), target, stream);
|
|
}
|
|
|
|
// repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_list_update_requests_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(3, this->_internal_list_update_requests(i), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
4, _Internal::chrome_client_info(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->list_update_requests_) {
|
|
total_size +=
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
|
|
}
|
|
|
|
cached_has_bits = _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(
|
|
*client_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*chrome_client_info_);
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FetchThreatListUpdatesRequest*>(
|
|
&from));
|
|
}
|
|
|
|
void FetchThreatListUpdatesRequest::MergeFrom(const FetchThreatListUpdatesRequest& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
list_update_requests_.MergeFrom(from.list_update_requests_);
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from._internal_client());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_chrome_client_info()->::mozilla::safebrowsing::ChromeClientInfo::MergeFrom(from._internal_chrome_client_info());
|
|
}
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
list_update_requests_.InternalSwap(&other->list_update_requests_);
|
|
swap(client_, other->client_);
|
|
swap(chrome_client_info_, other->chrome_client_info_);
|
|
}
|
|
|
|
std::string FetchThreatListUpdatesRequest::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FetchThreatListUpdatesRequest";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_._instance.get_mutable()->checksum_ = const_cast< ::mozilla::safebrowsing::Checksum*>(
|
|
::mozilla::safebrowsing::Checksum::internal_default_instance());
|
|
}
|
|
class FetchThreatListUpdatesResponse_ListUpdateResponse::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FetchThreatListUpdatesResponse_ListUpdateResponse>()._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->checksum_;
|
|
}
|
|
FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
|
|
}
|
|
FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
additions_(from.additions_),
|
|
removals_(from.removals_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
new_client_state_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_new_client_state()) {
|
|
new_client_state_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.new_client_state_);
|
|
}
|
|
if (from._internal_has_checksum()) {
|
|
checksum_ = new ::mozilla::safebrowsing::Checksum(*from.checksum_);
|
|
} else {
|
|
checksum_ = nullptr;
|
|
}
|
|
::memcpy(&threat_type_, &from.threat_type_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&response_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(response_type_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto.base);
|
|
new_client_state_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
::memset(&checksum_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&response_type_) -
|
|
reinterpret_cast<char*>(&checksum_)) + sizeof(response_type_));
|
|
}
|
|
|
|
FetchThreatListUpdatesResponse_ListUpdateResponse::~FetchThreatListUpdatesResponse_ListUpdateResponse() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedDtor() {
|
|
new_client_state_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (this != internal_default_instance()) delete checksum_;
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FetchThreatListUpdatesResponse_ListUpdateResponse_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
additions_.Clear();
|
|
removals_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
new_client_state_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(checksum_ != nullptr);
|
|
checksum_->Clear();
|
|
}
|
|
}
|
|
if (cached_has_bits & 0x0000003cu) {
|
|
::memset(&threat_type_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&response_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(response_type_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FetchThreatListUpdatesResponse_ListUpdateResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
|
|
auto str = _internal_mutable_new_client_state();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_checksum(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FetchThreatListUpdatesResponse_ListUpdateResponse::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
4, this->_internal_response_type(), target);
|
|
}
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_additions_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(5, this->_internal_additions(i), target, stream);
|
|
}
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_removals_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(6, this->_internal_removals(i), 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 = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
8, _Internal::checksum(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->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->removals_) {
|
|
total_size +=
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
|
|
}
|
|
|
|
cached_has_bits = _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(
|
|
*checksum_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_entry_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.PlatformType platform_type = 3;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_platform_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
|
|
if (cached_has_bits & 0x00000020u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_response_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>(
|
|
&from));
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse_ListUpdateResponse::MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
additions_.MergeFrom(from.additions_);
|
|
removals_.MergeFrom(from.removals_);
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000003fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
new_client_state_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.new_client_state_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_checksum()->::mozilla::safebrowsing::Checksum::MergeFrom(from._internal_checksum());
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
threat_type_ = from.threat_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
threat_entry_type_ = from.threat_entry_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000010u) {
|
|
platform_type_ = from.platform_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000020u) {
|
|
response_type_ = from.response_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
additions_.InternalSwap(&other->additions_);
|
|
removals_.InternalSwap(&other->removals_);
|
|
new_client_state_.Swap(&other->new_client_state_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
swap(checksum_, other->checksum_);
|
|
swap(threat_type_, other->threat_type_);
|
|
swap(threat_entry_type_, other->threat_entry_type_);
|
|
swap(platform_type_, other->platform_type_);
|
|
swap(response_type_, other->response_type_);
|
|
}
|
|
|
|
std::string FetchThreatListUpdatesResponse_ListUpdateResponse::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FetchThreatListUpdatesResponse::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FetchThreatListUpdatesResponse_default_instance_._instance.get_mutable()->minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
|
|
::mozilla::safebrowsing::Duration::internal_default_instance());
|
|
}
|
|
class FetchThreatListUpdatesResponse::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FetchThreatListUpdatesResponse>()._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->minimum_wait_duration_;
|
|
}
|
|
FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
|
|
}
|
|
FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
list_update_responses_(from.list_update_responses_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_minimum_wait_duration()) {
|
|
minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration(*from.minimum_wait_duration_);
|
|
} else {
|
|
minimum_wait_duration_ = nullptr;
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FetchThreatListUpdatesResponse_safebrowsing_2eproto.base);
|
|
minimum_wait_duration_ = nullptr;
|
|
}
|
|
|
|
FetchThreatListUpdatesResponse::~FetchThreatListUpdatesResponse() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse::SharedDtor() {
|
|
if (this != internal_default_instance()) delete minimum_wait_duration_;
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FetchThreatListUpdatesResponse& FetchThreatListUpdatesResponse::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FetchThreatListUpdatesResponse_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FetchThreatListUpdatesResponse::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
list_update_responses_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(minimum_wait_duration_ != nullptr);
|
|
minimum_wait_duration_->Clear();
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FetchThreatListUpdatesResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_minimum_wait_duration(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FetchThreatListUpdatesResponse::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
// repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_list_update_responses_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(1, this->_internal_list_update_responses(i), target, stream);
|
|
}
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
2, _Internal::minimum_wait_duration(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->list_update_responses_) {
|
|
total_size +=
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*minimum_wait_duration_);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FetchThreatListUpdatesResponse*>(
|
|
&from));
|
|
}
|
|
|
|
void FetchThreatListUpdatesResponse::MergeFrom(const FetchThreatListUpdatesResponse& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
list_update_responses_.MergeFrom(from.list_update_responses_);
|
|
if (from._internal_has_minimum_wait_duration()) {
|
|
_internal_mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from._internal_minimum_wait_duration());
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
list_update_responses_.InternalSwap(&other->list_update_responses_);
|
|
swap(minimum_wait_duration_, other->minimum_wait_duration_);
|
|
}
|
|
|
|
std::string FetchThreatListUpdatesResponse::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FetchThreatListUpdatesResponse";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FindFullHashesRequest::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FindFullHashesRequest_default_instance_._instance.get_mutable()->client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
|
|
::mozilla::safebrowsing::ClientInfo::internal_default_instance());
|
|
::mozilla::safebrowsing::_FindFullHashesRequest_default_instance_._instance.get_mutable()->threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(
|
|
::mozilla::safebrowsing::ThreatInfo::internal_default_instance());
|
|
}
|
|
class FindFullHashesRequest::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FindFullHashesRequest>()._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->client_;
|
|
}
|
|
const ::mozilla::safebrowsing::ThreatInfo&
|
|
FindFullHashesRequest::_Internal::threat_info(const FindFullHashesRequest* msg) {
|
|
return *msg->threat_info_;
|
|
}
|
|
FindFullHashesRequest::FindFullHashesRequest()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindFullHashesRequest)
|
|
}
|
|
FindFullHashesRequest::FindFullHashesRequest(const FindFullHashesRequest& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
client_states_(from.client_states_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_client()) {
|
|
client_ = new ::mozilla::safebrowsing::ClientInfo(*from.client_);
|
|
} else {
|
|
client_ = nullptr;
|
|
}
|
|
if (from._internal_has_threat_info()) {
|
|
threat_info_ = new ::mozilla::safebrowsing::ThreatInfo(*from.threat_info_);
|
|
} else {
|
|
threat_info_ = nullptr;
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesRequest)
|
|
}
|
|
|
|
void FindFullHashesRequest::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FindFullHashesRequest_safebrowsing_2eproto.base);
|
|
::memset(&client_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_info_) -
|
|
reinterpret_cast<char*>(&client_)) + sizeof(threat_info_));
|
|
}
|
|
|
|
FindFullHashesRequest::~FindFullHashesRequest() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesRequest)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FindFullHashesRequest::SharedDtor() {
|
|
if (this != internal_default_instance()) delete client_;
|
|
if (this != internal_default_instance()) delete threat_info_;
|
|
}
|
|
|
|
void FindFullHashesRequest::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FindFullHashesRequest& FindFullHashesRequest::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FindFullHashesRequest_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FindFullHashesRequest::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindFullHashesRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
client_states_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(client_ != nullptr);
|
|
client_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(threat_info_ != nullptr);
|
|
threat_info_->Clear();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FindFullHashesRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ClientInfo client = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
ptr -= 1;
|
|
do {
|
|
ptr += 1;
|
|
auto str = _internal_add_client_states();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_threat_info(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FindFullHashesRequest::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindFullHashesRequest)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ClientInfo client = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
1, _Internal::client(this), 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 = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::threat_info(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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(client_states_.size());
|
|
for (int i = 0, n = client_states_.size(); i < n; i++) {
|
|
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
|
|
client_states_.Get(i));
|
|
}
|
|
|
|
cached_has_bits = _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(
|
|
*client_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*threat_info_);
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FindFullHashesRequest::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FindFullHashesRequest*>(
|
|
&from));
|
|
}
|
|
|
|
void FindFullHashesRequest::MergeFrom(const FindFullHashesRequest& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindFullHashesRequest)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
client_states_.MergeFrom(from.client_states_);
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from._internal_client());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom(from._internal_threat_info());
|
|
}
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
client_states_.InternalSwap(&other->client_states_);
|
|
swap(client_, other->client_);
|
|
swap(threat_info_, other->threat_info_);
|
|
}
|
|
|
|
std::string FindFullHashesRequest::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FindFullHashesRequest";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void FindFullHashesResponse::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_FindFullHashesResponse_default_instance_._instance.get_mutable()->minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
|
|
::mozilla::safebrowsing::Duration::internal_default_instance());
|
|
::mozilla::safebrowsing::_FindFullHashesResponse_default_instance_._instance.get_mutable()->negative_cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
|
|
::mozilla::safebrowsing::Duration::internal_default_instance());
|
|
}
|
|
class FindFullHashesResponse::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<FindFullHashesResponse>()._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->minimum_wait_duration_;
|
|
}
|
|
const ::mozilla::safebrowsing::Duration&
|
|
FindFullHashesResponse::_Internal::negative_cache_duration(const FindFullHashesResponse* msg) {
|
|
return *msg->negative_cache_duration_;
|
|
}
|
|
FindFullHashesResponse::FindFullHashesResponse()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindFullHashesResponse)
|
|
}
|
|
FindFullHashesResponse::FindFullHashesResponse(const FindFullHashesResponse& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
matches_(from.matches_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_minimum_wait_duration()) {
|
|
minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration(*from.minimum_wait_duration_);
|
|
} else {
|
|
minimum_wait_duration_ = nullptr;
|
|
}
|
|
if (from._internal_has_negative_cache_duration()) {
|
|
negative_cache_duration_ = new ::mozilla::safebrowsing::Duration(*from.negative_cache_duration_);
|
|
} else {
|
|
negative_cache_duration_ = nullptr;
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesResponse)
|
|
}
|
|
|
|
void FindFullHashesResponse::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FindFullHashesResponse_safebrowsing_2eproto.base);
|
|
::memset(&minimum_wait_duration_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&negative_cache_duration_) -
|
|
reinterpret_cast<char*>(&minimum_wait_duration_)) + sizeof(negative_cache_duration_));
|
|
}
|
|
|
|
FindFullHashesResponse::~FindFullHashesResponse() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesResponse)
|
|
SharedDtor();
|
|
}
|
|
|
|
void FindFullHashesResponse::SharedDtor() {
|
|
if (this != internal_default_instance()) delete minimum_wait_duration_;
|
|
if (this != internal_default_instance()) delete negative_cache_duration_;
|
|
}
|
|
|
|
void FindFullHashesResponse::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const FindFullHashesResponse& FindFullHashesResponse::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FindFullHashesResponse_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void FindFullHashesResponse::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.FindFullHashesResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
matches_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(minimum_wait_duration_ != nullptr);
|
|
minimum_wait_duration_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(negative_cache_duration_ != nullptr);
|
|
negative_cache_duration_->Clear();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* FindFullHashesResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_negative_cache_duration(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* FindFullHashesResponse::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.FindFullHashesResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_matches_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(1, this->_internal_matches(i), target, stream);
|
|
}
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
2, _Internal::minimum_wait_duration(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::negative_cache_duration(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->matches_) {
|
|
total_size +=
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
|
|
}
|
|
|
|
cached_has_bits = _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(
|
|
*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(
|
|
*negative_cache_duration_);
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void FindFullHashesResponse::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FindFullHashesResponse*>(
|
|
&from));
|
|
}
|
|
|
|
void FindFullHashesResponse::MergeFrom(const FindFullHashesResponse& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.FindFullHashesResponse)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
matches_.MergeFrom(from.matches_);
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from._internal_minimum_wait_duration());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_negative_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from._internal_negative_cache_duration());
|
|
}
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
matches_.InternalSwap(&other->matches_);
|
|
swap(minimum_wait_duration_, other->minimum_wait_duration_);
|
|
swap(negative_cache_duration_, other->negative_cache_duration_);
|
|
}
|
|
|
|
std::string FindFullHashesResponse::GetTypeName() const {
|
|
return "mozilla.safebrowsing.FindFullHashesResponse";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatHit_ThreatSource::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatHit_ThreatSource::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatHit_ThreatSource>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit.ThreatSource)
|
|
}
|
|
ThreatHit_ThreatSource::ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_url()) {
|
|
url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_);
|
|
}
|
|
remote_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_remote_ip()) {
|
|
remote_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.remote_ip_);
|
|
}
|
|
referrer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_referrer()) {
|
|
referrer_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_);
|
|
}
|
|
type_ = from.type_;
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit.ThreatSource)
|
|
}
|
|
|
|
void ThreatHit_ThreatSource::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatHit_ThreatSource_safebrowsing_2eproto.base);
|
|
url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
remote_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
referrer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
type_ = 0;
|
|
}
|
|
|
|
ThreatHit_ThreatSource::~ThreatHit_ThreatSource() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit.ThreatSource)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatHit_ThreatSource::SharedDtor() {
|
|
url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
remote_ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
referrer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void ThreatHit_ThreatSource::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatHit_ThreatSource& ThreatHit_ThreatSource::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatHit_ThreatSource_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatHit_ThreatSource::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatHit.ThreatSource)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
url_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
remote_ip_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
referrer_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
}
|
|
type_ = 0;
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatHit_ThreatSource::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional string url = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
|
|
auto str = _internal_mutable_url();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
|
|
auto str = _internal_mutable_remote_ip();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional string referrer = 4;
|
|
case 4:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
|
|
auto str = _internal_mutable_referrer();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatHit_ThreatSource::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatHit.ThreatSource)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatHit_ThreatSource::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatHit_ThreatSource*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatHit_ThreatSource::MergeFrom(const ThreatHit_ThreatSource& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatHit.ThreatSource)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000000fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
remote_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.remote_ip_);
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
referrer_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_);
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
type_ = from.type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
remote_ip_.Swap(&other->remote_ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
referrer_.Swap(&other->referrer_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
swap(type_, other->type_);
|
|
}
|
|
|
|
std::string ThreatHit_ThreatSource::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatHit.ThreatSource";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatHit_UserInfo::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatHit_UserInfo::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatHit_UserInfo>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit.UserInfo)
|
|
}
|
|
ThreatHit_UserInfo::ThreatHit_UserInfo(const ThreatHit_UserInfo& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
region_code_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_region_code()) {
|
|
region_code_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.region_code_);
|
|
}
|
|
user_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_user_id()) {
|
|
user_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.user_id_);
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit.UserInfo)
|
|
}
|
|
|
|
void ThreatHit_UserInfo::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatHit_UserInfo_safebrowsing_2eproto.base);
|
|
region_code_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
user_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
ThreatHit_UserInfo::~ThreatHit_UserInfo() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit.UserInfo)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatHit_UserInfo::SharedDtor() {
|
|
region_code_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
user_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void ThreatHit_UserInfo::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatHit_UserInfo& ThreatHit_UserInfo::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatHit_UserInfo_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatHit_UserInfo::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatHit.UserInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
region_code_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
user_id_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatHit_UserInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional string region_code = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
|
|
auto str = _internal_mutable_region_code();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional bytes user_id = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
auto str = _internal_mutable_user_id();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatHit_UserInfo::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatHit.UserInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatHit_UserInfo::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatHit_UserInfo*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatHit_UserInfo::MergeFrom(const ThreatHit_UserInfo& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatHit.UserInfo)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
region_code_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.region_code_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
user_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.user_id_);
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
region_code_.Swap(&other->region_code_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
user_id_.Swap(&other->user_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
}
|
|
|
|
std::string ThreatHit_UserInfo::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatHit.UserInfo";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatHit::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_ThreatHit_default_instance_._instance.get_mutable()->entry_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(
|
|
::mozilla::safebrowsing::ThreatEntry::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatHit_default_instance_._instance.get_mutable()->client_info_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
|
|
::mozilla::safebrowsing::ClientInfo::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatHit_default_instance_._instance.get_mutable()->user_info_ = const_cast< ::mozilla::safebrowsing::ThreatHit_UserInfo*>(
|
|
::mozilla::safebrowsing::ThreatHit_UserInfo::internal_default_instance());
|
|
}
|
|
class ThreatHit::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatHit>()._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->entry_;
|
|
}
|
|
const ::mozilla::safebrowsing::ClientInfo&
|
|
ThreatHit::_Internal::client_info(const ThreatHit* msg) {
|
|
return *msg->client_info_;
|
|
}
|
|
const ::mozilla::safebrowsing::ThreatHit_UserInfo&
|
|
ThreatHit::_Internal::user_info(const ThreatHit* msg) {
|
|
return *msg->user_info_;
|
|
}
|
|
ThreatHit::ThreatHit()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit)
|
|
}
|
|
ThreatHit::ThreatHit(const ThreatHit& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
resources_(from.resources_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_entry()) {
|
|
entry_ = new ::mozilla::safebrowsing::ThreatEntry(*from.entry_);
|
|
} else {
|
|
entry_ = nullptr;
|
|
}
|
|
if (from._internal_has_client_info()) {
|
|
client_info_ = new ::mozilla::safebrowsing::ClientInfo(*from.client_info_);
|
|
} else {
|
|
client_info_ = nullptr;
|
|
}
|
|
if (from._internal_has_user_info()) {
|
|
user_info_ = new ::mozilla::safebrowsing::ThreatHit_UserInfo(*from.user_info_);
|
|
} else {
|
|
user_info_ = nullptr;
|
|
}
|
|
::memcpy(&threat_type_, &from.threat_type_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&platform_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(platform_type_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit)
|
|
}
|
|
|
|
void ThreatHit::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatHit_safebrowsing_2eproto.base);
|
|
::memset(&entry_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&platform_type_) -
|
|
reinterpret_cast<char*>(&entry_)) + sizeof(platform_type_));
|
|
}
|
|
|
|
ThreatHit::~ThreatHit() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatHit::SharedDtor() {
|
|
if (this != internal_default_instance()) delete entry_;
|
|
if (this != internal_default_instance()) delete client_info_;
|
|
if (this != internal_default_instance()) delete user_info_;
|
|
}
|
|
|
|
void ThreatHit::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatHit& ThreatHit::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatHit_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatHit::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatHit)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
resources_.Clear();
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(entry_ != nullptr);
|
|
entry_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(client_info_ != nullptr);
|
|
client_info_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
GOOGLE_DCHECK(user_info_ != nullptr);
|
|
user_info_->Clear();
|
|
}
|
|
}
|
|
if (cached_has_bits & 0x00000018u) {
|
|
::memset(&threat_type_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&platform_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(platform_type_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatHit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_user_info(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatHit::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatHit)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
2, this->_internal_platform_type(), target);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntry entry = 3;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::entry(this), target, stream);
|
|
}
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_resources_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(4, this->_internal_resources(i), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ClientInfo client_info = 5;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
5, _Internal::client_info(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
6, _Internal::user_info(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->resources_) {
|
|
total_size +=
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
|
|
}
|
|
|
|
cached_has_bits = _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(
|
|
*entry_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ClientInfo client_info = 5;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*client_info_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*user_info_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_platform_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatHit::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatHit*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatHit::MergeFrom(const ThreatHit& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatHit)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
resources_.MergeFrom(from.resources_);
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000001fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_entry()->::mozilla::safebrowsing::ThreatEntry::MergeFrom(from._internal_entry());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_client_info()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from._internal_client_info());
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
_internal_mutable_user_info()->::mozilla::safebrowsing::ThreatHit_UserInfo::MergeFrom(from._internal_user_info());
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
threat_type_ = from.threat_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000010u) {
|
|
platform_type_ = from.platform_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
resources_.InternalSwap(&other->resources_);
|
|
swap(entry_, other->entry_);
|
|
swap(client_info_, other->client_info_);
|
|
swap(user_info_, other->user_info_);
|
|
swap(threat_type_, other->threat_type_);
|
|
swap(platform_type_, other->platform_type_);
|
|
}
|
|
|
|
std::string ThreatHit::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatHit";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ClientInfo::InitAsDefaultInstance() {
|
|
}
|
|
class ClientInfo::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ClientInfo>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ClientInfo)
|
|
}
|
|
ClientInfo::ClientInfo(const ClientInfo& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
client_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_client_id()) {
|
|
client_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_id_);
|
|
}
|
|
client_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_client_version()) {
|
|
client_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_version_);
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ClientInfo)
|
|
}
|
|
|
|
void ClientInfo::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientInfo_safebrowsing_2eproto.base);
|
|
client_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
client_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
ClientInfo::~ClientInfo() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ClientInfo)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ClientInfo::SharedDtor() {
|
|
client_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
client_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void ClientInfo::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ClientInfo& ClientInfo::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientInfo_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ClientInfo::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ClientInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
client_id_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
client_version_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ClientInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional string client_id = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
|
|
auto str = _internal_mutable_client_id();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional string client_version = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
auto str = _internal_mutable_client_version();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ClientInfo::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ClientInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ClientInfo::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientInfo*>(
|
|
&from));
|
|
}
|
|
|
|
void ClientInfo::MergeFrom(const ClientInfo& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ClientInfo)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
client_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_id_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
client_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_version_);
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
client_id_.Swap(&other->client_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
client_version_.Swap(&other->client_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
}
|
|
|
|
std::string ClientInfo::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ClientInfo";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ChromeClientInfo::InitAsDefaultInstance() {
|
|
}
|
|
class ChromeClientInfo::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ChromeClientInfo>()._has_bits_);
|
|
static void set_has_reporting_population(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
};
|
|
|
|
ChromeClientInfo::ChromeClientInfo()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ChromeClientInfo)
|
|
}
|
|
ChromeClientInfo::ChromeClientInfo(const ChromeClientInfo& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
reporting_population_ = from.reporting_population_;
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ChromeClientInfo)
|
|
}
|
|
|
|
void ChromeClientInfo::SharedCtor() {
|
|
reporting_population_ = 0;
|
|
}
|
|
|
|
ChromeClientInfo::~ChromeClientInfo() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ChromeClientInfo)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ChromeClientInfo::SharedDtor() {
|
|
}
|
|
|
|
void ChromeClientInfo::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ChromeClientInfo& ChromeClientInfo::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ChromeClientInfo_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ChromeClientInfo::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ChromeClientInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
reporting_population_ = 0;
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ChromeClientInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ChromeClientInfo::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ChromeClientInfo)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->_internal_reporting_population(), target);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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 = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_reporting_population());
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ChromeClientInfo::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ChromeClientInfo*>(
|
|
&from));
|
|
}
|
|
|
|
void ChromeClientInfo::MergeFrom(const ChromeClientInfo& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ChromeClientInfo)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
if (from._internal_has_reporting_population()) {
|
|
_internal_set_reporting_population(from._internal_reporting_population());
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(reporting_population_, other->reporting_population_);
|
|
}
|
|
|
|
std::string ChromeClientInfo::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ChromeClientInfo";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void Checksum::InitAsDefaultInstance() {
|
|
}
|
|
class Checksum::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<Checksum>()._has_bits_);
|
|
static void set_has_sha256(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
};
|
|
|
|
Checksum::Checksum()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.Checksum)
|
|
}
|
|
Checksum::Checksum(const Checksum& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
sha256_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_sha256()) {
|
|
sha256_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sha256_);
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Checksum)
|
|
}
|
|
|
|
void Checksum::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Checksum_safebrowsing_2eproto.base);
|
|
sha256_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
Checksum::~Checksum() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.Checksum)
|
|
SharedDtor();
|
|
}
|
|
|
|
void Checksum::SharedDtor() {
|
|
sha256_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void Checksum::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const Checksum& Checksum::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Checksum_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void Checksum::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.Checksum)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
sha256_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* Checksum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional bytes sha256 = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
|
|
auto str = _internal_mutable_sha256();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* Checksum::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.Checksum)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
// optional bytes sha256 = 1;
|
|
cached_has_bits = _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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void Checksum::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Checksum*>(
|
|
&from));
|
|
}
|
|
|
|
void Checksum::MergeFrom(const Checksum& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.Checksum)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
if (from._internal_has_sha256()) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
sha256_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sha256_);
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
sha256_.Swap(&other->sha256_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
}
|
|
|
|
std::string Checksum::GetTypeName() const {
|
|
return "mozilla.safebrowsing.Checksum";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatEntry::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatEntry::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatEntry>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntry)
|
|
}
|
|
ThreatEntry::ThreatEntry(const ThreatEntry& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_hash()) {
|
|
hash_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.hash_);
|
|
}
|
|
url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_url()) {
|
|
url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_);
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntry)
|
|
}
|
|
|
|
void ThreatEntry::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatEntry_safebrowsing_2eproto.base);
|
|
hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
ThreatEntry::~ThreatEntry() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntry)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatEntry::SharedDtor() {
|
|
hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void ThreatEntry::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatEntry& ThreatEntry::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatEntry_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatEntry::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntry)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
hash_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
url_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatEntry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional bytes hash = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
|
|
auto str = _internal_mutable_hash();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional string url = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
auto str = _internal_mutable_url();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatEntry::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntry)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatEntry::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatEntry*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatEntry::MergeFrom(const ThreatEntry& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntry)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
hash_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.hash_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_);
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
hash_.Swap(&other->hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
}
|
|
|
|
std::string ThreatEntry::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatEntry";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatEntrySet::InitAsDefaultInstance() {
|
|
::mozilla::safebrowsing::_ThreatEntrySet_default_instance_._instance.get_mutable()->raw_hashes_ = const_cast< ::mozilla::safebrowsing::RawHashes*>(
|
|
::mozilla::safebrowsing::RawHashes::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatEntrySet_default_instance_._instance.get_mutable()->raw_indices_ = const_cast< ::mozilla::safebrowsing::RawIndices*>(
|
|
::mozilla::safebrowsing::RawIndices::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatEntrySet_default_instance_._instance.get_mutable()->rice_hashes_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(
|
|
::mozilla::safebrowsing::RiceDeltaEncoding::internal_default_instance());
|
|
::mozilla::safebrowsing::_ThreatEntrySet_default_instance_._instance.get_mutable()->rice_indices_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(
|
|
::mozilla::safebrowsing::RiceDeltaEncoding::internal_default_instance());
|
|
}
|
|
class ThreatEntrySet::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatEntrySet>()._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->raw_hashes_;
|
|
}
|
|
const ::mozilla::safebrowsing::RawIndices&
|
|
ThreatEntrySet::_Internal::raw_indices(const ThreatEntrySet* msg) {
|
|
return *msg->raw_indices_;
|
|
}
|
|
const ::mozilla::safebrowsing::RiceDeltaEncoding&
|
|
ThreatEntrySet::_Internal::rice_hashes(const ThreatEntrySet* msg) {
|
|
return *msg->rice_hashes_;
|
|
}
|
|
const ::mozilla::safebrowsing::RiceDeltaEncoding&
|
|
ThreatEntrySet::_Internal::rice_indices(const ThreatEntrySet* msg) {
|
|
return *msg->rice_indices_;
|
|
}
|
|
ThreatEntrySet::ThreatEntrySet()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntrySet)
|
|
}
|
|
ThreatEntrySet::ThreatEntrySet(const ThreatEntrySet& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
if (from._internal_has_raw_hashes()) {
|
|
raw_hashes_ = new ::mozilla::safebrowsing::RawHashes(*from.raw_hashes_);
|
|
} else {
|
|
raw_hashes_ = nullptr;
|
|
}
|
|
if (from._internal_has_raw_indices()) {
|
|
raw_indices_ = new ::mozilla::safebrowsing::RawIndices(*from.raw_indices_);
|
|
} else {
|
|
raw_indices_ = nullptr;
|
|
}
|
|
if (from._internal_has_rice_hashes()) {
|
|
rice_hashes_ = new ::mozilla::safebrowsing::RiceDeltaEncoding(*from.rice_hashes_);
|
|
} else {
|
|
rice_hashes_ = nullptr;
|
|
}
|
|
if (from._internal_has_rice_indices()) {
|
|
rice_indices_ = new ::mozilla::safebrowsing::RiceDeltaEncoding(*from.rice_indices_);
|
|
} else {
|
|
rice_indices_ = nullptr;
|
|
}
|
|
compression_type_ = from.compression_type_;
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntrySet)
|
|
}
|
|
|
|
void ThreatEntrySet::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatEntrySet_safebrowsing_2eproto.base);
|
|
::memset(&raw_hashes_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&compression_type_) -
|
|
reinterpret_cast<char*>(&raw_hashes_)) + sizeof(compression_type_));
|
|
}
|
|
|
|
ThreatEntrySet::~ThreatEntrySet() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntrySet)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatEntrySet::SharedDtor() {
|
|
if (this != internal_default_instance()) delete raw_hashes_;
|
|
if (this != internal_default_instance()) delete raw_indices_;
|
|
if (this != internal_default_instance()) delete rice_hashes_;
|
|
if (this != internal_default_instance()) delete rice_indices_;
|
|
}
|
|
|
|
void ThreatEntrySet::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatEntrySet& ThreatEntrySet::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatEntrySet_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatEntrySet::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntrySet)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x0000000fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
GOOGLE_DCHECK(raw_hashes_ != nullptr);
|
|
raw_hashes_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
GOOGLE_DCHECK(raw_indices_ != nullptr);
|
|
raw_indices_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
GOOGLE_DCHECK(rice_hashes_ != nullptr);
|
|
rice_hashes_->Clear();
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
GOOGLE_DCHECK(rice_indices_ != nullptr);
|
|
rice_indices_->Clear();
|
|
}
|
|
}
|
|
compression_type_ = 0;
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatEntrySet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.CompressionType compression_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_rice_indices(), ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatEntrySet::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntrySet)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.CompressionType compression_type = 1;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->_internal_compression_type(), target);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
2, _Internal::raw_hashes(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::raw_indices(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
4, _Internal::rice_hashes(this), target, stream);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
5, _Internal::rice_indices(this), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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(
|
|
*raw_hashes_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*raw_indices_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*rice_hashes_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*rice_indices_);
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.CompressionType compression_type = 1;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_compression_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatEntrySet::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatEntrySet*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatEntrySet::MergeFrom(const ThreatEntrySet& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntrySet)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000001fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_internal_mutable_raw_hashes()->::mozilla::safebrowsing::RawHashes::MergeFrom(from._internal_raw_hashes());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_mutable_raw_indices()->::mozilla::safebrowsing::RawIndices::MergeFrom(from._internal_raw_indices());
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
_internal_mutable_rice_hashes()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom(from._internal_rice_hashes());
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
_internal_mutable_rice_indices()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom(from._internal_rice_indices());
|
|
}
|
|
if (cached_has_bits & 0x00000010u) {
|
|
compression_type_ = from.compression_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(raw_hashes_, other->raw_hashes_);
|
|
swap(raw_indices_, other->raw_indices_);
|
|
swap(rice_hashes_, other->rice_hashes_);
|
|
swap(rice_indices_, other->rice_indices_);
|
|
swap(compression_type_, other->compression_type_);
|
|
}
|
|
|
|
std::string ThreatEntrySet::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatEntrySet";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void RawIndices::InitAsDefaultInstance() {
|
|
}
|
|
class RawIndices::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<RawIndices>()._has_bits_);
|
|
};
|
|
|
|
RawIndices::RawIndices()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.RawIndices)
|
|
}
|
|
RawIndices::RawIndices(const RawIndices& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
indices_(from.indices_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawIndices)
|
|
}
|
|
|
|
void RawIndices::SharedCtor() {
|
|
}
|
|
|
|
RawIndices::~RawIndices() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawIndices)
|
|
SharedDtor();
|
|
}
|
|
|
|
void RawIndices::SharedDtor() {
|
|
}
|
|
|
|
void RawIndices::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const RawIndices& RawIndices::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RawIndices_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void RawIndices::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.RawIndices)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
indices_.Clear();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* RawIndices::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated int32 indices = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
ptr -= 1;
|
|
do {
|
|
ptr += 1;
|
|
_internal_add_indices(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
|
|
CHK_(ptr);
|
|
if (!ctx->DataAvailable(ptr)) break;
|
|
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
|
|
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_indices(), ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* RawIndices::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.RawIndices)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_indices(i), target);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
Int32Size(this->indices_);
|
|
total_size += 1 *
|
|
::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_indices_size());
|
|
total_size += data_size;
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void RawIndices::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RawIndices*>(
|
|
&from));
|
|
}
|
|
|
|
void RawIndices::MergeFrom(const RawIndices& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.RawIndices)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
indices_.MergeFrom(from.indices_);
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
indices_.InternalSwap(&other->indices_);
|
|
}
|
|
|
|
std::string RawIndices::GetTypeName() const {
|
|
return "mozilla.safebrowsing.RawIndices";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void RawHashes::InitAsDefaultInstance() {
|
|
}
|
|
class RawHashes::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<RawHashes>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.RawHashes)
|
|
}
|
|
RawHashes::RawHashes(const RawHashes& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
raw_hashes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_raw_hashes()) {
|
|
raw_hashes_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.raw_hashes_);
|
|
}
|
|
prefix_size_ = from.prefix_size_;
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawHashes)
|
|
}
|
|
|
|
void RawHashes::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RawHashes_safebrowsing_2eproto.base);
|
|
raw_hashes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
prefix_size_ = 0;
|
|
}
|
|
|
|
RawHashes::~RawHashes() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawHashes)
|
|
SharedDtor();
|
|
}
|
|
|
|
void RawHashes::SharedDtor() {
|
|
raw_hashes_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void RawHashes::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const RawHashes& RawHashes::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RawHashes_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void RawHashes::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.RawHashes)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
raw_hashes_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
prefix_size_ = 0;
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* RawHashes::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional int32 prefix_size = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
_Internal::set_has_prefix_size(&has_bits);
|
|
prefix_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional bytes raw_hashes = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
auto str = _internal_mutable_raw_hashes();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* RawHashes::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.RawHashes)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional int32 prefix_size = 1;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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 += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
|
|
this->_internal_prefix_size());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void RawHashes::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RawHashes*>(
|
|
&from));
|
|
}
|
|
|
|
void RawHashes::MergeFrom(const RawHashes& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.RawHashes)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
raw_hashes_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.raw_hashes_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
prefix_size_ = from.prefix_size_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
raw_hashes_.Swap(&other->raw_hashes_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
swap(prefix_size_, other->prefix_size_);
|
|
}
|
|
|
|
std::string RawHashes::GetTypeName() const {
|
|
return "mozilla.safebrowsing.RawHashes";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void RiceDeltaEncoding::InitAsDefaultInstance() {
|
|
}
|
|
class RiceDeltaEncoding::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<RiceDeltaEncoding>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.RiceDeltaEncoding)
|
|
}
|
|
RiceDeltaEncoding::RiceDeltaEncoding(const RiceDeltaEncoding& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
encoded_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_encoded_data()) {
|
|
encoded_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.encoded_data_);
|
|
}
|
|
::memcpy(&first_value_, &from.first_value_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&num_entries_) -
|
|
reinterpret_cast<char*>(&first_value_)) + sizeof(num_entries_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RiceDeltaEncoding)
|
|
}
|
|
|
|
void RiceDeltaEncoding::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RiceDeltaEncoding_safebrowsing_2eproto.base);
|
|
encoded_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
::memset(&first_value_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&num_entries_) -
|
|
reinterpret_cast<char*>(&first_value_)) + sizeof(num_entries_));
|
|
}
|
|
|
|
RiceDeltaEncoding::~RiceDeltaEncoding() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.RiceDeltaEncoding)
|
|
SharedDtor();
|
|
}
|
|
|
|
void RiceDeltaEncoding::SharedDtor() {
|
|
encoded_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void RiceDeltaEncoding::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const RiceDeltaEncoding& RiceDeltaEncoding::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RiceDeltaEncoding_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void RiceDeltaEncoding::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.RiceDeltaEncoding)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
encoded_data_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x0000000eu) {
|
|
::memset(&first_value_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&num_entries_) -
|
|
reinterpret_cast<char*>(&first_value_)) + sizeof(num_entries_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* RiceDeltaEncoding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional int64 first_value = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
_Internal::set_has_first_value(&has_bits);
|
|
first_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional int32 rice_parameter = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
_Internal::set_has_rice_parameter(&has_bits);
|
|
rice_parameter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional int32 num_entries = 3;
|
|
case 3:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
|
|
_Internal::set_has_num_entries(&has_bits);
|
|
num_entries_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional bytes encoded_data = 4;
|
|
case 4:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
|
|
auto str = _internal_mutable_encoded_data();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* RiceDeltaEncoding::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.RiceDeltaEncoding)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional int64 first_value = 1;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_first_value(), target);
|
|
}
|
|
|
|
// optional int32 rice_parameter = 2;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_rice_parameter(), target);
|
|
}
|
|
|
|
// optional int32 num_entries = 3;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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 += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
|
|
this->_internal_first_value());
|
|
}
|
|
|
|
// optional int32 rice_parameter = 2;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
|
|
this->_internal_rice_parameter());
|
|
}
|
|
|
|
// optional int32 num_entries = 3;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
|
|
this->_internal_num_entries());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void RiceDeltaEncoding::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RiceDeltaEncoding*>(
|
|
&from));
|
|
}
|
|
|
|
void RiceDeltaEncoding::MergeFrom(const RiceDeltaEncoding& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.RiceDeltaEncoding)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x0000000fu) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
encoded_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.encoded_data_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
first_value_ = from.first_value_;
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
rice_parameter_ = from.rice_parameter_;
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
num_entries_ = from.num_entries_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
encoded_data_.Swap(&other->encoded_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
swap(first_value_, other->first_value_);
|
|
swap(rice_parameter_, other->rice_parameter_);
|
|
swap(num_entries_, other->num_entries_);
|
|
}
|
|
|
|
std::string RiceDeltaEncoding::GetTypeName() const {
|
|
return "mozilla.safebrowsing.RiceDeltaEncoding";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatEntryMetadata_MetadataEntry::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatEntryMetadata_MetadataEntry>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
|
|
}
|
|
ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_key()) {
|
|
key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_);
|
|
}
|
|
value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
if (from._internal_has_value()) {
|
|
value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
|
|
}
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto.base);
|
|
key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
ThreatEntryMetadata_MetadataEntry::~ThreatEntryMetadata_MetadataEntry() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::SharedDtor() {
|
|
key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata_MetadataEntry::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatEntryMetadata_MetadataEntry_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
key_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
value_.ClearNonDefaultToEmptyNoArena();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatEntryMetadata_MetadataEntry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional bytes key = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
|
|
auto str = _internal_mutable_key();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional bytes value = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
|
|
auto str = _internal_mutable_value();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatEntryMetadata_MetadataEntry::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatEntryMetadata_MetadataEntry*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatEntryMetadata_MetadataEntry::MergeFrom(const ThreatEntryMetadata_MetadataEntry& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
}
|
|
|
|
std::string ThreatEntryMetadata_MetadataEntry::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatEntryMetadata::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatEntryMetadata::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatEntryMetadata>()._has_bits_);
|
|
};
|
|
|
|
ThreatEntryMetadata::ThreatEntryMetadata()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntryMetadata)
|
|
}
|
|
ThreatEntryMetadata::ThreatEntryMetadata(const ThreatEntryMetadata& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
entries_(from.entries_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata)
|
|
}
|
|
|
|
void ThreatEntryMetadata::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ThreatEntryMetadata_safebrowsing_2eproto.base);
|
|
}
|
|
|
|
ThreatEntryMetadata::~ThreatEntryMetadata() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatEntryMetadata::SharedDtor() {
|
|
}
|
|
|
|
void ThreatEntryMetadata::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatEntryMetadata& ThreatEntryMetadata::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatEntryMetadata_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatEntryMetadata::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatEntryMetadata)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
entries_.Clear();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatEntryMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatEntryMetadata::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatEntryMetadata)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_entries_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(1, this->_internal_entries(i), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatEntryMetadata::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatEntryMetadata*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatEntryMetadata::MergeFrom(const ThreatEntryMetadata& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatEntryMetadata)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
entries_.MergeFrom(from.entries_);
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
entries_.InternalSwap(&other->entries_);
|
|
}
|
|
|
|
std::string ThreatEntryMetadata::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatEntryMetadata";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ThreatListDescriptor::InitAsDefaultInstance() {
|
|
}
|
|
class ThreatListDescriptor::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ThreatListDescriptor>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatListDescriptor)
|
|
}
|
|
ThreatListDescriptor::ThreatListDescriptor(const ThreatListDescriptor& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::memcpy(&threat_type_, &from.threat_type_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatListDescriptor)
|
|
}
|
|
|
|
void ThreatListDescriptor::SharedCtor() {
|
|
::memset(&threat_type_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
}
|
|
|
|
ThreatListDescriptor::~ThreatListDescriptor() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatListDescriptor)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ThreatListDescriptor::SharedDtor() {
|
|
}
|
|
|
|
void ThreatListDescriptor::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ThreatListDescriptor& ThreatListDescriptor::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ThreatListDescriptor_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ThreatListDescriptor::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ThreatListDescriptor)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
::memset(&threat_type_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&threat_entry_type_) -
|
|
reinterpret_cast<char*>(&threat_type_)) + sizeof(threat_entry_type_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ThreatListDescriptor::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ThreatListDescriptor::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ThreatListDescriptor)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_platform_type());
|
|
}
|
|
|
|
// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_threat_entry_type());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ThreatListDescriptor::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ThreatListDescriptor*>(
|
|
&from));
|
|
}
|
|
|
|
void ThreatListDescriptor::MergeFrom(const ThreatListDescriptor& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ThreatListDescriptor)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000007u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
threat_type_ = from.threat_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
platform_type_ = from.platform_type_;
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
threat_entry_type_ = from.threat_entry_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(threat_type_, other->threat_type_);
|
|
swap(platform_type_, other->platform_type_);
|
|
swap(threat_entry_type_, other->threat_entry_type_);
|
|
}
|
|
|
|
std::string ThreatListDescriptor::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ThreatListDescriptor";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void ListThreatListsResponse::InitAsDefaultInstance() {
|
|
}
|
|
class ListThreatListsResponse::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ListThreatListsResponse>()._has_bits_);
|
|
};
|
|
|
|
ListThreatListsResponse::ListThreatListsResponse()
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.ListThreatListsResponse)
|
|
}
|
|
ListThreatListsResponse::ListThreatListsResponse(const ListThreatListsResponse& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_),
|
|
threat_lists_(from.threat_lists_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ListThreatListsResponse)
|
|
}
|
|
|
|
void ListThreatListsResponse::SharedCtor() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ListThreatListsResponse_safebrowsing_2eproto.base);
|
|
}
|
|
|
|
ListThreatListsResponse::~ListThreatListsResponse() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.ListThreatListsResponse)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ListThreatListsResponse::SharedDtor() {
|
|
}
|
|
|
|
void ListThreatListsResponse::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const ListThreatListsResponse& ListThreatListsResponse::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ListThreatListsResponse_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void ListThreatListsResponse::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.ListThreatListsResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
threat_lists_.Clear();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* ListThreatListsResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* ListThreatListsResponse::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.ListThreatListsResponse)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
// repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
|
|
for (unsigned int i = 0,
|
|
n = static_cast<unsigned int>(this->_internal_threat_lists_size()); i < n; i++) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(1, this->_internal_threat_lists(i), target, stream);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 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->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().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void ListThreatListsResponse::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ListThreatListsResponse*>(
|
|
&from));
|
|
}
|
|
|
|
void ListThreatListsResponse::MergeFrom(const ListThreatListsResponse& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.ListThreatListsResponse)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
threat_lists_.MergeFrom(from.threat_lists_);
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
threat_lists_.InternalSwap(&other->threat_lists_);
|
|
}
|
|
|
|
std::string ListThreatListsResponse::GetTypeName() const {
|
|
return "mozilla.safebrowsing.ListThreatListsResponse";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void Duration::InitAsDefaultInstance() {
|
|
}
|
|
class Duration::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<Duration>()._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::MessageLite(), _internal_metadata_(nullptr) {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:mozilla.safebrowsing.Duration)
|
|
}
|
|
Duration::Duration(const Duration& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_internal_metadata_(nullptr),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::memcpy(&seconds_, &from.seconds_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&nanos_) -
|
|
reinterpret_cast<char*>(&seconds_)) + sizeof(nanos_));
|
|
// @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Duration)
|
|
}
|
|
|
|
void Duration::SharedCtor() {
|
|
::memset(&seconds_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&nanos_) -
|
|
reinterpret_cast<char*>(&seconds_)) + sizeof(nanos_));
|
|
}
|
|
|
|
Duration::~Duration() {
|
|
// @@protoc_insertion_point(destructor:mozilla.safebrowsing.Duration)
|
|
SharedDtor();
|
|
}
|
|
|
|
void Duration::SharedDtor() {
|
|
}
|
|
|
|
void Duration::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
const Duration& Duration::default_instance() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Duration_safebrowsing_2eproto.base);
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
|
|
void Duration::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:mozilla.safebrowsing.Duration)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
::memset(&seconds_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&nanos_) -
|
|
reinterpret_cast<char*>(&seconds_)) + sizeof(nanos_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
const char* Duration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
::PROTOBUF_NAMESPACE_ID::uint32 tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
CHK_(ptr);
|
|
switch (tag >> 3) {
|
|
// optional int64 seconds = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
|
|
_Internal::set_has_seconds(&has_bits);
|
|
seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
// optional int32 nanos = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
|
|
_Internal::set_has_nanos(&has_bits);
|
|
nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
|
|
CHK_(ptr);
|
|
} else goto handle_unusual;
|
|
continue;
|
|
default: {
|
|
handle_unusual:
|
|
if ((tag & 7) == 4 || tag == 0) {
|
|
ctx->SetLastTag(tag);
|
|
goto success;
|
|
}
|
|
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
|
|
CHK_(ptr != nullptr);
|
|
continue;
|
|
}
|
|
} // switch
|
|
} // while
|
|
success:
|
|
_has_bits_.Or(has_bits);
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto success;
|
|
#undef CHK_
|
|
}
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint8* Duration::_InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:mozilla.safebrowsing.Duration)
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional int64 seconds = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_seconds(), target);
|
|
}
|
|
|
|
// optional int32 nanos = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_nanos(), target);
|
|
}
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
|
|
static_cast<int>(_internal_metadata_.unknown_fields().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;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
// optional int64 seconds = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
|
|
this->_internal_seconds());
|
|
}
|
|
|
|
// optional int32 nanos = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
|
|
this->_internal_nanos());
|
|
}
|
|
|
|
}
|
|
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
|
total_size += _internal_metadata_.unknown_fields().size();
|
|
}
|
|
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
|
|
SetCachedSize(cached_size);
|
|
return total_size;
|
|
}
|
|
|
|
void Duration::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Duration*>(
|
|
&from));
|
|
}
|
|
|
|
void Duration::MergeFrom(const Duration& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.safebrowsing.Duration)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 0x00000003u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
seconds_ = from.seconds_;
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
nanos_ = from.nanos_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
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_.Swap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(seconds_, other->seconds_);
|
|
swap(nanos_, other->nanos_);
|
|
}
|
|
|
|
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::CreateInternal< ::mozilla::safebrowsing::ThreatInfo >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatMatch* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatMatch >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatMatch >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindThreatMatchesRequest* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindThreatMatchesRequest >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FindThreatMatchesRequest >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindThreatMatchesResponse* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindThreatMatchesResponse >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FindThreatMatchesResponse >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesRequest* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FetchThreatListUpdatesResponse* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindFullHashesRequest* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindFullHashesRequest >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FindFullHashesRequest >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::FindFullHashesResponse* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::FindFullHashesResponse >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::FindFullHashesResponse >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatHit_ThreatSource* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatHit_ThreatSource >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatHit_ThreatSource >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatHit_UserInfo* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatHit_UserInfo >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatHit_UserInfo >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatHit* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatHit >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatHit >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ClientInfo* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ClientInfo >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ClientInfo >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ChromeClientInfo* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ChromeClientInfo >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ChromeClientInfo >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::Checksum* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::Checksum >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::Checksum >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntry* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntry >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatEntry >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntrySet* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntrySet >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatEntrySet >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::RawIndices* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::RawIndices >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::RawIndices >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::RawHashes* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::RawHashes >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::RawHashes >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::RiceDeltaEncoding* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::RiceDeltaEncoding >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::RiceDeltaEncoding >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatEntryMetadata* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatEntryMetadata >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatEntryMetadata >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ThreatListDescriptor* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ThreatListDescriptor >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ThreatListDescriptor >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::ListThreatListsResponse* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::ListThreatListsResponse >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::ListThreatListsResponse >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::mozilla::safebrowsing::Duration* Arena::CreateMaybeMessage< ::mozilla::safebrowsing::Duration >(Arena* arena) {
|
|
return Arena::CreateInternal< ::mozilla::safebrowsing::Duration >(arena);
|
|
}
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
#include <google/protobuf/port_undef.inc>
|