1657 lines
79 KiB
C++
Executable File
1657 lines
79 KiB
C++
Executable File
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: protos/public/dtcp_usage.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdtcp_5fusage_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdtcp_5fusage_2eproto
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include <google/protobuf/port_def.inc>
|
|
#if PROTOBUF_VERSION < 3017000
|
|
#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 3017003 < 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/metadata_lite.h>
|
|
#include <google/protobuf/generated_message_reflection.h>
|
|
#include <google/protobuf/message.h>
|
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
|
#include <google/protobuf/generated_enum_reflection.h>
|
|
#include <google/protobuf/unknown_field_set.h>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdtcp_5fusage_2eproto
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
namespace internal {
|
|
class AnyMetadata;
|
|
} // namespace internal
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// Internal implementation detail -- do not use these members.
|
|
struct TableStruct_protos_2fpublic_2fdtcp_5fusage_2eproto {
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
|
|
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[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdtcp_5fusage_2eproto;
|
|
namespace video_widevine {
|
|
class DTCPUsageRules;
|
|
struct DTCPUsageRulesDefaultTypeInternal;
|
|
extern DTCPUsageRulesDefaultTypeInternal _DTCPUsageRules_default_instance_;
|
|
} // namespace video_widevine
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::video_widevine::DTCPUsageRules* Arena::CreateMaybeMessage<::video_widevine::DTCPUsageRules>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace video_widevine {
|
|
|
|
enum DTCPUsageRules_RetentionState : int {
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_FOREVER = 0,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_1_WEEK = 1,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_2_DAYS = 2,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_1_DAY = 3,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_12_HOURS = 4,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_6_HOURS = 5,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_3_HOURS = 6,
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_90_MINUTES = 7
|
|
};
|
|
bool DTCPUsageRules_RetentionState_IsValid(int value);
|
|
constexpr DTCPUsageRules_RetentionState DTCPUsageRules_RetentionState_RetentionState_MIN = DTCPUsageRules_RetentionState_RETENTION_STATE_FOREVER;
|
|
constexpr DTCPUsageRules_RetentionState DTCPUsageRules_RetentionState_RetentionState_MAX = DTCPUsageRules_RetentionState_RETENTION_STATE_90_MINUTES;
|
|
constexpr int DTCPUsageRules_RetentionState_RetentionState_ARRAYSIZE = DTCPUsageRules_RetentionState_RetentionState_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_RetentionState_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_RetentionState_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_RetentionState>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_RetentionState_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_RetentionState_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_RetentionState_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_RetentionState* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_RetentionState>(
|
|
DTCPUsageRules_RetentionState_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_CopyControlInfo : int {
|
|
DTCPUsageRules_CopyControlInfo_COPY_FREE = 0,
|
|
DTCPUsageRules_CopyControlInfo_COPY_NO_MORE = 1,
|
|
DTCPUsageRules_CopyControlInfo_COPY_ONE = 2,
|
|
DTCPUsageRules_CopyControlInfo_COPY_NEVER = 3
|
|
};
|
|
bool DTCPUsageRules_CopyControlInfo_IsValid(int value);
|
|
constexpr DTCPUsageRules_CopyControlInfo DTCPUsageRules_CopyControlInfo_CopyControlInfo_MIN = DTCPUsageRules_CopyControlInfo_COPY_FREE;
|
|
constexpr DTCPUsageRules_CopyControlInfo DTCPUsageRules_CopyControlInfo_CopyControlInfo_MAX = DTCPUsageRules_CopyControlInfo_COPY_NEVER;
|
|
constexpr int DTCPUsageRules_CopyControlInfo_CopyControlInfo_ARRAYSIZE = DTCPUsageRules_CopyControlInfo_CopyControlInfo_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_CopyControlInfo_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_CopyControlInfo_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_CopyControlInfo>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_CopyControlInfo_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_CopyControlInfo_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_CopyControlInfo_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_CopyControlInfo* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_CopyControlInfo>(
|
|
DTCPUsageRules_CopyControlInfo_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_AnalogProtectionSystem : int {
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_OFF = 0,
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_TYPE1 = 1,
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_TYPE2 = 2,
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_TYPE3 = 3
|
|
};
|
|
bool DTCPUsageRules_AnalogProtectionSystem_IsValid(int value);
|
|
constexpr DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MIN = DTCPUsageRules_AnalogProtectionSystem_APS_OFF;
|
|
constexpr DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MAX = DTCPUsageRules_AnalogProtectionSystem_APS_TYPE3;
|
|
constexpr int DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_ARRAYSIZE = DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_AnalogProtectionSystem_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_AnalogProtectionSystem_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_AnalogProtectionSystem>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_AnalogProtectionSystem_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_AnalogProtectionSystem_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_AnalogProtectionSystem_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_AnalogProtectionSystem* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_AnalogProtectionSystem>(
|
|
DTCPUsageRules_AnalogProtectionSystem_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_ImageConstraintToken : int {
|
|
DTCPUsageRules_ImageConstraintToken_ICT_CONSTRAINED = 0,
|
|
DTCPUsageRules_ImageConstraintToken_ICT_HD_ANALOG = 1
|
|
};
|
|
bool DTCPUsageRules_ImageConstraintToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_ImageConstraintToken DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MIN = DTCPUsageRules_ImageConstraintToken_ICT_CONSTRAINED;
|
|
constexpr DTCPUsageRules_ImageConstraintToken DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MAX = DTCPUsageRules_ImageConstraintToken_ICT_HD_ANALOG;
|
|
constexpr int DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_ARRAYSIZE = DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_ImageConstraintToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_ImageConstraintToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_ImageConstraintToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_ImageConstraintToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_ImageConstraintToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_ImageConstraintToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_ImageConstraintToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_ImageConstraintToken>(
|
|
DTCPUsageRules_ImageConstraintToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_AnalogSunsetToken : int {
|
|
DTCPUsageRules_AnalogSunsetToken_AST_ASSERTED = 0,
|
|
DTCPUsageRules_AnalogSunsetToken_AST_UNASERTED = 1
|
|
};
|
|
bool DTCPUsageRules_AnalogSunsetToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_AnalogSunsetToken DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MIN = DTCPUsageRules_AnalogSunsetToken_AST_ASSERTED;
|
|
constexpr DTCPUsageRules_AnalogSunsetToken DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MAX = DTCPUsageRules_AnalogSunsetToken_AST_UNASERTED;
|
|
constexpr int DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_ARRAYSIZE = DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_AnalogSunsetToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_AnalogSunsetToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_AnalogSunsetToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_AnalogSunsetToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_AnalogSunsetToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_AnalogSunsetToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_AnalogSunsetToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_AnalogSunsetToken>(
|
|
DTCPUsageRules_AnalogSunsetToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_DigitalOnlyToken : int {
|
|
DTCPUsageRules_DigitalOnlyToken_DOT_ASSERTED = 0,
|
|
DTCPUsageRules_DigitalOnlyToken_DOT_UNASSERTED = 1
|
|
};
|
|
bool DTCPUsageRules_DigitalOnlyToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_DigitalOnlyToken DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MIN = DTCPUsageRules_DigitalOnlyToken_DOT_ASSERTED;
|
|
constexpr DTCPUsageRules_DigitalOnlyToken DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MAX = DTCPUsageRules_DigitalOnlyToken_DOT_UNASSERTED;
|
|
constexpr int DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_ARRAYSIZE = DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_DigitalOnlyToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_DigitalOnlyToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_DigitalOnlyToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_DigitalOnlyToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_DigitalOnlyToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_DigitalOnlyToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_DigitalOnlyToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_DigitalOnlyToken>(
|
|
DTCPUsageRules_DigitalOnlyToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_AudioEnhancedToken : int {
|
|
DTCPUsageRules_AudioEnhancedToken_AET_ASSERTED = 0,
|
|
DTCPUsageRules_AudioEnhancedToken_AET_UNASSERTED = 1
|
|
};
|
|
bool DTCPUsageRules_AudioEnhancedToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_AudioEnhancedToken DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MIN = DTCPUsageRules_AudioEnhancedToken_AET_ASSERTED;
|
|
constexpr DTCPUsageRules_AudioEnhancedToken DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MAX = DTCPUsageRules_AudioEnhancedToken_AET_UNASSERTED;
|
|
constexpr int DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_ARRAYSIZE = DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_AudioEnhancedToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_AudioEnhancedToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_AudioEnhancedToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_AudioEnhancedToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_AudioEnhancedToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_AudioEnhancedToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_AudioEnhancedToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_AudioEnhancedToken>(
|
|
DTCPUsageRules_AudioEnhancedToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_StandardDigitalOutputToken : int {
|
|
DTCPUsageRules_StandardDigitalOutputToken_SDO_UNASSEERTED = 0,
|
|
DTCPUsageRules_StandardDigitalOutputToken_SDO_ASSEERTED = 1
|
|
};
|
|
bool DTCPUsageRules_StandardDigitalOutputToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MIN = DTCPUsageRules_StandardDigitalOutputToken_SDO_UNASSEERTED;
|
|
constexpr DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MAX = DTCPUsageRules_StandardDigitalOutputToken_SDO_ASSEERTED;
|
|
constexpr int DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_ARRAYSIZE = DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_StandardDigitalOutputToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_StandardDigitalOutputToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_StandardDigitalOutputToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_StandardDigitalOutputToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_StandardDigitalOutputToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_StandardDigitalOutputToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_StandardDigitalOutputToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_StandardDigitalOutputToken>(
|
|
DTCPUsageRules_StandardDigitalOutputToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_HighDynamicRangeToken : int {
|
|
DTCPUsageRules_HighDynamicRangeToken_HDR_UNASSERTED = 0,
|
|
DTCPUsageRules_HighDynamicRangeToken_HDR_ASSERTED = 1
|
|
};
|
|
bool DTCPUsageRules_HighDynamicRangeToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MIN = DTCPUsageRules_HighDynamicRangeToken_HDR_UNASSERTED;
|
|
constexpr DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MAX = DTCPUsageRules_HighDynamicRangeToken_HDR_ASSERTED;
|
|
constexpr int DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_ARRAYSIZE = DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_HighDynamicRangeToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_HighDynamicRangeToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_HighDynamicRangeToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_HighDynamicRangeToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_HighDynamicRangeToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_HighDynamicRangeToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_HighDynamicRangeToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_HighDynamicRangeToken>(
|
|
DTCPUsageRules_HighDynamicRangeToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_L2ProtectionOnlyToken : int {
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_UNASSERTED = 0,
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_ASSERTED = 1
|
|
};
|
|
bool DTCPUsageRules_L2ProtectionOnlyToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MIN = DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_UNASSERTED;
|
|
constexpr DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MAX = DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_ASSERTED;
|
|
constexpr int DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_ARRAYSIZE = DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_L2ProtectionOnlyToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_L2ProtectionOnlyToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_L2ProtectionOnlyToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_L2ProtectionOnlyToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_L2ProtectionOnlyToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_L2ProtectionOnlyToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_L2ProtectionOnlyToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_L2ProtectionOnlyToken>(
|
|
DTCPUsageRules_L2ProtectionOnlyToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_EnhancedImageToken : int {
|
|
DTCPUsageRules_EnhancedImageToken_EI_UNASSERTED = 0,
|
|
DTCPUsageRules_EnhancedImageToken_EI_ASSERTED = 1
|
|
};
|
|
bool DTCPUsageRules_EnhancedImageToken_IsValid(int value);
|
|
constexpr DTCPUsageRules_EnhancedImageToken DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MIN = DTCPUsageRules_EnhancedImageToken_EI_UNASSERTED;
|
|
constexpr DTCPUsageRules_EnhancedImageToken DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MAX = DTCPUsageRules_EnhancedImageToken_EI_ASSERTED;
|
|
constexpr int DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_ARRAYSIZE = DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_EnhancedImageToken_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_EnhancedImageToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_EnhancedImageToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_EnhancedImageToken_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_EnhancedImageToken_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_EnhancedImageToken_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_EnhancedImageToken* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_EnhancedImageToken>(
|
|
DTCPUsageRules_EnhancedImageToken_descriptor(), name, value);
|
|
}
|
|
enum DTCPUsageRules_FurtherBoundCopy : int {
|
|
DTCPUsageRules_FurtherBoundCopy_FBC_PROHIBITED = 0,
|
|
DTCPUsageRules_FurtherBoundCopy_FBC_PERMITTED = 1
|
|
};
|
|
bool DTCPUsageRules_FurtherBoundCopy_IsValid(int value);
|
|
constexpr DTCPUsageRules_FurtherBoundCopy DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MIN = DTCPUsageRules_FurtherBoundCopy_FBC_PROHIBITED;
|
|
constexpr DTCPUsageRules_FurtherBoundCopy DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MAX = DTCPUsageRules_FurtherBoundCopy_FBC_PERMITTED;
|
|
constexpr int DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_ARRAYSIZE = DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_FurtherBoundCopy_descriptor();
|
|
template<typename T>
|
|
inline const std::string& DTCPUsageRules_FurtherBoundCopy_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DTCPUsageRules_FurtherBoundCopy>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DTCPUsageRules_FurtherBoundCopy_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
DTCPUsageRules_FurtherBoundCopy_descriptor(), enum_t_value);
|
|
}
|
|
inline bool DTCPUsageRules_FurtherBoundCopy_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_FurtherBoundCopy* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_FurtherBoundCopy>(
|
|
DTCPUsageRules_FurtherBoundCopy_descriptor(), name, value);
|
|
}
|
|
// ===================================================================
|
|
|
|
class DTCPUsageRules final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DTCPUsageRules) */ {
|
|
public:
|
|
inline DTCPUsageRules() : DTCPUsageRules(nullptr) {}
|
|
~DTCPUsageRules() override;
|
|
explicit constexpr DTCPUsageRules(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
DTCPUsageRules(const DTCPUsageRules& from);
|
|
DTCPUsageRules(DTCPUsageRules&& from) noexcept
|
|
: DTCPUsageRules() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline DTCPUsageRules& operator=(const DTCPUsageRules& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline DTCPUsageRules& operator=(DTCPUsageRules&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const DTCPUsageRules& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const DTCPUsageRules* internal_default_instance() {
|
|
return reinterpret_cast<const DTCPUsageRules*>(
|
|
&_DTCPUsageRules_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(DTCPUsageRules& a, DTCPUsageRules& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(DTCPUsageRules* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(DTCPUsageRules* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline DTCPUsageRules* New() const final {
|
|
return new DTCPUsageRules();
|
|
}
|
|
|
|
DTCPUsageRules* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<DTCPUsageRules>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const DTCPUsageRules& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const DTCPUsageRules& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(DTCPUsageRules* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.DTCPUsageRules";
|
|
}
|
|
protected:
|
|
explicit DTCPUsageRules(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef DTCPUsageRules_RetentionState RetentionState;
|
|
static constexpr RetentionState RETENTION_STATE_FOREVER =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_FOREVER;
|
|
static constexpr RetentionState RETENTION_STATE_1_WEEK =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_1_WEEK;
|
|
static constexpr RetentionState RETENTION_STATE_2_DAYS =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_2_DAYS;
|
|
static constexpr RetentionState RETENTION_STATE_1_DAY =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_1_DAY;
|
|
static constexpr RetentionState RETENTION_STATE_12_HOURS =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_12_HOURS;
|
|
static constexpr RetentionState RETENTION_STATE_6_HOURS =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_6_HOURS;
|
|
static constexpr RetentionState RETENTION_STATE_3_HOURS =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_3_HOURS;
|
|
static constexpr RetentionState RETENTION_STATE_90_MINUTES =
|
|
DTCPUsageRules_RetentionState_RETENTION_STATE_90_MINUTES;
|
|
static inline bool RetentionState_IsValid(int value) {
|
|
return DTCPUsageRules_RetentionState_IsValid(value);
|
|
}
|
|
static constexpr RetentionState RetentionState_MIN =
|
|
DTCPUsageRules_RetentionState_RetentionState_MIN;
|
|
static constexpr RetentionState RetentionState_MAX =
|
|
DTCPUsageRules_RetentionState_RetentionState_MAX;
|
|
static constexpr int RetentionState_ARRAYSIZE =
|
|
DTCPUsageRules_RetentionState_RetentionState_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
RetentionState_descriptor() {
|
|
return DTCPUsageRules_RetentionState_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& RetentionState_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, RetentionState>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function RetentionState_Name.");
|
|
return DTCPUsageRules_RetentionState_Name(enum_t_value);
|
|
}
|
|
static inline bool RetentionState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
RetentionState* value) {
|
|
return DTCPUsageRules_RetentionState_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_CopyControlInfo CopyControlInfo;
|
|
static constexpr CopyControlInfo COPY_FREE =
|
|
DTCPUsageRules_CopyControlInfo_COPY_FREE;
|
|
static constexpr CopyControlInfo COPY_NO_MORE =
|
|
DTCPUsageRules_CopyControlInfo_COPY_NO_MORE;
|
|
static constexpr CopyControlInfo COPY_ONE =
|
|
DTCPUsageRules_CopyControlInfo_COPY_ONE;
|
|
static constexpr CopyControlInfo COPY_NEVER =
|
|
DTCPUsageRules_CopyControlInfo_COPY_NEVER;
|
|
static inline bool CopyControlInfo_IsValid(int value) {
|
|
return DTCPUsageRules_CopyControlInfo_IsValid(value);
|
|
}
|
|
static constexpr CopyControlInfo CopyControlInfo_MIN =
|
|
DTCPUsageRules_CopyControlInfo_CopyControlInfo_MIN;
|
|
static constexpr CopyControlInfo CopyControlInfo_MAX =
|
|
DTCPUsageRules_CopyControlInfo_CopyControlInfo_MAX;
|
|
static constexpr int CopyControlInfo_ARRAYSIZE =
|
|
DTCPUsageRules_CopyControlInfo_CopyControlInfo_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
CopyControlInfo_descriptor() {
|
|
return DTCPUsageRules_CopyControlInfo_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& CopyControlInfo_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, CopyControlInfo>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function CopyControlInfo_Name.");
|
|
return DTCPUsageRules_CopyControlInfo_Name(enum_t_value);
|
|
}
|
|
static inline bool CopyControlInfo_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
CopyControlInfo* value) {
|
|
return DTCPUsageRules_CopyControlInfo_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_AnalogProtectionSystem AnalogProtectionSystem;
|
|
static constexpr AnalogProtectionSystem APS_OFF =
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_OFF;
|
|
static constexpr AnalogProtectionSystem APS_TYPE1 =
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_TYPE1;
|
|
static constexpr AnalogProtectionSystem APS_TYPE2 =
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_TYPE2;
|
|
static constexpr AnalogProtectionSystem APS_TYPE3 =
|
|
DTCPUsageRules_AnalogProtectionSystem_APS_TYPE3;
|
|
static inline bool AnalogProtectionSystem_IsValid(int value) {
|
|
return DTCPUsageRules_AnalogProtectionSystem_IsValid(value);
|
|
}
|
|
static constexpr AnalogProtectionSystem AnalogProtectionSystem_MIN =
|
|
DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MIN;
|
|
static constexpr AnalogProtectionSystem AnalogProtectionSystem_MAX =
|
|
DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MAX;
|
|
static constexpr int AnalogProtectionSystem_ARRAYSIZE =
|
|
DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
AnalogProtectionSystem_descriptor() {
|
|
return DTCPUsageRules_AnalogProtectionSystem_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& AnalogProtectionSystem_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, AnalogProtectionSystem>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function AnalogProtectionSystem_Name.");
|
|
return DTCPUsageRules_AnalogProtectionSystem_Name(enum_t_value);
|
|
}
|
|
static inline bool AnalogProtectionSystem_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
AnalogProtectionSystem* value) {
|
|
return DTCPUsageRules_AnalogProtectionSystem_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_ImageConstraintToken ImageConstraintToken;
|
|
static constexpr ImageConstraintToken ICT_CONSTRAINED =
|
|
DTCPUsageRules_ImageConstraintToken_ICT_CONSTRAINED;
|
|
static constexpr ImageConstraintToken ICT_HD_ANALOG =
|
|
DTCPUsageRules_ImageConstraintToken_ICT_HD_ANALOG;
|
|
static inline bool ImageConstraintToken_IsValid(int value) {
|
|
return DTCPUsageRules_ImageConstraintToken_IsValid(value);
|
|
}
|
|
static constexpr ImageConstraintToken ImageConstraintToken_MIN =
|
|
DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MIN;
|
|
static constexpr ImageConstraintToken ImageConstraintToken_MAX =
|
|
DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MAX;
|
|
static constexpr int ImageConstraintToken_ARRAYSIZE =
|
|
DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
ImageConstraintToken_descriptor() {
|
|
return DTCPUsageRules_ImageConstraintToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& ImageConstraintToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ImageConstraintToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ImageConstraintToken_Name.");
|
|
return DTCPUsageRules_ImageConstraintToken_Name(enum_t_value);
|
|
}
|
|
static inline bool ImageConstraintToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
ImageConstraintToken* value) {
|
|
return DTCPUsageRules_ImageConstraintToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_AnalogSunsetToken AnalogSunsetToken;
|
|
static constexpr AnalogSunsetToken AST_ASSERTED =
|
|
DTCPUsageRules_AnalogSunsetToken_AST_ASSERTED;
|
|
static constexpr AnalogSunsetToken AST_UNASERTED =
|
|
DTCPUsageRules_AnalogSunsetToken_AST_UNASERTED;
|
|
static inline bool AnalogSunsetToken_IsValid(int value) {
|
|
return DTCPUsageRules_AnalogSunsetToken_IsValid(value);
|
|
}
|
|
static constexpr AnalogSunsetToken AnalogSunsetToken_MIN =
|
|
DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MIN;
|
|
static constexpr AnalogSunsetToken AnalogSunsetToken_MAX =
|
|
DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MAX;
|
|
static constexpr int AnalogSunsetToken_ARRAYSIZE =
|
|
DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
AnalogSunsetToken_descriptor() {
|
|
return DTCPUsageRules_AnalogSunsetToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& AnalogSunsetToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, AnalogSunsetToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function AnalogSunsetToken_Name.");
|
|
return DTCPUsageRules_AnalogSunsetToken_Name(enum_t_value);
|
|
}
|
|
static inline bool AnalogSunsetToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
AnalogSunsetToken* value) {
|
|
return DTCPUsageRules_AnalogSunsetToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_DigitalOnlyToken DigitalOnlyToken;
|
|
static constexpr DigitalOnlyToken DOT_ASSERTED =
|
|
DTCPUsageRules_DigitalOnlyToken_DOT_ASSERTED;
|
|
static constexpr DigitalOnlyToken DOT_UNASSERTED =
|
|
DTCPUsageRules_DigitalOnlyToken_DOT_UNASSERTED;
|
|
static inline bool DigitalOnlyToken_IsValid(int value) {
|
|
return DTCPUsageRules_DigitalOnlyToken_IsValid(value);
|
|
}
|
|
static constexpr DigitalOnlyToken DigitalOnlyToken_MIN =
|
|
DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MIN;
|
|
static constexpr DigitalOnlyToken DigitalOnlyToken_MAX =
|
|
DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MAX;
|
|
static constexpr int DigitalOnlyToken_ARRAYSIZE =
|
|
DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
DigitalOnlyToken_descriptor() {
|
|
return DTCPUsageRules_DigitalOnlyToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& DigitalOnlyToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, DigitalOnlyToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function DigitalOnlyToken_Name.");
|
|
return DTCPUsageRules_DigitalOnlyToken_Name(enum_t_value);
|
|
}
|
|
static inline bool DigitalOnlyToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
DigitalOnlyToken* value) {
|
|
return DTCPUsageRules_DigitalOnlyToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_AudioEnhancedToken AudioEnhancedToken;
|
|
static constexpr AudioEnhancedToken AET_ASSERTED =
|
|
DTCPUsageRules_AudioEnhancedToken_AET_ASSERTED;
|
|
static constexpr AudioEnhancedToken AET_UNASSERTED =
|
|
DTCPUsageRules_AudioEnhancedToken_AET_UNASSERTED;
|
|
static inline bool AudioEnhancedToken_IsValid(int value) {
|
|
return DTCPUsageRules_AudioEnhancedToken_IsValid(value);
|
|
}
|
|
static constexpr AudioEnhancedToken AudioEnhancedToken_MIN =
|
|
DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MIN;
|
|
static constexpr AudioEnhancedToken AudioEnhancedToken_MAX =
|
|
DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MAX;
|
|
static constexpr int AudioEnhancedToken_ARRAYSIZE =
|
|
DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
AudioEnhancedToken_descriptor() {
|
|
return DTCPUsageRules_AudioEnhancedToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& AudioEnhancedToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, AudioEnhancedToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function AudioEnhancedToken_Name.");
|
|
return DTCPUsageRules_AudioEnhancedToken_Name(enum_t_value);
|
|
}
|
|
static inline bool AudioEnhancedToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
AudioEnhancedToken* value) {
|
|
return DTCPUsageRules_AudioEnhancedToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_StandardDigitalOutputToken StandardDigitalOutputToken;
|
|
static constexpr StandardDigitalOutputToken SDO_UNASSEERTED =
|
|
DTCPUsageRules_StandardDigitalOutputToken_SDO_UNASSEERTED;
|
|
static constexpr StandardDigitalOutputToken SDO_ASSEERTED =
|
|
DTCPUsageRules_StandardDigitalOutputToken_SDO_ASSEERTED;
|
|
static inline bool StandardDigitalOutputToken_IsValid(int value) {
|
|
return DTCPUsageRules_StandardDigitalOutputToken_IsValid(value);
|
|
}
|
|
static constexpr StandardDigitalOutputToken StandardDigitalOutputToken_MIN =
|
|
DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MIN;
|
|
static constexpr StandardDigitalOutputToken StandardDigitalOutputToken_MAX =
|
|
DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MAX;
|
|
static constexpr int StandardDigitalOutputToken_ARRAYSIZE =
|
|
DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
StandardDigitalOutputToken_descriptor() {
|
|
return DTCPUsageRules_StandardDigitalOutputToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& StandardDigitalOutputToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, StandardDigitalOutputToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function StandardDigitalOutputToken_Name.");
|
|
return DTCPUsageRules_StandardDigitalOutputToken_Name(enum_t_value);
|
|
}
|
|
static inline bool StandardDigitalOutputToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
StandardDigitalOutputToken* value) {
|
|
return DTCPUsageRules_StandardDigitalOutputToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_HighDynamicRangeToken HighDynamicRangeToken;
|
|
static constexpr HighDynamicRangeToken HDR_UNASSERTED =
|
|
DTCPUsageRules_HighDynamicRangeToken_HDR_UNASSERTED;
|
|
static constexpr HighDynamicRangeToken HDR_ASSERTED =
|
|
DTCPUsageRules_HighDynamicRangeToken_HDR_ASSERTED;
|
|
static inline bool HighDynamicRangeToken_IsValid(int value) {
|
|
return DTCPUsageRules_HighDynamicRangeToken_IsValid(value);
|
|
}
|
|
static constexpr HighDynamicRangeToken HighDynamicRangeToken_MIN =
|
|
DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MIN;
|
|
static constexpr HighDynamicRangeToken HighDynamicRangeToken_MAX =
|
|
DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MAX;
|
|
static constexpr int HighDynamicRangeToken_ARRAYSIZE =
|
|
DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
HighDynamicRangeToken_descriptor() {
|
|
return DTCPUsageRules_HighDynamicRangeToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& HighDynamicRangeToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, HighDynamicRangeToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function HighDynamicRangeToken_Name.");
|
|
return DTCPUsageRules_HighDynamicRangeToken_Name(enum_t_value);
|
|
}
|
|
static inline bool HighDynamicRangeToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
HighDynamicRangeToken* value) {
|
|
return DTCPUsageRules_HighDynamicRangeToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_L2ProtectionOnlyToken L2ProtectionOnlyToken;
|
|
static constexpr L2ProtectionOnlyToken L2_ONLY_UNASSERTED =
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_UNASSERTED;
|
|
static constexpr L2ProtectionOnlyToken L2_ONLY_ASSERTED =
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_ASSERTED;
|
|
static inline bool L2ProtectionOnlyToken_IsValid(int value) {
|
|
return DTCPUsageRules_L2ProtectionOnlyToken_IsValid(value);
|
|
}
|
|
static constexpr L2ProtectionOnlyToken L2ProtectionOnlyToken_MIN =
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MIN;
|
|
static constexpr L2ProtectionOnlyToken L2ProtectionOnlyToken_MAX =
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MAX;
|
|
static constexpr int L2ProtectionOnlyToken_ARRAYSIZE =
|
|
DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
L2ProtectionOnlyToken_descriptor() {
|
|
return DTCPUsageRules_L2ProtectionOnlyToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& L2ProtectionOnlyToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, L2ProtectionOnlyToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function L2ProtectionOnlyToken_Name.");
|
|
return DTCPUsageRules_L2ProtectionOnlyToken_Name(enum_t_value);
|
|
}
|
|
static inline bool L2ProtectionOnlyToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
L2ProtectionOnlyToken* value) {
|
|
return DTCPUsageRules_L2ProtectionOnlyToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_EnhancedImageToken EnhancedImageToken;
|
|
static constexpr EnhancedImageToken EI_UNASSERTED =
|
|
DTCPUsageRules_EnhancedImageToken_EI_UNASSERTED;
|
|
static constexpr EnhancedImageToken EI_ASSERTED =
|
|
DTCPUsageRules_EnhancedImageToken_EI_ASSERTED;
|
|
static inline bool EnhancedImageToken_IsValid(int value) {
|
|
return DTCPUsageRules_EnhancedImageToken_IsValid(value);
|
|
}
|
|
static constexpr EnhancedImageToken EnhancedImageToken_MIN =
|
|
DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MIN;
|
|
static constexpr EnhancedImageToken EnhancedImageToken_MAX =
|
|
DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MAX;
|
|
static constexpr int EnhancedImageToken_ARRAYSIZE =
|
|
DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
EnhancedImageToken_descriptor() {
|
|
return DTCPUsageRules_EnhancedImageToken_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& EnhancedImageToken_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, EnhancedImageToken>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function EnhancedImageToken_Name.");
|
|
return DTCPUsageRules_EnhancedImageToken_Name(enum_t_value);
|
|
}
|
|
static inline bool EnhancedImageToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
EnhancedImageToken* value) {
|
|
return DTCPUsageRules_EnhancedImageToken_Parse(name, value);
|
|
}
|
|
|
|
typedef DTCPUsageRules_FurtherBoundCopy FurtherBoundCopy;
|
|
static constexpr FurtherBoundCopy FBC_PROHIBITED =
|
|
DTCPUsageRules_FurtherBoundCopy_FBC_PROHIBITED;
|
|
static constexpr FurtherBoundCopy FBC_PERMITTED =
|
|
DTCPUsageRules_FurtherBoundCopy_FBC_PERMITTED;
|
|
static inline bool FurtherBoundCopy_IsValid(int value) {
|
|
return DTCPUsageRules_FurtherBoundCopy_IsValid(value);
|
|
}
|
|
static constexpr FurtherBoundCopy FurtherBoundCopy_MIN =
|
|
DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MIN;
|
|
static constexpr FurtherBoundCopy FurtherBoundCopy_MAX =
|
|
DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MAX;
|
|
static constexpr int FurtherBoundCopy_ARRAYSIZE =
|
|
DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
FurtherBoundCopy_descriptor() {
|
|
return DTCPUsageRules_FurtherBoundCopy_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& FurtherBoundCopy_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, FurtherBoundCopy>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function FurtherBoundCopy_Name.");
|
|
return DTCPUsageRules_FurtherBoundCopy_Name(enum_t_value);
|
|
}
|
|
static inline bool FurtherBoundCopy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
FurtherBoundCopy* value) {
|
|
return DTCPUsageRules_FurtherBoundCopy_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCopyControlFieldNumber = 2,
|
|
kRequireDtcp2FieldNumber = 1,
|
|
kEncryptionPlusFieldNumber = 3,
|
|
kRetentionStateFieldNumber = 4,
|
|
kAnalogProtectionSystemFieldNumber = 5,
|
|
kImageConstraintTokenFieldNumber = 6,
|
|
kAnalogSunsetTokenFieldNumber = 7,
|
|
kDigitalOnlyTokenFieldNumber = 8,
|
|
kAudioEnhancedTokenFieldNumber = 9,
|
|
kCopyCountFieldNumber = 10,
|
|
kStandardDigitalTokenFieldNumber = 11,
|
|
kHighDynamicTokenFieldNumber = 12,
|
|
kL2OnlyTokenFieldNumber = 13,
|
|
kEnhanedImageTokenFieldNumber = 14,
|
|
kRetentionTimeFieldNumber = 15,
|
|
kFurtherCopyFieldNumber = 16,
|
|
};
|
|
// optional .video_widevine.DTCPUsageRules.CopyControlInfo copy_control = 2;
|
|
bool has_copy_control() const;
|
|
private:
|
|
bool _internal_has_copy_control() const;
|
|
public:
|
|
void clear_copy_control();
|
|
::video_widevine::DTCPUsageRules_CopyControlInfo copy_control() const;
|
|
void set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_CopyControlInfo _internal_copy_control() const;
|
|
void _internal_set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value);
|
|
public:
|
|
|
|
// optional bool require_dtcp2 = 1 [default = false];
|
|
bool has_require_dtcp2() const;
|
|
private:
|
|
bool _internal_has_require_dtcp2() const;
|
|
public:
|
|
void clear_require_dtcp2();
|
|
bool require_dtcp2() const;
|
|
void set_require_dtcp2(bool value);
|
|
private:
|
|
bool _internal_require_dtcp2() const;
|
|
void _internal_set_require_dtcp2(bool value);
|
|
public:
|
|
|
|
// optional bool encryption_plus = 3;
|
|
bool has_encryption_plus() const;
|
|
private:
|
|
bool _internal_has_encryption_plus() const;
|
|
public:
|
|
void clear_encryption_plus();
|
|
bool encryption_plus() const;
|
|
void set_encryption_plus(bool value);
|
|
private:
|
|
bool _internal_encryption_plus() const;
|
|
void _internal_set_encryption_plus(bool value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.RetentionState retention_state = 4;
|
|
bool has_retention_state() const;
|
|
private:
|
|
bool _internal_has_retention_state() const;
|
|
public:
|
|
void clear_retention_state();
|
|
::video_widevine::DTCPUsageRules_RetentionState retention_state() const;
|
|
void set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_RetentionState _internal_retention_state() const;
|
|
void _internal_set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.AnalogProtectionSystem analog_protection_system = 5;
|
|
bool has_analog_protection_system() const;
|
|
private:
|
|
bool _internal_has_analog_protection_system() const;
|
|
public:
|
|
void clear_analog_protection_system();
|
|
::video_widevine::DTCPUsageRules_AnalogProtectionSystem analog_protection_system() const;
|
|
void set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_AnalogProtectionSystem _internal_analog_protection_system() const;
|
|
void _internal_set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.ImageConstraintToken image_constraint_token = 6;
|
|
bool has_image_constraint_token() const;
|
|
private:
|
|
bool _internal_has_image_constraint_token() const;
|
|
public:
|
|
void clear_image_constraint_token();
|
|
::video_widevine::DTCPUsageRules_ImageConstraintToken image_constraint_token() const;
|
|
void set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_ImageConstraintToken _internal_image_constraint_token() const;
|
|
void _internal_set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.AnalogSunsetToken analog_sunset_token = 7;
|
|
bool has_analog_sunset_token() const;
|
|
private:
|
|
bool _internal_has_analog_sunset_token() const;
|
|
public:
|
|
void clear_analog_sunset_token();
|
|
::video_widevine::DTCPUsageRules_AnalogSunsetToken analog_sunset_token() const;
|
|
void set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_AnalogSunsetToken _internal_analog_sunset_token() const;
|
|
void _internal_set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.DigitalOnlyToken digital_only_token = 8;
|
|
bool has_digital_only_token() const;
|
|
private:
|
|
bool _internal_has_digital_only_token() const;
|
|
public:
|
|
void clear_digital_only_token();
|
|
::video_widevine::DTCPUsageRules_DigitalOnlyToken digital_only_token() const;
|
|
void set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_DigitalOnlyToken _internal_digital_only_token() const;
|
|
void _internal_set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.AudioEnhancedToken audio_enhanced_token = 9;
|
|
bool has_audio_enhanced_token() const;
|
|
private:
|
|
bool _internal_has_audio_enhanced_token() const;
|
|
public:
|
|
void clear_audio_enhanced_token();
|
|
::video_widevine::DTCPUsageRules_AudioEnhancedToken audio_enhanced_token() const;
|
|
void set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_AudioEnhancedToken _internal_audio_enhanced_token() const;
|
|
void _internal_set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value);
|
|
public:
|
|
|
|
// optional uint32 copy_count = 10;
|
|
bool has_copy_count() const;
|
|
private:
|
|
bool _internal_has_copy_count() const;
|
|
public:
|
|
void clear_copy_count();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 copy_count() const;
|
|
void set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_copy_count() const;
|
|
void _internal_set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.StandardDigitalOutputToken standard_digital_token = 11;
|
|
bool has_standard_digital_token() const;
|
|
private:
|
|
bool _internal_has_standard_digital_token() const;
|
|
public:
|
|
void clear_standard_digital_token();
|
|
::video_widevine::DTCPUsageRules_StandardDigitalOutputToken standard_digital_token() const;
|
|
void set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_StandardDigitalOutputToken _internal_standard_digital_token() const;
|
|
void _internal_set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.HighDynamicRangeToken high_dynamic_token = 12;
|
|
bool has_high_dynamic_token() const;
|
|
private:
|
|
bool _internal_has_high_dynamic_token() const;
|
|
public:
|
|
void clear_high_dynamic_token();
|
|
::video_widevine::DTCPUsageRules_HighDynamicRangeToken high_dynamic_token() const;
|
|
void set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_HighDynamicRangeToken _internal_high_dynamic_token() const;
|
|
void _internal_set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.L2ProtectionOnlyToken l2_only_token = 13;
|
|
bool has_l2_only_token() const;
|
|
private:
|
|
bool _internal_has_l2_only_token() const;
|
|
public:
|
|
void clear_l2_only_token();
|
|
::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken l2_only_token() const;
|
|
void set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken _internal_l2_only_token() const;
|
|
void _internal_set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.EnhancedImageToken enhaned_image_token = 14;
|
|
bool has_enhaned_image_token() const;
|
|
private:
|
|
bool _internal_has_enhaned_image_token() const;
|
|
public:
|
|
void clear_enhaned_image_token();
|
|
::video_widevine::DTCPUsageRules_EnhancedImageToken enhaned_image_token() const;
|
|
void set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_EnhancedImageToken _internal_enhaned_image_token() const;
|
|
void _internal_set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value);
|
|
public:
|
|
|
|
// optional uint32 retention_time = 15;
|
|
bool has_retention_time() const;
|
|
private:
|
|
bool _internal_has_retention_time() const;
|
|
public:
|
|
void clear_retention_time();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 retention_time() const;
|
|
void set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_retention_time() const;
|
|
void _internal_set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// optional .video_widevine.DTCPUsageRules.FurtherBoundCopy further_copy = 16;
|
|
bool has_further_copy() const;
|
|
private:
|
|
bool _internal_has_further_copy() const;
|
|
public:
|
|
void clear_further_copy();
|
|
::video_widevine::DTCPUsageRules_FurtherBoundCopy further_copy() const;
|
|
void set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value);
|
|
private:
|
|
::video_widevine::DTCPUsageRules_FurtherBoundCopy _internal_further_copy() const;
|
|
void _internal_set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.DTCPUsageRules)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
int copy_control_;
|
|
bool require_dtcp2_;
|
|
bool encryption_plus_;
|
|
int retention_state_;
|
|
int analog_protection_system_;
|
|
int image_constraint_token_;
|
|
int analog_sunset_token_;
|
|
int digital_only_token_;
|
|
int audio_enhanced_token_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 copy_count_;
|
|
int standard_digital_token_;
|
|
int high_dynamic_token_;
|
|
int l2_only_token_;
|
|
int enhaned_image_token_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 retention_time_;
|
|
int further_copy_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fdtcp_5fusage_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// DTCPUsageRules
|
|
|
|
// optional bool require_dtcp2 = 1 [default = false];
|
|
inline bool DTCPUsageRules::_internal_has_require_dtcp2() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_require_dtcp2() const {
|
|
return _internal_has_require_dtcp2();
|
|
}
|
|
inline void DTCPUsageRules::clear_require_dtcp2() {
|
|
require_dtcp2_ = false;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline bool DTCPUsageRules::_internal_require_dtcp2() const {
|
|
return require_dtcp2_;
|
|
}
|
|
inline bool DTCPUsageRules::require_dtcp2() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.require_dtcp2)
|
|
return _internal_require_dtcp2();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_require_dtcp2(bool value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
require_dtcp2_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_require_dtcp2(bool value) {
|
|
_internal_set_require_dtcp2(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.require_dtcp2)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.CopyControlInfo copy_control = 2;
|
|
inline bool DTCPUsageRules::_internal_has_copy_control() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_copy_control() const {
|
|
return _internal_has_copy_control();
|
|
}
|
|
inline void DTCPUsageRules::clear_copy_control() {
|
|
copy_control_ = 0;
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_CopyControlInfo DTCPUsageRules::_internal_copy_control() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_CopyControlInfo >(copy_control_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_CopyControlInfo DTCPUsageRules::copy_control() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.copy_control)
|
|
return _internal_copy_control();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value) {
|
|
assert(::video_widevine::DTCPUsageRules_CopyControlInfo_IsValid(value));
|
|
_has_bits_[0] |= 0x00000001u;
|
|
copy_control_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value) {
|
|
_internal_set_copy_control(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.copy_control)
|
|
}
|
|
|
|
// optional bool encryption_plus = 3;
|
|
inline bool DTCPUsageRules::_internal_has_encryption_plus() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_encryption_plus() const {
|
|
return _internal_has_encryption_plus();
|
|
}
|
|
inline void DTCPUsageRules::clear_encryption_plus() {
|
|
encryption_plus_ = false;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline bool DTCPUsageRules::_internal_encryption_plus() const {
|
|
return encryption_plus_;
|
|
}
|
|
inline bool DTCPUsageRules::encryption_plus() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.encryption_plus)
|
|
return _internal_encryption_plus();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_encryption_plus(bool value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
encryption_plus_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_encryption_plus(bool value) {
|
|
_internal_set_encryption_plus(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.encryption_plus)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.RetentionState retention_state = 4;
|
|
inline bool DTCPUsageRules::_internal_has_retention_state() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_retention_state() const {
|
|
return _internal_has_retention_state();
|
|
}
|
|
inline void DTCPUsageRules::clear_retention_state() {
|
|
retention_state_ = 0;
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_RetentionState DTCPUsageRules::_internal_retention_state() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_RetentionState >(retention_state_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_RetentionState DTCPUsageRules::retention_state() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.retention_state)
|
|
return _internal_retention_state();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value) {
|
|
assert(::video_widevine::DTCPUsageRules_RetentionState_IsValid(value));
|
|
_has_bits_[0] |= 0x00000008u;
|
|
retention_state_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value) {
|
|
_internal_set_retention_state(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.retention_state)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.AnalogProtectionSystem analog_protection_system = 5;
|
|
inline bool DTCPUsageRules::_internal_has_analog_protection_system() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_analog_protection_system() const {
|
|
return _internal_has_analog_protection_system();
|
|
}
|
|
inline void DTCPUsageRules::clear_analog_protection_system() {
|
|
analog_protection_system_ = 0;
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules::_internal_analog_protection_system() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_AnalogProtectionSystem >(analog_protection_system_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules::analog_protection_system() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.analog_protection_system)
|
|
return _internal_analog_protection_system();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value) {
|
|
assert(::video_widevine::DTCPUsageRules_AnalogProtectionSystem_IsValid(value));
|
|
_has_bits_[0] |= 0x00000010u;
|
|
analog_protection_system_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value) {
|
|
_internal_set_analog_protection_system(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.analog_protection_system)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.ImageConstraintToken image_constraint_token = 6;
|
|
inline bool DTCPUsageRules::_internal_has_image_constraint_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000020u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_image_constraint_token() const {
|
|
return _internal_has_image_constraint_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_image_constraint_token() {
|
|
image_constraint_token_ = 0;
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_ImageConstraintToken DTCPUsageRules::_internal_image_constraint_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_ImageConstraintToken >(image_constraint_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_ImageConstraintToken DTCPUsageRules::image_constraint_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.image_constraint_token)
|
|
return _internal_image_constraint_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_ImageConstraintToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00000020u;
|
|
image_constraint_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value) {
|
|
_internal_set_image_constraint_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.image_constraint_token)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.AnalogSunsetToken analog_sunset_token = 7;
|
|
inline bool DTCPUsageRules::_internal_has_analog_sunset_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000040u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_analog_sunset_token() const {
|
|
return _internal_has_analog_sunset_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_analog_sunset_token() {
|
|
analog_sunset_token_ = 0;
|
|
_has_bits_[0] &= ~0x00000040u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_AnalogSunsetToken DTCPUsageRules::_internal_analog_sunset_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_AnalogSunsetToken >(analog_sunset_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_AnalogSunsetToken DTCPUsageRules::analog_sunset_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.analog_sunset_token)
|
|
return _internal_analog_sunset_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_AnalogSunsetToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00000040u;
|
|
analog_sunset_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value) {
|
|
_internal_set_analog_sunset_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.analog_sunset_token)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.DigitalOnlyToken digital_only_token = 8;
|
|
inline bool DTCPUsageRules::_internal_has_digital_only_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000080u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_digital_only_token() const {
|
|
return _internal_has_digital_only_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_digital_only_token() {
|
|
digital_only_token_ = 0;
|
|
_has_bits_[0] &= ~0x00000080u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_DigitalOnlyToken DTCPUsageRules::_internal_digital_only_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_DigitalOnlyToken >(digital_only_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_DigitalOnlyToken DTCPUsageRules::digital_only_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.digital_only_token)
|
|
return _internal_digital_only_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_DigitalOnlyToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00000080u;
|
|
digital_only_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value) {
|
|
_internal_set_digital_only_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.digital_only_token)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.AudioEnhancedToken audio_enhanced_token = 9;
|
|
inline bool DTCPUsageRules::_internal_has_audio_enhanced_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000100u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_audio_enhanced_token() const {
|
|
return _internal_has_audio_enhanced_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_audio_enhanced_token() {
|
|
audio_enhanced_token_ = 0;
|
|
_has_bits_[0] &= ~0x00000100u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_AudioEnhancedToken DTCPUsageRules::_internal_audio_enhanced_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_AudioEnhancedToken >(audio_enhanced_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_AudioEnhancedToken DTCPUsageRules::audio_enhanced_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.audio_enhanced_token)
|
|
return _internal_audio_enhanced_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_AudioEnhancedToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00000100u;
|
|
audio_enhanced_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value) {
|
|
_internal_set_audio_enhanced_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.audio_enhanced_token)
|
|
}
|
|
|
|
// optional uint32 copy_count = 10;
|
|
inline bool DTCPUsageRules::_internal_has_copy_count() const {
|
|
bool value = (_has_bits_[0] & 0x00000200u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_copy_count() const {
|
|
return _internal_has_copy_count();
|
|
}
|
|
inline void DTCPUsageRules::clear_copy_count() {
|
|
copy_count_ = 0u;
|
|
_has_bits_[0] &= ~0x00000200u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::_internal_copy_count() const {
|
|
return copy_count_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::copy_count() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.copy_count)
|
|
return _internal_copy_count();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_has_bits_[0] |= 0x00000200u;
|
|
copy_count_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_copy_count(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.copy_count)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.StandardDigitalOutputToken standard_digital_token = 11;
|
|
inline bool DTCPUsageRules::_internal_has_standard_digital_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000400u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_standard_digital_token() const {
|
|
return _internal_has_standard_digital_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_standard_digital_token() {
|
|
standard_digital_token_ = 0;
|
|
_has_bits_[0] &= ~0x00000400u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules::_internal_standard_digital_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken >(standard_digital_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules::standard_digital_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.standard_digital_token)
|
|
return _internal_standard_digital_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00000400u;
|
|
standard_digital_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value) {
|
|
_internal_set_standard_digital_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.standard_digital_token)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.HighDynamicRangeToken high_dynamic_token = 12;
|
|
inline bool DTCPUsageRules::_internal_has_high_dynamic_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000800u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_high_dynamic_token() const {
|
|
return _internal_has_high_dynamic_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_high_dynamic_token() {
|
|
high_dynamic_token_ = 0;
|
|
_has_bits_[0] &= ~0x00000800u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules::_internal_high_dynamic_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_HighDynamicRangeToken >(high_dynamic_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules::high_dynamic_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.high_dynamic_token)
|
|
return _internal_high_dynamic_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_HighDynamicRangeToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00000800u;
|
|
high_dynamic_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value) {
|
|
_internal_set_high_dynamic_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.high_dynamic_token)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.L2ProtectionOnlyToken l2_only_token = 13;
|
|
inline bool DTCPUsageRules::_internal_has_l2_only_token() const {
|
|
bool value = (_has_bits_[0] & 0x00001000u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_l2_only_token() const {
|
|
return _internal_has_l2_only_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_l2_only_token() {
|
|
l2_only_token_ = 0;
|
|
_has_bits_[0] &= ~0x00001000u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules::_internal_l2_only_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken >(l2_only_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules::l2_only_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.l2_only_token)
|
|
return _internal_l2_only_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00001000u;
|
|
l2_only_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value) {
|
|
_internal_set_l2_only_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.l2_only_token)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.EnhancedImageToken enhaned_image_token = 14;
|
|
inline bool DTCPUsageRules::_internal_has_enhaned_image_token() const {
|
|
bool value = (_has_bits_[0] & 0x00002000u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_enhaned_image_token() const {
|
|
return _internal_has_enhaned_image_token();
|
|
}
|
|
inline void DTCPUsageRules::clear_enhaned_image_token() {
|
|
enhaned_image_token_ = 0;
|
|
_has_bits_[0] &= ~0x00002000u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_EnhancedImageToken DTCPUsageRules::_internal_enhaned_image_token() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_EnhancedImageToken >(enhaned_image_token_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_EnhancedImageToken DTCPUsageRules::enhaned_image_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.enhaned_image_token)
|
|
return _internal_enhaned_image_token();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value) {
|
|
assert(::video_widevine::DTCPUsageRules_EnhancedImageToken_IsValid(value));
|
|
_has_bits_[0] |= 0x00002000u;
|
|
enhaned_image_token_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value) {
|
|
_internal_set_enhaned_image_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.enhaned_image_token)
|
|
}
|
|
|
|
// optional uint32 retention_time = 15;
|
|
inline bool DTCPUsageRules::_internal_has_retention_time() const {
|
|
bool value = (_has_bits_[0] & 0x00004000u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_retention_time() const {
|
|
return _internal_has_retention_time();
|
|
}
|
|
inline void DTCPUsageRules::clear_retention_time() {
|
|
retention_time_ = 0u;
|
|
_has_bits_[0] &= ~0x00004000u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::_internal_retention_time() const {
|
|
return retention_time_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::retention_time() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.retention_time)
|
|
return _internal_retention_time();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_has_bits_[0] |= 0x00004000u;
|
|
retention_time_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_retention_time(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.retention_time)
|
|
}
|
|
|
|
// optional .video_widevine.DTCPUsageRules.FurtherBoundCopy further_copy = 16;
|
|
inline bool DTCPUsageRules::_internal_has_further_copy() const {
|
|
bool value = (_has_bits_[0] & 0x00008000u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DTCPUsageRules::has_further_copy() const {
|
|
return _internal_has_further_copy();
|
|
}
|
|
inline void DTCPUsageRules::clear_further_copy() {
|
|
further_copy_ = 0;
|
|
_has_bits_[0] &= ~0x00008000u;
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_FurtherBoundCopy DTCPUsageRules::_internal_further_copy() const {
|
|
return static_cast< ::video_widevine::DTCPUsageRules_FurtherBoundCopy >(further_copy_);
|
|
}
|
|
inline ::video_widevine::DTCPUsageRules_FurtherBoundCopy DTCPUsageRules::further_copy() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.further_copy)
|
|
return _internal_further_copy();
|
|
}
|
|
inline void DTCPUsageRules::_internal_set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value) {
|
|
assert(::video_widevine::DTCPUsageRules_FurtherBoundCopy_IsValid(value));
|
|
_has_bits_[0] |= 0x00008000u;
|
|
further_copy_ = value;
|
|
}
|
|
inline void DTCPUsageRules::set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value) {
|
|
_internal_set_further_copy(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.further_copy)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace video_widevine
|
|
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_RetentionState> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_RetentionState>() {
|
|
return ::video_widevine::DTCPUsageRules_RetentionState_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_CopyControlInfo> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_CopyControlInfo>() {
|
|
return ::video_widevine::DTCPUsageRules_CopyControlInfo_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_AnalogProtectionSystem> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_AnalogProtectionSystem>() {
|
|
return ::video_widevine::DTCPUsageRules_AnalogProtectionSystem_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_ImageConstraintToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_ImageConstraintToken>() {
|
|
return ::video_widevine::DTCPUsageRules_ImageConstraintToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_AnalogSunsetToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_AnalogSunsetToken>() {
|
|
return ::video_widevine::DTCPUsageRules_AnalogSunsetToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_DigitalOnlyToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_DigitalOnlyToken>() {
|
|
return ::video_widevine::DTCPUsageRules_DigitalOnlyToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_AudioEnhancedToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_AudioEnhancedToken>() {
|
|
return ::video_widevine::DTCPUsageRules_AudioEnhancedToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken>() {
|
|
return ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_HighDynamicRangeToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_HighDynamicRangeToken>() {
|
|
return ::video_widevine::DTCPUsageRules_HighDynamicRangeToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken>() {
|
|
return ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_EnhancedImageToken> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_EnhancedImageToken>() {
|
|
return ::video_widevine::DTCPUsageRules_EnhancedImageToken_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_FurtherBoundCopy> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_FurtherBoundCopy>() {
|
|
return ::video_widevine::DTCPUsageRules_FurtherBoundCopy_descriptor();
|
|
}
|
|
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdtcp_5fusage_2eproto
|