Android build for ungoogled-chromium. https://uc.droidware.info
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

2085 lines
93 KiB

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: webprotect.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_webprotect_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_webprotect_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#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 3009000 < 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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.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_webprotect_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_webprotect_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace safe_browsing {
class DeepScanningClientRequest;
class DeepScanningClientRequestDefaultTypeInternal;
extern DeepScanningClientRequestDefaultTypeInternal _DeepScanningClientRequest_default_instance_;
class DeepScanningClientResponse;
class DeepScanningClientResponseDefaultTypeInternal;
extern DeepScanningClientResponseDefaultTypeInternal _DeepScanningClientResponse_default_instance_;
class DlpDeepScanningClientRequest;
class DlpDeepScanningClientRequestDefaultTypeInternal;
extern DlpDeepScanningClientRequestDefaultTypeInternal _DlpDeepScanningClientRequest_default_instance_;
class DlpDeepScanningVerdict;
class DlpDeepScanningVerdictDefaultTypeInternal;
extern DlpDeepScanningVerdictDefaultTypeInternal _DlpDeepScanningVerdict_default_instance_;
class DlpDeepScanningVerdict_TriggeredRule;
class DlpDeepScanningVerdict_TriggeredRuleDefaultTypeInternal;
extern DlpDeepScanningVerdict_TriggeredRuleDefaultTypeInternal _DlpDeepScanningVerdict_TriggeredRule_default_instance_;
class MalwareDeepScanningClientRequest;
class MalwareDeepScanningClientRequestDefaultTypeInternal;
extern MalwareDeepScanningClientRequestDefaultTypeInternal _MalwareDeepScanningClientRequest_default_instance_;
class MalwareDeepScanningVerdict;
class MalwareDeepScanningVerdictDefaultTypeInternal;
extern MalwareDeepScanningVerdictDefaultTypeInternal _MalwareDeepScanningVerdict_default_instance_;
} // namespace safe_browsing
PROTOBUF_NAMESPACE_OPEN
template<> ::safe_browsing::DeepScanningClientRequest* Arena::CreateMaybeMessage<::safe_browsing::DeepScanningClientRequest>(Arena*);
template<> ::safe_browsing::DeepScanningClientResponse* Arena::CreateMaybeMessage<::safe_browsing::DeepScanningClientResponse>(Arena*);
template<> ::safe_browsing::DlpDeepScanningClientRequest* Arena::CreateMaybeMessage<::safe_browsing::DlpDeepScanningClientRequest>(Arena*);
template<> ::safe_browsing::DlpDeepScanningVerdict* Arena::CreateMaybeMessage<::safe_browsing::DlpDeepScanningVerdict>(Arena*);
template<> ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule* Arena::CreateMaybeMessage<::safe_browsing::DlpDeepScanningVerdict_TriggeredRule>(Arena*);
template<> ::safe_browsing::MalwareDeepScanningClientRequest* Arena::CreateMaybeMessage<::safe_browsing::MalwareDeepScanningClientRequest>(Arena*);
template<> ::safe_browsing::MalwareDeepScanningVerdict* Arena::CreateMaybeMessage<::safe_browsing::MalwareDeepScanningVerdict>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace safe_browsing {
enum MalwareDeepScanningClientRequest_Population : int {
MalwareDeepScanningClientRequest_Population_POPULATION_UNKNOWN = 0,
MalwareDeepScanningClientRequest_Population_POPULATION_ENTERPRISE = 1,
MalwareDeepScanningClientRequest_Population_POPULATION_TITANIUM = 2
};
bool MalwareDeepScanningClientRequest_Population_IsValid(int value);
constexpr MalwareDeepScanningClientRequest_Population MalwareDeepScanningClientRequest_Population_Population_MIN = MalwareDeepScanningClientRequest_Population_POPULATION_UNKNOWN;
constexpr MalwareDeepScanningClientRequest_Population MalwareDeepScanningClientRequest_Population_Population_MAX = MalwareDeepScanningClientRequest_Population_POPULATION_TITANIUM;
constexpr int MalwareDeepScanningClientRequest_Population_Population_ARRAYSIZE = MalwareDeepScanningClientRequest_Population_Population_MAX + 1;
const std::string& MalwareDeepScanningClientRequest_Population_Name(MalwareDeepScanningClientRequest_Population value);
template<typename T>
inline const std::string& MalwareDeepScanningClientRequest_Population_Name(T enum_t_value) {
static_assert(::std::is_same<T, MalwareDeepScanningClientRequest_Population>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MalwareDeepScanningClientRequest_Population_Name.");
return MalwareDeepScanningClientRequest_Population_Name(static_cast<MalwareDeepScanningClientRequest_Population>(enum_t_value));
}
bool MalwareDeepScanningClientRequest_Population_Parse(
const std::string& name, MalwareDeepScanningClientRequest_Population* value);
enum DlpDeepScanningClientRequest_ContentSource : int {
DlpDeepScanningClientRequest_ContentSource_CONTENT_SOURCE_UNKNOWN = 0,
DlpDeepScanningClientRequest_ContentSource_FILE_DOWNLOAD = 1,
DlpDeepScanningClientRequest_ContentSource_FILE_UPLOAD = 2,
DlpDeepScanningClientRequest_ContentSource_WEB_CONTENT_UPLOAD = 3
};
bool DlpDeepScanningClientRequest_ContentSource_IsValid(int value);
constexpr DlpDeepScanningClientRequest_ContentSource DlpDeepScanningClientRequest_ContentSource_ContentSource_MIN = DlpDeepScanningClientRequest_ContentSource_CONTENT_SOURCE_UNKNOWN;
constexpr DlpDeepScanningClientRequest_ContentSource DlpDeepScanningClientRequest_ContentSource_ContentSource_MAX = DlpDeepScanningClientRequest_ContentSource_WEB_CONTENT_UPLOAD;
constexpr int DlpDeepScanningClientRequest_ContentSource_ContentSource_ARRAYSIZE = DlpDeepScanningClientRequest_ContentSource_ContentSource_MAX + 1;
const std::string& DlpDeepScanningClientRequest_ContentSource_Name(DlpDeepScanningClientRequest_ContentSource value);
template<typename T>
inline const std::string& DlpDeepScanningClientRequest_ContentSource_Name(T enum_t_value) {
static_assert(::std::is_same<T, DlpDeepScanningClientRequest_ContentSource>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DlpDeepScanningClientRequest_ContentSource_Name.");
return DlpDeepScanningClientRequest_ContentSource_Name(static_cast<DlpDeepScanningClientRequest_ContentSource>(enum_t_value));
}
bool DlpDeepScanningClientRequest_ContentSource_Parse(
const std::string& name, DlpDeepScanningClientRequest_ContentSource* value);
enum MalwareDeepScanningVerdict_Verdict : int {
MalwareDeepScanningVerdict_Verdict_VERDICT_UNSPECIFIED = 0,
MalwareDeepScanningVerdict_Verdict_CLEAN = 1,
MalwareDeepScanningVerdict_Verdict_UWS = 2,
MalwareDeepScanningVerdict_Verdict_MALWARE = 3
};
bool MalwareDeepScanningVerdict_Verdict_IsValid(int value);
constexpr MalwareDeepScanningVerdict_Verdict MalwareDeepScanningVerdict_Verdict_Verdict_MIN = MalwareDeepScanningVerdict_Verdict_VERDICT_UNSPECIFIED;
constexpr MalwareDeepScanningVerdict_Verdict MalwareDeepScanningVerdict_Verdict_Verdict_MAX = MalwareDeepScanningVerdict_Verdict_MALWARE;
constexpr int MalwareDeepScanningVerdict_Verdict_Verdict_ARRAYSIZE = MalwareDeepScanningVerdict_Verdict_Verdict_MAX + 1;
const std::string& MalwareDeepScanningVerdict_Verdict_Name(MalwareDeepScanningVerdict_Verdict value);
template<typename T>
inline const std::string& MalwareDeepScanningVerdict_Verdict_Name(T enum_t_value) {
static_assert(::std::is_same<T, MalwareDeepScanningVerdict_Verdict>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MalwareDeepScanningVerdict_Verdict_Name.");
return MalwareDeepScanningVerdict_Verdict_Name(static_cast<MalwareDeepScanningVerdict_Verdict>(enum_t_value));
}
bool MalwareDeepScanningVerdict_Verdict_Parse(
const std::string& name, MalwareDeepScanningVerdict_Verdict* value);
enum DlpDeepScanningVerdict_TriggeredRule_Action : int {
DlpDeepScanningVerdict_TriggeredRule_Action_ACTION_UNKNOWN = 0,
DlpDeepScanningVerdict_TriggeredRule_Action_REPORT_ONLY = 1,
DlpDeepScanningVerdict_TriggeredRule_Action_WARN = 2,
DlpDeepScanningVerdict_TriggeredRule_Action_BLOCK = 3
};
bool DlpDeepScanningVerdict_TriggeredRule_Action_IsValid(int value);
constexpr DlpDeepScanningVerdict_TriggeredRule_Action DlpDeepScanningVerdict_TriggeredRule_Action_Action_MIN = DlpDeepScanningVerdict_TriggeredRule_Action_ACTION_UNKNOWN;
constexpr DlpDeepScanningVerdict_TriggeredRule_Action DlpDeepScanningVerdict_TriggeredRule_Action_Action_MAX = DlpDeepScanningVerdict_TriggeredRule_Action_BLOCK;
constexpr int DlpDeepScanningVerdict_TriggeredRule_Action_Action_ARRAYSIZE = DlpDeepScanningVerdict_TriggeredRule_Action_Action_MAX + 1;
const std::string& DlpDeepScanningVerdict_TriggeredRule_Action_Name(DlpDeepScanningVerdict_TriggeredRule_Action value);
template<typename T>
inline const std::string& DlpDeepScanningVerdict_TriggeredRule_Action_Name(T enum_t_value) {
static_assert(::std::is_same<T, DlpDeepScanningVerdict_TriggeredRule_Action>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DlpDeepScanningVerdict_TriggeredRule_Action_Name.");
return DlpDeepScanningVerdict_TriggeredRule_Action_Name(static_cast<DlpDeepScanningVerdict_TriggeredRule_Action>(enum_t_value));
}
bool DlpDeepScanningVerdict_TriggeredRule_Action_Parse(
const std::string& name, DlpDeepScanningVerdict_TriggeredRule_Action* value);
enum DlpDeepScanningVerdict_Status : int {
DlpDeepScanningVerdict_Status_STATUS_UNKNOWN = 0,
DlpDeepScanningVerdict_Status_SUCCESS = 1,
DlpDeepScanningVerdict_Status_FAILURE = 2
};
bool DlpDeepScanningVerdict_Status_IsValid(int value);
constexpr DlpDeepScanningVerdict_Status DlpDeepScanningVerdict_Status_Status_MIN = DlpDeepScanningVerdict_Status_STATUS_UNKNOWN;
constexpr DlpDeepScanningVerdict_Status DlpDeepScanningVerdict_Status_Status_MAX = DlpDeepScanningVerdict_Status_FAILURE;
constexpr int DlpDeepScanningVerdict_Status_Status_ARRAYSIZE = DlpDeepScanningVerdict_Status_Status_MAX + 1;
const std::string& DlpDeepScanningVerdict_Status_Name(DlpDeepScanningVerdict_Status value);
template<typename T>
inline const std::string& DlpDeepScanningVerdict_Status_Name(T enum_t_value) {
static_assert(::std::is_same<T, DlpDeepScanningVerdict_Status>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DlpDeepScanningVerdict_Status_Name.");
return DlpDeepScanningVerdict_Status_Name(static_cast<DlpDeepScanningVerdict_Status>(enum_t_value));
}
bool DlpDeepScanningVerdict_Status_Parse(
const std::string& name, DlpDeepScanningVerdict_Status* value);
// ===================================================================
class MalwareDeepScanningClientRequest :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.MalwareDeepScanningClientRequest) */ {
public:
MalwareDeepScanningClientRequest();
virtual ~MalwareDeepScanningClientRequest();
MalwareDeepScanningClientRequest(const MalwareDeepScanningClientRequest& from);
MalwareDeepScanningClientRequest(MalwareDeepScanningClientRequest&& from) noexcept
: MalwareDeepScanningClientRequest() {
*this = ::std::move(from);
}
inline MalwareDeepScanningClientRequest& operator=(const MalwareDeepScanningClientRequest& from) {
CopyFrom(from);
return *this;
}
inline MalwareDeepScanningClientRequest& operator=(MalwareDeepScanningClientRequest&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const MalwareDeepScanningClientRequest& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const MalwareDeepScanningClientRequest* internal_default_instance() {
return reinterpret_cast<const MalwareDeepScanningClientRequest*>(
&_MalwareDeepScanningClientRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(MalwareDeepScanningClientRequest& a, MalwareDeepScanningClientRequest& b) {
a.Swap(&b);
}
inline void Swap(MalwareDeepScanningClientRequest* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MalwareDeepScanningClientRequest* New() const final {
return CreateMaybeMessage<MalwareDeepScanningClientRequest>(nullptr);
}
MalwareDeepScanningClientRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MalwareDeepScanningClientRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const MalwareDeepScanningClientRequest& from);
void MergeFrom(const MalwareDeepScanningClientRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(MalwareDeepScanningClientRequest* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.MalwareDeepScanningClientRequest";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef MalwareDeepScanningClientRequest_Population Population;
static constexpr Population POPULATION_UNKNOWN =
MalwareDeepScanningClientRequest_Population_POPULATION_UNKNOWN;
static constexpr Population POPULATION_ENTERPRISE =
MalwareDeepScanningClientRequest_Population_POPULATION_ENTERPRISE;
static constexpr Population POPULATION_TITANIUM =
MalwareDeepScanningClientRequest_Population_POPULATION_TITANIUM;
static inline bool Population_IsValid(int value) {
return MalwareDeepScanningClientRequest_Population_IsValid(value);
}
static constexpr Population Population_MIN =
MalwareDeepScanningClientRequest_Population_Population_MIN;
static constexpr Population Population_MAX =
MalwareDeepScanningClientRequest_Population_Population_MAX;
static constexpr int Population_ARRAYSIZE =
MalwareDeepScanningClientRequest_Population_Population_ARRAYSIZE;
template<typename T>
static inline const std::string& Population_Name(T enum_t_value) {
static_assert(::std::is_same<T, Population>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Population_Name.");
return MalwareDeepScanningClientRequest_Population_Name(enum_t_value);
}
static inline bool Population_Parse(const std::string& name,
Population* value) {
return MalwareDeepScanningClientRequest_Population_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kDownloadTokenFieldNumber = 2,
kPopulationFieldNumber = 1,
};
// optional string download_token = 2;
bool has_download_token() const;
void clear_download_token();
const std::string& download_token() const;
void set_download_token(const std::string& value);
void set_download_token(std::string&& value);
void set_download_token(const char* value);
void set_download_token(const char* value, size_t size);
std::string* mutable_download_token();
std::string* release_download_token();
void set_allocated_download_token(std::string* download_token);
// optional .safe_browsing.MalwareDeepScanningClientRequest.Population population = 1;
bool has_population() const;
void clear_population();
::safe_browsing::MalwareDeepScanningClientRequest_Population population() const;
void set_population(::safe_browsing::MalwareDeepScanningClientRequest_Population value);
// @@protoc_insertion_point(class_scope:safe_browsing.MalwareDeepScanningClientRequest)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr download_token_;
int population_;
friend struct ::TableStruct_webprotect_2eproto;
};
// -------------------------------------------------------------------
class DlpDeepScanningClientRequest :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DlpDeepScanningClientRequest) */ {
public:
DlpDeepScanningClientRequest();
virtual ~DlpDeepScanningClientRequest();
DlpDeepScanningClientRequest(const DlpDeepScanningClientRequest& from);
DlpDeepScanningClientRequest(DlpDeepScanningClientRequest&& from) noexcept
: DlpDeepScanningClientRequest() {
*this = ::std::move(from);
}
inline DlpDeepScanningClientRequest& operator=(const DlpDeepScanningClientRequest& from) {
CopyFrom(from);
return *this;
}
inline DlpDeepScanningClientRequest& operator=(DlpDeepScanningClientRequest&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const DlpDeepScanningClientRequest& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DlpDeepScanningClientRequest* internal_default_instance() {
return reinterpret_cast<const DlpDeepScanningClientRequest*>(
&_DlpDeepScanningClientRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(DlpDeepScanningClientRequest& a, DlpDeepScanningClientRequest& b) {
a.Swap(&b);
}
inline void Swap(DlpDeepScanningClientRequest* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DlpDeepScanningClientRequest* New() const final {
return CreateMaybeMessage<DlpDeepScanningClientRequest>(nullptr);
}
DlpDeepScanningClientRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DlpDeepScanningClientRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const DlpDeepScanningClientRequest& from);
void MergeFrom(const DlpDeepScanningClientRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(DlpDeepScanningClientRequest* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.DlpDeepScanningClientRequest";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef DlpDeepScanningClientRequest_ContentSource ContentSource;
static constexpr ContentSource CONTENT_SOURCE_UNKNOWN =
DlpDeepScanningClientRequest_ContentSource_CONTENT_SOURCE_UNKNOWN;
static constexpr ContentSource FILE_DOWNLOAD =
DlpDeepScanningClientRequest_ContentSource_FILE_DOWNLOAD;
static constexpr ContentSource FILE_UPLOAD =
DlpDeepScanningClientRequest_ContentSource_FILE_UPLOAD;
static constexpr ContentSource WEB_CONTENT_UPLOAD =
DlpDeepScanningClientRequest_ContentSource_WEB_CONTENT_UPLOAD;
static inline bool ContentSource_IsValid(int value) {
return DlpDeepScanningClientRequest_ContentSource_IsValid(value);
}
static constexpr ContentSource ContentSource_MIN =
DlpDeepScanningClientRequest_ContentSource_ContentSource_MIN;
static constexpr ContentSource ContentSource_MAX =
DlpDeepScanningClientRequest_ContentSource_ContentSource_MAX;
static constexpr int ContentSource_ARRAYSIZE =
DlpDeepScanningClientRequest_ContentSource_ContentSource_ARRAYSIZE;
template<typename T>
static inline const std::string& ContentSource_Name(T enum_t_value) {
static_assert(::std::is_same<T, ContentSource>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ContentSource_Name.");
return DlpDeepScanningClientRequest_ContentSource_Name(enum_t_value);
}
static inline bool ContentSource_Parse(const std::string& name,
ContentSource* value) {
return DlpDeepScanningClientRequest_ContentSource_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kContentSourceFieldNumber = 1,
};
// optional .safe_browsing.DlpDeepScanningClientRequest.ContentSource content_source = 1;
bool has_content_source() const;
void clear_content_source();
::safe_browsing::DlpDeepScanningClientRequest_ContentSource content_source() const;
void set_content_source(::safe_browsing::DlpDeepScanningClientRequest_ContentSource value);
// @@protoc_insertion_point(class_scope:safe_browsing.DlpDeepScanningClientRequest)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int content_source_;
friend struct ::TableStruct_webprotect_2eproto;
};
// -------------------------------------------------------------------
class DeepScanningClientRequest :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DeepScanningClientRequest) */ {
public:
DeepScanningClientRequest();
virtual ~DeepScanningClientRequest();
DeepScanningClientRequest(const DeepScanningClientRequest& from);
DeepScanningClientRequest(DeepScanningClientRequest&& from) noexcept
: DeepScanningClientRequest() {
*this = ::std::move(from);
}
inline DeepScanningClientRequest& operator=(const DeepScanningClientRequest& from) {
CopyFrom(from);
return *this;
}
inline DeepScanningClientRequest& operator=(DeepScanningClientRequest&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const DeepScanningClientRequest& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DeepScanningClientRequest* internal_default_instance() {
return reinterpret_cast<const DeepScanningClientRequest*>(
&_DeepScanningClientRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(DeepScanningClientRequest& a, DeepScanningClientRequest& b) {
a.Swap(&b);
}
inline void Swap(DeepScanningClientRequest* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DeepScanningClientRequest* New() const final {
return CreateMaybeMessage<DeepScanningClientRequest>(nullptr);
}
DeepScanningClientRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DeepScanningClientRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const DeepScanningClientRequest& from);
void MergeFrom(const DeepScanningClientRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(DeepScanningClientRequest* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.DeepScanningClientRequest";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDmTokenFieldNumber = 1,
kFcmNotificationTokenFieldNumber = 2,
kRequestTokenFieldNumber = 5,
kMalwareScanRequestFieldNumber = 3,
kDlpScanRequestFieldNumber = 4,
};
// optional string dm_token = 1;
bool has_dm_token() const;
void clear_dm_token();
const std::string& dm_token() const;
void set_dm_token(const std::string& value);
void set_dm_token(std::string&& value);
void set_dm_token(const char* value);
void set_dm_token(const char* value, size_t size);
std::string* mutable_dm_token();
std::string* release_dm_token();
void set_allocated_dm_token(std::string* dm_token);
// optional string fcm_notification_token = 2;
bool has_fcm_notification_token() const;
void clear_fcm_notification_token();
const std::string& fcm_notification_token() const;
void set_fcm_notification_token(const std::string& value);
void set_fcm_notification_token(std::string&& value);
void set_fcm_notification_token(const char* value);
void set_fcm_notification_token(const char* value, size_t size);
std::string* mutable_fcm_notification_token();
std::string* release_fcm_notification_token();
void set_allocated_fcm_notification_token(std::string* fcm_notification_token);
// optional string request_token = 5;
bool has_request_token() const;
void clear_request_token();
const std::string& request_token() const;
void set_request_token(const std::string& value);
void set_request_token(std::string&& value);
void set_request_token(const char* value);
void set_request_token(const char* value, size_t size);
std::string* mutable_request_token();
std::string* release_request_token();
void set_allocated_request_token(std::string* request_token);
// optional .safe_browsing.MalwareDeepScanningClientRequest malware_scan_request = 3;
bool has_malware_scan_request() const;
void clear_malware_scan_request();
const ::safe_browsing::MalwareDeepScanningClientRequest& malware_scan_request() const;
::safe_browsing::MalwareDeepScanningClientRequest* release_malware_scan_request();
::safe_browsing::MalwareDeepScanningClientRequest* mutable_malware_scan_request();
void set_allocated_malware_scan_request(::safe_browsing::MalwareDeepScanningClientRequest* malware_scan_request);
// optional .safe_browsing.DlpDeepScanningClientRequest dlp_scan_request = 4;
bool has_dlp_scan_request() const;
void clear_dlp_scan_request();
const ::safe_browsing::DlpDeepScanningClientRequest& dlp_scan_request() const;
::safe_browsing::DlpDeepScanningClientRequest* release_dlp_scan_request();
::safe_browsing::DlpDeepScanningClientRequest* mutable_dlp_scan_request();
void set_allocated_dlp_scan_request(::safe_browsing::DlpDeepScanningClientRequest* dlp_scan_request);
// @@protoc_insertion_point(class_scope:safe_browsing.DeepScanningClientRequest)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dm_token_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fcm_notification_token_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_token_;
::safe_browsing::MalwareDeepScanningClientRequest* malware_scan_request_;
::safe_browsing::DlpDeepScanningClientRequest* dlp_scan_request_;
friend struct ::TableStruct_webprotect_2eproto;
};
// -------------------------------------------------------------------
class MalwareDeepScanningVerdict :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.MalwareDeepScanningVerdict) */ {
public:
MalwareDeepScanningVerdict();
virtual ~MalwareDeepScanningVerdict();
MalwareDeepScanningVerdict(const MalwareDeepScanningVerdict& from);
MalwareDeepScanningVerdict(MalwareDeepScanningVerdict&& from) noexcept
: MalwareDeepScanningVerdict() {
*this = ::std::move(from);
}
inline MalwareDeepScanningVerdict& operator=(const MalwareDeepScanningVerdict& from) {
CopyFrom(from);
return *this;
}
inline MalwareDeepScanningVerdict& operator=(MalwareDeepScanningVerdict&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const MalwareDeepScanningVerdict& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const MalwareDeepScanningVerdict* internal_default_instance() {
return reinterpret_cast<const MalwareDeepScanningVerdict*>(
&_MalwareDeepScanningVerdict_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(MalwareDeepScanningVerdict& a, MalwareDeepScanningVerdict& b) {
a.Swap(&b);
}
inline void Swap(MalwareDeepScanningVerdict* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MalwareDeepScanningVerdict* New() const final {
return CreateMaybeMessage<MalwareDeepScanningVerdict>(nullptr);
}
MalwareDeepScanningVerdict* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MalwareDeepScanningVerdict>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const MalwareDeepScanningVerdict& from);
void MergeFrom(const MalwareDeepScanningVerdict& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(MalwareDeepScanningVerdict* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.MalwareDeepScanningVerdict";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef MalwareDeepScanningVerdict_Verdict Verdict;
static constexpr Verdict VERDICT_UNSPECIFIED =
MalwareDeepScanningVerdict_Verdict_VERDICT_UNSPECIFIED;
static constexpr Verdict CLEAN =
MalwareDeepScanningVerdict_Verdict_CLEAN;
static constexpr Verdict UWS =
MalwareDeepScanningVerdict_Verdict_UWS;
static constexpr Verdict MALWARE =
MalwareDeepScanningVerdict_Verdict_MALWARE;
static inline bool Verdict_IsValid(int value) {
return MalwareDeepScanningVerdict_Verdict_IsValid(value);
}
static constexpr Verdict Verdict_MIN =
MalwareDeepScanningVerdict_Verdict_Verdict_MIN;
static constexpr Verdict Verdict_MAX =
MalwareDeepScanningVerdict_Verdict_Verdict_MAX;
static constexpr int Verdict_ARRAYSIZE =
MalwareDeepScanningVerdict_Verdict_Verdict_ARRAYSIZE;
template<typename T>
static inline const std::string& Verdict_Name(T enum_t_value) {
static_assert(::std::is_same<T, Verdict>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Verdict_Name.");
return MalwareDeepScanningVerdict_Verdict_Name(enum_t_value);
}
static inline bool Verdict_Parse(const std::string& name,
Verdict* value) {
return MalwareDeepScanningVerdict_Verdict_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kVerdictFieldNumber = 1,
};
// optional .safe_browsing.MalwareDeepScanningVerdict.Verdict verdict = 1;
bool has_verdict() const;
void clear_verdict();
::safe_browsing::MalwareDeepScanningVerdict_Verdict verdict() const;
void set_verdict(::safe_browsing::MalwareDeepScanningVerdict_Verdict value);
// @@protoc_insertion_point(class_scope:safe_browsing.MalwareDeepScanningVerdict)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int verdict_;
friend struct ::TableStruct_webprotect_2eproto;
};
// -------------------------------------------------------------------
class DlpDeepScanningVerdict_TriggeredRule :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DlpDeepScanningVerdict.TriggeredRule) */ {
public:
DlpDeepScanningVerdict_TriggeredRule();
virtual ~DlpDeepScanningVerdict_TriggeredRule();
DlpDeepScanningVerdict_TriggeredRule(const DlpDeepScanningVerdict_TriggeredRule& from);
DlpDeepScanningVerdict_TriggeredRule(DlpDeepScanningVerdict_TriggeredRule&& from) noexcept
: DlpDeepScanningVerdict_TriggeredRule() {
*this = ::std::move(from);
}
inline DlpDeepScanningVerdict_TriggeredRule& operator=(const DlpDeepScanningVerdict_TriggeredRule& from) {
CopyFrom(from);
return *this;
}
inline DlpDeepScanningVerdict_TriggeredRule& operator=(DlpDeepScanningVerdict_TriggeredRule&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const DlpDeepScanningVerdict_TriggeredRule& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DlpDeepScanningVerdict_TriggeredRule* internal_default_instance() {
return reinterpret_cast<const DlpDeepScanningVerdict_TriggeredRule*>(
&_DlpDeepScanningVerdict_TriggeredRule_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(DlpDeepScanningVerdict_TriggeredRule& a, DlpDeepScanningVerdict_TriggeredRule& b) {
a.Swap(&b);
}
inline void Swap(DlpDeepScanningVerdict_TriggeredRule* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DlpDeepScanningVerdict_TriggeredRule* New() const final {
return CreateMaybeMessage<DlpDeepScanningVerdict_TriggeredRule>(nullptr);
}
DlpDeepScanningVerdict_TriggeredRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DlpDeepScanningVerdict_TriggeredRule>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const DlpDeepScanningVerdict_TriggeredRule& from);
void MergeFrom(const DlpDeepScanningVerdict_TriggeredRule& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(DlpDeepScanningVerdict_TriggeredRule* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.DlpDeepScanningVerdict.TriggeredRule";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef DlpDeepScanningVerdict_TriggeredRule_Action Action;
static constexpr Action ACTION_UNKNOWN =
DlpDeepScanningVerdict_TriggeredRule_Action_ACTION_UNKNOWN;
static constexpr Action REPORT_ONLY =
DlpDeepScanningVerdict_TriggeredRule_Action_REPORT_ONLY;
static constexpr Action WARN =
DlpDeepScanningVerdict_TriggeredRule_Action_WARN;
static constexpr Action BLOCK =
DlpDeepScanningVerdict_TriggeredRule_Action_BLOCK;
static inline bool Action_IsValid(int value) {
return DlpDeepScanningVerdict_TriggeredRule_Action_IsValid(value);
}
static constexpr Action Action_MIN =
DlpDeepScanningVerdict_TriggeredRule_Action_Action_MIN;
static constexpr Action Action_MAX =
DlpDeepScanningVerdict_TriggeredRule_Action_Action_MAX;
static constexpr int Action_ARRAYSIZE =
DlpDeepScanningVerdict_TriggeredRule_Action_Action_ARRAYSIZE;
template<typename T>
static inline const std::string& Action_Name(T enum_t_value) {
static_assert(::std::is_same<T, Action>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Action_Name.");
return DlpDeepScanningVerdict_TriggeredRule_Action_Name(enum_t_value);
}
static inline bool Action_Parse(const std::string& name,
Action* value) {
return DlpDeepScanningVerdict_TriggeredRule_Action_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kRuleNameFieldNumber = 2,
kRuleIdFieldNumber = 3,
kActionFieldNumber = 1,
};
// optional string rule_name = 2;
bool has_rule_name() const;
void clear_rule_name();
const std::string& rule_name() const;
void set_rule_name(const std::string& value);
void set_rule_name(std::string&& value);
void set_rule_name(const char* value);
void set_rule_name(const char* value, size_t size);
std::string* mutable_rule_name();
std::string* release_rule_name();
void set_allocated_rule_name(std::string* rule_name);
// optional int64 rule_id = 3;
bool has_rule_id() const;
void clear_rule_id();
::PROTOBUF_NAMESPACE_ID::int64 rule_id() const;
void set_rule_id(::PROTOBUF_NAMESPACE_ID::int64 value);
// optional .safe_browsing.DlpDeepScanningVerdict.TriggeredRule.Action action = 1;
bool has_action() const;
void clear_action();
::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action action() const;
void set_action(::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action value);
// @@protoc_insertion_point(class_scope:safe_browsing.DlpDeepScanningVerdict.TriggeredRule)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rule_name_;
::PROTOBUF_NAMESPACE_ID::int64 rule_id_;
int action_;
friend struct ::TableStruct_webprotect_2eproto;
};
// -------------------------------------------------------------------
class DlpDeepScanningVerdict :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DlpDeepScanningVerdict) */ {
public:
DlpDeepScanningVerdict();
virtual ~DlpDeepScanningVerdict();
DlpDeepScanningVerdict(const DlpDeepScanningVerdict& from);
DlpDeepScanningVerdict(DlpDeepScanningVerdict&& from) noexcept
: DlpDeepScanningVerdict() {
*this = ::std::move(from);
}
inline DlpDeepScanningVerdict& operator=(const DlpDeepScanningVerdict& from) {
CopyFrom(from);
return *this;
}
inline DlpDeepScanningVerdict& operator=(DlpDeepScanningVerdict&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const DlpDeepScanningVerdict& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DlpDeepScanningVerdict* internal_default_instance() {
return reinterpret_cast<const DlpDeepScanningVerdict*>(
&_DlpDeepScanningVerdict_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(DlpDeepScanningVerdict& a, DlpDeepScanningVerdict& b) {
a.Swap(&b);
}
inline void Swap(DlpDeepScanningVerdict* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DlpDeepScanningVerdict* New() const final {
return CreateMaybeMessage<DlpDeepScanningVerdict>(nullptr);
}
DlpDeepScanningVerdict* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DlpDeepScanningVerdict>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const DlpDeepScanningVerdict& from);
void MergeFrom(const DlpDeepScanningVerdict& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(DlpDeepScanningVerdict* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.DlpDeepScanningVerdict";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef DlpDeepScanningVerdict_TriggeredRule TriggeredRule;
typedef DlpDeepScanningVerdict_Status Status;
static constexpr Status STATUS_UNKNOWN =
DlpDeepScanningVerdict_Status_STATUS_UNKNOWN;
static constexpr Status SUCCESS =
DlpDeepScanningVerdict_Status_SUCCESS;
static constexpr Status FAILURE =
DlpDeepScanningVerdict_Status_FAILURE;
static inline bool Status_IsValid(int value) {
return DlpDeepScanningVerdict_Status_IsValid(value);
}
static constexpr Status Status_MIN =
DlpDeepScanningVerdict_Status_Status_MIN;
static constexpr Status Status_MAX =
DlpDeepScanningVerdict_Status_Status_MAX;
static constexpr int Status_ARRAYSIZE =
DlpDeepScanningVerdict_Status_Status_ARRAYSIZE;
template<typename T>
static inline const std::string& Status_Name(T enum_t_value) {
static_assert(::std::is_same<T, Status>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Status_Name.");
return DlpDeepScanningVerdict_Status_Name(enum_t_value);
}
static inline bool Status_Parse(const std::string& name,
Status* value) {
return DlpDeepScanningVerdict_Status_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kTriggeredRulesFieldNumber = 2,
kStatusFieldNumber = 1,
};
// repeated .safe_browsing.DlpDeepScanningVerdict.TriggeredRule triggered_rules = 2;
int triggered_rules_size() const;
void clear_triggered_rules();
::safe_browsing::DlpDeepScanningVerdict_TriggeredRule* mutable_triggered_rules(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule >*
mutable_triggered_rules();
const ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule& triggered_rules(int index) const;
::safe_browsing::DlpDeepScanningVerdict_TriggeredRule* add_triggered_rules();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule >&
triggered_rules() const;
// optional .safe_browsing.DlpDeepScanningVerdict.Status status = 1;
bool has_status() const;
void clear_status();
::safe_browsing::DlpDeepScanningVerdict_Status status() const;
void set_status(::safe_browsing::DlpDeepScanningVerdict_Status value);
// @@protoc_insertion_point(class_scope:safe_browsing.DlpDeepScanningVerdict)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule > triggered_rules_;
int status_;
friend struct ::TableStruct_webprotect_2eproto;
};
// -------------------------------------------------------------------
class DeepScanningClientResponse :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DeepScanningClientResponse) */ {
public:
DeepScanningClientResponse();
virtual ~DeepScanningClientResponse();
DeepScanningClientResponse(const DeepScanningClientResponse& from);
DeepScanningClientResponse(DeepScanningClientResponse&& from) noexcept
: DeepScanningClientResponse() {
*this = ::std::move(from);
}
inline DeepScanningClientResponse& operator=(const DeepScanningClientResponse& from) {
CopyFrom(from);
return *this;
}
inline DeepScanningClientResponse& operator=(DeepScanningClientResponse&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const DeepScanningClientResponse& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DeepScanningClientResponse* internal_default_instance() {
return reinterpret_cast<const DeepScanningClientResponse*>(
&_DeepScanningClientResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(DeepScanningClientResponse& a, DeepScanningClientResponse& b) {
a.Swap(&b);
}
inline void Swap(DeepScanningClientResponse* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DeepScanningClientResponse* New() const final {
return CreateMaybeMessage<DeepScanningClientResponse>(nullptr);
}
DeepScanningClientResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DeepScanningClientResponse>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
final;
void CopyFrom(const DeepScanningClientResponse& from);
void MergeFrom(const DeepScanningClientResponse& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
void DiscardUnknownFields();
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(DeepScanningClientResponse* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "safe_browsing.DeepScanningClientResponse";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kTokenFieldNumber = 1,
kMalwareScanVerdictFieldNumber = 2,
kDlpScanVerdictFieldNumber = 3,
};
// optional string token = 1;
bool has_token() const;
void clear_token();
const std::string& token() const;
void set_token(const std::string& value);
void set_token(std::string&& value);
void set_token(const char* value);
void set_token(const char* value, size_t size);
std::string* mutable_token();
std::string* release_token();
void set_allocated_token(std::string* token);
// optional .safe_browsing.MalwareDeepScanningVerdict malware_scan_verdict = 2;
bool has_malware_scan_verdict() const;
void clear_malware_scan_verdict();
const ::safe_browsing::MalwareDeepScanningVerdict& malware_scan_verdict() const;
::safe_browsing::MalwareDeepScanningVerdict* release_malware_scan_verdict();
::safe_browsing::MalwareDeepScanningVerdict* mutable_malware_scan_verdict();
void set_allocated_malware_scan_verdict(::safe_browsing::MalwareDeepScanningVerdict* malware_scan_verdict);
// optional .safe_browsing.DlpDeepScanningVerdict dlp_scan_verdict = 3;
bool has_dlp_scan_verdict() const;
void clear_dlp_scan_verdict();
const ::safe_browsing::DlpDeepScanningVerdict& dlp_scan_verdict() const;
::safe_browsing::DlpDeepScanningVerdict* release_dlp_scan_verdict();
::safe_browsing::DlpDeepScanningVerdict* mutable_dlp_scan_verdict();
void set_allocated_dlp_scan_verdict(::safe_browsing::DlpDeepScanningVerdict* dlp_scan_verdict);
// @@protoc_insertion_point(class_scope:safe_browsing.DeepScanningClientResponse)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
::safe_browsing::MalwareDeepScanningVerdict* malware_scan_verdict_;
::safe_browsing::DlpDeepScanningVerdict* dlp_scan_verdict_;
friend struct ::TableStruct_webprotect_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// MalwareDeepScanningClientRequest
// optional .safe_browsing.MalwareDeepScanningClientRequest.Population population = 1;
inline bool MalwareDeepScanningClientRequest::has_population() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MalwareDeepScanningClientRequest::clear_population() {
population_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::safe_browsing::MalwareDeepScanningClientRequest_Population MalwareDeepScanningClientRequest::population() const {
// @@protoc_insertion_point(field_get:safe_browsing.MalwareDeepScanningClientRequest.population)
return static_cast< ::safe_browsing::MalwareDeepScanningClientRequest_Population >(population_);
}
inline void MalwareDeepScanningClientRequest::set_population(::safe_browsing::MalwareDeepScanningClientRequest_Population value) {
assert(::safe_browsing::MalwareDeepScanningClientRequest_Population_IsValid(value));
_has_bits_[0] |= 0x00000002u;
population_ = value;
// @@protoc_insertion_point(field_set:safe_browsing.MalwareDeepScanningClientRequest.population)
}
// optional string download_token = 2;
inline bool MalwareDeepScanningClientRequest::has_download_token() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MalwareDeepScanningClientRequest::clear_download_token() {
download_token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MalwareDeepScanningClientRequest::download_token() const {
// @@protoc_insertion_point(field_get:safe_browsing.MalwareDeepScanningClientRequest.download_token)
return download_token_.GetNoArena();
}
inline void MalwareDeepScanningClientRequest::set_download_token(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
download_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:safe_browsing.MalwareDeepScanningClientRequest.download_token)
}
inline void MalwareDeepScanningClientRequest::set_download_token(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
download_token_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:safe_browsing.MalwareDeepScanningClientRequest.download_token)
}
inline void MalwareDeepScanningClientRequest::set_download_token(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
download_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:safe_browsing.MalwareDeepScanningClientRequest.download_token)
}
inline void MalwareDeepScanningClientRequest::set_download_token(const char* value, size_t size) {
_has_bits_[0] |= 0x00000001u;
download_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:safe_browsing.MalwareDeepScanningClientRequest.download_token)
}
inline std::string* MalwareDeepScanningClientRequest::mutable_download_token() {
_has_bits_[0] |= 0x00000001u;
// @@protoc_insertion_point(field_mutable:safe_browsing.MalwareDeepScanningClientRequest.download_token)
return download_token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MalwareDeepScanningClientRequest::release_download_token() {
// @@protoc_insertion_point(field_release:safe_browsing.MalwareDeepScanningClientRequest.download_token)
if (!has_download_token()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return download_token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MalwareDeepScanningClientRequest::set_allocated_download_token(std::string* download_token) {
if (download_token != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
download_token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), download_token);
// @@protoc_insertion_point(field_set_allocated:safe_browsing.MalwareDeepScanningClientRequest.download_token)
}
// -------------------------------------------------------------------
// DlpDeepScanningClientRequest
// optional .safe_browsing.DlpDeepScanningClientRequest.ContentSource content_source = 1;
inline bool DlpDeepScanningClientRequest::has_content_source() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DlpDeepScanningClientRequest::clear_content_source() {
content_source_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::safe_browsing::DlpDeepScanningClientRequest_ContentSource DlpDeepScanningClientRequest::content_source() const {
// @@protoc_insertion_point(field_get:safe_browsing.DlpDeepScanningClientRequest.content_source)
return static_cast< ::safe_browsing::DlpDeepScanningClientRequest_ContentSource >(content_source_);
}
inline void DlpDeepScanningClientRequest::set_content_source(::safe_browsing::DlpDeepScanningClientRequest_ContentSource value) {
assert(::safe_browsing::DlpDeepScanningClientRequest_ContentSource_IsValid(value));
_has_bits_[0] |= 0x00000001u;
content_source_ = value;
// @@protoc_insertion_point(field_set:safe_browsing.DlpDeepScanningClientRequest.content_source)
}
// -------------------------------------------------------------------
// DeepScanningClientRequest
// optional string dm_token = 1;
inline bool DeepScanningClientRequest::has_dm_token() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeepScanningClientRequest::clear_dm_token() {
dm_token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeepScanningClientRequest::dm_token() const {
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientRequest.dm_token)
return dm_token_.GetNoArena();
}
inline void DeepScanningClientRequest::set_dm_token(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
dm_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:safe_browsing.DeepScanningClientRequest.dm_token)
}
inline void DeepScanningClientRequest::set_dm_token(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
dm_token_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:safe_browsing.DeepScanningClientRequest.dm_token)
}
inline void DeepScanningClientRequest::set_dm_token(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
dm_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:safe_browsing.DeepScanningClientRequest.dm_token)
}
inline void DeepScanningClientRequest::set_dm_token(const char* value, size_t size) {
_has_bits_[0] |= 0x00000001u;
dm_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:safe_browsing.DeepScanningClientRequest.dm_token)
}
inline std::string* DeepScanningClientRequest::mutable_dm_token() {
_has_bits_[0] |= 0x00000001u;
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientRequest.dm_token)
return dm_token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeepScanningClientRequest::release_dm_token() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientRequest.dm_token)
if (!has_dm_token()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return dm_token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeepScanningClientRequest::set_allocated_dm_token(std::string* dm_token) {
if (dm_token != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
dm_token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dm_token);
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientRequest.dm_token)
}
// optional string fcm_notification_token = 2;
inline bool DeepScanningClientRequest::has_fcm_notification_token() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeepScanningClientRequest::clear_fcm_notification_token() {
fcm_notification_token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DeepScanningClientRequest::fcm_notification_token() const {
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
return fcm_notification_token_.GetNoArena();
}
inline void DeepScanningClientRequest::set_fcm_notification_token(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
fcm_notification_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
}
inline void DeepScanningClientRequest::set_fcm_notification_token(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
fcm_notification_token_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
}
inline void DeepScanningClientRequest::set_fcm_notification_token(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
fcm_notification_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
}
inline void DeepScanningClientRequest::set_fcm_notification_token(const char* value, size_t size) {
_has_bits_[0] |= 0x00000002u;
fcm_notification_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
}
inline std::string* DeepScanningClientRequest::mutable_fcm_notification_token() {
_has_bits_[0] |= 0x00000002u;
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
return fcm_notification_token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeepScanningClientRequest::release_fcm_notification_token() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
if (!has_fcm_notification_token()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return fcm_notification_token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeepScanningClientRequest::set_allocated_fcm_notification_token(std::string* fcm_notification_token) {
if (fcm_notification_token != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
fcm_notification_token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fcm_notification_token);
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientRequest.fcm_notification_token)
}
// optional .safe_browsing.MalwareDeepScanningClientRequest malware_scan_request = 3;
inline bool DeepScanningClientRequest::has_malware_scan_request() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DeepScanningClientRequest::clear_malware_scan_request() {
if (malware_scan_request_ != nullptr) malware_scan_request_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const ::safe_browsing::MalwareDeepScanningClientRequest& DeepScanningClientRequest::malware_scan_request() const {
const ::safe_browsing::MalwareDeepScanningClientRequest* p = malware_scan_request_;
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientRequest.malware_scan_request)
return p != nullptr ? *p : *reinterpret_cast<const ::safe_browsing::MalwareDeepScanningClientRequest*>(
&::safe_browsing::_MalwareDeepScanningClientRequest_default_instance_);
}
inline ::safe_browsing::MalwareDeepScanningClientRequest* DeepScanningClientRequest::release_malware_scan_request() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientRequest.malware_scan_request)
_has_bits_[0] &= ~0x00000008u;
::safe_browsing::MalwareDeepScanningClientRequest* temp = malware_scan_request_;
malware_scan_request_ = nullptr;
return temp;
}
inline ::safe_browsing::MalwareDeepScanningClientRequest* DeepScanningClientRequest::mutable_malware_scan_request() {
_has_bits_[0] |= 0x00000008u;
if (malware_scan_request_ == nullptr) {
auto* p = CreateMaybeMessage<::safe_browsing::MalwareDeepScanningClientRequest>(GetArenaNoVirtual());
malware_scan_request_ = p;
}
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientRequest.malware_scan_request)
return malware_scan_request_;
}
inline void DeepScanningClientRequest::set_allocated_malware_scan_request(::safe_browsing::MalwareDeepScanningClientRequest* malware_scan_request) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete malware_scan_request_;
}
if (malware_scan_request) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
malware_scan_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, malware_scan_request, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
malware_scan_request_ = malware_scan_request;
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientRequest.malware_scan_request)
}
// optional .safe_browsing.DlpDeepScanningClientRequest dlp_scan_request = 4;
inline bool DeepScanningClientRequest::has_dlp_scan_request() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DeepScanningClientRequest::clear_dlp_scan_request() {
if (dlp_scan_request_ != nullptr) dlp_scan_request_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const ::safe_browsing::DlpDeepScanningClientRequest& DeepScanningClientRequest::dlp_scan_request() const {
const ::safe_browsing::DlpDeepScanningClientRequest* p = dlp_scan_request_;
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientRequest.dlp_scan_request)
return p != nullptr ? *p : *reinterpret_cast<const ::safe_browsing::DlpDeepScanningClientRequest*>(
&::safe_browsing::_DlpDeepScanningClientRequest_default_instance_);
}
inline ::safe_browsing::DlpDeepScanningClientRequest* DeepScanningClientRequest::release_dlp_scan_request() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientRequest.dlp_scan_request)
_has_bits_[0] &= ~0x00000010u;
::safe_browsing::DlpDeepScanningClientRequest* temp = dlp_scan_request_;
dlp_scan_request_ = nullptr;
return temp;
}
inline ::safe_browsing::DlpDeepScanningClientRequest* DeepScanningClientRequest::mutable_dlp_scan_request() {
_has_bits_[0] |= 0x00000010u;
if (dlp_scan_request_ == nullptr) {
auto* p = CreateMaybeMessage<::safe_browsing::DlpDeepScanningClientRequest>(GetArenaNoVirtual());
dlp_scan_request_ = p;
}
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientRequest.dlp_scan_request)
return dlp_scan_request_;
}
inline void DeepScanningClientRequest::set_allocated_dlp_scan_request(::safe_browsing::DlpDeepScanningClientRequest* dlp_scan_request) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete dlp_scan_request_;
}
if (dlp_scan_request) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
dlp_scan_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, dlp_scan_request, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
dlp_scan_request_ = dlp_scan_request;
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientRequest.dlp_scan_request)
}
// optional string request_token = 5;
inline bool DeepScanningClientRequest::has_request_token() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeepScanningClientRequest::clear_request_token() {
request_token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& DeepScanningClientRequest::request_token() const {
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientRequest.request_token)
return request_token_.GetNoArena();
}
inline void DeepScanningClientRequest::set_request_token(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
request_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:safe_browsing.DeepScanningClientRequest.request_token)
}
inline void DeepScanningClientRequest::set_request_token(std::string&& value) {
_has_bits_[0] |= 0x00000004u;
request_token_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:safe_browsing.DeepScanningClientRequest.request_token)
}
inline void DeepScanningClientRequest::set_request_token(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000004u;
request_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:safe_browsing.DeepScanningClientRequest.request_token)
}
inline void DeepScanningClientRequest::set_request_token(const char* value, size_t size) {
_has_bits_[0] |= 0x00000004u;
request_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:safe_browsing.DeepScanningClientRequest.request_token)
}
inline std::string* DeepScanningClientRequest::mutable_request_token() {
_has_bits_[0] |= 0x00000004u;
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientRequest.request_token)
return request_token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeepScanningClientRequest::release_request_token() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientRequest.request_token)
if (!has_request_token()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
return request_token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeepScanningClientRequest::set_allocated_request_token(std::string* request_token) {
if (request_token != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
request_token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_token);
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientRequest.request_token)
}
// -------------------------------------------------------------------
// MalwareDeepScanningVerdict
// optional .safe_browsing.MalwareDeepScanningVerdict.Verdict verdict = 1;
inline bool MalwareDeepScanningVerdict::has_verdict() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MalwareDeepScanningVerdict::clear_verdict() {
verdict_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::safe_browsing::MalwareDeepScanningVerdict_Verdict MalwareDeepScanningVerdict::verdict() const {
// @@protoc_insertion_point(field_get:safe_browsing.MalwareDeepScanningVerdict.verdict)
return static_cast< ::safe_browsing::MalwareDeepScanningVerdict_Verdict >(verdict_);
}
inline void MalwareDeepScanningVerdict::set_verdict(::safe_browsing::MalwareDeepScanningVerdict_Verdict value) {
assert(::safe_browsing::MalwareDeepScanningVerdict_Verdict_IsValid(value));
_has_bits_[0] |= 0x00000001u;
verdict_ = value;
// @@protoc_insertion_point(field_set:safe_browsing.MalwareDeepScanningVerdict.verdict)
}
// -------------------------------------------------------------------
// DlpDeepScanningVerdict_TriggeredRule
// optional .safe_browsing.DlpDeepScanningVerdict.TriggeredRule.Action action = 1;
inline bool DlpDeepScanningVerdict_TriggeredRule::has_action() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DlpDeepScanningVerdict_TriggeredRule::clear_action() {
action_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action DlpDeepScanningVerdict_TriggeredRule::action() const {
// @@protoc_insertion_point(field_get:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.action)
return static_cast< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action >(action_);
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_action(::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action value) {
assert(::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action_IsValid(value));
_has_bits_[0] |= 0x00000004u;
action_ = value;
// @@protoc_insertion_point(field_set:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.action)
}
// optional string rule_name = 2;
inline bool DlpDeepScanningVerdict_TriggeredRule::has_rule_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DlpDeepScanningVerdict_TriggeredRule::clear_rule_name() {
rule_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DlpDeepScanningVerdict_TriggeredRule::rule_name() const {
// @@protoc_insertion_point(field_get:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
return rule_name_.GetNoArena();
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_rule_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
rule_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_rule_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
rule_name_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_rule_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
rule_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_rule_name(const char* value, size_t size) {
_has_bits_[0] |= 0x00000001u;
rule_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
}
inline std::string* DlpDeepScanningVerdict_TriggeredRule::mutable_rule_name() {
_has_bits_[0] |= 0x00000001u;
// @@protoc_insertion_point(field_mutable:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
return rule_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DlpDeepScanningVerdict_TriggeredRule::release_rule_name() {
// @@protoc_insertion_point(field_release:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
if (!has_rule_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return rule_name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_allocated_rule_name(std::string* rule_name) {
if (rule_name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
rule_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rule_name);
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_name)
}
// optional int64 rule_id = 3;
inline bool DlpDeepScanningVerdict_TriggeredRule::has_rule_id() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DlpDeepScanningVerdict_TriggeredRule::clear_rule_id() {
rule_id_ = PROTOBUF_LONGLONG(0);
_has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DlpDeepScanningVerdict_TriggeredRule::rule_id() const {
// @@protoc_insertion_point(field_get:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_id)
return rule_id_;
}
inline void DlpDeepScanningVerdict_TriggeredRule::set_rule_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
_has_bits_[0] |= 0x00000002u;
rule_id_ = value;
// @@protoc_insertion_point(field_set:safe_browsing.DlpDeepScanningVerdict.TriggeredRule.rule_id)
}
// -------------------------------------------------------------------
// DlpDeepScanningVerdict
// optional .safe_browsing.DlpDeepScanningVerdict.Status status = 1;
inline bool DlpDeepScanningVerdict::has_status() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DlpDeepScanningVerdict::clear_status() {
status_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::safe_browsing::DlpDeepScanningVerdict_Status DlpDeepScanningVerdict::status() const {
// @@protoc_insertion_point(field_get:safe_browsing.DlpDeepScanningVerdict.status)
return static_cast< ::safe_browsing::DlpDeepScanningVerdict_Status >(status_);
}
inline void DlpDeepScanningVerdict::set_status(::safe_browsing::DlpDeepScanningVerdict_Status value) {
assert(::safe_browsing::DlpDeepScanningVerdict_Status_IsValid(value));
_has_bits_[0] |= 0x00000001u;
status_ = value;
// @@protoc_insertion_point(field_set:safe_browsing.DlpDeepScanningVerdict.status)
}
// repeated .safe_browsing.DlpDeepScanningVerdict.TriggeredRule triggered_rules = 2;
inline int DlpDeepScanningVerdict::triggered_rules_size() const {
return triggered_rules_.size();
}
inline void DlpDeepScanningVerdict::clear_triggered_rules() {
triggered_rules_.Clear();
}
inline ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule* DlpDeepScanningVerdict::mutable_triggered_rules(int index) {
// @@protoc_insertion_point(field_mutable:safe_browsing.DlpDeepScanningVerdict.triggered_rules)
return triggered_rules_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule >*
DlpDeepScanningVerdict::mutable_triggered_rules() {
// @@protoc_insertion_point(field_mutable_list:safe_browsing.DlpDeepScanningVerdict.triggered_rules)
return &triggered_rules_;
}
inline const ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule& DlpDeepScanningVerdict::triggered_rules(int index) const {
// @@protoc_insertion_point(field_get:safe_browsing.DlpDeepScanningVerdict.triggered_rules)
return triggered_rules_.Get(index);
}
inline ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule* DlpDeepScanningVerdict::add_triggered_rules() {
// @@protoc_insertion_point(field_add:safe_browsing.DlpDeepScanningVerdict.triggered_rules)
return triggered_rules_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule >&
DlpDeepScanningVerdict::triggered_rules() const {
// @@protoc_insertion_point(field_list:safe_browsing.DlpDeepScanningVerdict.triggered_rules)
return triggered_rules_;
}
// -------------------------------------------------------------------
// DeepScanningClientResponse
// optional string token = 1;
inline bool DeepScanningClientResponse::has_token() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeepScanningClientResponse::clear_token() {
token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeepScanningClientResponse::token() const {
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientResponse.token)
return token_.GetNoArena();
}
inline void DeepScanningClientResponse::set_token(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:safe_browsing.DeepScanningClientResponse.token)
}
inline void DeepScanningClientResponse::set_token(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
token_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:safe_browsing.DeepScanningClientResponse.token)
}
inline void DeepScanningClientResponse::set_token(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:safe_browsing.DeepScanningClientResponse.token)
}
inline void DeepScanningClientResponse::set_token(const char* value, size_t size) {
_has_bits_[0] |= 0x00000001u;
token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:safe_browsing.DeepScanningClientResponse.token)
}
inline std::string* DeepScanningClientResponse::mutable_token() {
_has_bits_[0] |= 0x00000001u;
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientResponse.token)
return token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeepScanningClientResponse::release_token() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientResponse.token)
if (!has_token()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeepScanningClientResponse::set_allocated_token(std::string* token) {
if (token != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token);
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientResponse.token)
}
// optional .safe_browsing.MalwareDeepScanningVerdict malware_scan_verdict = 2;
inline bool DeepScanningClientResponse::has_malware_scan_verdict() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeepScanningClientResponse::clear_malware_scan_verdict() {
if (malware_scan_verdict_ != nullptr) malware_scan_verdict_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::safe_browsing::MalwareDeepScanningVerdict& DeepScanningClientResponse::malware_scan_verdict() const {
const ::safe_browsing::MalwareDeepScanningVerdict* p = malware_scan_verdict_;
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientResponse.malware_scan_verdict)
return p != nullptr ? *p : *reinterpret_cast<const ::safe_browsing::MalwareDeepScanningVerdict*>(
&::safe_browsing::_MalwareDeepScanningVerdict_default_instance_);
}
inline ::safe_browsing::MalwareDeepScanningVerdict* DeepScanningClientResponse::release_malware_scan_verdict() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientResponse.malware_scan_verdict)
_has_bits_[0] &= ~0x00000002u;
::safe_browsing::MalwareDeepScanningVerdict* temp = malware_scan_verdict_;
malware_scan_verdict_ = nullptr;
return temp;
}
inline ::safe_browsing::MalwareDeepScanningVerdict* DeepScanningClientResponse::mutable_malware_scan_verdict() {
_has_bits_[0] |= 0x00000002u;
if (malware_scan_verdict_ == nullptr) {
auto* p = CreateMaybeMessage<::safe_browsing::MalwareDeepScanningVerdict>(GetArenaNoVirtual());
malware_scan_verdict_ = p;
}
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientResponse.malware_scan_verdict)
return malware_scan_verdict_;
}
inline void DeepScanningClientResponse::set_allocated_malware_scan_verdict(::safe_browsing::MalwareDeepScanningVerdict* malware_scan_verdict) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete malware_scan_verdict_;
}
if (malware_scan_verdict) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
malware_scan_verdict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, malware_scan_verdict, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
malware_scan_verdict_ = malware_scan_verdict;
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientResponse.malware_scan_verdict)
}
// optional .safe_browsing.DlpDeepScanningVerdict dlp_scan_verdict = 3;
inline bool DeepScanningClientResponse::has_dlp_scan_verdict() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeepScanningClientResponse::clear_dlp_scan_verdict() {
if (dlp_scan_verdict_ != nullptr) dlp_scan_verdict_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::safe_browsing::DlpDeepScanningVerdict& DeepScanningClientResponse::dlp_scan_verdict() const {
const ::safe_browsing::DlpDeepScanningVerdict* p = dlp_scan_verdict_;
// @@protoc_insertion_point(field_get:safe_browsing.DeepScanningClientResponse.dlp_scan_verdict)
return p != nullptr ? *p : *reinterpret_cast<const ::safe_browsing::DlpDeepScanningVerdict*>(
&::safe_browsing::_DlpDeepScanningVerdict_default_instance_);
}
inline ::safe_browsing::DlpDeepScanningVerdict* DeepScanningClientResponse::release_dlp_scan_verdict() {
// @@protoc_insertion_point(field_release:safe_browsing.DeepScanningClientResponse.dlp_scan_verdict)
_has_bits_[0] &= ~0x00000004u;
::safe_browsing::DlpDeepScanningVerdict* temp = dlp_scan_verdict_;
dlp_scan_verdict_ = nullptr;
return temp;
}
inline ::safe_browsing::DlpDeepScanningVerdict* DeepScanningClientResponse::mutable_dlp_scan_verdict() {
_has_bits_[0] |= 0x00000004u;
if (dlp_scan_verdict_ == nullptr) {
auto* p = CreateMaybeMessage<::safe_browsing::DlpDeepScanningVerdict>(GetArenaNoVirtual());
dlp_scan_verdict_ = p;
}
// @@protoc_insertion_point(field_mutable:safe_browsing.DeepScanningClientResponse.dlp_scan_verdict)
return dlp_scan_verdict_;
}
inline void DeepScanningClientResponse::set_allocated_dlp_scan_verdict(::safe_browsing::DlpDeepScanningVerdict* dlp_scan_verdict) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete dlp_scan_verdict_;
}
if (dlp_scan_verdict) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
dlp_scan_verdict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, dlp_scan_verdict, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
dlp_scan_verdict_ = dlp_scan_verdict;
// @@protoc_insertion_point(field_set_allocated:safe_browsing.DeepScanningClientResponse.dlp_scan_verdict)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace safe_browsing
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::safe_browsing::MalwareDeepScanningClientRequest_Population> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DlpDeepScanningClientRequest_ContentSource> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::MalwareDeepScanningVerdict_Verdict> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DlpDeepScanningVerdict_TriggeredRule_Action> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DlpDeepScanningVerdict_Status> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_webprotect_2eproto