1877 lines
82 KiB
C++
Executable File
1877 lines
82 KiB
C++
Executable File
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: protos/public/sdk_stats.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_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/unknown_field_set.h>
|
|
#include "protos/public/hash_algorithm.pb.h"
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsdk_5fstats_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_2fsdk_5fstats_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[6]
|
|
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_2fsdk_5fstats_2eproto;
|
|
namespace video_widevine {
|
|
class DeviceLicenseCounterByMake;
|
|
struct DeviceLicenseCounterByMakeDefaultTypeInternal;
|
|
extern DeviceLicenseCounterByMakeDefaultTypeInternal _DeviceLicenseCounterByMake_default_instance_;
|
|
class DeviceLicenseCounterByModel;
|
|
struct DeviceLicenseCounterByModelDefaultTypeInternal;
|
|
extern DeviceLicenseCounterByModelDefaultTypeInternal _DeviceLicenseCounterByModel_default_instance_;
|
|
class DeviceLicenseCounterByStatus;
|
|
struct DeviceLicenseCounterByStatusDefaultTypeInternal;
|
|
extern DeviceLicenseCounterByStatusDefaultTypeInternal _DeviceLicenseCounterByStatus_default_instance_;
|
|
class DeviceLicenseCounterBySystemId;
|
|
struct DeviceLicenseCounterBySystemIdDefaultTypeInternal;
|
|
extern DeviceLicenseCounterBySystemIdDefaultTypeInternal _DeviceLicenseCounterBySystemId_default_instance_;
|
|
class DeviceLicenseCounterRequest;
|
|
struct DeviceLicenseCounterRequestDefaultTypeInternal;
|
|
extern DeviceLicenseCounterRequestDefaultTypeInternal _DeviceLicenseCounterRequest_default_instance_;
|
|
class SignedDeviceLicenseCounterRequest;
|
|
struct SignedDeviceLicenseCounterRequestDefaultTypeInternal;
|
|
extern SignedDeviceLicenseCounterRequestDefaultTypeInternal _SignedDeviceLicenseCounterRequest_default_instance_;
|
|
} // namespace video_widevine
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::video_widevine::DeviceLicenseCounterByMake* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByMake>(Arena*);
|
|
template<> ::video_widevine::DeviceLicenseCounterByModel* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByModel>(Arena*);
|
|
template<> ::video_widevine::DeviceLicenseCounterByStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByStatus>(Arena*);
|
|
template<> ::video_widevine::DeviceLicenseCounterBySystemId* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterBySystemId>(Arena*);
|
|
template<> ::video_widevine::DeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(Arena*);
|
|
template<> ::video_widevine::SignedDeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceLicenseCounterRequest>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace video_widevine {
|
|
|
|
// ===================================================================
|
|
|
|
class DeviceLicenseCounterByStatus final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByStatus) */ {
|
|
public:
|
|
inline DeviceLicenseCounterByStatus() : DeviceLicenseCounterByStatus(nullptr) {}
|
|
~DeviceLicenseCounterByStatus() override;
|
|
explicit constexpr DeviceLicenseCounterByStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
DeviceLicenseCounterByStatus(const DeviceLicenseCounterByStatus& from);
|
|
DeviceLicenseCounterByStatus(DeviceLicenseCounterByStatus&& from) noexcept
|
|
: DeviceLicenseCounterByStatus() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline DeviceLicenseCounterByStatus& operator=(const DeviceLicenseCounterByStatus& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline DeviceLicenseCounterByStatus& operator=(DeviceLicenseCounterByStatus&& 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 DeviceLicenseCounterByStatus& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const DeviceLicenseCounterByStatus* internal_default_instance() {
|
|
return reinterpret_cast<const DeviceLicenseCounterByStatus*>(
|
|
&_DeviceLicenseCounterByStatus_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(DeviceLicenseCounterByStatus& a, DeviceLicenseCounterByStatus& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(DeviceLicenseCounterByStatus* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(DeviceLicenseCounterByStatus* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline DeviceLicenseCounterByStatus* New() const final {
|
|
return new DeviceLicenseCounterByStatus();
|
|
}
|
|
|
|
DeviceLicenseCounterByStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<DeviceLicenseCounterByStatus>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const DeviceLicenseCounterByStatus& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const DeviceLicenseCounterByStatus& 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(DeviceLicenseCounterByStatus* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.DeviceLicenseCounterByStatus";
|
|
}
|
|
protected:
|
|
explicit DeviceLicenseCounterByStatus(::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 ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCountFieldNumber = 2,
|
|
kLicenseStatusFieldNumber = 1,
|
|
};
|
|
// optional int64 count = 2;
|
|
bool has_count() const;
|
|
private:
|
|
bool _internal_has_count() const;
|
|
public:
|
|
void clear_count();
|
|
::PROTOBUF_NAMESPACE_ID::int64 count() const;
|
|
void set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int64 _internal_count() const;
|
|
void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
public:
|
|
|
|
// optional int32 license_status = 1;
|
|
bool has_license_status() const;
|
|
private:
|
|
bool _internal_has_license_status() const;
|
|
public:
|
|
void clear_license_status();
|
|
::PROTOBUF_NAMESPACE_ID::int32 license_status() const;
|
|
void set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int32 _internal_license_status() const;
|
|
void _internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByStatus)
|
|
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_;
|
|
::PROTOBUF_NAMESPACE_ID::int64 count_;
|
|
::PROTOBUF_NAMESPACE_ID::int32 license_status_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class DeviceLicenseCounterByModel final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByModel) */ {
|
|
public:
|
|
inline DeviceLicenseCounterByModel() : DeviceLicenseCounterByModel(nullptr) {}
|
|
~DeviceLicenseCounterByModel() override;
|
|
explicit constexpr DeviceLicenseCounterByModel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
DeviceLicenseCounterByModel(const DeviceLicenseCounterByModel& from);
|
|
DeviceLicenseCounterByModel(DeviceLicenseCounterByModel&& from) noexcept
|
|
: DeviceLicenseCounterByModel() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline DeviceLicenseCounterByModel& operator=(const DeviceLicenseCounterByModel& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline DeviceLicenseCounterByModel& operator=(DeviceLicenseCounterByModel&& 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 DeviceLicenseCounterByModel& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const DeviceLicenseCounterByModel* internal_default_instance() {
|
|
return reinterpret_cast<const DeviceLicenseCounterByModel*>(
|
|
&_DeviceLicenseCounterByModel_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(DeviceLicenseCounterByModel& a, DeviceLicenseCounterByModel& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(DeviceLicenseCounterByModel* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(DeviceLicenseCounterByModel* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline DeviceLicenseCounterByModel* New() const final {
|
|
return new DeviceLicenseCounterByModel();
|
|
}
|
|
|
|
DeviceLicenseCounterByModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<DeviceLicenseCounterByModel>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const DeviceLicenseCounterByModel& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const DeviceLicenseCounterByModel& 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(DeviceLicenseCounterByModel* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.DeviceLicenseCounterByModel";
|
|
}
|
|
protected:
|
|
explicit DeviceLicenseCounterByModel(::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 ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCounterByStatusFieldNumber = 2,
|
|
kDeviceModelFieldNumber = 1,
|
|
};
|
|
// repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
|
|
int counter_by_status_size() const;
|
|
private:
|
|
int _internal_counter_by_status_size() const;
|
|
public:
|
|
void clear_counter_by_status();
|
|
::video_widevine::DeviceLicenseCounterByStatus* mutable_counter_by_status(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
|
|
mutable_counter_by_status();
|
|
private:
|
|
const ::video_widevine::DeviceLicenseCounterByStatus& _internal_counter_by_status(int index) const;
|
|
::video_widevine::DeviceLicenseCounterByStatus* _internal_add_counter_by_status();
|
|
public:
|
|
const ::video_widevine::DeviceLicenseCounterByStatus& counter_by_status(int index) const;
|
|
::video_widevine::DeviceLicenseCounterByStatus* add_counter_by_status();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
|
|
counter_by_status() const;
|
|
|
|
// optional string device_model = 1;
|
|
bool has_device_model() const;
|
|
private:
|
|
bool _internal_has_device_model() const;
|
|
public:
|
|
void clear_device_model();
|
|
const std::string& device_model() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_device_model(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_device_model();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_device_model();
|
|
void set_allocated_device_model(std::string* device_model);
|
|
private:
|
|
const std::string& _internal_device_model() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model(const std::string& value);
|
|
std::string* _internal_mutable_device_model();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByModel)
|
|
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_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus > counter_by_status_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_model_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class DeviceLicenseCounterByMake final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByMake) */ {
|
|
public:
|
|
inline DeviceLicenseCounterByMake() : DeviceLicenseCounterByMake(nullptr) {}
|
|
~DeviceLicenseCounterByMake() override;
|
|
explicit constexpr DeviceLicenseCounterByMake(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
DeviceLicenseCounterByMake(const DeviceLicenseCounterByMake& from);
|
|
DeviceLicenseCounterByMake(DeviceLicenseCounterByMake&& from) noexcept
|
|
: DeviceLicenseCounterByMake() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline DeviceLicenseCounterByMake& operator=(const DeviceLicenseCounterByMake& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline DeviceLicenseCounterByMake& operator=(DeviceLicenseCounterByMake&& 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 DeviceLicenseCounterByMake& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const DeviceLicenseCounterByMake* internal_default_instance() {
|
|
return reinterpret_cast<const DeviceLicenseCounterByMake*>(
|
|
&_DeviceLicenseCounterByMake_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(DeviceLicenseCounterByMake& a, DeviceLicenseCounterByMake& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(DeviceLicenseCounterByMake* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(DeviceLicenseCounterByMake* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline DeviceLicenseCounterByMake* New() const final {
|
|
return new DeviceLicenseCounterByMake();
|
|
}
|
|
|
|
DeviceLicenseCounterByMake* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<DeviceLicenseCounterByMake>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const DeviceLicenseCounterByMake& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const DeviceLicenseCounterByMake& 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(DeviceLicenseCounterByMake* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.DeviceLicenseCounterByMake";
|
|
}
|
|
protected:
|
|
explicit DeviceLicenseCounterByMake(::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 ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCounterByModelFieldNumber = 2,
|
|
kDeviceMakeFieldNumber = 1,
|
|
};
|
|
// repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
|
|
int counter_by_model_size() const;
|
|
private:
|
|
int _internal_counter_by_model_size() const;
|
|
public:
|
|
void clear_counter_by_model();
|
|
::video_widevine::DeviceLicenseCounterByModel* mutable_counter_by_model(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
|
|
mutable_counter_by_model();
|
|
private:
|
|
const ::video_widevine::DeviceLicenseCounterByModel& _internal_counter_by_model(int index) const;
|
|
::video_widevine::DeviceLicenseCounterByModel* _internal_add_counter_by_model();
|
|
public:
|
|
const ::video_widevine::DeviceLicenseCounterByModel& counter_by_model(int index) const;
|
|
::video_widevine::DeviceLicenseCounterByModel* add_counter_by_model();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
|
|
counter_by_model() const;
|
|
|
|
// optional string device_make = 1;
|
|
bool has_device_make() const;
|
|
private:
|
|
bool _internal_has_device_make() const;
|
|
public:
|
|
void clear_device_make();
|
|
const std::string& device_make() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_device_make(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_device_make();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_device_make();
|
|
void set_allocated_device_make(std::string* device_make);
|
|
private:
|
|
const std::string& _internal_device_make() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_make(const std::string& value);
|
|
std::string* _internal_mutable_device_make();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByMake)
|
|
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_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel > counter_by_model_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_make_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class DeviceLicenseCounterBySystemId final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterBySystemId) */ {
|
|
public:
|
|
inline DeviceLicenseCounterBySystemId() : DeviceLicenseCounterBySystemId(nullptr) {}
|
|
~DeviceLicenseCounterBySystemId() override;
|
|
explicit constexpr DeviceLicenseCounterBySystemId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
DeviceLicenseCounterBySystemId(const DeviceLicenseCounterBySystemId& from);
|
|
DeviceLicenseCounterBySystemId(DeviceLicenseCounterBySystemId&& from) noexcept
|
|
: DeviceLicenseCounterBySystemId() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline DeviceLicenseCounterBySystemId& operator=(const DeviceLicenseCounterBySystemId& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline DeviceLicenseCounterBySystemId& operator=(DeviceLicenseCounterBySystemId&& 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 DeviceLicenseCounterBySystemId& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const DeviceLicenseCounterBySystemId* internal_default_instance() {
|
|
return reinterpret_cast<const DeviceLicenseCounterBySystemId*>(
|
|
&_DeviceLicenseCounterBySystemId_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(DeviceLicenseCounterBySystemId& a, DeviceLicenseCounterBySystemId& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(DeviceLicenseCounterBySystemId* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(DeviceLicenseCounterBySystemId* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline DeviceLicenseCounterBySystemId* New() const final {
|
|
return new DeviceLicenseCounterBySystemId();
|
|
}
|
|
|
|
DeviceLicenseCounterBySystemId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<DeviceLicenseCounterBySystemId>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const DeviceLicenseCounterBySystemId& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const DeviceLicenseCounterBySystemId& 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(DeviceLicenseCounterBySystemId* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.DeviceLicenseCounterBySystemId";
|
|
}
|
|
protected:
|
|
explicit DeviceLicenseCounterBySystemId(::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 ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCounterByMakeFieldNumber = 2,
|
|
kDeviceSystemIdFieldNumber = 1,
|
|
};
|
|
// repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
|
|
int counter_by_make_size() const;
|
|
private:
|
|
int _internal_counter_by_make_size() const;
|
|
public:
|
|
void clear_counter_by_make();
|
|
::video_widevine::DeviceLicenseCounterByMake* mutable_counter_by_make(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
|
|
mutable_counter_by_make();
|
|
private:
|
|
const ::video_widevine::DeviceLicenseCounterByMake& _internal_counter_by_make(int index) const;
|
|
::video_widevine::DeviceLicenseCounterByMake* _internal_add_counter_by_make();
|
|
public:
|
|
const ::video_widevine::DeviceLicenseCounterByMake& counter_by_make(int index) const;
|
|
::video_widevine::DeviceLicenseCounterByMake* add_counter_by_make();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
|
|
counter_by_make() const;
|
|
|
|
// optional int32 device_system_id = 1;
|
|
bool has_device_system_id() const;
|
|
private:
|
|
bool _internal_has_device_system_id() const;
|
|
public:
|
|
void clear_device_system_id();
|
|
::PROTOBUF_NAMESPACE_ID::int32 device_system_id() const;
|
|
void set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int32 _internal_device_system_id() const;
|
|
void _internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterBySystemId)
|
|
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_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake > counter_by_make_;
|
|
::PROTOBUF_NAMESPACE_ID::int32 device_system_id_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class DeviceLicenseCounterRequest final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterRequest) */ {
|
|
public:
|
|
inline DeviceLicenseCounterRequest() : DeviceLicenseCounterRequest(nullptr) {}
|
|
~DeviceLicenseCounterRequest() override;
|
|
explicit constexpr DeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
DeviceLicenseCounterRequest(const DeviceLicenseCounterRequest& from);
|
|
DeviceLicenseCounterRequest(DeviceLicenseCounterRequest&& from) noexcept
|
|
: DeviceLicenseCounterRequest() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline DeviceLicenseCounterRequest& operator=(const DeviceLicenseCounterRequest& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline DeviceLicenseCounterRequest& operator=(DeviceLicenseCounterRequest&& 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 DeviceLicenseCounterRequest& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const DeviceLicenseCounterRequest* internal_default_instance() {
|
|
return reinterpret_cast<const DeviceLicenseCounterRequest*>(
|
|
&_DeviceLicenseCounterRequest_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(DeviceLicenseCounterRequest& a, DeviceLicenseCounterRequest& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(DeviceLicenseCounterRequest* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(DeviceLicenseCounterRequest* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline DeviceLicenseCounterRequest* New() const final {
|
|
return new DeviceLicenseCounterRequest();
|
|
}
|
|
|
|
DeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<DeviceLicenseCounterRequest>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const DeviceLicenseCounterRequest& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const DeviceLicenseCounterRequest& 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(DeviceLicenseCounterRequest* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.DeviceLicenseCounterRequest";
|
|
}
|
|
protected:
|
|
explicit DeviceLicenseCounterRequest(::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 ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCounterBySystemidFieldNumber = 4,
|
|
kProviderFieldNumber = 1,
|
|
kCounterUtcStartTimeUsecFieldNumber = 2,
|
|
kCounterUtcEndTimeUsecFieldNumber = 3,
|
|
};
|
|
// repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
|
|
int counter_by_systemid_size() const;
|
|
private:
|
|
int _internal_counter_by_systemid_size() const;
|
|
public:
|
|
void clear_counter_by_systemid();
|
|
::video_widevine::DeviceLicenseCounterBySystemId* mutable_counter_by_systemid(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
|
|
mutable_counter_by_systemid();
|
|
private:
|
|
const ::video_widevine::DeviceLicenseCounterBySystemId& _internal_counter_by_systemid(int index) const;
|
|
::video_widevine::DeviceLicenseCounterBySystemId* _internal_add_counter_by_systemid();
|
|
public:
|
|
const ::video_widevine::DeviceLicenseCounterBySystemId& counter_by_systemid(int index) const;
|
|
::video_widevine::DeviceLicenseCounterBySystemId* add_counter_by_systemid();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
|
|
counter_by_systemid() const;
|
|
|
|
// optional string provider = 1;
|
|
bool has_provider() const;
|
|
private:
|
|
bool _internal_has_provider() const;
|
|
public:
|
|
void clear_provider();
|
|
const std::string& provider() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_provider(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_provider();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_provider();
|
|
void set_allocated_provider(std::string* provider);
|
|
private:
|
|
const std::string& _internal_provider() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
|
|
std::string* _internal_mutable_provider();
|
|
public:
|
|
|
|
// optional int64 counter_utc_start_time_usec = 2;
|
|
bool has_counter_utc_start_time_usec() const;
|
|
private:
|
|
bool _internal_has_counter_utc_start_time_usec() const;
|
|
public:
|
|
void clear_counter_utc_start_time_usec();
|
|
::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec() const;
|
|
void set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_start_time_usec() const;
|
|
void _internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
public:
|
|
|
|
// optional int64 counter_utc_end_time_usec = 3;
|
|
bool has_counter_utc_end_time_usec() const;
|
|
private:
|
|
bool _internal_has_counter_utc_end_time_usec() const;
|
|
public:
|
|
void clear_counter_utc_end_time_usec();
|
|
::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec() const;
|
|
void set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_end_time_usec() const;
|
|
void _internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterRequest)
|
|
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_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId > counter_by_systemid_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
|
|
::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec_;
|
|
::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class SignedDeviceLicenseCounterRequest final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceLicenseCounterRequest) */ {
|
|
public:
|
|
inline SignedDeviceLicenseCounterRequest() : SignedDeviceLicenseCounterRequest(nullptr) {}
|
|
~SignedDeviceLicenseCounterRequest() override;
|
|
explicit constexpr SignedDeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
SignedDeviceLicenseCounterRequest(const SignedDeviceLicenseCounterRequest& from);
|
|
SignedDeviceLicenseCounterRequest(SignedDeviceLicenseCounterRequest&& from) noexcept
|
|
: SignedDeviceLicenseCounterRequest() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline SignedDeviceLicenseCounterRequest& operator=(const SignedDeviceLicenseCounterRequest& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline SignedDeviceLicenseCounterRequest& operator=(SignedDeviceLicenseCounterRequest&& 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 SignedDeviceLicenseCounterRequest& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const SignedDeviceLicenseCounterRequest* internal_default_instance() {
|
|
return reinterpret_cast<const SignedDeviceLicenseCounterRequest*>(
|
|
&_SignedDeviceLicenseCounterRequest_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
5;
|
|
|
|
friend void swap(SignedDeviceLicenseCounterRequest& a, SignedDeviceLicenseCounterRequest& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(SignedDeviceLicenseCounterRequest* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(SignedDeviceLicenseCounterRequest* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline SignedDeviceLicenseCounterRequest* New() const final {
|
|
return new SignedDeviceLicenseCounterRequest();
|
|
}
|
|
|
|
SignedDeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<SignedDeviceLicenseCounterRequest>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const SignedDeviceLicenseCounterRequest& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const SignedDeviceLicenseCounterRequest& 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(SignedDeviceLicenseCounterRequest* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.SignedDeviceLicenseCounterRequest";
|
|
}
|
|
protected:
|
|
explicit SignedDeviceLicenseCounterRequest(::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 ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kSignatureFieldNumber = 2,
|
|
kDeviceLicenseCounterRequestFieldNumber = 1,
|
|
kHashAlgorithmFieldNumber = 3,
|
|
};
|
|
// optional bytes signature = 2;
|
|
bool has_signature() const;
|
|
private:
|
|
bool _internal_has_signature() const;
|
|
public:
|
|
void clear_signature();
|
|
const std::string& signature() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_signature(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_signature();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_signature();
|
|
void set_allocated_signature(std::string* signature);
|
|
private:
|
|
const std::string& _internal_signature() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
|
|
std::string* _internal_mutable_signature();
|
|
public:
|
|
|
|
// optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
|
|
bool has_device_license_counter_request() const;
|
|
private:
|
|
bool _internal_has_device_license_counter_request() const;
|
|
public:
|
|
void clear_device_license_counter_request();
|
|
const ::video_widevine::DeviceLicenseCounterRequest& device_license_counter_request() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceLicenseCounterRequest* release_device_license_counter_request();
|
|
::video_widevine::DeviceLicenseCounterRequest* mutable_device_license_counter_request();
|
|
void set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
|
|
private:
|
|
const ::video_widevine::DeviceLicenseCounterRequest& _internal_device_license_counter_request() const;
|
|
::video_widevine::DeviceLicenseCounterRequest* _internal_mutable_device_license_counter_request();
|
|
public:
|
|
void unsafe_arena_set_allocated_device_license_counter_request(
|
|
::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
|
|
::video_widevine::DeviceLicenseCounterRequest* unsafe_arena_release_device_license_counter_request();
|
|
|
|
// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
|
|
bool has_hash_algorithm() const;
|
|
private:
|
|
bool _internal_has_hash_algorithm() const;
|
|
public:
|
|
void clear_hash_algorithm();
|
|
::video_widevine::HashAlgorithmProto hash_algorithm() const;
|
|
void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
|
|
private:
|
|
::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
|
|
void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceLicenseCounterRequest)
|
|
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_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
|
|
::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request_;
|
|
int hash_algorithm_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// DeviceLicenseCounterByStatus
|
|
|
|
// optional int32 license_status = 1;
|
|
inline bool DeviceLicenseCounterByStatus::_internal_has_license_status() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterByStatus::has_license_status() const {
|
|
return _internal_has_license_status();
|
|
}
|
|
inline void DeviceLicenseCounterByStatus::clear_license_status() {
|
|
license_status_ = 0;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::_internal_license_status() const {
|
|
return license_status_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::license_status() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.license_status)
|
|
return _internal_license_status();
|
|
}
|
|
inline void DeviceLicenseCounterByStatus::_internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
license_status_ = value;
|
|
}
|
|
inline void DeviceLicenseCounterByStatus::set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
|
|
_internal_set_license_status(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.license_status)
|
|
}
|
|
|
|
// optional int64 count = 2;
|
|
inline bool DeviceLicenseCounterByStatus::_internal_has_count() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterByStatus::has_count() const {
|
|
return _internal_has_count();
|
|
}
|
|
inline void DeviceLicenseCounterByStatus::clear_count() {
|
|
count_ = int64_t{0};
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::_internal_count() const {
|
|
return count_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::count() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.count)
|
|
return _internal_count();
|
|
}
|
|
inline void DeviceLicenseCounterByStatus::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
count_ = value;
|
|
}
|
|
inline void DeviceLicenseCounterByStatus::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_internal_set_count(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.count)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// DeviceLicenseCounterByModel
|
|
|
|
// optional string device_model = 1;
|
|
inline bool DeviceLicenseCounterByModel::_internal_has_device_model() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterByModel::has_device_model() const {
|
|
return _internal_has_device_model();
|
|
}
|
|
inline void DeviceLicenseCounterByModel::clear_device_model() {
|
|
device_model_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& DeviceLicenseCounterByModel::device_model() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.device_model)
|
|
return _internal_device_model();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void DeviceLicenseCounterByModel::set_device_model(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByModel.device_model)
|
|
}
|
|
inline std::string* DeviceLicenseCounterByModel::mutable_device_model() {
|
|
std::string* _s = _internal_mutable_device_model();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.device_model)
|
|
return _s;
|
|
}
|
|
inline const std::string& DeviceLicenseCounterByModel::_internal_device_model() const {
|
|
return device_model_.Get();
|
|
}
|
|
inline void DeviceLicenseCounterByModel::_internal_set_device_model(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* DeviceLicenseCounterByModel::_internal_mutable_device_model() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return device_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* DeviceLicenseCounterByModel::release_device_model() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByModel.device_model)
|
|
if (!_internal_has_device_model()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return device_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void DeviceLicenseCounterByModel::set_allocated_device_model(std::string* device_model) {
|
|
if (device_model != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
device_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_model,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByModel.device_model)
|
|
}
|
|
|
|
// repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
|
|
inline int DeviceLicenseCounterByModel::_internal_counter_by_status_size() const {
|
|
return counter_by_status_.size();
|
|
}
|
|
inline int DeviceLicenseCounterByModel::counter_by_status_size() const {
|
|
return _internal_counter_by_status_size();
|
|
}
|
|
inline void DeviceLicenseCounterByModel::clear_counter_by_status() {
|
|
counter_by_status_.Clear();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::mutable_counter_by_status(int index) {
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
|
|
return counter_by_status_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
|
|
DeviceLicenseCounterByModel::mutable_counter_by_status() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
|
|
return &counter_by_status_;
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::_internal_counter_by_status(int index) const {
|
|
return counter_by_status_.Get(index);
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::counter_by_status(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
|
|
return _internal_counter_by_status(index);
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::_internal_add_counter_by_status() {
|
|
return counter_by_status_.Add();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::add_counter_by_status() {
|
|
::video_widevine::DeviceLicenseCounterByStatus* _add = _internal_add_counter_by_status();
|
|
// @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
|
|
DeviceLicenseCounterByModel::counter_by_status() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
|
|
return counter_by_status_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// DeviceLicenseCounterByMake
|
|
|
|
// optional string device_make = 1;
|
|
inline bool DeviceLicenseCounterByMake::_internal_has_device_make() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterByMake::has_device_make() const {
|
|
return _internal_has_device_make();
|
|
}
|
|
inline void DeviceLicenseCounterByMake::clear_device_make() {
|
|
device_make_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& DeviceLicenseCounterByMake::device_make() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.device_make)
|
|
return _internal_device_make();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void DeviceLicenseCounterByMake::set_device_make(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByMake.device_make)
|
|
}
|
|
inline std::string* DeviceLicenseCounterByMake::mutable_device_make() {
|
|
std::string* _s = _internal_mutable_device_make();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.device_make)
|
|
return _s;
|
|
}
|
|
inline const std::string& DeviceLicenseCounterByMake::_internal_device_make() const {
|
|
return device_make_.Get();
|
|
}
|
|
inline void DeviceLicenseCounterByMake::_internal_set_device_make(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* DeviceLicenseCounterByMake::_internal_mutable_device_make() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return device_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* DeviceLicenseCounterByMake::release_device_make() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByMake.device_make)
|
|
if (!_internal_has_device_make()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return device_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void DeviceLicenseCounterByMake::set_allocated_device_make(std::string* device_make) {
|
|
if (device_make != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
device_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_make,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByMake.device_make)
|
|
}
|
|
|
|
// repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
|
|
inline int DeviceLicenseCounterByMake::_internal_counter_by_model_size() const {
|
|
return counter_by_model_.size();
|
|
}
|
|
inline int DeviceLicenseCounterByMake::counter_by_model_size() const {
|
|
return _internal_counter_by_model_size();
|
|
}
|
|
inline void DeviceLicenseCounterByMake::clear_counter_by_model() {
|
|
counter_by_model_.Clear();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::mutable_counter_by_model(int index) {
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
|
|
return counter_by_model_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
|
|
DeviceLicenseCounterByMake::mutable_counter_by_model() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
|
|
return &counter_by_model_;
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::_internal_counter_by_model(int index) const {
|
|
return counter_by_model_.Get(index);
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::counter_by_model(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
|
|
return _internal_counter_by_model(index);
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::_internal_add_counter_by_model() {
|
|
return counter_by_model_.Add();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::add_counter_by_model() {
|
|
::video_widevine::DeviceLicenseCounterByModel* _add = _internal_add_counter_by_model();
|
|
// @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
|
|
DeviceLicenseCounterByMake::counter_by_model() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
|
|
return counter_by_model_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// DeviceLicenseCounterBySystemId
|
|
|
|
// optional int32 device_system_id = 1;
|
|
inline bool DeviceLicenseCounterBySystemId::_internal_has_device_system_id() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterBySystemId::has_device_system_id() const {
|
|
return _internal_has_device_system_id();
|
|
}
|
|
inline void DeviceLicenseCounterBySystemId::clear_device_system_id() {
|
|
device_system_id_ = 0;
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::_internal_device_system_id() const {
|
|
return device_system_id_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::device_system_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
|
|
return _internal_device_system_id();
|
|
}
|
|
inline void DeviceLicenseCounterBySystemId::_internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
device_system_id_ = value;
|
|
}
|
|
inline void DeviceLicenseCounterBySystemId::set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
|
|
_internal_set_device_system_id(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
|
|
}
|
|
|
|
// repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
|
|
inline int DeviceLicenseCounterBySystemId::_internal_counter_by_make_size() const {
|
|
return counter_by_make_.size();
|
|
}
|
|
inline int DeviceLicenseCounterBySystemId::counter_by_make_size() const {
|
|
return _internal_counter_by_make_size();
|
|
}
|
|
inline void DeviceLicenseCounterBySystemId::clear_counter_by_make() {
|
|
counter_by_make_.Clear();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::mutable_counter_by_make(int index) {
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
|
|
return counter_by_make_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
|
|
DeviceLicenseCounterBySystemId::mutable_counter_by_make() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
|
|
return &counter_by_make_;
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::_internal_counter_by_make(int index) const {
|
|
return counter_by_make_.Get(index);
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::counter_by_make(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
|
|
return _internal_counter_by_make(index);
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::_internal_add_counter_by_make() {
|
|
return counter_by_make_.Add();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::add_counter_by_make() {
|
|
::video_widevine::DeviceLicenseCounterByMake* _add = _internal_add_counter_by_make();
|
|
// @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
|
|
DeviceLicenseCounterBySystemId::counter_by_make() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
|
|
return counter_by_make_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// DeviceLicenseCounterRequest
|
|
|
|
// optional string provider = 1;
|
|
inline bool DeviceLicenseCounterRequest::_internal_has_provider() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterRequest::has_provider() const {
|
|
return _internal_has_provider();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::clear_provider() {
|
|
provider_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& DeviceLicenseCounterRequest::provider() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.provider)
|
|
return _internal_provider();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void DeviceLicenseCounterRequest::set_provider(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.provider)
|
|
}
|
|
inline std::string* DeviceLicenseCounterRequest::mutable_provider() {
|
|
std::string* _s = _internal_mutable_provider();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.provider)
|
|
return _s;
|
|
}
|
|
inline const std::string& DeviceLicenseCounterRequest::_internal_provider() const {
|
|
return provider_.Get();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::_internal_set_provider(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* DeviceLicenseCounterRequest::_internal_mutable_provider() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* DeviceLicenseCounterRequest::release_provider() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterRequest.provider)
|
|
if (!_internal_has_provider()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void DeviceLicenseCounterRequest::set_allocated_provider(std::string* provider) {
|
|
if (provider != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterRequest.provider)
|
|
}
|
|
|
|
// optional int64 counter_utc_start_time_usec = 2;
|
|
inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_start_time_usec() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterRequest::has_counter_utc_start_time_usec() const {
|
|
return _internal_has_counter_utc_start_time_usec();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::clear_counter_utc_start_time_usec() {
|
|
counter_utc_start_time_usec_ = int64_t{0};
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_start_time_usec() const {
|
|
return counter_utc_start_time_usec_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_start_time_usec() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
|
|
return _internal_counter_utc_start_time_usec();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
counter_utc_start_time_usec_ = value;
|
|
}
|
|
inline void DeviceLicenseCounterRequest::set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_internal_set_counter_utc_start_time_usec(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
|
|
}
|
|
|
|
// optional int64 counter_utc_end_time_usec = 3;
|
|
inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_end_time_usec() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool DeviceLicenseCounterRequest::has_counter_utc_end_time_usec() const {
|
|
return _internal_has_counter_utc_end_time_usec();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::clear_counter_utc_end_time_usec() {
|
|
counter_utc_end_time_usec_ = int64_t{0};
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_end_time_usec() const {
|
|
return counter_utc_end_time_usec_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_end_time_usec() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
|
|
return _internal_counter_utc_end_time_usec();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
counter_utc_end_time_usec_ = value;
|
|
}
|
|
inline void DeviceLicenseCounterRequest::set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_internal_set_counter_utc_end_time_usec(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
|
|
}
|
|
|
|
// repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
|
|
inline int DeviceLicenseCounterRequest::_internal_counter_by_systemid_size() const {
|
|
return counter_by_systemid_.size();
|
|
}
|
|
inline int DeviceLicenseCounterRequest::counter_by_systemid_size() const {
|
|
return _internal_counter_by_systemid_size();
|
|
}
|
|
inline void DeviceLicenseCounterRequest::clear_counter_by_systemid() {
|
|
counter_by_systemid_.Clear();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::mutable_counter_by_systemid(int index) {
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
|
|
return counter_by_systemid_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
|
|
DeviceLicenseCounterRequest::mutable_counter_by_systemid() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
|
|
return &counter_by_systemid_;
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::_internal_counter_by_systemid(int index) const {
|
|
return counter_by_systemid_.Get(index);
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::counter_by_systemid(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
|
|
return _internal_counter_by_systemid(index);
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::_internal_add_counter_by_systemid() {
|
|
return counter_by_systemid_.Add();
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::add_counter_by_systemid() {
|
|
::video_widevine::DeviceLicenseCounterBySystemId* _add = _internal_add_counter_by_systemid();
|
|
// @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
|
|
DeviceLicenseCounterRequest::counter_by_systemid() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
|
|
return counter_by_systemid_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// SignedDeviceLicenseCounterRequest
|
|
|
|
// optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
|
|
inline bool SignedDeviceLicenseCounterRequest::_internal_has_device_license_counter_request() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
PROTOBUF_ASSUME(!value || device_license_counter_request_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool SignedDeviceLicenseCounterRequest::has_device_license_counter_request() const {
|
|
return _internal_has_device_license_counter_request();
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::clear_device_license_counter_request() {
|
|
if (device_license_counter_request_ != nullptr) device_license_counter_request_->Clear();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::_internal_device_license_counter_request() const {
|
|
const ::video_widevine::DeviceLicenseCounterRequest* p = device_license_counter_request_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceLicenseCounterRequest&>(
|
|
::video_widevine::_DeviceLicenseCounterRequest_default_instance_);
|
|
}
|
|
inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::device_license_counter_request() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
|
|
return _internal_device_license_counter_request();
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::unsafe_arena_set_allocated_device_license_counter_request(
|
|
::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_license_counter_request_);
|
|
}
|
|
device_license_counter_request_ = device_license_counter_request;
|
|
if (device_license_counter_request) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::release_device_license_counter_request() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
|
|
device_license_counter_request_ = nullptr;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
if (GetArenaForAllocation() == nullptr) { delete old; }
|
|
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::unsafe_arena_release_device_license_counter_request() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
|
|
device_license_counter_request_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::_internal_mutable_device_license_counter_request() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
if (device_license_counter_request_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(GetArenaForAllocation());
|
|
device_license_counter_request_ = p;
|
|
}
|
|
return device_license_counter_request_;
|
|
}
|
|
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::mutable_device_license_counter_request() {
|
|
::video_widevine::DeviceLicenseCounterRequest* _msg = _internal_mutable_device_license_counter_request();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
|
|
return _msg;
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete device_license_counter_request_;
|
|
}
|
|
if (device_license_counter_request) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceLicenseCounterRequest>::GetOwningArena(device_license_counter_request);
|
|
if (message_arena != submessage_arena) {
|
|
device_license_counter_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, device_license_counter_request, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
device_license_counter_request_ = device_license_counter_request;
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
|
|
}
|
|
|
|
// optional bytes signature = 2;
|
|
inline bool SignedDeviceLicenseCounterRequest::_internal_has_signature() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool SignedDeviceLicenseCounterRequest::has_signature() const {
|
|
return _internal_has_signature();
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::clear_signature() {
|
|
signature_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& SignedDeviceLicenseCounterRequest::signature() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.signature)
|
|
return _internal_signature();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void SignedDeviceLicenseCounterRequest::set_signature(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.SignedDeviceLicenseCounterRequest.signature)
|
|
}
|
|
inline std::string* SignedDeviceLicenseCounterRequest::mutable_signature() {
|
|
std::string* _s = _internal_mutable_signature();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.signature)
|
|
return _s;
|
|
}
|
|
inline const std::string& SignedDeviceLicenseCounterRequest::_internal_signature() const {
|
|
return signature_.Get();
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::_internal_set_signature(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* SignedDeviceLicenseCounterRequest::_internal_mutable_signature() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* SignedDeviceLicenseCounterRequest::release_signature() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.signature)
|
|
if (!_internal_has_signature()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::set_allocated_signature(std::string* signature) {
|
|
if (signature != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.signature)
|
|
}
|
|
|
|
// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
|
|
inline bool SignedDeviceLicenseCounterRequest::_internal_has_hash_algorithm() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool SignedDeviceLicenseCounterRequest::has_hash_algorithm() const {
|
|
return _internal_has_hash_algorithm();
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::clear_hash_algorithm() {
|
|
hash_algorithm_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline ::video_widevine::HashAlgorithmProto SignedDeviceLicenseCounterRequest::_internal_hash_algorithm() const {
|
|
return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
|
|
}
|
|
inline ::video_widevine::HashAlgorithmProto SignedDeviceLicenseCounterRequest::hash_algorithm() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.hash_algorithm)
|
|
return _internal_hash_algorithm();
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
|
|
assert(::video_widevine::HashAlgorithmProto_IsValid(value));
|
|
_has_bits_[0] |= 0x00000004u;
|
|
hash_algorithm_ = value;
|
|
}
|
|
inline void SignedDeviceLicenseCounterRequest::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
|
|
_internal_set_hash_algorithm(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.SignedDeviceLicenseCounterRequest.hash_algorithm)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace video_widevine
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
|