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
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
|
|
|