mozilla-central/toolkit/components/url-classifier/chromium/safebrowsing_v5.pb.h (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: safebrowsing_v5.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_safebrowsing_5fv5_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_safebrowsing_5fv5_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_safebrowsing_5fv5_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_safebrowsing_5fv5_2eproto {
static const uint32_t offsets[];
};
namespace mozilla {
namespace safebrowsing {
namespace v5 {
class BatchGetHashListsRequest;
struct BatchGetHashListsRequestDefaultTypeInternal;
extern BatchGetHashListsRequestDefaultTypeInternal _BatchGetHashListsRequest_default_instance_;
class BatchGetHashListsResponse;
struct BatchGetHashListsResponseDefaultTypeInternal;
extern BatchGetHashListsResponseDefaultTypeInternal _BatchGetHashListsResponse_default_instance_;
class Duration;
struct DurationDefaultTypeInternal;
extern DurationDefaultTypeInternal _Duration_default_instance_;
class FullHash;
struct FullHashDefaultTypeInternal;
extern FullHashDefaultTypeInternal _FullHash_default_instance_;
class FullHash_FullHashDetail;
struct FullHash_FullHashDetailDefaultTypeInternal;
extern FullHash_FullHashDetailDefaultTypeInternal _FullHash_FullHashDetail_default_instance_;
class GetHashListRequest;
struct GetHashListRequestDefaultTypeInternal;
extern GetHashListRequestDefaultTypeInternal _GetHashListRequest_default_instance_;
class HashList;
struct HashListDefaultTypeInternal;
extern HashListDefaultTypeInternal _HashList_default_instance_;
class HashListMetadata;
struct HashListMetadataDefaultTypeInternal;
extern HashListMetadataDefaultTypeInternal _HashListMetadata_default_instance_;
class ListHashListsRequest;
struct ListHashListsRequestDefaultTypeInternal;
extern ListHashListsRequestDefaultTypeInternal _ListHashListsRequest_default_instance_;
class ListHashListsResponse;
struct ListHashListsResponseDefaultTypeInternal;
extern ListHashListsResponseDefaultTypeInternal _ListHashListsResponse_default_instance_;
class RiceDeltaEncoded128Bit;
struct RiceDeltaEncoded128BitDefaultTypeInternal;
extern RiceDeltaEncoded128BitDefaultTypeInternal _RiceDeltaEncoded128Bit_default_instance_;
class RiceDeltaEncoded256Bit;
struct RiceDeltaEncoded256BitDefaultTypeInternal;
extern RiceDeltaEncoded256BitDefaultTypeInternal _RiceDeltaEncoded256Bit_default_instance_;
class RiceDeltaEncoded32Bit;
struct RiceDeltaEncoded32BitDefaultTypeInternal;
extern RiceDeltaEncoded32BitDefaultTypeInternal _RiceDeltaEncoded32Bit_default_instance_;
class RiceDeltaEncoded64Bit;
struct RiceDeltaEncoded64BitDefaultTypeInternal;
extern RiceDeltaEncoded64BitDefaultTypeInternal _RiceDeltaEncoded64Bit_default_instance_;
class SearchHashesRequest;
struct SearchHashesRequestDefaultTypeInternal;
extern SearchHashesRequestDefaultTypeInternal _SearchHashesRequest_default_instance_;
class SearchHashesResponse;
struct SearchHashesResponseDefaultTypeInternal;
extern SearchHashesResponseDefaultTypeInternal _SearchHashesResponse_default_instance_;
class SizeConstraints;
struct SizeConstraintsDefaultTypeInternal;
extern SizeConstraintsDefaultTypeInternal _SizeConstraints_default_instance_;
} // namespace v5
} // namespace safebrowsing
} // namespace mozilla
PROTOBUF_NAMESPACE_OPEN
template<> ::mozilla::safebrowsing::v5::BatchGetHashListsRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::BatchGetHashListsRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::BatchGetHashListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::BatchGetHashListsResponse>(Arena*);
template<> ::mozilla::safebrowsing::v5::Duration* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::Duration>(Arena*);
template<> ::mozilla::safebrowsing::v5::FullHash* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::FullHash>(Arena*);
template<> ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::FullHash_FullHashDetail>(Arena*);
template<> ::mozilla::safebrowsing::v5::GetHashListRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::GetHashListRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::HashList* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::HashList>(Arena*);
template<> ::mozilla::safebrowsing::v5::HashListMetadata* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::HashListMetadata>(Arena*);
template<> ::mozilla::safebrowsing::v5::ListHashListsRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::ListHashListsRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::ListHashListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::ListHashListsResponse>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::SearchHashesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::SearchHashesRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::SearchHashesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::SearchHashesResponse>(Arena*);
template<> ::mozilla::safebrowsing::v5::SizeConstraints* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::SizeConstraints>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace mozilla {
namespace safebrowsing {
namespace v5 {
enum HashListMetadata_HashLength : int {
HashListMetadata_HashLength_HASH_LENGTH_UNSPECIFIED = 0,
HashListMetadata_HashLength_FOUR_BYTES = 2,
HashListMetadata_HashLength_EIGHT_BYTES = 3,
HashListMetadata_HashLength_SIXTEEN_BYTES = 4,
HashListMetadata_HashLength_THIRTY_TWO_BYTES = 5,
HashListMetadata_HashLength_HashListMetadata_HashLength_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
HashListMetadata_HashLength_HashListMetadata_HashLength_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool HashListMetadata_HashLength_IsValid(int value);
constexpr HashListMetadata_HashLength HashListMetadata_HashLength_HashLength_MIN = HashListMetadata_HashLength_HASH_LENGTH_UNSPECIFIED;
constexpr HashListMetadata_HashLength HashListMetadata_HashLength_HashLength_MAX = HashListMetadata_HashLength_THIRTY_TWO_BYTES;
constexpr int HashListMetadata_HashLength_HashLength_ARRAYSIZE = HashListMetadata_HashLength_HashLength_MAX + 1;
const std::string& HashListMetadata_HashLength_Name(HashListMetadata_HashLength value);
template<typename T>
inline const std::string& HashListMetadata_HashLength_Name(T enum_t_value) {
static_assert(::std::is_same<T, HashListMetadata_HashLength>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function HashListMetadata_HashLength_Name.");
return HashListMetadata_HashLength_Name(static_cast<HashListMetadata_HashLength>(enum_t_value));
}
bool HashListMetadata_HashLength_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HashListMetadata_HashLength* value);
enum ThreatType : int {
THREAT_TYPE_UNSPECIFIED = 0,
MALWARE = 1,
SOCIAL_ENGINEERING = 2,
UNWANTED_SOFTWARE = 3,
POTENTIALLY_HARMFUL_APPLICATION = 4,
ThreatType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
ThreatType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ThreatType_IsValid(int value);
constexpr ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED;
constexpr ThreatType ThreatType_MAX = POTENTIALLY_HARMFUL_APPLICATION;
constexpr int ThreatType_ARRAYSIZE = ThreatType_MAX + 1;
const std::string& ThreatType_Name(ThreatType value);
template<typename T>
inline const std::string& ThreatType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ThreatType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ThreatType_Name.");
return ThreatType_Name(static_cast<ThreatType>(enum_t_value));
}
bool ThreatType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatType* value);
enum LikelySafeType : int {
LIKELY_SAFE_TYPE_UNSPECIFIED = 0,
GENERAL_BROWSING = 1,
CSD = 2,
DOWNLOAD = 3,
LikelySafeType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
LikelySafeType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool LikelySafeType_IsValid(int value);
constexpr LikelySafeType LikelySafeType_MIN = LIKELY_SAFE_TYPE_UNSPECIFIED;
constexpr LikelySafeType LikelySafeType_MAX = DOWNLOAD;
constexpr int LikelySafeType_ARRAYSIZE = LikelySafeType_MAX + 1;
const std::string& LikelySafeType_Name(LikelySafeType value);
template<typename T>
inline const std::string& LikelySafeType_Name(T enum_t_value) {
static_assert(::std::is_same<T, LikelySafeType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LikelySafeType_Name.");
return LikelySafeType_Name(static_cast<LikelySafeType>(enum_t_value));
}
bool LikelySafeType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LikelySafeType* value);
enum ThreatAttribute : int {
THREAT_ATTRIBUTE_UNSPECIFIED = 0,
CANARY = 1,
FRAME_ONLY = 2,
ThreatAttribute_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
ThreatAttribute_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ThreatAttribute_IsValid(int value);
constexpr ThreatAttribute ThreatAttribute_MIN = THREAT_ATTRIBUTE_UNSPECIFIED;
constexpr ThreatAttribute ThreatAttribute_MAX = FRAME_ONLY;
constexpr int ThreatAttribute_ARRAYSIZE = ThreatAttribute_MAX + 1;
const std::string& ThreatAttribute_Name(ThreatAttribute value);
template<typename T>
inline const std::string& ThreatAttribute_Name(T enum_t_value) {
static_assert(::std::is_same<T, ThreatAttribute>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ThreatAttribute_Name.");
return ThreatAttribute_Name(static_cast<ThreatAttribute>(enum_t_value));
}
bool ThreatAttribute_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatAttribute* value);
// ===================================================================
class SearchHashesRequest final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.SearchHashesRequest) */ {
public:
inline SearchHashesRequest() : SearchHashesRequest(nullptr) {}
~SearchHashesRequest() override;
explicit PROTOBUF_CONSTEXPR SearchHashesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SearchHashesRequest(const SearchHashesRequest& from);
SearchHashesRequest(SearchHashesRequest&& from) noexcept
: SearchHashesRequest() {
*this = ::std::move(from);
}
inline SearchHashesRequest& operator=(const SearchHashesRequest& from) {
CopyFrom(from);
return *this;
}
inline SearchHashesRequest& operator=(SearchHashesRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const SearchHashesRequest& default_instance() {
return *internal_default_instance();
}
static inline const SearchHashesRequest* internal_default_instance() {
return reinterpret_cast<const SearchHashesRequest*>(
&_SearchHashesRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(SearchHashesRequest& a, SearchHashesRequest& b) {
a.Swap(&b);
}
inline void Swap(SearchHashesRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SearchHashesRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SearchHashesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SearchHashesRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const SearchHashesRequest& from);
void MergeFrom(const SearchHashesRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(SearchHashesRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.SearchHashesRequest";
}
protected:
explicit SearchHashesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHashPrefixesFieldNumber = 1,
};
// repeated bytes hash_prefixes = 1;
int hash_prefixes_size() const;
private:
int _internal_hash_prefixes_size() const;
public:
void clear_hash_prefixes();
const std::string& hash_prefixes(int index) const;
std::string* mutable_hash_prefixes(int index);
void set_hash_prefixes(int index, const std::string& value);
void set_hash_prefixes(int index, std::string&& value);
void set_hash_prefixes(int index, const char* value);
void set_hash_prefixes(int index, const void* value, size_t size);
std::string* add_hash_prefixes();
void add_hash_prefixes(const std::string& value);
void add_hash_prefixes(std::string&& value);
void add_hash_prefixes(const char* value);
void add_hash_prefixes(const void* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& hash_prefixes() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_hash_prefixes();
private:
const std::string& _internal_hash_prefixes(int index) const;
std::string* _internal_add_hash_prefixes();
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.SearchHashesRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> hash_prefixes_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class Duration final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.Duration) */ {
public:
inline Duration() : Duration(nullptr) {}
~Duration() override;
explicit PROTOBUF_CONSTEXPR Duration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Duration(const Duration& from);
Duration(Duration&& from) noexcept
: Duration() {
*this = ::std::move(from);
}
inline Duration& operator=(const Duration& from) {
CopyFrom(from);
return *this;
}
inline Duration& operator=(Duration&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const Duration& default_instance() {
return *internal_default_instance();
}
static inline const Duration* internal_default_instance() {
return reinterpret_cast<const Duration*>(
&_Duration_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(Duration& a, Duration& b) {
a.Swap(&b);
}
inline void Swap(Duration* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Duration* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Duration>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const Duration& from);
void MergeFrom(const Duration& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(Duration* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.Duration";
}
protected:
explicit Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSecondsFieldNumber = 1,
kNanosFieldNumber = 2,
};
// int64 seconds = 1;
void clear_seconds();
int64_t seconds() const;
void set_seconds(int64_t value);
private:
int64_t _internal_seconds() const;
void _internal_set_seconds(int64_t value);
public:
// int32 nanos = 2;
void clear_nanos();
int32_t nanos() const;
void set_nanos(int32_t value);
private:
int32_t _internal_nanos() const;
void _internal_set_nanos(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.Duration)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int64_t seconds_;
int32_t nanos_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class SearchHashesResponse final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.SearchHashesResponse) */ {
public:
inline SearchHashesResponse() : SearchHashesResponse(nullptr) {}
~SearchHashesResponse() override;
explicit PROTOBUF_CONSTEXPR SearchHashesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SearchHashesResponse(const SearchHashesResponse& from);
SearchHashesResponse(SearchHashesResponse&& from) noexcept
: SearchHashesResponse() {
*this = ::std::move(from);
}
inline SearchHashesResponse& operator=(const SearchHashesResponse& from) {
CopyFrom(from);
return *this;
}
inline SearchHashesResponse& operator=(SearchHashesResponse&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const SearchHashesResponse& default_instance() {
return *internal_default_instance();
}
static inline const SearchHashesResponse* internal_default_instance() {
return reinterpret_cast<const SearchHashesResponse*>(
&_SearchHashesResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(SearchHashesResponse& a, SearchHashesResponse& b) {
a.Swap(&b);
}
inline void Swap(SearchHashesResponse* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SearchHashesResponse* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SearchHashesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SearchHashesResponse>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const SearchHashesResponse& from);
void MergeFrom(const SearchHashesResponse& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(SearchHashesResponse* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.SearchHashesResponse";
}
protected:
explicit SearchHashesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFullHashesFieldNumber = 1,
kCacheDurationFieldNumber = 2,
};
// repeated .mozilla.safebrowsing.v5.FullHash full_hashes = 1;
int full_hashes_size() const;
private:
int _internal_full_hashes_size() const;
public:
void clear_full_hashes();
::mozilla::safebrowsing::v5::FullHash* mutable_full_hashes(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >*
mutable_full_hashes();
private:
const ::mozilla::safebrowsing::v5::FullHash& _internal_full_hashes(int index) const;
::mozilla::safebrowsing::v5::FullHash* _internal_add_full_hashes();
public:
const ::mozilla::safebrowsing::v5::FullHash& full_hashes(int index) const;
::mozilla::safebrowsing::v5::FullHash* add_full_hashes();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >&
full_hashes() const;
// .mozilla.safebrowsing.v5.Duration cache_duration = 2;
bool has_cache_duration() const;
private:
bool _internal_has_cache_duration() const;
public:
void clear_cache_duration();
const ::mozilla::safebrowsing::v5::Duration& cache_duration() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::Duration* release_cache_duration();
::mozilla::safebrowsing::v5::Duration* mutable_cache_duration();
void set_allocated_cache_duration(::mozilla::safebrowsing::v5::Duration* cache_duration);
private:
const ::mozilla::safebrowsing::v5::Duration& _internal_cache_duration() const;
::mozilla::safebrowsing::v5::Duration* _internal_mutable_cache_duration();
public:
void unsafe_arena_set_allocated_cache_duration(
::mozilla::safebrowsing::v5::Duration* cache_duration);
::mozilla::safebrowsing::v5::Duration* unsafe_arena_release_cache_duration();
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.SearchHashesResponse)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash > full_hashes_;
::mozilla::safebrowsing::v5::Duration* cache_duration_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class FullHash_FullHashDetail final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.FullHash.FullHashDetail) */ {
public:
inline FullHash_FullHashDetail() : FullHash_FullHashDetail(nullptr) {}
~FullHash_FullHashDetail() override;
explicit PROTOBUF_CONSTEXPR FullHash_FullHashDetail(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FullHash_FullHashDetail(const FullHash_FullHashDetail& from);
FullHash_FullHashDetail(FullHash_FullHashDetail&& from) noexcept
: FullHash_FullHashDetail() {
*this = ::std::move(from);
}
inline FullHash_FullHashDetail& operator=(const FullHash_FullHashDetail& from) {
CopyFrom(from);
return *this;
}
inline FullHash_FullHashDetail& operator=(FullHash_FullHashDetail&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const FullHash_FullHashDetail& default_instance() {
return *internal_default_instance();
}
static inline const FullHash_FullHashDetail* internal_default_instance() {
return reinterpret_cast<const FullHash_FullHashDetail*>(
&_FullHash_FullHashDetail_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(FullHash_FullHashDetail& a, FullHash_FullHashDetail& b) {
a.Swap(&b);
}
inline void Swap(FullHash_FullHashDetail* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FullHash_FullHashDetail* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FullHash_FullHashDetail* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FullHash_FullHashDetail>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const FullHash_FullHashDetail& from);
void MergeFrom(const FullHash_FullHashDetail& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(FullHash_FullHashDetail* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.FullHash.FullHashDetail";
}
protected:
explicit FullHash_FullHashDetail(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAttributesFieldNumber = 2,
kThreatTypeFieldNumber = 1,
};
// repeated .mozilla.safebrowsing.v5.ThreatAttribute attributes = 2;
int attributes_size() const;
private:
int _internal_attributes_size() const;
public:
void clear_attributes();
private:
::mozilla::safebrowsing::v5::ThreatAttribute _internal_attributes(int index) const;
void _internal_add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value);
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_attributes();
public:
::mozilla::safebrowsing::v5::ThreatAttribute attributes(int index) const;
void set_attributes(int index, ::mozilla::safebrowsing::v5::ThreatAttribute value);
void add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& attributes() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_attributes();
// .mozilla.safebrowsing.v5.ThreatType threat_type = 1;
void clear_threat_type();
::mozilla::safebrowsing::v5::ThreatType threat_type() const;
void set_threat_type(::mozilla::safebrowsing::v5::ThreatType value);
private:
::mozilla::safebrowsing::v5::ThreatType _internal_threat_type() const;
void _internal_set_threat_type(::mozilla::safebrowsing::v5::ThreatType value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.FullHash.FullHashDetail)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> attributes_;
mutable std::atomic<int> _attributes_cached_byte_size_;
int threat_type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class FullHash final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.FullHash) */ {
public:
inline FullHash() : FullHash(nullptr) {}
~FullHash() override;
explicit PROTOBUF_CONSTEXPR FullHash(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FullHash(const FullHash& from);
FullHash(FullHash&& from) noexcept
: FullHash() {
*this = ::std::move(from);
}
inline FullHash& operator=(const FullHash& from) {
CopyFrom(from);
return *this;
}
inline FullHash& operator=(FullHash&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const FullHash& default_instance() {
return *internal_default_instance();
}
static inline const FullHash* internal_default_instance() {
return reinterpret_cast<const FullHash*>(
&_FullHash_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(FullHash& a, FullHash& b) {
a.Swap(&b);
}
inline void Swap(FullHash* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FullHash* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FullHash* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FullHash>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const FullHash& from);
void MergeFrom(const FullHash& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(FullHash* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.FullHash";
}
protected:
explicit FullHash(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef FullHash_FullHashDetail FullHashDetail;
// accessors -------------------------------------------------------
enum : int {
kFullHashDetailsFieldNumber = 2,
kFullHashFieldNumber = 1,
};
// repeated .mozilla.safebrowsing.v5.FullHash.FullHashDetail full_hash_details = 2;
int full_hash_details_size() const;
private:
int _internal_full_hash_details_size() const;
public:
void clear_full_hash_details();
::mozilla::safebrowsing::v5::FullHash_FullHashDetail* mutable_full_hash_details(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >*
mutable_full_hash_details();
private:
const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& _internal_full_hash_details(int index) const;
::mozilla::safebrowsing::v5::FullHash_FullHashDetail* _internal_add_full_hash_details();
public:
const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& full_hash_details(int index) const;
::mozilla::safebrowsing::v5::FullHash_FullHashDetail* add_full_hash_details();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >&
full_hash_details() const;
// bytes full_hash = 1;
void clear_full_hash();
const std::string& full_hash() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_full_hash(ArgT0&& arg0, ArgT... args);
std::string* mutable_full_hash();
PROTOBUF_NODISCARD std::string* release_full_hash();
void set_allocated_full_hash(std::string* full_hash);
private:
const std::string& _internal_full_hash() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_full_hash(const std::string& value);
std::string* _internal_mutable_full_hash();
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.FullHash)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail > full_hash_details_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr full_hash_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class GetHashListRequest final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.GetHashListRequest) */ {
public:
inline GetHashListRequest() : GetHashListRequest(nullptr) {}
~GetHashListRequest() override;
explicit PROTOBUF_CONSTEXPR GetHashListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
GetHashListRequest(const GetHashListRequest& from);
GetHashListRequest(GetHashListRequest&& from) noexcept
: GetHashListRequest() {
*this = ::std::move(from);
}
inline GetHashListRequest& operator=(const GetHashListRequest& from) {
CopyFrom(from);
return *this;
}
inline GetHashListRequest& operator=(GetHashListRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const GetHashListRequest& default_instance() {
return *internal_default_instance();
}
static inline const GetHashListRequest* internal_default_instance() {
return reinterpret_cast<const GetHashListRequest*>(
&_GetHashListRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(GetHashListRequest& a, GetHashListRequest& b) {
a.Swap(&b);
}
inline void Swap(GetHashListRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(GetHashListRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
GetHashListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<GetHashListRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const GetHashListRequest& from);
void MergeFrom(const GetHashListRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(GetHashListRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.GetHashListRequest";
}
protected:
explicit GetHashListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kVersionFieldNumber = 2,
kSizeConstraintsFieldNumber = 4,
};
// string name = 1;
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// bytes version = 2;
void clear_version();
const std::string& version() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_version(ArgT0&& arg0, ArgT... args);
std::string* mutable_version();
PROTOBUF_NODISCARD std::string* release_version();
void set_allocated_version(std::string* version);
private:
const std::string& _internal_version() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
std::string* _internal_mutable_version();
public:
// .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
bool has_size_constraints() const;
private:
bool _internal_has_size_constraints() const;
public:
void clear_size_constraints();
const ::mozilla::safebrowsing::v5::SizeConstraints& size_constraints() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::SizeConstraints* release_size_constraints();
::mozilla::safebrowsing::v5::SizeConstraints* mutable_size_constraints();
void set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
private:
const ::mozilla::safebrowsing::v5::SizeConstraints& _internal_size_constraints() const;
::mozilla::safebrowsing::v5::SizeConstraints* _internal_mutable_size_constraints();
public:
void unsafe_arena_set_allocated_size_constraints(
::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
::mozilla::safebrowsing::v5::SizeConstraints* unsafe_arena_release_size_constraints();
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.GetHashListRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
::mozilla::safebrowsing::v5::SizeConstraints* size_constraints_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class SizeConstraints final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.SizeConstraints) */ {
public:
inline SizeConstraints() : SizeConstraints(nullptr) {}
~SizeConstraints() override;
explicit PROTOBUF_CONSTEXPR SizeConstraints(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SizeConstraints(const SizeConstraints& from);
SizeConstraints(SizeConstraints&& from) noexcept
: SizeConstraints() {
*this = ::std::move(from);
}
inline SizeConstraints& operator=(const SizeConstraints& from) {
CopyFrom(from);
return *this;
}
inline SizeConstraints& operator=(SizeConstraints&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const SizeConstraints& default_instance() {
return *internal_default_instance();
}
static inline const SizeConstraints* internal_default_instance() {
return reinterpret_cast<const SizeConstraints*>(
&_SizeConstraints_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(SizeConstraints& a, SizeConstraints& b) {
a.Swap(&b);
}
inline void Swap(SizeConstraints* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SizeConstraints* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SizeConstraints* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SizeConstraints>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const SizeConstraints& from);
void MergeFrom(const SizeConstraints& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(SizeConstraints* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.SizeConstraints";
}
protected:
explicit SizeConstraints(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMaxUpdateEntriesFieldNumber = 1,
kMaxDatabaseEntriesFieldNumber = 2,
};
// int32 max_update_entries = 1;
void clear_max_update_entries();
int32_t max_update_entries() const;
void set_max_update_entries(int32_t value);
private:
int32_t _internal_max_update_entries() const;
void _internal_set_max_update_entries(int32_t value);
public:
// int32 max_database_entries = 2;
void clear_max_database_entries();
int32_t max_database_entries() const;
void set_max_database_entries(int32_t value);
private:
int32_t _internal_max_database_entries() const;
void _internal_set_max_database_entries(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.SizeConstraints)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int32_t max_update_entries_;
int32_t max_database_entries_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class RiceDeltaEncoded32Bit final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit) */ {
public:
inline RiceDeltaEncoded32Bit() : RiceDeltaEncoded32Bit(nullptr) {}
~RiceDeltaEncoded32Bit() override;
explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded32Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RiceDeltaEncoded32Bit(const RiceDeltaEncoded32Bit& from);
RiceDeltaEncoded32Bit(RiceDeltaEncoded32Bit&& from) noexcept
: RiceDeltaEncoded32Bit() {
*this = ::std::move(from);
}
inline RiceDeltaEncoded32Bit& operator=(const RiceDeltaEncoded32Bit& from) {
CopyFrom(from);
return *this;
}
inline RiceDeltaEncoded32Bit& operator=(RiceDeltaEncoded32Bit&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const RiceDeltaEncoded32Bit& default_instance() {
return *internal_default_instance();
}
static inline const RiceDeltaEncoded32Bit* internal_default_instance() {
return reinterpret_cast<const RiceDeltaEncoded32Bit*>(
&_RiceDeltaEncoded32Bit_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(RiceDeltaEncoded32Bit& a, RiceDeltaEncoded32Bit& b) {
a.Swap(&b);
}
inline void Swap(RiceDeltaEncoded32Bit* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RiceDeltaEncoded32Bit* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RiceDeltaEncoded32Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RiceDeltaEncoded32Bit>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const RiceDeltaEncoded32Bit& from);
void MergeFrom(const RiceDeltaEncoded32Bit& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(RiceDeltaEncoded32Bit* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit";
}
protected:
explicit RiceDeltaEncoded32Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kEncodedDataFieldNumber = 4,
kFirstValueFieldNumber = 1,
kRiceParameterFieldNumber = 2,
kEntriesCountFieldNumber = 3,
};
// bytes encoded_data = 4;
void clear_encoded_data();
const std::string& encoded_data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_encoded_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_encoded_data();
PROTOBUF_NODISCARD std::string* release_encoded_data();
void set_allocated_encoded_data(std::string* encoded_data);
private:
const std::string& _internal_encoded_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
std::string* _internal_mutable_encoded_data();
public:
// uint32 first_value = 1;
void clear_first_value();
uint32_t first_value() const;
void set_first_value(uint32_t value);
private:
uint32_t _internal_first_value() const;
void _internal_set_first_value(uint32_t value);
public:
// int32 rice_parameter = 2;
void clear_rice_parameter();
int32_t rice_parameter() const;
void set_rice_parameter(int32_t value);
private:
int32_t _internal_rice_parameter() const;
void _internal_set_rice_parameter(int32_t value);
public:
// int32 entries_count = 3;
void clear_entries_count();
int32_t entries_count() const;
void set_entries_count(int32_t value);
private:
int32_t _internal_entries_count() const;
void _internal_set_entries_count(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
uint32_t first_value_;
int32_t rice_parameter_;
int32_t entries_count_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class RiceDeltaEncoded64Bit final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit) */ {
public:
inline RiceDeltaEncoded64Bit() : RiceDeltaEncoded64Bit(nullptr) {}
~RiceDeltaEncoded64Bit() override;
explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded64Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RiceDeltaEncoded64Bit(const RiceDeltaEncoded64Bit& from);
RiceDeltaEncoded64Bit(RiceDeltaEncoded64Bit&& from) noexcept
: RiceDeltaEncoded64Bit() {
*this = ::std::move(from);
}
inline RiceDeltaEncoded64Bit& operator=(const RiceDeltaEncoded64Bit& from) {
CopyFrom(from);
return *this;
}
inline RiceDeltaEncoded64Bit& operator=(RiceDeltaEncoded64Bit&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const RiceDeltaEncoded64Bit& default_instance() {
return *internal_default_instance();
}
static inline const RiceDeltaEncoded64Bit* internal_default_instance() {
return reinterpret_cast<const RiceDeltaEncoded64Bit*>(
&_RiceDeltaEncoded64Bit_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(RiceDeltaEncoded64Bit& a, RiceDeltaEncoded64Bit& b) {
a.Swap(&b);
}
inline void Swap(RiceDeltaEncoded64Bit* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RiceDeltaEncoded64Bit* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RiceDeltaEncoded64Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RiceDeltaEncoded64Bit>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const RiceDeltaEncoded64Bit& from);
void MergeFrom(const RiceDeltaEncoded64Bit& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(RiceDeltaEncoded64Bit* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit";
}
protected:
explicit RiceDeltaEncoded64Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kEncodedDataFieldNumber = 4,
kFirstValueFieldNumber = 1,
kRiceParameterFieldNumber = 2,
kEntriesCountFieldNumber = 3,
};
// bytes encoded_data = 4;
void clear_encoded_data();
const std::string& encoded_data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_encoded_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_encoded_data();
PROTOBUF_NODISCARD std::string* release_encoded_data();
void set_allocated_encoded_data(std::string* encoded_data);
private:
const std::string& _internal_encoded_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
std::string* _internal_mutable_encoded_data();
public:
// uint64 first_value = 1;
void clear_first_value();
uint64_t first_value() const;
void set_first_value(uint64_t value);
private:
uint64_t _internal_first_value() const;
void _internal_set_first_value(uint64_t value);
public:
// int32 rice_parameter = 2;
void clear_rice_parameter();
int32_t rice_parameter() const;
void set_rice_parameter(int32_t value);
private:
int32_t _internal_rice_parameter() const;
void _internal_set_rice_parameter(int32_t value);
public:
// int32 entries_count = 3;
void clear_entries_count();
int32_t entries_count() const;
void set_entries_count(int32_t value);
private:
int32_t _internal_entries_count() const;
void _internal_set_entries_count(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
uint64_t first_value_;
int32_t rice_parameter_;
int32_t entries_count_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class RiceDeltaEncoded128Bit final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit) */ {
public:
inline RiceDeltaEncoded128Bit() : RiceDeltaEncoded128Bit(nullptr) {}
~RiceDeltaEncoded128Bit() override;
explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded128Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RiceDeltaEncoded128Bit(const RiceDeltaEncoded128Bit& from);
RiceDeltaEncoded128Bit(RiceDeltaEncoded128Bit&& from) noexcept
: RiceDeltaEncoded128Bit() {
*this = ::std::move(from);
}
inline RiceDeltaEncoded128Bit& operator=(const RiceDeltaEncoded128Bit& from) {
CopyFrom(from);
return *this;
}
inline RiceDeltaEncoded128Bit& operator=(RiceDeltaEncoded128Bit&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const RiceDeltaEncoded128Bit& default_instance() {
return *internal_default_instance();
}
static inline const RiceDeltaEncoded128Bit* internal_default_instance() {
return reinterpret_cast<const RiceDeltaEncoded128Bit*>(
&_RiceDeltaEncoded128Bit_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
friend void swap(RiceDeltaEncoded128Bit& a, RiceDeltaEncoded128Bit& b) {
a.Swap(&b);
}
inline void Swap(RiceDeltaEncoded128Bit* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RiceDeltaEncoded128Bit* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RiceDeltaEncoded128Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RiceDeltaEncoded128Bit>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const RiceDeltaEncoded128Bit& from);
void MergeFrom(const RiceDeltaEncoded128Bit& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(RiceDeltaEncoded128Bit* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit";
}
protected:
explicit RiceDeltaEncoded128Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kEncodedDataFieldNumber = 5,
kFirstValueHiFieldNumber = 1,
kFirstValueLoFieldNumber = 2,
kRiceParameterFieldNumber = 3,
kEntriesCountFieldNumber = 4,
};
// bytes encoded_data = 5;
void clear_encoded_data();
const std::string& encoded_data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_encoded_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_encoded_data();
PROTOBUF_NODISCARD std::string* release_encoded_data();
void set_allocated_encoded_data(std::string* encoded_data);
private:
const std::string& _internal_encoded_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
std::string* _internal_mutable_encoded_data();
public:
// uint64 first_value_hi = 1;
void clear_first_value_hi();
uint64_t first_value_hi() const;
void set_first_value_hi(uint64_t value);
private:
uint64_t _internal_first_value_hi() const;
void _internal_set_first_value_hi(uint64_t value);
public:
// fixed64 first_value_lo = 2;
void clear_first_value_lo();
uint64_t first_value_lo() const;
void set_first_value_lo(uint64_t value);
private:
uint64_t _internal_first_value_lo() const;
void _internal_set_first_value_lo(uint64_t value);
public:
// int32 rice_parameter = 3;
void clear_rice_parameter();
int32_t rice_parameter() const;
void set_rice_parameter(int32_t value);
private:
int32_t _internal_rice_parameter() const;
void _internal_set_rice_parameter(int32_t value);
public:
// int32 entries_count = 4;
void clear_entries_count();
int32_t entries_count() const;
void set_entries_count(int32_t value);
private:
int32_t _internal_entries_count() const;
void _internal_set_entries_count(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
uint64_t first_value_hi_;
uint64_t first_value_lo_;
int32_t rice_parameter_;
int32_t entries_count_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class RiceDeltaEncoded256Bit final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit) */ {
public:
inline RiceDeltaEncoded256Bit() : RiceDeltaEncoded256Bit(nullptr) {}
~RiceDeltaEncoded256Bit() override;
explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded256Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RiceDeltaEncoded256Bit(const RiceDeltaEncoded256Bit& from);
RiceDeltaEncoded256Bit(RiceDeltaEncoded256Bit&& from) noexcept
: RiceDeltaEncoded256Bit() {
*this = ::std::move(from);
}
inline RiceDeltaEncoded256Bit& operator=(const RiceDeltaEncoded256Bit& from) {
CopyFrom(from);
return *this;
}
inline RiceDeltaEncoded256Bit& operator=(RiceDeltaEncoded256Bit&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const RiceDeltaEncoded256Bit& default_instance() {
return *internal_default_instance();
}
static inline const RiceDeltaEncoded256Bit* internal_default_instance() {
return reinterpret_cast<const RiceDeltaEncoded256Bit*>(
&_RiceDeltaEncoded256Bit_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
friend void swap(RiceDeltaEncoded256Bit& a, RiceDeltaEncoded256Bit& b) {
a.Swap(&b);
}
inline void Swap(RiceDeltaEncoded256Bit* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RiceDeltaEncoded256Bit* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RiceDeltaEncoded256Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RiceDeltaEncoded256Bit>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const RiceDeltaEncoded256Bit& from);
void MergeFrom(const RiceDeltaEncoded256Bit& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(RiceDeltaEncoded256Bit* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit";
}
protected:
explicit RiceDeltaEncoded256Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kEncodedDataFieldNumber = 7,
kFirstValueFirstPartFieldNumber = 1,
kFirstValueSecondPartFieldNumber = 2,
kFirstValueThirdPartFieldNumber = 3,
kFirstValueFourthPartFieldNumber = 4,
kRiceParameterFieldNumber = 5,
kEntriesCountFieldNumber = 6,
};
// bytes encoded_data = 7;
void clear_encoded_data();
const std::string& encoded_data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_encoded_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_encoded_data();
PROTOBUF_NODISCARD std::string* release_encoded_data();
void set_allocated_encoded_data(std::string* encoded_data);
private:
const std::string& _internal_encoded_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
std::string* _internal_mutable_encoded_data();
public:
// uint64 first_value_first_part = 1;
void clear_first_value_first_part();
uint64_t first_value_first_part() const;
void set_first_value_first_part(uint64_t value);
private:
uint64_t _internal_first_value_first_part() const;
void _internal_set_first_value_first_part(uint64_t value);
public:
// fixed64 first_value_second_part = 2;
void clear_first_value_second_part();
uint64_t first_value_second_part() const;
void set_first_value_second_part(uint64_t value);
private:
uint64_t _internal_first_value_second_part() const;
void _internal_set_first_value_second_part(uint64_t value);
public:
// fixed64 first_value_third_part = 3;
void clear_first_value_third_part();
uint64_t first_value_third_part() const;
void set_first_value_third_part(uint64_t value);
private:
uint64_t _internal_first_value_third_part() const;
void _internal_set_first_value_third_part(uint64_t value);
public:
// fixed64 first_value_fourth_part = 4;
void clear_first_value_fourth_part();
uint64_t first_value_fourth_part() const;
void set_first_value_fourth_part(uint64_t value);
private:
uint64_t _internal_first_value_fourth_part() const;
void _internal_set_first_value_fourth_part(uint64_t value);
public:
// int32 rice_parameter = 5;
void clear_rice_parameter();
int32_t rice_parameter() const;
void set_rice_parameter(int32_t value);
private:
int32_t _internal_rice_parameter() const;
void _internal_set_rice_parameter(int32_t value);
public:
// int32 entries_count = 6;
void clear_entries_count();
int32_t entries_count() const;
void set_entries_count(int32_t value);
private:
int32_t _internal_entries_count() const;
void _internal_set_entries_count(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
uint64_t first_value_first_part_;
uint64_t first_value_second_part_;
uint64_t first_value_third_part_;
uint64_t first_value_fourth_part_;
int32_t rice_parameter_;
int32_t entries_count_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class HashListMetadata final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.HashListMetadata) */ {
public:
inline HashListMetadata() : HashListMetadata(nullptr) {}
~HashListMetadata() override;
explicit PROTOBUF_CONSTEXPR HashListMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
HashListMetadata(const HashListMetadata& from);
HashListMetadata(HashListMetadata&& from) noexcept
: HashListMetadata() {
*this = ::std::move(from);
}
inline HashListMetadata& operator=(const HashListMetadata& from) {
CopyFrom(from);
return *this;
}
inline HashListMetadata& operator=(HashListMetadata&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const HashListMetadata& default_instance() {
return *internal_default_instance();
}
static inline const HashListMetadata* internal_default_instance() {
return reinterpret_cast<const HashListMetadata*>(
&_HashListMetadata_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
friend void swap(HashListMetadata& a, HashListMetadata& b) {
a.Swap(&b);
}
inline void Swap(HashListMetadata* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HashListMetadata* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
HashListMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<HashListMetadata>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const HashListMetadata& from);
void MergeFrom(const HashListMetadata& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(HashListMetadata* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.HashListMetadata";
}
protected:
explicit HashListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef HashListMetadata_HashLength HashLength;
static constexpr HashLength HASH_LENGTH_UNSPECIFIED =
HashListMetadata_HashLength_HASH_LENGTH_UNSPECIFIED;
static constexpr HashLength FOUR_BYTES =
HashListMetadata_HashLength_FOUR_BYTES;
static constexpr HashLength EIGHT_BYTES =
HashListMetadata_HashLength_EIGHT_BYTES;
static constexpr HashLength SIXTEEN_BYTES =
HashListMetadata_HashLength_SIXTEEN_BYTES;
static constexpr HashLength THIRTY_TWO_BYTES =
HashListMetadata_HashLength_THIRTY_TWO_BYTES;
static inline bool HashLength_IsValid(int value) {
return HashListMetadata_HashLength_IsValid(value);
}
static constexpr HashLength HashLength_MIN =
HashListMetadata_HashLength_HashLength_MIN;
static constexpr HashLength HashLength_MAX =
HashListMetadata_HashLength_HashLength_MAX;
static constexpr int HashLength_ARRAYSIZE =
HashListMetadata_HashLength_HashLength_ARRAYSIZE;
template<typename T>
static inline const std::string& HashLength_Name(T enum_t_value) {
static_assert(::std::is_same<T, HashLength>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function HashLength_Name.");
return HashListMetadata_HashLength_Name(enum_t_value);
}
static inline bool HashLength_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
HashLength* value) {
return HashListMetadata_HashLength_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kThreatTypesFieldNumber = 1,
kLikelySafeTypesFieldNumber = 2,
kDescriptionFieldNumber = 4,
kHashLengthFieldNumber = 6,
};
// repeated .mozilla.safebrowsing.v5.ThreatType threat_types = 1;
int threat_types_size() const;
private:
int _internal_threat_types_size() const;
public:
void clear_threat_types();
private:
::mozilla::safebrowsing::v5::ThreatType _internal_threat_types(int index) const;
void _internal_add_threat_types(::mozilla::safebrowsing::v5::ThreatType value);
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_types();
public:
::mozilla::safebrowsing::v5::ThreatType threat_types(int index) const;
void set_threat_types(int index, ::mozilla::safebrowsing::v5::ThreatType value);
void add_threat_types(::mozilla::safebrowsing::v5::ThreatType value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_types() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_types();
// repeated .mozilla.safebrowsing.v5.LikelySafeType likely_safe_types = 2;
int likely_safe_types_size() const;
private:
int _internal_likely_safe_types_size() const;
public:
void clear_likely_safe_types();
private:
::mozilla::safebrowsing::v5::LikelySafeType _internal_likely_safe_types(int index) const;
void _internal_add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value);
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_likely_safe_types();
public:
::mozilla::safebrowsing::v5::LikelySafeType likely_safe_types(int index) const;
void set_likely_safe_types(int index, ::mozilla::safebrowsing::v5::LikelySafeType value);
void add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& likely_safe_types() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_likely_safe_types();
// string description = 4;
void clear_description();
const std::string& description() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_description(ArgT0&& arg0, ArgT... args);
std::string* mutable_description();
PROTOBUF_NODISCARD std::string* release_description();
void set_allocated_description(std::string* description);
private:
const std::string& _internal_description() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
std::string* _internal_mutable_description();
public:
// .mozilla.safebrowsing.v5.HashListMetadata.HashLength hash_length = 6;
void clear_hash_length();
::mozilla::safebrowsing::v5::HashListMetadata_HashLength hash_length() const;
void set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value);
private:
::mozilla::safebrowsing::v5::HashListMetadata_HashLength _internal_hash_length() const;
void _internal_set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.HashListMetadata)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_types_;
mutable std::atomic<int> _threat_types_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> likely_safe_types_;
mutable std::atomic<int> _likely_safe_types_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
int hash_length_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class HashList final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.HashList) */ {
public:
inline HashList() : HashList(nullptr) {}
~HashList() override;
explicit PROTOBUF_CONSTEXPR HashList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
HashList(const HashList& from);
HashList(HashList&& from) noexcept
: HashList() {
*this = ::std::move(from);
}
inline HashList& operator=(const HashList& from) {
CopyFrom(from);
return *this;
}
inline HashList& operator=(HashList&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const HashList& default_instance() {
return *internal_default_instance();
}
enum CompressedAdditionsCase {
kAdditionsFourBytes = 4,
kAdditionsEightBytes = 9,
kAdditionsSixteenBytes = 10,
kAdditionsThirtyTwoBytes = 11,
COMPRESSED_ADDITIONS_NOT_SET = 0,
};
static inline const HashList* internal_default_instance() {
return reinterpret_cast<const HashList*>(
&_HashList_default_instance_);
}
static constexpr int kIndexInFileMessages =
12;
friend void swap(HashList& a, HashList& b) {
a.Swap(&b);
}
inline void Swap(HashList* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HashList* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
HashList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<HashList>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const HashList& from);
void MergeFrom(const HashList& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(HashList* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.HashList";
}
protected:
explicit HashList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kVersionFieldNumber = 2,
kSha256ChecksumFieldNumber = 7,
kCompressedRemovalsFieldNumber = 5,
kMinimumWaitDurationFieldNumber = 6,
kMetadataFieldNumber = 8,
kPartialUpdateFieldNumber = 3,
kAdditionsFourBytesFieldNumber = 4,
kAdditionsEightBytesFieldNumber = 9,
kAdditionsSixteenBytesFieldNumber = 10,
kAdditionsThirtyTwoBytesFieldNumber = 11,
};
// string name = 1;
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// bytes version = 2;
void clear_version();
const std::string& version() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_version(ArgT0&& arg0, ArgT... args);
std::string* mutable_version();
PROTOBUF_NODISCARD std::string* release_version();
void set_allocated_version(std::string* version);
private:
const std::string& _internal_version() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
std::string* _internal_mutable_version();
public:
// bytes sha256_checksum = 7;
void clear_sha256_checksum();
const std::string& sha256_checksum() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_sha256_checksum(ArgT0&& arg0, ArgT... args);
std::string* mutable_sha256_checksum();
PROTOBUF_NODISCARD std::string* release_sha256_checksum();
void set_allocated_sha256_checksum(std::string* sha256_checksum);
private:
const std::string& _internal_sha256_checksum() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_sha256_checksum(const std::string& value);
std::string* _internal_mutable_sha256_checksum();
public:
// .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit compressed_removals = 5;
bool has_compressed_removals() const;
private:
bool _internal_has_compressed_removals() const;
public:
void clear_compressed_removals();
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& compressed_removals() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* release_compressed_removals();
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* mutable_compressed_removals();
void set_allocated_compressed_removals(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals);
private:
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& _internal_compressed_removals() const;
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _internal_mutable_compressed_removals();
public:
void unsafe_arena_set_allocated_compressed_removals(
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals);
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* unsafe_arena_release_compressed_removals();
// .mozilla.safebrowsing.v5.Duration minimum_wait_duration = 6;
bool has_minimum_wait_duration() const;
private:
bool _internal_has_minimum_wait_duration() const;
public:
void clear_minimum_wait_duration();
const ::mozilla::safebrowsing::v5::Duration& minimum_wait_duration() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::Duration* release_minimum_wait_duration();
::mozilla::safebrowsing::v5::Duration* mutable_minimum_wait_duration();
void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::v5::Duration* minimum_wait_duration);
private:
const ::mozilla::safebrowsing::v5::Duration& _internal_minimum_wait_duration() const;
::mozilla::safebrowsing::v5::Duration* _internal_mutable_minimum_wait_duration();
public:
void unsafe_arena_set_allocated_minimum_wait_duration(
::mozilla::safebrowsing::v5::Duration* minimum_wait_duration);
::mozilla::safebrowsing::v5::Duration* unsafe_arena_release_minimum_wait_duration();
// .mozilla.safebrowsing.v5.HashListMetadata metadata = 8;
bool has_metadata() const;
private:
bool _internal_has_metadata() const;
public:
void clear_metadata();
const ::mozilla::safebrowsing::v5::HashListMetadata& metadata() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::HashListMetadata* release_metadata();
::mozilla::safebrowsing::v5::HashListMetadata* mutable_metadata();
void set_allocated_metadata(::mozilla::safebrowsing::v5::HashListMetadata* metadata);
private:
const ::mozilla::safebrowsing::v5::HashListMetadata& _internal_metadata() const;
::mozilla::safebrowsing::v5::HashListMetadata* _internal_mutable_metadata();
public:
void unsafe_arena_set_allocated_metadata(
::mozilla::safebrowsing::v5::HashListMetadata* metadata);
::mozilla::safebrowsing::v5::HashListMetadata* unsafe_arena_release_metadata();
// bool partial_update = 3;
void clear_partial_update();
bool partial_update() const;
void set_partial_update(bool value);
private:
bool _internal_partial_update() const;
void _internal_set_partial_update(bool value);
public:
// .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit additions_four_bytes = 4;
bool has_additions_four_bytes() const;
private:
bool _internal_has_additions_four_bytes() const;
public:
void clear_additions_four_bytes();
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& additions_four_bytes() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* release_additions_four_bytes();
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* mutable_additions_four_bytes();
void set_allocated_additions_four_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes);
private:
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& _internal_additions_four_bytes() const;
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _internal_mutable_additions_four_bytes();
public:
void unsafe_arena_set_allocated_additions_four_bytes(
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes);
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* unsafe_arena_release_additions_four_bytes();
// .mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit additions_eight_bytes = 9;
bool has_additions_eight_bytes() const;
private:
bool _internal_has_additions_eight_bytes() const;
public:
void clear_additions_eight_bytes();
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& additions_eight_bytes() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* release_additions_eight_bytes();
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* mutable_additions_eight_bytes();
void set_allocated_additions_eight_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes);
private:
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& _internal_additions_eight_bytes() const;
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* _internal_mutable_additions_eight_bytes();
public:
void unsafe_arena_set_allocated_additions_eight_bytes(
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes);
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* unsafe_arena_release_additions_eight_bytes();
// .mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit additions_sixteen_bytes = 10;
bool has_additions_sixteen_bytes() const;
private:
bool _internal_has_additions_sixteen_bytes() const;
public:
void clear_additions_sixteen_bytes();
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& additions_sixteen_bytes() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* release_additions_sixteen_bytes();
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* mutable_additions_sixteen_bytes();
void set_allocated_additions_sixteen_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes);
private:
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& _internal_additions_sixteen_bytes() const;
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* _internal_mutable_additions_sixteen_bytes();
public:
void unsafe_arena_set_allocated_additions_sixteen_bytes(
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes);
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* unsafe_arena_release_additions_sixteen_bytes();
// .mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit additions_thirty_two_bytes = 11;
bool has_additions_thirty_two_bytes() const;
private:
bool _internal_has_additions_thirty_two_bytes() const;
public:
void clear_additions_thirty_two_bytes();
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& additions_thirty_two_bytes() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* release_additions_thirty_two_bytes();
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* mutable_additions_thirty_two_bytes();
void set_allocated_additions_thirty_two_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes);
private:
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& _internal_additions_thirty_two_bytes() const;
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* _internal_mutable_additions_thirty_two_bytes();
public:
void unsafe_arena_set_allocated_additions_thirty_two_bytes(
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes);
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* unsafe_arena_release_additions_thirty_two_bytes();
void clear_compressed_additions();
CompressedAdditionsCase compressed_additions_case() const;
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.HashList)
private:
class _Internal;
void set_has_additions_four_bytes();
void set_has_additions_eight_bytes();
void set_has_additions_sixteen_bytes();
void set_has_additions_thirty_two_bytes();
inline bool has_compressed_additions() const;
inline void clear_has_compressed_additions();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha256_checksum_;
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals_;
::mozilla::safebrowsing::v5::Duration* minimum_wait_duration_;
::mozilla::safebrowsing::v5::HashListMetadata* metadata_;
bool partial_update_;
union CompressedAdditionsUnion {
constexpr CompressedAdditionsUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes_;
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes_;
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes_;
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes_;
} compressed_additions_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t _oneof_case_[1];
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class BatchGetHashListsRequest final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.BatchGetHashListsRequest) */ {
public:
inline BatchGetHashListsRequest() : BatchGetHashListsRequest(nullptr) {}
~BatchGetHashListsRequest() override;
explicit PROTOBUF_CONSTEXPR BatchGetHashListsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BatchGetHashListsRequest(const BatchGetHashListsRequest& from);
BatchGetHashListsRequest(BatchGetHashListsRequest&& from) noexcept
: BatchGetHashListsRequest() {
*this = ::std::move(from);
}
inline BatchGetHashListsRequest& operator=(const BatchGetHashListsRequest& from) {
CopyFrom(from);
return *this;
}
inline BatchGetHashListsRequest& operator=(BatchGetHashListsRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const BatchGetHashListsRequest& default_instance() {
return *internal_default_instance();
}
static inline const BatchGetHashListsRequest* internal_default_instance() {
return reinterpret_cast<const BatchGetHashListsRequest*>(
&_BatchGetHashListsRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
13;
friend void swap(BatchGetHashListsRequest& a, BatchGetHashListsRequest& b) {
a.Swap(&b);
}
inline void Swap(BatchGetHashListsRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BatchGetHashListsRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BatchGetHashListsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BatchGetHashListsRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const BatchGetHashListsRequest& from);
void MergeFrom(const BatchGetHashListsRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(BatchGetHashListsRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.BatchGetHashListsRequest";
}
protected:
explicit BatchGetHashListsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNamesFieldNumber = 1,
kVersionFieldNumber = 2,
kSizeConstraintsFieldNumber = 4,
};
// repeated string names = 1;
int names_size() const;
private:
int _internal_names_size() const;
public:
void clear_names();
const std::string& names(int index) const;
std::string* mutable_names(int index);
void set_names(int index, const std::string& value);
void set_names(int index, std::string&& value);
void set_names(int index, const char* value);
void set_names(int index, const char* value, size_t size);
std::string* add_names();
void add_names(const std::string& value);
void add_names(std::string&& value);
void add_names(const char* value);
void add_names(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
private:
const std::string& _internal_names(int index) const;
std::string* _internal_add_names();
public:
// repeated bytes version = 2;
int version_size() const;
private:
int _internal_version_size() const;
public:
void clear_version();
const std::string& version(int index) const;
std::string* mutable_version(int index);
void set_version(int index, const std::string& value);
void set_version(int index, std::string&& value);
void set_version(int index, const char* value);
void set_version(int index, const void* value, size_t size);
std::string* add_version();
void add_version(const std::string& value);
void add_version(std::string&& value);
void add_version(const char* value);
void add_version(const void* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& version() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_version();
private:
const std::string& _internal_version(int index) const;
std::string* _internal_add_version();
public:
// .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
bool has_size_constraints() const;
private:
bool _internal_has_size_constraints() const;
public:
void clear_size_constraints();
const ::mozilla::safebrowsing::v5::SizeConstraints& size_constraints() const;
PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::SizeConstraints* release_size_constraints();
::mozilla::safebrowsing::v5::SizeConstraints* mutable_size_constraints();
void set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
private:
const ::mozilla::safebrowsing::v5::SizeConstraints& _internal_size_constraints() const;
::mozilla::safebrowsing::v5::SizeConstraints* _internal_mutable_size_constraints();
public:
void unsafe_arena_set_allocated_size_constraints(
::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
::mozilla::safebrowsing::v5::SizeConstraints* unsafe_arena_release_size_constraints();
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.BatchGetHashListsRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> version_;
::mozilla::safebrowsing::v5::SizeConstraints* size_constraints_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class BatchGetHashListsResponse final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.BatchGetHashListsResponse) */ {
public:
inline BatchGetHashListsResponse() : BatchGetHashListsResponse(nullptr) {}
~BatchGetHashListsResponse() override;
explicit PROTOBUF_CONSTEXPR BatchGetHashListsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BatchGetHashListsResponse(const BatchGetHashListsResponse& from);
BatchGetHashListsResponse(BatchGetHashListsResponse&& from) noexcept
: BatchGetHashListsResponse() {
*this = ::std::move(from);
}
inline BatchGetHashListsResponse& operator=(const BatchGetHashListsResponse& from) {
CopyFrom(from);
return *this;
}
inline BatchGetHashListsResponse& operator=(BatchGetHashListsResponse&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const BatchGetHashListsResponse& default_instance() {
return *internal_default_instance();
}
static inline const BatchGetHashListsResponse* internal_default_instance() {
return reinterpret_cast<const BatchGetHashListsResponse*>(
&_BatchGetHashListsResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
friend void swap(BatchGetHashListsResponse& a, BatchGetHashListsResponse& b) {
a.Swap(&b);
}
inline void Swap(BatchGetHashListsResponse* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BatchGetHashListsResponse* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BatchGetHashListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BatchGetHashListsResponse>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const BatchGetHashListsResponse& from);
void MergeFrom(const BatchGetHashListsResponse& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(BatchGetHashListsResponse* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.BatchGetHashListsResponse";
}
protected:
explicit BatchGetHashListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHashListsFieldNumber = 1,
};
// repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
int hash_lists_size() const;
private:
int _internal_hash_lists_size() const;
public:
void clear_hash_lists();
::mozilla::safebrowsing::v5::HashList* mutable_hash_lists(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
mutable_hash_lists();
private:
const ::mozilla::safebrowsing::v5::HashList& _internal_hash_lists(int index) const;
::mozilla::safebrowsing::v5::HashList* _internal_add_hash_lists();
public:
const ::mozilla::safebrowsing::v5::HashList& hash_lists(int index) const;
::mozilla::safebrowsing::v5::HashList* add_hash_lists();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
hash_lists() const;
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.BatchGetHashListsResponse)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList > hash_lists_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class ListHashListsRequest final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.ListHashListsRequest) */ {
public:
inline ListHashListsRequest() : ListHashListsRequest(nullptr) {}
~ListHashListsRequest() override;
explicit PROTOBUF_CONSTEXPR ListHashListsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ListHashListsRequest(const ListHashListsRequest& from);
ListHashListsRequest(ListHashListsRequest&& from) noexcept
: ListHashListsRequest() {
*this = ::std::move(from);
}
inline ListHashListsRequest& operator=(const ListHashListsRequest& from) {
CopyFrom(from);
return *this;
}
inline ListHashListsRequest& operator=(ListHashListsRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ListHashListsRequest& default_instance() {
return *internal_default_instance();
}
static inline const ListHashListsRequest* internal_default_instance() {
return reinterpret_cast<const ListHashListsRequest*>(
&_ListHashListsRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
friend void swap(ListHashListsRequest& a, ListHashListsRequest& b) {
a.Swap(&b);
}
inline void Swap(ListHashListsRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ListHashListsRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ListHashListsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ListHashListsRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const ListHashListsRequest& from);
void MergeFrom(const ListHashListsRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ListHashListsRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.ListHashListsRequest";
}
protected:
explicit ListHashListsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPageTokenFieldNumber = 2,
kPageSizeFieldNumber = 1,
};
// string page_token = 2;
void clear_page_token();
const std::string& page_token() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_page_token(ArgT0&& arg0, ArgT... args);
std::string* mutable_page_token();
PROTOBUF_NODISCARD std::string* release_page_token();
void set_allocated_page_token(std::string* page_token);
private:
const std::string& _internal_page_token() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_token(const std::string& value);
std::string* _internal_mutable_page_token();
public:
// int32 page_size = 1;
void clear_page_size();
int32_t page_size() const;
void set_page_size(int32_t value);
private:
int32_t _internal_page_size() const;
void _internal_set_page_size(int32_t value);
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.ListHashListsRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr page_token_;
int32_t page_size_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------
class ListHashListsResponse final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.ListHashListsResponse) */ {
public:
inline ListHashListsResponse() : ListHashListsResponse(nullptr) {}
~ListHashListsResponse() override;
explicit PROTOBUF_CONSTEXPR ListHashListsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ListHashListsResponse(const ListHashListsResponse& from);
ListHashListsResponse(ListHashListsResponse&& from) noexcept
: ListHashListsResponse() {
*this = ::std::move(from);
}
inline ListHashListsResponse& operator=(const ListHashListsResponse& from) {
CopyFrom(from);
return *this;
}
inline ListHashListsResponse& operator=(ListHashListsResponse&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ListHashListsResponse& default_instance() {
return *internal_default_instance();
}
static inline const ListHashListsResponse* internal_default_instance() {
return reinterpret_cast<const ListHashListsResponse*>(
&_ListHashListsResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
friend void swap(ListHashListsResponse& a, ListHashListsResponse& b) {
a.Swap(&b);
}
inline void Swap(ListHashListsResponse* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ListHashListsResponse* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ListHashListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ListHashListsResponse>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const ListHashListsResponse& from);
void MergeFrom(const ListHashListsResponse& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ListHashListsResponse* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "mozilla.safebrowsing.v5.ListHashListsResponse";
}
protected:
explicit ListHashListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHashListsFieldNumber = 1,
kNextPageTokenFieldNumber = 2,
};
// repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
int hash_lists_size() const;
private:
int _internal_hash_lists_size() const;
public:
void clear_hash_lists();
::mozilla::safebrowsing::v5::HashList* mutable_hash_lists(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
mutable_hash_lists();
private:
const ::mozilla::safebrowsing::v5::HashList& _internal_hash_lists(int index) const;
::mozilla::safebrowsing::v5::HashList* _internal_add_hash_lists();
public:
const ::mozilla::safebrowsing::v5::HashList& hash_lists(int index) const;
::mozilla::safebrowsing::v5::HashList* add_hash_lists();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
hash_lists() const;
// string next_page_token = 2;
void clear_next_page_token();
const std::string& next_page_token() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_next_page_token(ArgT0&& arg0, ArgT... args);
std::string* mutable_next_page_token();
PROTOBUF_NODISCARD std::string* release_next_page_token();
void set_allocated_next_page_token(std::string* next_page_token);
private:
const std::string& _internal_next_page_token() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_page_token(const std::string& value);
std::string* _internal_mutable_next_page_token();
public:
// @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.ListHashListsResponse)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList > hash_lists_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr next_page_token_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// SearchHashesRequest
// repeated bytes hash_prefixes = 1;
inline int SearchHashesRequest::_internal_hash_prefixes_size() const {
return _impl_.hash_prefixes_.size();
}
inline int SearchHashesRequest::hash_prefixes_size() const {
return _internal_hash_prefixes_size();
}
inline void SearchHashesRequest::clear_hash_prefixes() {
_impl_.hash_prefixes_.Clear();
}
inline std::string* SearchHashesRequest::add_hash_prefixes() {
std::string* _s = _internal_add_hash_prefixes();
// @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
return _s;
}
inline const std::string& SearchHashesRequest::_internal_hash_prefixes(int index) const {
return _impl_.hash_prefixes_.Get(index);
}
inline const std::string& SearchHashesRequest::hash_prefixes(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
return _internal_hash_prefixes(index);
}
inline std::string* SearchHashesRequest::mutable_hash_prefixes(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
return _impl_.hash_prefixes_.Mutable(index);
}
inline void SearchHashesRequest::set_hash_prefixes(int index, const std::string& value) {
_impl_.hash_prefixes_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::set_hash_prefixes(int index, std::string&& value) {
_impl_.hash_prefixes_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::set_hash_prefixes(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.hash_prefixes_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::set_hash_prefixes(int index, const void* value, size_t size) {
_impl_.hash_prefixes_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline std::string* SearchHashesRequest::_internal_add_hash_prefixes() {
return _impl_.hash_prefixes_.Add();
}
inline void SearchHashesRequest::add_hash_prefixes(const std::string& value) {
_impl_.hash_prefixes_.Add()->assign(value);
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::add_hash_prefixes(std::string&& value) {
_impl_.hash_prefixes_.Add(std::move(value));
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::add_hash_prefixes(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.hash_prefixes_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::add_hash_prefixes(const void* value, size_t size) {
_impl_.hash_prefixes_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchHashesRequest::hash_prefixes() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
return _impl_.hash_prefixes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchHashesRequest::mutable_hash_prefixes() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
return &_impl_.hash_prefixes_;
}
// -------------------------------------------------------------------
// Duration
// int64 seconds = 1;
inline void Duration::clear_seconds() {
_impl_.seconds_ = int64_t{0};
}
inline int64_t Duration::_internal_seconds() const {
return _impl_.seconds_;
}
inline int64_t Duration::seconds() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.Duration.seconds)
return _internal_seconds();
}
inline void Duration::_internal_set_seconds(int64_t value) {
_impl_.seconds_ = value;
}
inline void Duration::set_seconds(int64_t value) {
_internal_set_seconds(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.Duration.seconds)
}
// int32 nanos = 2;
inline void Duration::clear_nanos() {
_impl_.nanos_ = 0;
}
inline int32_t Duration::_internal_nanos() const {
return _impl_.nanos_;
}
inline int32_t Duration::nanos() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.Duration.nanos)
return _internal_nanos();
}
inline void Duration::_internal_set_nanos(int32_t value) {
_impl_.nanos_ = value;
}
inline void Duration::set_nanos(int32_t value) {
_internal_set_nanos(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.Duration.nanos)
}
// -------------------------------------------------------------------
// SearchHashesResponse
// repeated .mozilla.safebrowsing.v5.FullHash full_hashes = 1;
inline int SearchHashesResponse::_internal_full_hashes_size() const {
return _impl_.full_hashes_.size();
}
inline int SearchHashesResponse::full_hashes_size() const {
return _internal_full_hashes_size();
}
inline void SearchHashesResponse::clear_full_hashes() {
_impl_.full_hashes_.Clear();
}
inline ::mozilla::safebrowsing::v5::FullHash* SearchHashesResponse::mutable_full_hashes(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
return _impl_.full_hashes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >*
SearchHashesResponse::mutable_full_hashes() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
return &_impl_.full_hashes_;
}
inline const ::mozilla::safebrowsing::v5::FullHash& SearchHashesResponse::_internal_full_hashes(int index) const {
return _impl_.full_hashes_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::FullHash& SearchHashesResponse::full_hashes(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
return _internal_full_hashes(index);
}
inline ::mozilla::safebrowsing::v5::FullHash* SearchHashesResponse::_internal_add_full_hashes() {
return _impl_.full_hashes_.Add();
}
inline ::mozilla::safebrowsing::v5::FullHash* SearchHashesResponse::add_full_hashes() {
::mozilla::safebrowsing::v5::FullHash* _add = _internal_add_full_hashes();
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >&
SearchHashesResponse::full_hashes() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
return _impl_.full_hashes_;
}
// .mozilla.safebrowsing.v5.Duration cache_duration = 2;
inline bool SearchHashesResponse::_internal_has_cache_duration() const {
return this != internal_default_instance() && _impl_.cache_duration_ != nullptr;
}
inline bool SearchHashesResponse::has_cache_duration() const {
return _internal_has_cache_duration();
}
inline void SearchHashesResponse::clear_cache_duration() {
if (GetArenaForAllocation() == nullptr && _impl_.cache_duration_ != nullptr) {
delete _impl_.cache_duration_;
}
_impl_.cache_duration_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::Duration& SearchHashesResponse::_internal_cache_duration() const {
const ::mozilla::safebrowsing::v5::Duration* p = _impl_.cache_duration_;
return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::Duration&>(
::mozilla::safebrowsing::v5::_Duration_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::Duration& SearchHashesResponse::cache_duration() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
return _internal_cache_duration();
}
inline void SearchHashesResponse::unsafe_arena_set_allocated_cache_duration(
::mozilla::safebrowsing::v5::Duration* cache_duration) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cache_duration_);
}
_impl_.cache_duration_ = cache_duration;
if (cache_duration) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::release_cache_duration() {
::mozilla::safebrowsing::v5::Duration* temp = _impl_.cache_duration_;
_impl_.cache_duration_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::unsafe_arena_release_cache_duration() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
::mozilla::safebrowsing::v5::Duration* temp = _impl_.cache_duration_;
_impl_.cache_duration_ = nullptr;
return temp;
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::_internal_mutable_cache_duration() {
if (_impl_.cache_duration_ == nullptr) {
auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::Duration>(GetArenaForAllocation());
_impl_.cache_duration_ = p;
}
return _impl_.cache_duration_;
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::mutable_cache_duration() {
::mozilla::safebrowsing::v5::Duration* _msg = _internal_mutable_cache_duration();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
return _msg;
}
inline void SearchHashesResponse::set_allocated_cache_duration(::mozilla::safebrowsing::v5::Duration* cache_duration) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.cache_duration_;
}
if (cache_duration) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cache_duration);
if (message_arena != submessage_arena) {
cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, cache_duration, submessage_arena);
}
} else {
}
_impl_.cache_duration_ = cache_duration;
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
}
// -------------------------------------------------------------------
// FullHash_FullHashDetail
// .mozilla.safebrowsing.v5.ThreatType threat_type = 1;
inline void FullHash_FullHashDetail::clear_threat_type() {
_impl_.threat_type_ = 0;
}
inline ::mozilla::safebrowsing::v5::ThreatType FullHash_FullHashDetail::_internal_threat_type() const {
return static_cast< ::mozilla::safebrowsing::v5::ThreatType >(_impl_.threat_type_);
}
inline ::mozilla::safebrowsing::v5::ThreatType FullHash_FullHashDetail::threat_type() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.FullHashDetail.threat_type)
return _internal_threat_type();
}
inline void FullHash_FullHashDetail::_internal_set_threat_type(::mozilla::safebrowsing::v5::ThreatType value) {
_impl_.threat_type_ = value;
}
inline void FullHash_FullHashDetail::set_threat_type(::mozilla::safebrowsing::v5::ThreatType value) {
_internal_set_threat_type(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.FullHash.FullHashDetail.threat_type)
}
// repeated .mozilla.safebrowsing.v5.ThreatAttribute attributes = 2;
inline int FullHash_FullHashDetail::_internal_attributes_size() const {
return _impl_.attributes_.size();
}
inline int FullHash_FullHashDetail::attributes_size() const {
return _internal_attributes_size();
}
inline void FullHash_FullHashDetail::clear_attributes() {
_impl_.attributes_.Clear();
}
inline ::mozilla::safebrowsing::v5::ThreatAttribute FullHash_FullHashDetail::_internal_attributes(int index) const {
return static_cast< ::mozilla::safebrowsing::v5::ThreatAttribute >(_impl_.attributes_.Get(index));
}
inline ::mozilla::safebrowsing::v5::ThreatAttribute FullHash_FullHashDetail::attributes(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
return _internal_attributes(index);
}
inline void FullHash_FullHashDetail::set_attributes(int index, ::mozilla::safebrowsing::v5::ThreatAttribute value) {
_impl_.attributes_.Set(index, value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
}
inline void FullHash_FullHashDetail::_internal_add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value) {
_impl_.attributes_.Add(value);
}
inline void FullHash_FullHashDetail::add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value) {
_internal_add_attributes(value);
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
FullHash_FullHashDetail::attributes() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
return _impl_.attributes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
FullHash_FullHashDetail::_internal_mutable_attributes() {
return &_impl_.attributes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
FullHash_FullHashDetail::mutable_attributes() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
return _internal_mutable_attributes();
}
// -------------------------------------------------------------------
// FullHash
// bytes full_hash = 1;
inline void FullHash::clear_full_hash() {
_impl_.full_hash_.ClearToEmpty();
}
inline const std::string& FullHash::full_hash() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.full_hash)
return _internal_full_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FullHash::set_full_hash(ArgT0&& arg0, ArgT... args) {
_impl_.full_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.FullHash.full_hash)
}
inline std::string* FullHash::mutable_full_hash() {
std::string* _s = _internal_mutable_full_hash();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.FullHash.full_hash)
return _s;
}
inline const std::string& FullHash::_internal_full_hash() const {
return _impl_.full_hash_.Get();
}
inline void FullHash::_internal_set_full_hash(const std::string& value) {
_impl_.full_hash_.Set(value, GetArenaForAllocation());
}
inline std::string* FullHash::_internal_mutable_full_hash() {
return _impl_.full_hash_.Mutable(GetArenaForAllocation());
}
inline std::string* FullHash::release_full_hash() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.FullHash.full_hash)
return _impl_.full_hash_.Release();
}
inline void FullHash::set_allocated_full_hash(std::string* full_hash) {
if (full_hash != nullptr) {
} else {
}
_impl_.full_hash_.SetAllocated(full_hash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.full_hash_.IsDefault()) {
_impl_.full_hash_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.FullHash.full_hash)
}
// repeated .mozilla.safebrowsing.v5.FullHash.FullHashDetail full_hash_details = 2;
inline int FullHash::_internal_full_hash_details_size() const {
return _impl_.full_hash_details_.size();
}
inline int FullHash::full_hash_details_size() const {
return _internal_full_hash_details_size();
}
inline void FullHash::clear_full_hash_details() {
_impl_.full_hash_details_.Clear();
}
inline ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* FullHash::mutable_full_hash_details(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.FullHash.full_hash_details)
return _impl_.full_hash_details_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >*
FullHash::mutable_full_hash_details() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.FullHash.full_hash_details)
return &_impl_.full_hash_details_;
}
inline const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& FullHash::_internal_full_hash_details(int index) const {
return _impl_.full_hash_details_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& FullHash::full_hash_details(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.full_hash_details)
return _internal_full_hash_details(index);
}
inline ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* FullHash::_internal_add_full_hash_details() {
return _impl_.full_hash_details_.Add();
}
inline ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* FullHash::add_full_hash_details() {
::mozilla::safebrowsing::v5::FullHash_FullHashDetail* _add = _internal_add_full_hash_details();
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.FullHash.full_hash_details)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >&
FullHash::full_hash_details() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.FullHash.full_hash_details)
return _impl_.full_hash_details_;
}
// -------------------------------------------------------------------
// GetHashListRequest
// string name = 1;
inline void GetHashListRequest::clear_name() {
_impl_.name_.ClearToEmpty();
}
inline const std::string& GetHashListRequest::name() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.GetHashListRequest.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GetHashListRequest::set_name(ArgT0&& arg0, ArgT... args) {
_impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.GetHashListRequest.name)
}
inline std::string* GetHashListRequest::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.GetHashListRequest.name)
return _s;
}
inline const std::string& GetHashListRequest::_internal_name() const {
return _impl_.name_.Get();
}
inline void GetHashListRequest::_internal_set_name(const std::string& value) {
_impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* GetHashListRequest::_internal_mutable_name() {
return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* GetHashListRequest::release_name() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.GetHashListRequest.name)
return _impl_.name_.Release();
}
inline void GetHashListRequest::set_allocated_name(std::string* name) {
if (name != nullptr) {
} else {
}
_impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.name_.IsDefault()) {
_impl_.name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.name)
}
// bytes version = 2;
inline void GetHashListRequest::clear_version() {
_impl_.version_.ClearToEmpty();
}
inline const std::string& GetHashListRequest::version() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.GetHashListRequest.version)
return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GetHashListRequest::set_version(ArgT0&& arg0, ArgT... args) {
_impl_.version_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.GetHashListRequest.version)
}
inline std::string* GetHashListRequest::mutable_version() {
std::string* _s = _internal_mutable_version();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.GetHashListRequest.version)
return _s;
}
inline const std::string& GetHashListRequest::_internal_version() const {
return _impl_.version_.Get();
}
inline void GetHashListRequest::_internal_set_version(const std::string& value) {
_impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* GetHashListRequest::_internal_mutable_version() {
return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* GetHashListRequest::release_version() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.GetHashListRequest.version)
return _impl_.version_.Release();
}
inline void GetHashListRequest::set_allocated_version(std::string* version) {
if (version != nullptr) {
} else {
}
_impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.version_.IsDefault()) {
_impl_.version_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.version)
}
// .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
inline bool GetHashListRequest::_internal_has_size_constraints() const {
return this != internal_default_instance() && _impl_.size_constraints_ != nullptr;
}
inline bool GetHashListRequest::has_size_constraints() const {
return _internal_has_size_constraints();
}
inline void GetHashListRequest::clear_size_constraints() {
if (GetArenaForAllocation() == nullptr && _impl_.size_constraints_ != nullptr) {
delete _impl_.size_constraints_;
}
_impl_.size_constraints_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& GetHashListRequest::_internal_size_constraints() const {
const ::mozilla::safebrowsing::v5::SizeConstraints* p = _impl_.size_constraints_;
return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::SizeConstraints&>(
::mozilla::safebrowsing::v5::_SizeConstraints_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& GetHashListRequest::size_constraints() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
return _internal_size_constraints();
}
inline void GetHashListRequest::unsafe_arena_set_allocated_size_constraints(
::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.size_constraints_);
}
_impl_.size_constraints_ = size_constraints;
if (size_constraints) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::release_size_constraints() {
::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
_impl_.size_constraints_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::unsafe_arena_release_size_constraints() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
_impl_.size_constraints_ = nullptr;
return temp;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::_internal_mutable_size_constraints() {
if (_impl_.size_constraints_ == nullptr) {
auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::SizeConstraints>(GetArenaForAllocation());
_impl_.size_constraints_ = p;
}
return _impl_.size_constraints_;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::mutable_size_constraints() {
::mozilla::safebrowsing::v5::SizeConstraints* _msg = _internal_mutable_size_constraints();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
return _msg;
}
inline void GetHashListRequest::set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.size_constraints_;
}
if (size_constraints) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(size_constraints);
if (message_arena != submessage_arena) {
size_constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, size_constraints, submessage_arena);
}
} else {
}
_impl_.size_constraints_ = size_constraints;
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
}
// -------------------------------------------------------------------
// SizeConstraints
// int32 max_update_entries = 1;
inline void SizeConstraints::clear_max_update_entries() {
_impl_.max_update_entries_ = 0;
}
inline int32_t SizeConstraints::_internal_max_update_entries() const {
return _impl_.max_update_entries_;
}
inline int32_t SizeConstraints::max_update_entries() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SizeConstraints.max_update_entries)
return _internal_max_update_entries();
}
inline void SizeConstraints::_internal_set_max_update_entries(int32_t value) {
_impl_.max_update_entries_ = value;
}
inline void SizeConstraints::set_max_update_entries(int32_t value) {
_internal_set_max_update_entries(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SizeConstraints.max_update_entries)
}
// int32 max_database_entries = 2;
inline void SizeConstraints::clear_max_database_entries() {
_impl_.max_database_entries_ = 0;
}
inline int32_t SizeConstraints::_internal_max_database_entries() const {
return _impl_.max_database_entries_;
}
inline int32_t SizeConstraints::max_database_entries() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SizeConstraints.max_database_entries)
return _internal_max_database_entries();
}
inline void SizeConstraints::_internal_set_max_database_entries(int32_t value) {
_impl_.max_database_entries_ = value;
}
inline void SizeConstraints::set_max_database_entries(int32_t value) {
_internal_set_max_database_entries(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SizeConstraints.max_database_entries)
}
// -------------------------------------------------------------------
// RiceDeltaEncoded32Bit
// uint32 first_value = 1;
inline void RiceDeltaEncoded32Bit::clear_first_value() {
_impl_.first_value_ = 0u;
}
inline uint32_t RiceDeltaEncoded32Bit::_internal_first_value() const {
return _impl_.first_value_;
}
inline uint32_t RiceDeltaEncoded32Bit::first_value() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.first_value)
return _internal_first_value();
}
inline void RiceDeltaEncoded32Bit::_internal_set_first_value(uint32_t value) {
_impl_.first_value_ = value;
}
inline void RiceDeltaEncoded32Bit::set_first_value(uint32_t value) {
_internal_set_first_value(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.first_value)
}
// int32 rice_parameter = 2;
inline void RiceDeltaEncoded32Bit::clear_rice_parameter() {
_impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded32Bit::_internal_rice_parameter() const {
return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded32Bit::rice_parameter() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.rice_parameter)
return _internal_rice_parameter();
}
inline void RiceDeltaEncoded32Bit::_internal_set_rice_parameter(int32_t value) {
_impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded32Bit::set_rice_parameter(int32_t value) {
_internal_set_rice_parameter(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.rice_parameter)
}
// int32 entries_count = 3;
inline void RiceDeltaEncoded32Bit::clear_entries_count() {
_impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded32Bit::_internal_entries_count() const {
return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded32Bit::entries_count() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.entries_count)
return _internal_entries_count();
}
inline void RiceDeltaEncoded32Bit::_internal_set_entries_count(int32_t value) {
_impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded32Bit::set_entries_count(int32_t value) {
_internal_set_entries_count(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.entries_count)
}
// bytes encoded_data = 4;
inline void RiceDeltaEncoded32Bit::clear_encoded_data() {
_impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded32Bit::encoded_data() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded32Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
_impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded32Bit::mutable_encoded_data() {
std::string* _s = _internal_mutable_encoded_data();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
return _s;
}
inline const std::string& RiceDeltaEncoded32Bit::_internal_encoded_data() const {
return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded32Bit::_internal_set_encoded_data(const std::string& value) {
_impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded32Bit::_internal_mutable_encoded_data() {
return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded32Bit::release_encoded_data() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded32Bit::set_allocated_encoded_data(std::string* encoded_data) {
if (encoded_data != nullptr) {
} else {
}
_impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.encoded_data_.IsDefault()) {
_impl_.encoded_data_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
}
// -------------------------------------------------------------------
// RiceDeltaEncoded64Bit
// uint64 first_value = 1;
inline void RiceDeltaEncoded64Bit::clear_first_value() {
_impl_.first_value_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded64Bit::_internal_first_value() const {
return _impl_.first_value_;
}
inline uint64_t RiceDeltaEncoded64Bit::first_value() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.first_value)
return _internal_first_value();
}
inline void RiceDeltaEncoded64Bit::_internal_set_first_value(uint64_t value) {
_impl_.first_value_ = value;
}
inline void RiceDeltaEncoded64Bit::set_first_value(uint64_t value) {
_internal_set_first_value(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.first_value)
}
// int32 rice_parameter = 2;
inline void RiceDeltaEncoded64Bit::clear_rice_parameter() {
_impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded64Bit::_internal_rice_parameter() const {
return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded64Bit::rice_parameter() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.rice_parameter)
return _internal_rice_parameter();
}
inline void RiceDeltaEncoded64Bit::_internal_set_rice_parameter(int32_t value) {
_impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded64Bit::set_rice_parameter(int32_t value) {
_internal_set_rice_parameter(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.rice_parameter)
}
// int32 entries_count = 3;
inline void RiceDeltaEncoded64Bit::clear_entries_count() {
_impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded64Bit::_internal_entries_count() const {
return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded64Bit::entries_count() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.entries_count)
return _internal_entries_count();
}
inline void RiceDeltaEncoded64Bit::_internal_set_entries_count(int32_t value) {
_impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded64Bit::set_entries_count(int32_t value) {
_internal_set_entries_count(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.entries_count)
}
// bytes encoded_data = 4;
inline void RiceDeltaEncoded64Bit::clear_encoded_data() {
_impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded64Bit::encoded_data() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded64Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
_impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded64Bit::mutable_encoded_data() {
std::string* _s = _internal_mutable_encoded_data();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
return _s;
}
inline const std::string& RiceDeltaEncoded64Bit::_internal_encoded_data() const {
return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded64Bit::_internal_set_encoded_data(const std::string& value) {
_impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded64Bit::_internal_mutable_encoded_data() {
return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded64Bit::release_encoded_data() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded64Bit::set_allocated_encoded_data(std::string* encoded_data) {
if (encoded_data != nullptr) {
} else {
}
_impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.encoded_data_.IsDefault()) {
_impl_.encoded_data_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
}
// -------------------------------------------------------------------
// RiceDeltaEncoded128Bit
// uint64 first_value_hi = 1;
inline void RiceDeltaEncoded128Bit::clear_first_value_hi() {
_impl_.first_value_hi_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded128Bit::_internal_first_value_hi() const {
return _impl_.first_value_hi_;
}
inline uint64_t RiceDeltaEncoded128Bit::first_value_hi() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_hi)
return _internal_first_value_hi();
}
inline void RiceDeltaEncoded128Bit::_internal_set_first_value_hi(uint64_t value) {
_impl_.first_value_hi_ = value;
}
inline void RiceDeltaEncoded128Bit::set_first_value_hi(uint64_t value) {
_internal_set_first_value_hi(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_hi)
}
// fixed64 first_value_lo = 2;
inline void RiceDeltaEncoded128Bit::clear_first_value_lo() {
_impl_.first_value_lo_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded128Bit::_internal_first_value_lo() const {
return _impl_.first_value_lo_;
}
inline uint64_t RiceDeltaEncoded128Bit::first_value_lo() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_lo)
return _internal_first_value_lo();
}
inline void RiceDeltaEncoded128Bit::_internal_set_first_value_lo(uint64_t value) {
_impl_.first_value_lo_ = value;
}
inline void RiceDeltaEncoded128Bit::set_first_value_lo(uint64_t value) {
_internal_set_first_value_lo(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_lo)
}
// int32 rice_parameter = 3;
inline void RiceDeltaEncoded128Bit::clear_rice_parameter() {
_impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded128Bit::_internal_rice_parameter() const {
return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded128Bit::rice_parameter() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.rice_parameter)
return _internal_rice_parameter();
}
inline void RiceDeltaEncoded128Bit::_internal_set_rice_parameter(int32_t value) {
_impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded128Bit::set_rice_parameter(int32_t value) {
_internal_set_rice_parameter(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.rice_parameter)
}
// int32 entries_count = 4;
inline void RiceDeltaEncoded128Bit::clear_entries_count() {
_impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded128Bit::_internal_entries_count() const {
return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded128Bit::entries_count() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.entries_count)
return _internal_entries_count();
}
inline void RiceDeltaEncoded128Bit::_internal_set_entries_count(int32_t value) {
_impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded128Bit::set_entries_count(int32_t value) {
_internal_set_entries_count(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.entries_count)
}
// bytes encoded_data = 5;
inline void RiceDeltaEncoded128Bit::clear_encoded_data() {
_impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded128Bit::encoded_data() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded128Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
_impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded128Bit::mutable_encoded_data() {
std::string* _s = _internal_mutable_encoded_data();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
return _s;
}
inline const std::string& RiceDeltaEncoded128Bit::_internal_encoded_data() const {
return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded128Bit::_internal_set_encoded_data(const std::string& value) {
_impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded128Bit::_internal_mutable_encoded_data() {
return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded128Bit::release_encoded_data() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded128Bit::set_allocated_encoded_data(std::string* encoded_data) {
if (encoded_data != nullptr) {
} else {
}
_impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.encoded_data_.IsDefault()) {
_impl_.encoded_data_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
}
// -------------------------------------------------------------------
// RiceDeltaEncoded256Bit
// uint64 first_value_first_part = 1;
inline void RiceDeltaEncoded256Bit::clear_first_value_first_part() {
_impl_.first_value_first_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_first_part() const {
return _impl_.first_value_first_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_first_part() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_first_part)
return _internal_first_value_first_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_first_part(uint64_t value) {
_impl_.first_value_first_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_first_part(uint64_t value) {
_internal_set_first_value_first_part(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_first_part)
}
// fixed64 first_value_second_part = 2;
inline void RiceDeltaEncoded256Bit::clear_first_value_second_part() {
_impl_.first_value_second_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_second_part() const {
return _impl_.first_value_second_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_second_part() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_second_part)
return _internal_first_value_second_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_second_part(uint64_t value) {
_impl_.first_value_second_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_second_part(uint64_t value) {
_internal_set_first_value_second_part(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_second_part)
}
// fixed64 first_value_third_part = 3;
inline void RiceDeltaEncoded256Bit::clear_first_value_third_part() {
_impl_.first_value_third_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_third_part() const {
return _impl_.first_value_third_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_third_part() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_third_part)
return _internal_first_value_third_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_third_part(uint64_t value) {
_impl_.first_value_third_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_third_part(uint64_t value) {
_internal_set_first_value_third_part(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_third_part)
}
// fixed64 first_value_fourth_part = 4;
inline void RiceDeltaEncoded256Bit::clear_first_value_fourth_part() {
_impl_.first_value_fourth_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_fourth_part() const {
return _impl_.first_value_fourth_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_fourth_part() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_fourth_part)
return _internal_first_value_fourth_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_fourth_part(uint64_t value) {
_impl_.first_value_fourth_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_fourth_part(uint64_t value) {
_internal_set_first_value_fourth_part(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_fourth_part)
}
// int32 rice_parameter = 5;
inline void RiceDeltaEncoded256Bit::clear_rice_parameter() {
_impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded256Bit::_internal_rice_parameter() const {
return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded256Bit::rice_parameter() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.rice_parameter)
return _internal_rice_parameter();
}
inline void RiceDeltaEncoded256Bit::_internal_set_rice_parameter(int32_t value) {
_impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded256Bit::set_rice_parameter(int32_t value) {
_internal_set_rice_parameter(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.rice_parameter)
}
// int32 entries_count = 6;
inline void RiceDeltaEncoded256Bit::clear_entries_count() {
_impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded256Bit::_internal_entries_count() const {
return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded256Bit::entries_count() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.entries_count)
return _internal_entries_count();
}
inline void RiceDeltaEncoded256Bit::_internal_set_entries_count(int32_t value) {
_impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded256Bit::set_entries_count(int32_t value) {
_internal_set_entries_count(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.entries_count)
}
// bytes encoded_data = 7;
inline void RiceDeltaEncoded256Bit::clear_encoded_data() {
_impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded256Bit::encoded_data() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded256Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
_impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded256Bit::mutable_encoded_data() {
std::string* _s = _internal_mutable_encoded_data();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
return _s;
}
inline const std::string& RiceDeltaEncoded256Bit::_internal_encoded_data() const {
return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded256Bit::_internal_set_encoded_data(const std::string& value) {
_impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded256Bit::_internal_mutable_encoded_data() {
return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded256Bit::release_encoded_data() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded256Bit::set_allocated_encoded_data(std::string* encoded_data) {
if (encoded_data != nullptr) {
} else {
}
_impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.encoded_data_.IsDefault()) {
_impl_.encoded_data_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
}
// -------------------------------------------------------------------
// HashListMetadata
// repeated .mozilla.safebrowsing.v5.ThreatType threat_types = 1;
inline int HashListMetadata::_internal_threat_types_size() const {
return _impl_.threat_types_.size();
}
inline int HashListMetadata::threat_types_size() const {
return _internal_threat_types_size();
}
inline void HashListMetadata::clear_threat_types() {
_impl_.threat_types_.Clear();
}
inline ::mozilla::safebrowsing::v5::ThreatType HashListMetadata::_internal_threat_types(int index) const {
return static_cast< ::mozilla::safebrowsing::v5::ThreatType >(_impl_.threat_types_.Get(index));
}
inline ::mozilla::safebrowsing::v5::ThreatType HashListMetadata::threat_types(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
return _internal_threat_types(index);
}
inline void HashListMetadata::set_threat_types(int index, ::mozilla::safebrowsing::v5::ThreatType value) {
_impl_.threat_types_.Set(index, value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
}
inline void HashListMetadata::_internal_add_threat_types(::mozilla::safebrowsing::v5::ThreatType value) {
_impl_.threat_types_.Add(value);
}
inline void HashListMetadata::add_threat_types(::mozilla::safebrowsing::v5::ThreatType value) {
_internal_add_threat_types(value);
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
HashListMetadata::threat_types() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
return _impl_.threat_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::_internal_mutable_threat_types() {
return &_impl_.threat_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::mutable_threat_types() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
return _internal_mutable_threat_types();
}
// repeated .mozilla.safebrowsing.v5.LikelySafeType likely_safe_types = 2;
inline int HashListMetadata::_internal_likely_safe_types_size() const {
return _impl_.likely_safe_types_.size();
}
inline int HashListMetadata::likely_safe_types_size() const {
return _internal_likely_safe_types_size();
}
inline void HashListMetadata::clear_likely_safe_types() {
_impl_.likely_safe_types_.Clear();
}
inline ::mozilla::safebrowsing::v5::LikelySafeType HashListMetadata::_internal_likely_safe_types(int index) const {
return static_cast< ::mozilla::safebrowsing::v5::LikelySafeType >(_impl_.likely_safe_types_.Get(index));
}
inline ::mozilla::safebrowsing::v5::LikelySafeType HashListMetadata::likely_safe_types(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
return _internal_likely_safe_types(index);
}
inline void HashListMetadata::set_likely_safe_types(int index, ::mozilla::safebrowsing::v5::LikelySafeType value) {
_impl_.likely_safe_types_.Set(index, value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
}
inline void HashListMetadata::_internal_add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value) {
_impl_.likely_safe_types_.Add(value);
}
inline void HashListMetadata::add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value) {
_internal_add_likely_safe_types(value);
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
HashListMetadata::likely_safe_types() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
return _impl_.likely_safe_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::_internal_mutable_likely_safe_types() {
return &_impl_.likely_safe_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::mutable_likely_safe_types() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
return _internal_mutable_likely_safe_types();
}
// string description = 4;
inline void HashListMetadata::clear_description() {
_impl_.description_.ClearToEmpty();
}
inline const std::string& HashListMetadata::description() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.description)
return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashListMetadata::set_description(ArgT0&& arg0, ArgT... args) {
_impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.description)
}
inline std::string* HashListMetadata::mutable_description() {
std::string* _s = _internal_mutable_description();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashListMetadata.description)
return _s;
}
inline const std::string& HashListMetadata::_internal_description() const {
return _impl_.description_.Get();
}
inline void HashListMetadata::_internal_set_description(const std::string& value) {
_impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* HashListMetadata::_internal_mutable_description() {
return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* HashListMetadata::release_description() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashListMetadata.description)
return _impl_.description_.Release();
}
inline void HashListMetadata::set_allocated_description(std::string* description) {
if (description != nullptr) {
} else {
}
_impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.description_.IsDefault()) {
_impl_.description_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashListMetadata.description)
}
// .mozilla.safebrowsing.v5.HashListMetadata.HashLength hash_length = 6;
inline void HashListMetadata::clear_hash_length() {
_impl_.hash_length_ = 0;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata_HashLength HashListMetadata::_internal_hash_length() const {
return static_cast< ::mozilla::safebrowsing::v5::HashListMetadata_HashLength >(_impl_.hash_length_);
}
inline ::mozilla::safebrowsing::v5::HashListMetadata_HashLength HashListMetadata::hash_length() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.hash_length)
return _internal_hash_length();
}
inline void HashListMetadata::_internal_set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value) {
_impl_.hash_length_ = value;
}
inline void HashListMetadata::set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value) {
_internal_set_hash_length(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.hash_length)
}
// -------------------------------------------------------------------
// HashList
// .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit additions_four_bytes = 4;
inline bool HashList::_internal_has_additions_four_bytes() const {
return compressed_additions_case() == kAdditionsFourBytes;
}
inline bool HashList::has_additions_four_bytes() const {
return _internal_has_additions_four_bytes();
}
inline void HashList::set_has_additions_four_bytes() {
_impl_._oneof_case_[0] = kAdditionsFourBytes;
}
inline void HashList::clear_additions_four_bytes() {
if (_internal_has_additions_four_bytes()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.compressed_additions_.additions_four_bytes_;
}
clear_has_compressed_additions();
}
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::release_additions_four_bytes() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
if (_internal_has_additions_four_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_additions_.additions_four_bytes_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.compressed_additions_.additions_four_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::_internal_additions_four_bytes() const {
return _internal_has_additions_four_bytes()
? *_impl_.compressed_additions_.additions_four_bytes_
: reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded32Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::additions_four_bytes() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
return _internal_additions_four_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::unsafe_arena_release_additions_four_bytes() {
// @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
if (_internal_has_additions_four_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_additions_.additions_four_bytes_;
_impl_.compressed_additions_.additions_four_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void HashList::unsafe_arena_set_allocated_additions_four_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes) {
clear_compressed_additions();
if (additions_four_bytes) {
set_has_additions_four_bytes();
_impl_.compressed_additions_.additions_four_bytes_ = additions_four_bytes;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::_internal_mutable_additions_four_bytes() {
if (!_internal_has_additions_four_bytes()) {
clear_compressed_additions();
set_has_additions_four_bytes();
_impl_.compressed_additions_.additions_four_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit >(GetArenaForAllocation());
}
return _impl_.compressed_additions_.additions_four_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::mutable_additions_four_bytes() {
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _msg = _internal_mutable_additions_four_bytes();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
return _msg;
}
// .mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit additions_eight_bytes = 9;
inline bool HashList::_internal_has_additions_eight_bytes() const {
return compressed_additions_case() == kAdditionsEightBytes;
}
inline bool HashList::has_additions_eight_bytes() const {
return _internal_has_additions_eight_bytes();
}
inline void HashList::set_has_additions_eight_bytes() {
_impl_._oneof_case_[0] = kAdditionsEightBytes;
}
inline void HashList::clear_additions_eight_bytes() {
if (_internal_has_additions_eight_bytes()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.compressed_additions_.additions_eight_bytes_;
}
clear_has_compressed_additions();
}
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::release_additions_eight_bytes() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
if (_internal_has_additions_eight_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* temp = _impl_.compressed_additions_.additions_eight_bytes_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.compressed_additions_.additions_eight_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& HashList::_internal_additions_eight_bytes() const {
return _internal_has_additions_eight_bytes()
? *_impl_.compressed_additions_.additions_eight_bytes_
: reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded64Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& HashList::additions_eight_bytes() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
return _internal_additions_eight_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::unsafe_arena_release_additions_eight_bytes() {
// @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
if (_internal_has_additions_eight_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* temp = _impl_.compressed_additions_.additions_eight_bytes_;
_impl_.compressed_additions_.additions_eight_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void HashList::unsafe_arena_set_allocated_additions_eight_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes) {
clear_compressed_additions();
if (additions_eight_bytes) {
set_has_additions_eight_bytes();
_impl_.compressed_additions_.additions_eight_bytes_ = additions_eight_bytes;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::_internal_mutable_additions_eight_bytes() {
if (!_internal_has_additions_eight_bytes()) {
clear_compressed_additions();
set_has_additions_eight_bytes();
_impl_.compressed_additions_.additions_eight_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit >(GetArenaForAllocation());
}
return _impl_.compressed_additions_.additions_eight_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::mutable_additions_eight_bytes() {
::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* _msg = _internal_mutable_additions_eight_bytes();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
return _msg;
}
// .mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit additions_sixteen_bytes = 10;
inline bool HashList::_internal_has_additions_sixteen_bytes() const {
return compressed_additions_case() == kAdditionsSixteenBytes;
}
inline bool HashList::has_additions_sixteen_bytes() const {
return _internal_has_additions_sixteen_bytes();
}
inline void HashList::set_has_additions_sixteen_bytes() {
_impl_._oneof_case_[0] = kAdditionsSixteenBytes;
}
inline void HashList::clear_additions_sixteen_bytes() {
if (_internal_has_additions_sixteen_bytes()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.compressed_additions_.additions_sixteen_bytes_;
}
clear_has_compressed_additions();
}
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::release_additions_sixteen_bytes() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
if (_internal_has_additions_sixteen_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* temp = _impl_.compressed_additions_.additions_sixteen_bytes_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.compressed_additions_.additions_sixteen_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& HashList::_internal_additions_sixteen_bytes() const {
return _internal_has_additions_sixteen_bytes()
? *_impl_.compressed_additions_.additions_sixteen_bytes_
: reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded128Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& HashList::additions_sixteen_bytes() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
return _internal_additions_sixteen_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::unsafe_arena_release_additions_sixteen_bytes() {
// @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
if (_internal_has_additions_sixteen_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* temp = _impl_.compressed_additions_.additions_sixteen_bytes_;
_impl_.compressed_additions_.additions_sixteen_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void HashList::unsafe_arena_set_allocated_additions_sixteen_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes) {
clear_compressed_additions();
if (additions_sixteen_bytes) {
set_has_additions_sixteen_bytes();
_impl_.compressed_additions_.additions_sixteen_bytes_ = additions_sixteen_bytes;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::_internal_mutable_additions_sixteen_bytes() {
if (!_internal_has_additions_sixteen_bytes()) {
clear_compressed_additions();
set_has_additions_sixteen_bytes();
_impl_.compressed_additions_.additions_sixteen_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit >(GetArenaForAllocation());
}
return _impl_.compressed_additions_.additions_sixteen_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::mutable_additions_sixteen_bytes() {
::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* _msg = _internal_mutable_additions_sixteen_bytes();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
return _msg;
}
// .mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit additions_thirty_two_bytes = 11;
inline bool HashList::_internal_has_additions_thirty_two_bytes() const {
return compressed_additions_case() == kAdditionsThirtyTwoBytes;
}
inline bool HashList::has_additions_thirty_two_bytes() const {
return _internal_has_additions_thirty_two_bytes();
}
inline void HashList::set_has_additions_thirty_two_bytes() {
_impl_._oneof_case_[0] = kAdditionsThirtyTwoBytes;
}
inline void HashList::clear_additions_thirty_two_bytes() {
if (_internal_has_additions_thirty_two_bytes()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.compressed_additions_.additions_thirty_two_bytes_;
}
clear_has_compressed_additions();
}
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::release_additions_thirty_two_bytes() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
if (_internal_has_additions_thirty_two_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* temp = _impl_.compressed_additions_.additions_thirty_two_bytes_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.compressed_additions_.additions_thirty_two_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& HashList::_internal_additions_thirty_two_bytes() const {
return _internal_has_additions_thirty_two_bytes()
? *_impl_.compressed_additions_.additions_thirty_two_bytes_
: reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded256Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& HashList::additions_thirty_two_bytes() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
return _internal_additions_thirty_two_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::unsafe_arena_release_additions_thirty_two_bytes() {
// @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
if (_internal_has_additions_thirty_two_bytes()) {
clear_has_compressed_additions();
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* temp = _impl_.compressed_additions_.additions_thirty_two_bytes_;
_impl_.compressed_additions_.additions_thirty_two_bytes_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void HashList::unsafe_arena_set_allocated_additions_thirty_two_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes) {
clear_compressed_additions();
if (additions_thirty_two_bytes) {
set_has_additions_thirty_two_bytes();
_impl_.compressed_additions_.additions_thirty_two_bytes_ = additions_thirty_two_bytes;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::_internal_mutable_additions_thirty_two_bytes() {
if (!_internal_has_additions_thirty_two_bytes()) {
clear_compressed_additions();
set_has_additions_thirty_two_bytes();
_impl_.compressed_additions_.additions_thirty_two_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit >(GetArenaForAllocation());
}
return _impl_.compressed_additions_.additions_thirty_two_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::mutable_additions_thirty_two_bytes() {
::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* _msg = _internal_mutable_additions_thirty_two_bytes();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
return _msg;
}
// string name = 1;
inline void HashList::clear_name() {
_impl_.name_.ClearToEmpty();
}
inline const std::string& HashList::name() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashList::set_name(ArgT0&& arg0, ArgT... args) {
_impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.name)
}
inline std::string* HashList::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.name)
return _s;
}
inline const std::string& HashList::_internal_name() const {
return _impl_.name_.Get();
}
inline void HashList::_internal_set_name(const std::string& value) {
_impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* HashList::_internal_mutable_name() {
return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* HashList::release_name() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.name)
return _impl_.name_.Release();
}
inline void HashList::set_allocated_name(std::string* name) {
if (name != nullptr) {
} else {
}
_impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.name_.IsDefault()) {
_impl_.name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.name)
}
// bytes version = 2;
inline void HashList::clear_version() {
_impl_.version_.ClearToEmpty();
}
inline const std::string& HashList::version() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.version)
return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashList::set_version(ArgT0&& arg0, ArgT... args) {
_impl_.version_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.version)
}
inline std::string* HashList::mutable_version() {
std::string* _s = _internal_mutable_version();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.version)
return _s;
}
inline const std::string& HashList::_internal_version() const {
return _impl_.version_.Get();
}
inline void HashList::_internal_set_version(const std::string& value) {
_impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* HashList::_internal_mutable_version() {
return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* HashList::release_version() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.version)
return _impl_.version_.Release();
}
inline void HashList::set_allocated_version(std::string* version) {
if (version != nullptr) {
} else {
}
_impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.version_.IsDefault()) {
_impl_.version_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.version)
}
// bool partial_update = 3;
inline void HashList::clear_partial_update() {
_impl_.partial_update_ = false;
}
inline bool HashList::_internal_partial_update() const {
return _impl_.partial_update_;
}
inline bool HashList::partial_update() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.partial_update)
return _internal_partial_update();
}
inline void HashList::_internal_set_partial_update(bool value) {
_impl_.partial_update_ = value;
}
inline void HashList::set_partial_update(bool value) {
_internal_set_partial_update(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.partial_update)
}
// .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit compressed_removals = 5;
inline bool HashList::_internal_has_compressed_removals() const {
return this != internal_default_instance() && _impl_.compressed_removals_ != nullptr;
}
inline bool HashList::has_compressed_removals() const {
return _internal_has_compressed_removals();
}
inline void HashList::clear_compressed_removals() {
if (GetArenaForAllocation() == nullptr && _impl_.compressed_removals_ != nullptr) {
delete _impl_.compressed_removals_;
}
_impl_.compressed_removals_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::_internal_compressed_removals() const {
const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* p = _impl_.compressed_removals_;
return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit&>(
::mozilla::safebrowsing::v5::_RiceDeltaEncoded32Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::compressed_removals() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.compressed_removals)
return _internal_compressed_removals();
}
inline void HashList::unsafe_arena_set_allocated_compressed_removals(
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compressed_removals_);
}
_impl_.compressed_removals_ = compressed_removals;
if (compressed_removals) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.compressed_removals)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::release_compressed_removals() {
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_removals_;
_impl_.compressed_removals_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::unsafe_arena_release_compressed_removals() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.compressed_removals)
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_removals_;
_impl_.compressed_removals_ = nullptr;
return temp;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::_internal_mutable_compressed_removals() {
if (_impl_.compressed_removals_ == nullptr) {
auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit>(GetArenaForAllocation());
_impl_.compressed_removals_ = p;
}
return _impl_.compressed_removals_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::mutable_compressed_removals() {
::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _msg = _internal_mutable_compressed_removals();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.compressed_removals)
return _msg;
}
inline void HashList::set_allocated_compressed_removals(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.compressed_removals_;
}
if (compressed_removals) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compressed_removals);
if (message_arena != submessage_arena) {
compressed_removals = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, compressed_removals, submessage_arena);
}
} else {
}
_impl_.compressed_removals_ = compressed_removals;
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.compressed_removals)
}
// .mozilla.safebrowsing.v5.Duration minimum_wait_duration = 6;
inline bool HashList::_internal_has_minimum_wait_duration() const {
return this != internal_default_instance() && _impl_.minimum_wait_duration_ != nullptr;
}
inline bool HashList::has_minimum_wait_duration() const {
return _internal_has_minimum_wait_duration();
}
inline void HashList::clear_minimum_wait_duration() {
if (GetArenaForAllocation() == nullptr && _impl_.minimum_wait_duration_ != nullptr) {
delete _impl_.minimum_wait_duration_;
}
_impl_.minimum_wait_duration_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::Duration& HashList::_internal_minimum_wait_duration() const {
const ::mozilla::safebrowsing::v5::Duration* p = _impl_.minimum_wait_duration_;
return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::Duration&>(
::mozilla::safebrowsing::v5::_Duration_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::Duration& HashList::minimum_wait_duration() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
return _internal_minimum_wait_duration();
}
inline void HashList::unsafe_arena_set_allocated_minimum_wait_duration(
::mozilla::safebrowsing::v5::Duration* minimum_wait_duration) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.minimum_wait_duration_);
}
_impl_.minimum_wait_duration_ = minimum_wait_duration;
if (minimum_wait_duration) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::release_minimum_wait_duration() {
::mozilla::safebrowsing::v5::Duration* temp = _impl_.minimum_wait_duration_;
_impl_.minimum_wait_duration_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::unsafe_arena_release_minimum_wait_duration() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
::mozilla::safebrowsing::v5::Duration* temp = _impl_.minimum_wait_duration_;
_impl_.minimum_wait_duration_ = nullptr;
return temp;
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::_internal_mutable_minimum_wait_duration() {
if (_impl_.minimum_wait_duration_ == nullptr) {
auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::Duration>(GetArenaForAllocation());
_impl_.minimum_wait_duration_ = p;
}
return _impl_.minimum_wait_duration_;
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::mutable_minimum_wait_duration() {
::mozilla::safebrowsing::v5::Duration* _msg = _internal_mutable_minimum_wait_duration();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
return _msg;
}
inline void HashList::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::v5::Duration* minimum_wait_duration) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.minimum_wait_duration_;
}
if (minimum_wait_duration) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(minimum_wait_duration);
if (message_arena != submessage_arena) {
minimum_wait_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, minimum_wait_duration, submessage_arena);
}
} else {
}
_impl_.minimum_wait_duration_ = minimum_wait_duration;
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
}
// bytes sha256_checksum = 7;
inline void HashList::clear_sha256_checksum() {
_impl_.sha256_checksum_.ClearToEmpty();
}
inline const std::string& HashList::sha256_checksum() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.sha256_checksum)
return _internal_sha256_checksum();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashList::set_sha256_checksum(ArgT0&& arg0, ArgT... args) {
_impl_.sha256_checksum_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.sha256_checksum)
}
inline std::string* HashList::mutable_sha256_checksum() {
std::string* _s = _internal_mutable_sha256_checksum();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.sha256_checksum)
return _s;
}
inline const std::string& HashList::_internal_sha256_checksum() const {
return _impl_.sha256_checksum_.Get();
}
inline void HashList::_internal_set_sha256_checksum(const std::string& value) {
_impl_.sha256_checksum_.Set(value, GetArenaForAllocation());
}
inline std::string* HashList::_internal_mutable_sha256_checksum() {
return _impl_.sha256_checksum_.Mutable(GetArenaForAllocation());
}
inline std::string* HashList::release_sha256_checksum() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.sha256_checksum)
return _impl_.sha256_checksum_.Release();
}
inline void HashList::set_allocated_sha256_checksum(std::string* sha256_checksum) {
if (sha256_checksum != nullptr) {
} else {
}
_impl_.sha256_checksum_.SetAllocated(sha256_checksum, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.sha256_checksum_.IsDefault()) {
_impl_.sha256_checksum_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.sha256_checksum)
}
// .mozilla.safebrowsing.v5.HashListMetadata metadata = 8;
inline bool HashList::_internal_has_metadata() const {
return this != internal_default_instance() && _impl_.metadata_ != nullptr;
}
inline bool HashList::has_metadata() const {
return _internal_has_metadata();
}
inline void HashList::clear_metadata() {
if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
delete _impl_.metadata_;
}
_impl_.metadata_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::HashListMetadata& HashList::_internal_metadata() const {
const ::mozilla::safebrowsing::v5::HashListMetadata* p = _impl_.metadata_;
return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::HashListMetadata&>(
::mozilla::safebrowsing::v5::_HashListMetadata_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::HashListMetadata& HashList::metadata() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.metadata)
return _internal_metadata();
}
inline void HashList::unsafe_arena_set_allocated_metadata(
::mozilla::safebrowsing::v5::HashListMetadata* metadata) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
}
_impl_.metadata_ = metadata;
if (metadata) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.metadata)
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::release_metadata() {
::mozilla::safebrowsing::v5::HashListMetadata* temp = _impl_.metadata_;
_impl_.metadata_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::unsafe_arena_release_metadata() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.metadata)
::mozilla::safebrowsing::v5::HashListMetadata* temp = _impl_.metadata_;
_impl_.metadata_ = nullptr;
return temp;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::_internal_mutable_metadata() {
if (_impl_.metadata_ == nullptr) {
auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::HashListMetadata>(GetArenaForAllocation());
_impl_.metadata_ = p;
}
return _impl_.metadata_;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::mutable_metadata() {
::mozilla::safebrowsing::v5::HashListMetadata* _msg = _internal_mutable_metadata();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.metadata)
return _msg;
}
inline void HashList::set_allocated_metadata(::mozilla::safebrowsing::v5::HashListMetadata* metadata) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.metadata_;
}
if (metadata) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata);
if (message_arena != submessage_arena) {
metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, metadata, submessage_arena);
}
} else {
}
_impl_.metadata_ = metadata;
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.metadata)
}
inline bool HashList::has_compressed_additions() const {
return compressed_additions_case() != COMPRESSED_ADDITIONS_NOT_SET;
}
inline void HashList::clear_has_compressed_additions() {
_impl_._oneof_case_[0] = COMPRESSED_ADDITIONS_NOT_SET;
}
inline HashList::CompressedAdditionsCase HashList::compressed_additions_case() const {
return HashList::CompressedAdditionsCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
// BatchGetHashListsRequest
// repeated string names = 1;
inline int BatchGetHashListsRequest::_internal_names_size() const {
return _impl_.names_.size();
}
inline int BatchGetHashListsRequest::names_size() const {
return _internal_names_size();
}
inline void BatchGetHashListsRequest::clear_names() {
_impl_.names_.Clear();
}
inline std::string* BatchGetHashListsRequest::add_names() {
std::string* _s = _internal_add_names();
// @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
return _s;
}
inline const std::string& BatchGetHashListsRequest::_internal_names(int index) const {
return _impl_.names_.Get(index);
}
inline const std::string& BatchGetHashListsRequest::names(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
return _internal_names(index);
}
inline std::string* BatchGetHashListsRequest::mutable_names(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
return _impl_.names_.Mutable(index);
}
inline void BatchGetHashListsRequest::set_names(int index, const std::string& value) {
_impl_.names_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::set_names(int index, std::string&& value) {
_impl_.names_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::set_names(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.names_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::set_names(int index, const char* value, size_t size) {
_impl_.names_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline std::string* BatchGetHashListsRequest::_internal_add_names() {
return _impl_.names_.Add();
}
inline void BatchGetHashListsRequest::add_names(const std::string& value) {
_impl_.names_.Add()->assign(value);
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::add_names(std::string&& value) {
_impl_.names_.Add(std::move(value));
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::add_names(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.names_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::add_names(const char* value, size_t size) {
_impl_.names_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BatchGetHashListsRequest::names() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
return _impl_.names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BatchGetHashListsRequest::mutable_names() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
return &_impl_.names_;
}
// repeated bytes version = 2;
inline int BatchGetHashListsRequest::_internal_version_size() const {
return _impl_.version_.size();
}
inline int BatchGetHashListsRequest::version_size() const {
return _internal_version_size();
}
inline void BatchGetHashListsRequest::clear_version() {
_impl_.version_.Clear();
}
inline std::string* BatchGetHashListsRequest::add_version() {
std::string* _s = _internal_add_version();
// @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
return _s;
}
inline const std::string& BatchGetHashListsRequest::_internal_version(int index) const {
return _impl_.version_.Get(index);
}
inline const std::string& BatchGetHashListsRequest::version(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
return _internal_version(index);
}
inline std::string* BatchGetHashListsRequest::mutable_version(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
return _impl_.version_.Mutable(index);
}
inline void BatchGetHashListsRequest::set_version(int index, const std::string& value) {
_impl_.version_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::set_version(int index, std::string&& value) {
_impl_.version_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::set_version(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.version_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::set_version(int index, const void* value, size_t size) {
_impl_.version_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline std::string* BatchGetHashListsRequest::_internal_add_version() {
return _impl_.version_.Add();
}
inline void BatchGetHashListsRequest::add_version(const std::string& value) {
_impl_.version_.Add()->assign(value);
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::add_version(std::string&& value) {
_impl_.version_.Add(std::move(value));
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::add_version(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.version_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::add_version(const void* value, size_t size) {
_impl_.version_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BatchGetHashListsRequest::version() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
return _impl_.version_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BatchGetHashListsRequest::mutable_version() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
return &_impl_.version_;
}
// .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
inline bool BatchGetHashListsRequest::_internal_has_size_constraints() const {
return this != internal_default_instance() && _impl_.size_constraints_ != nullptr;
}
inline bool BatchGetHashListsRequest::has_size_constraints() const {
return _internal_has_size_constraints();
}
inline void BatchGetHashListsRequest::clear_size_constraints() {
if (GetArenaForAllocation() == nullptr && _impl_.size_constraints_ != nullptr) {
delete _impl_.size_constraints_;
}
_impl_.size_constraints_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& BatchGetHashListsRequest::_internal_size_constraints() const {
const ::mozilla::safebrowsing::v5::SizeConstraints* p = _impl_.size_constraints_;
return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::SizeConstraints&>(
::mozilla::safebrowsing::v5::_SizeConstraints_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& BatchGetHashListsRequest::size_constraints() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
return _internal_size_constraints();
}
inline void BatchGetHashListsRequest::unsafe_arena_set_allocated_size_constraints(
::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.size_constraints_);
}
_impl_.size_constraints_ = size_constraints;
if (size_constraints) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::release_size_constraints() {
::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
_impl_.size_constraints_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::unsafe_arena_release_size_constraints() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
_impl_.size_constraints_ = nullptr;
return temp;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::_internal_mutable_size_constraints() {
if (_impl_.size_constraints_ == nullptr) {
auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::SizeConstraints>(GetArenaForAllocation());
_impl_.size_constraints_ = p;
}
return _impl_.size_constraints_;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::mutable_size_constraints() {
::mozilla::safebrowsing::v5::SizeConstraints* _msg = _internal_mutable_size_constraints();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
return _msg;
}
inline void BatchGetHashListsRequest::set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.size_constraints_;
}
if (size_constraints) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(size_constraints);
if (message_arena != submessage_arena) {
size_constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, size_constraints, submessage_arena);
}
} else {
}
_impl_.size_constraints_ = size_constraints;
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
}
// -------------------------------------------------------------------
// BatchGetHashListsResponse
// repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
inline int BatchGetHashListsResponse::_internal_hash_lists_size() const {
return _impl_.hash_lists_.size();
}
inline int BatchGetHashListsResponse::hash_lists_size() const {
return _internal_hash_lists_size();
}
inline void BatchGetHashListsResponse::clear_hash_lists() {
_impl_.hash_lists_.Clear();
}
inline ::mozilla::safebrowsing::v5::HashList* BatchGetHashListsResponse::mutable_hash_lists(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
return _impl_.hash_lists_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
BatchGetHashListsResponse::mutable_hash_lists() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
return &_impl_.hash_lists_;
}
inline const ::mozilla::safebrowsing::v5::HashList& BatchGetHashListsResponse::_internal_hash_lists(int index) const {
return _impl_.hash_lists_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::HashList& BatchGetHashListsResponse::hash_lists(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
return _internal_hash_lists(index);
}
inline ::mozilla::safebrowsing::v5::HashList* BatchGetHashListsResponse::_internal_add_hash_lists() {
return _impl_.hash_lists_.Add();
}
inline ::mozilla::safebrowsing::v5::HashList* BatchGetHashListsResponse::add_hash_lists() {
::mozilla::safebrowsing::v5::HashList* _add = _internal_add_hash_lists();
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
BatchGetHashListsResponse::hash_lists() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
return _impl_.hash_lists_;
}
// -------------------------------------------------------------------
// ListHashListsRequest
// int32 page_size = 1;
inline void ListHashListsRequest::clear_page_size() {
_impl_.page_size_ = 0;
}
inline int32_t ListHashListsRequest::_internal_page_size() const {
return _impl_.page_size_;
}
inline int32_t ListHashListsRequest::page_size() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsRequest.page_size)
return _internal_page_size();
}
inline void ListHashListsRequest::_internal_set_page_size(int32_t value) {
_impl_.page_size_ = value;
}
inline void ListHashListsRequest::set_page_size(int32_t value) {
_internal_set_page_size(value);
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.ListHashListsRequest.page_size)
}
// string page_token = 2;
inline void ListHashListsRequest::clear_page_token() {
_impl_.page_token_.ClearToEmpty();
}
inline const std::string& ListHashListsRequest::page_token() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
return _internal_page_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ListHashListsRequest::set_page_token(ArgT0&& arg0, ArgT... args) {
_impl_.page_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
}
inline std::string* ListHashListsRequest::mutable_page_token() {
std::string* _s = _internal_mutable_page_token();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
return _s;
}
inline const std::string& ListHashListsRequest::_internal_page_token() const {
return _impl_.page_token_.Get();
}
inline void ListHashListsRequest::_internal_set_page_token(const std::string& value) {
_impl_.page_token_.Set(value, GetArenaForAllocation());
}
inline std::string* ListHashListsRequest::_internal_mutable_page_token() {
return _impl_.page_token_.Mutable(GetArenaForAllocation());
}
inline std::string* ListHashListsRequest::release_page_token() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
return _impl_.page_token_.Release();
}
inline void ListHashListsRequest::set_allocated_page_token(std::string* page_token) {
if (page_token != nullptr) {
} else {
}
_impl_.page_token_.SetAllocated(page_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.page_token_.IsDefault()) {
_impl_.page_token_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
}
// -------------------------------------------------------------------
// ListHashListsResponse
// repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
inline int ListHashListsResponse::_internal_hash_lists_size() const {
return _impl_.hash_lists_.size();
}
inline int ListHashListsResponse::hash_lists_size() const {
return _internal_hash_lists_size();
}
inline void ListHashListsResponse::clear_hash_lists() {
_impl_.hash_lists_.Clear();
}
inline ::mozilla::safebrowsing::v5::HashList* ListHashListsResponse::mutable_hash_lists(int index) {
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
return _impl_.hash_lists_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
ListHashListsResponse::mutable_hash_lists() {
// @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
return &_impl_.hash_lists_;
}
inline const ::mozilla::safebrowsing::v5::HashList& ListHashListsResponse::_internal_hash_lists(int index) const {
return _impl_.hash_lists_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::HashList& ListHashListsResponse::hash_lists(int index) const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
return _internal_hash_lists(index);
}
inline ::mozilla::safebrowsing::v5::HashList* ListHashListsResponse::_internal_add_hash_lists() {
return _impl_.hash_lists_.Add();
}
inline ::mozilla::safebrowsing::v5::HashList* ListHashListsResponse::add_hash_lists() {
::mozilla::safebrowsing::v5::HashList* _add = _internal_add_hash_lists();
// @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
ListHashListsResponse::hash_lists() const {
// @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
return _impl_.hash_lists_;
}
// string next_page_token = 2;
inline void ListHashListsResponse::clear_next_page_token() {
_impl_.next_page_token_.ClearToEmpty();
}
inline const std::string& ListHashListsResponse::next_page_token() const {
// @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
return _internal_next_page_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ListHashListsResponse::set_next_page_token(ArgT0&& arg0, ArgT... args) {
_impl_.next_page_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
}
inline std::string* ListHashListsResponse::mutable_next_page_token() {
std::string* _s = _internal_mutable_next_page_token();
// @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
return _s;
}
inline const std::string& ListHashListsResponse::_internal_next_page_token() const {
return _impl_.next_page_token_.Get();
}
inline void ListHashListsResponse::_internal_set_next_page_token(const std::string& value) {
_impl_.next_page_token_.Set(value, GetArenaForAllocation());
}
inline std::string* ListHashListsResponse::_internal_mutable_next_page_token() {
return _impl_.next_page_token_.Mutable(GetArenaForAllocation());
}
inline std::string* ListHashListsResponse::release_next_page_token() {
// @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
return _impl_.next_page_token_.Release();
}
inline void ListHashListsResponse::set_allocated_next_page_token(std::string* next_page_token) {
if (next_page_token != nullptr) {
} else {
}
_impl_.next_page_token_.SetAllocated(next_page_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.next_page_token_.IsDefault()) {
_impl_.next_page_token_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace v5
} // namespace safebrowsing
} // namespace mozilla
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::HashListMetadata_HashLength> : ::std::true_type {};
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::ThreatType> : ::std::true_type {};
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::LikelySafeType> : ::std::true_type {};
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::ThreatAttribute> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_safebrowsing_5fv5_2eproto