dlp_policy_event.pb.h | Explore in Territory

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: dlp_policy_event.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_dlp_5fpolicy_5fevent_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_dlp_5fpolicy_5fevent_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_dlp_5fpolicy_5fevent_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_dlp_5fpolicy_5fevent_2eproto { … };
class DlpPolicyEvent;
struct DlpPolicyEventDefaultTypeInternal;
extern DlpPolicyEventDefaultTypeInternal _DlpPolicyEvent_default_instance_;
class DlpPolicyEventDestination;
struct DlpPolicyEventDestinationDefaultTypeInternal;
extern DlpPolicyEventDestinationDefaultTypeInternal _DlpPolicyEventDestination_default_instance_;
class DlpPolicyEventSource;
struct DlpPolicyEventSourceDefaultTypeInternal;
extern DlpPolicyEventSourceDefaultTypeInternal _DlpPolicyEventSource_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::DlpPolicyEvent* Arena::CreateMaybeMessage<::DlpPolicyEvent>(Arena*);
template<> ::DlpPolicyEventDestination* Arena::CreateMaybeMessage<::DlpPolicyEventDestination>(Arena*);
template<> ::DlpPolicyEventSource* Arena::CreateMaybeMessage<::DlpPolicyEventSource>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum DlpPolicyEventDestination_Component : int { … };
bool DlpPolicyEventDestination_Component_IsValid(int value);
constexpr DlpPolicyEventDestination_Component DlpPolicyEventDestination_Component_Component_MIN = …;
constexpr DlpPolicyEventDestination_Component DlpPolicyEventDestination_Component_Component_MAX = …;
constexpr int DlpPolicyEventDestination_Component_Component_ARRAYSIZE = …;

const std::string& DlpPolicyEventDestination_Component_Name(DlpPolicyEventDestination_Component value);
template<typename T>
inline const std::string& DlpPolicyEventDestination_Component_Name(T enum_t_value) { … }
bool DlpPolicyEventDestination_Component_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DlpPolicyEventDestination_Component* value);
enum DlpPolicyEvent_Restriction : int { … };
bool DlpPolicyEvent_Restriction_IsValid(int value);
constexpr DlpPolicyEvent_Restriction DlpPolicyEvent_Restriction_Restriction_MIN = …;
constexpr DlpPolicyEvent_Restriction DlpPolicyEvent_Restriction_Restriction_MAX = …;
constexpr int DlpPolicyEvent_Restriction_Restriction_ARRAYSIZE = …;

const std::string& DlpPolicyEvent_Restriction_Name(DlpPolicyEvent_Restriction value);
template<typename T>
inline const std::string& DlpPolicyEvent_Restriction_Name(T enum_t_value) { … }
bool DlpPolicyEvent_Restriction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DlpPolicyEvent_Restriction* value);
enum DlpPolicyEvent_Mode : int { … };
bool DlpPolicyEvent_Mode_IsValid(int value);
constexpr DlpPolicyEvent_Mode DlpPolicyEvent_Mode_Mode_MIN = …;
constexpr DlpPolicyEvent_Mode DlpPolicyEvent_Mode_Mode_MAX = …;
constexpr int DlpPolicyEvent_Mode_Mode_ARRAYSIZE = …;

const std::string& DlpPolicyEvent_Mode_Name(DlpPolicyEvent_Mode value);
template<typename T>
inline const std::string& DlpPolicyEvent_Mode_Name(T enum_t_value) { … }
bool DlpPolicyEvent_Mode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DlpPolicyEvent_Mode* value);
enum DlpPolicyEvent_UserType : int { … };
bool DlpPolicyEvent_UserType_IsValid(int value);
constexpr DlpPolicyEvent_UserType DlpPolicyEvent_UserType_UserType_MIN = …;
constexpr DlpPolicyEvent_UserType DlpPolicyEvent_UserType_UserType_MAX = …;
constexpr int DlpPolicyEvent_UserType_UserType_ARRAYSIZE = …;

const std::string& DlpPolicyEvent_UserType_Name(DlpPolicyEvent_UserType value);
template<typename T>
inline const std::string& DlpPolicyEvent_UserType_Name(T enum_t_value) { … }
bool DlpPolicyEvent_UserType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DlpPolicyEvent_UserType* value);
// ===================================================================

class DlpPolicyEventSource final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:DlpPolicyEventSource) */ { … };
// -------------------------------------------------------------------

class DlpPolicyEventDestination final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:DlpPolicyEventDestination) */ { … };
// -------------------------------------------------------------------

class DlpPolicyEvent final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:DlpPolicyEvent) */ { … };
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// DlpPolicyEventSource

// optional string url = 1;
inline bool DlpPolicyEventSource::_internal_has_url() const { … }
inline bool DlpPolicyEventSource::has_url() const { … }
inline void DlpPolicyEventSource::clear_url() { … }
inline const std::string& DlpPolicyEventSource::url() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DlpPolicyEventSource::set_url(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DlpPolicyEventSource::mutable_url() { … }
inline const std::string& DlpPolicyEventSource::_internal_url() const { … }
inline void DlpPolicyEventSource::_internal_set_url(const std::string& value) { … }
inline std::string* DlpPolicyEventSource::_internal_mutable_url() { … }
inline std::string* DlpPolicyEventSource::release_url() { … }
inline void DlpPolicyEventSource::set_allocated_url(std::string* url) { … }

// -------------------------------------------------------------------

// DlpPolicyEventDestination

// optional string url = 1;
inline bool DlpPolicyEventDestination::_internal_has_url() const { … }
inline bool DlpPolicyEventDestination::has_url() const { … }
inline void DlpPolicyEventDestination::clear_url() { … }
inline const std::string& DlpPolicyEventDestination::url() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DlpPolicyEventDestination::set_url(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DlpPolicyEventDestination::mutable_url() { … }
inline const std::string& DlpPolicyEventDestination::_internal_url() const { … }
inline void DlpPolicyEventDestination::_internal_set_url(const std::string& value) { … }
inline std::string* DlpPolicyEventDestination::_internal_mutable_url() { … }
inline std::string* DlpPolicyEventDestination::release_url() { … }
inline void DlpPolicyEventDestination::set_allocated_url(std::string* url) { … }

// optional .DlpPolicyEventDestination.Component component = 2;
inline bool DlpPolicyEventDestination::_internal_has_component() const { … }
inline bool DlpPolicyEventDestination::has_component() const { … }
inline void DlpPolicyEventDestination::clear_component() { … }
inline ::DlpPolicyEventDestination_Component DlpPolicyEventDestination::_internal_component() const { … }
inline ::DlpPolicyEventDestination_Component DlpPolicyEventDestination::component() const { … }
inline void DlpPolicyEventDestination::_internal_set_component(::DlpPolicyEventDestination_Component value) { … }
inline void DlpPolicyEventDestination::set_component(::DlpPolicyEventDestination_Component value) { … }

// -------------------------------------------------------------------

// DlpPolicyEvent

// optional .DlpPolicyEventSource source = 1;
inline bool DlpPolicyEvent::_internal_has_source() const { … }
inline bool DlpPolicyEvent::has_source() const { … }
inline void DlpPolicyEvent::clear_source() { … }
inline const ::DlpPolicyEventSource& DlpPolicyEvent::_internal_source() const { … }
inline const ::DlpPolicyEventSource& DlpPolicyEvent::source() const { … }
inline void DlpPolicyEvent::unsafe_arena_set_allocated_source(
    ::DlpPolicyEventSource* source) { … }
inline ::DlpPolicyEventSource* DlpPolicyEvent::release_source() { … }
inline ::DlpPolicyEventSource* DlpPolicyEvent::unsafe_arena_release_source() { … }
inline ::DlpPolicyEventSource* DlpPolicyEvent::_internal_mutable_source() { … }
inline ::DlpPolicyEventSource* DlpPolicyEvent::mutable_source() { … }
inline void DlpPolicyEvent::set_allocated_source(::DlpPolicyEventSource* source) { … }

// optional .DlpPolicyEventDestination destination = 2;
inline bool DlpPolicyEvent::_internal_has_destination() const { … }
inline bool DlpPolicyEvent::has_destination() const { … }
inline void DlpPolicyEvent::clear_destination() { … }
inline const ::DlpPolicyEventDestination& DlpPolicyEvent::_internal_destination() const { … }
inline const ::DlpPolicyEventDestination& DlpPolicyEvent::destination() const { … }
inline void DlpPolicyEvent::unsafe_arena_set_allocated_destination(
    ::DlpPolicyEventDestination* destination) { … }
inline ::DlpPolicyEventDestination* DlpPolicyEvent::release_destination() { … }
inline ::DlpPolicyEventDestination* DlpPolicyEvent::unsafe_arena_release_destination() { … }
inline ::DlpPolicyEventDestination* DlpPolicyEvent::_internal_mutable_destination() { … }
inline ::DlpPolicyEventDestination* DlpPolicyEvent::mutable_destination() { … }
inline void DlpPolicyEvent::set_allocated_destination(::DlpPolicyEventDestination* destination) { … }

// optional .DlpPolicyEvent.Restriction restriction = 3;
inline bool DlpPolicyEvent::_internal_has_restriction() const { … }
inline bool DlpPolicyEvent::has_restriction() const { … }
inline void DlpPolicyEvent::clear_restriction() { … }
inline ::DlpPolicyEvent_Restriction DlpPolicyEvent::_internal_restriction() const { … }
inline ::DlpPolicyEvent_Restriction DlpPolicyEvent::restriction() const { … }
inline void DlpPolicyEvent::_internal_set_restriction(::DlpPolicyEvent_Restriction value) { … }
inline void DlpPolicyEvent::set_restriction(::DlpPolicyEvent_Restriction value) { … }

// optional .DlpPolicyEvent.Mode mode = 4;
inline bool DlpPolicyEvent::_internal_has_mode() const { … }
inline bool DlpPolicyEvent::has_mode() const { … }
inline void DlpPolicyEvent::clear_mode() { … }
inline ::DlpPolicyEvent_Mode DlpPolicyEvent::_internal_mode() const { … }
inline ::DlpPolicyEvent_Mode DlpPolicyEvent::mode() const { … }
inline void DlpPolicyEvent::_internal_set_mode(::DlpPolicyEvent_Mode value) { … }
inline void DlpPolicyEvent::set_mode(::DlpPolicyEvent_Mode value) { … }

// optional int64 timestamp_micro = 6;
inline bool DlpPolicyEvent::_internal_has_timestamp_micro() const { … }
inline bool DlpPolicyEvent::has_timestamp_micro() const { … }
inline void DlpPolicyEvent::clear_timestamp_micro() { … }
inline int64_t DlpPolicyEvent::_internal_timestamp_micro() const { … }
inline int64_t DlpPolicyEvent::timestamp_micro() const { … }
inline void DlpPolicyEvent::_internal_set_timestamp_micro(int64_t value) { … }
inline void DlpPolicyEvent::set_timestamp_micro(int64_t value) { … }

// optional .DlpPolicyEvent.UserType user_type = 7;
inline bool DlpPolicyEvent::_internal_has_user_type() const { … }
inline bool DlpPolicyEvent::has_user_type() const { … }
inline void DlpPolicyEvent::clear_user_type() { … }
inline ::DlpPolicyEvent_UserType DlpPolicyEvent::_internal_user_type() const { … }
inline ::DlpPolicyEvent_UserType DlpPolicyEvent::user_type() const { … }
inline void DlpPolicyEvent::_internal_set_user_type(::DlpPolicyEvent_UserType value) { … }
inline void DlpPolicyEvent::set_user_type(::DlpPolicyEvent_UserType value) { … }

// optional string content_name = 8;
inline bool DlpPolicyEvent::_internal_has_content_name() const { … }
inline bool DlpPolicyEvent::has_content_name() const { … }
inline void DlpPolicyEvent::clear_content_name() { … }
inline const std::string& DlpPolicyEvent::content_name() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DlpPolicyEvent::set_content_name(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DlpPolicyEvent::mutable_content_name() { … }
inline const std::string& DlpPolicyEvent::_internal_content_name() const { … }
inline void DlpPolicyEvent::_internal_set_content_name(const std::string& value) { … }
inline std::string* DlpPolicyEvent::_internal_mutable_content_name() { … }
inline std::string* DlpPolicyEvent::release_content_name() { … }
inline void DlpPolicyEvent::set_allocated_content_name(std::string* content_name) { … }

// optional string triggered_rule_name = 9;
inline bool DlpPolicyEvent::_internal_has_triggered_rule_name() const { … }
inline bool DlpPolicyEvent::has_triggered_rule_name() const { … }
inline void DlpPolicyEvent::clear_triggered_rule_name() { … }
inline const std::string& DlpPolicyEvent::triggered_rule_name() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DlpPolicyEvent::set_triggered_rule_name(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DlpPolicyEvent::mutable_triggered_rule_name() { … }
inline const std::string& DlpPolicyEvent::_internal_triggered_rule_name() const { … }
inline void DlpPolicyEvent::_internal_set_triggered_rule_name(const std::string& value) { … }
inline std::string* DlpPolicyEvent::_internal_mutable_triggered_rule_name() { … }
inline std::string* DlpPolicyEvent::release_triggered_rule_name() { … }
inline void DlpPolicyEvent::set_allocated_triggered_rule_name(std::string* triggered_rule_name) { … }

// optional string triggered_rule_id = 10;
inline bool DlpPolicyEvent::_internal_has_triggered_rule_id() const { … }
inline bool DlpPolicyEvent::has_triggered_rule_id() const { … }
inline void DlpPolicyEvent::clear_triggered_rule_id() { … }
inline const std::string& DlpPolicyEvent::triggered_rule_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DlpPolicyEvent::set_triggered_rule_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DlpPolicyEvent::mutable_triggered_rule_id() { … }
inline const std::string& DlpPolicyEvent::_internal_triggered_rule_id() const { … }
inline void DlpPolicyEvent::_internal_set_triggered_rule_id(const std::string& value) { … }
inline std::string* DlpPolicyEvent::_internal_mutable_triggered_rule_id() { … }
inline std::string* DlpPolicyEvent::release_triggered_rule_id() { … }
inline void DlpPolicyEvent::set_allocated_triggered_rule_id(std::string* triggered_rule_id) { … }

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::DlpPolicyEventDestination_Component> : ::std::true_type { … };
template <> struct is_proto_enum< ::DlpPolicyEvent_Restriction> : ::std::true_type { … };
template <> struct is_proto_enum< ::DlpPolicyEvent_Mode> : ::std::true_type { … };
template <> struct is_proto_enum< ::DlpPolicyEvent_UserType> : ::std::true_type { … };

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_dlp_5fpolicy_5fevent_2eproto
chromium/out/Default/gen/components/enterprise/data_controls/core/browser/dlp_policy_event.pb.h
