AtguiguCorp/KeyBoard_QT
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9ba44586b3f71a227e646db7a4b7f75a2ba0a3a1
KeyBoard_QT/KeyBorad/generated/cpp/keyboard.pb.h

3531 lines
120 KiB
C
Raw Normal View History

Add full protobuf schema and generated code
2026-04-11 10:20:28 +08:00
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: keyboard.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_keyboard_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_keyboard_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#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 3013000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/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_keyboard_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_keyboard_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[11]
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_keyboard_2eproto;
namespace keyboard {
namespace cdc {
class Ack;
class AckDefaultTypeInternal;
extern AckDefaultTypeInternal _Ack_default_instance_;
class Bitmap;
class BitmapDefaultTypeInternal;
extern BitmapDefaultTypeInternal _Bitmap_default_instance_;
class CdcFrame;
class CdcFrameDefaultTypeInternal;
extern CdcFrameDefaultTypeInternal _CdcFrame_default_instance_;
class CdcPacketBody;
class CdcPacketBodyDefaultTypeInternal;
extern CdcPacketBodyDefaultTypeInternal _CdcPacketBody_default_instance_;
class Error;
class ErrorDefaultTypeInternal;
extern ErrorDefaultTypeInternal _Error_default_instance_;
class FunctionKeyEvent;
class FunctionKeyEventDefaultTypeInternal;
extern FunctionKeyEventDefaultTypeInternal _FunctionKeyEvent_default_instance_;
class HelloReq;
class HelloReqDefaultTypeInternal;
extern HelloReqDefaultTypeInternal _HelloReq_default_instance_;
class HelloRsp;
class HelloRspDefaultTypeInternal;
extern HelloRspDefaultTypeInternal _HelloRsp_default_instance_;
class LedState;
class LedStateDefaultTypeInternal;
extern LedStateDefaultTypeInternal _LedState_default_instance_;
class ThemeRgb;
class ThemeRgbDefaultTypeInternal;
extern ThemeRgbDefaultTypeInternal _ThemeRgb_default_instance_;
class TimeSync;
class TimeSyncDefaultTypeInternal;
extern TimeSyncDefaultTypeInternal _TimeSync_default_instance_;
} // namespace cdc
} // namespace keyboard
PROTOBUF_NAMESPACE_OPEN
template<> ::keyboard::cdc::Ack* Arena::CreateMaybeMessage<::keyboard::cdc::Ack>(Arena*);
template<> ::keyboard::cdc::Bitmap* Arena::CreateMaybeMessage<::keyboard::cdc::Bitmap>(Arena*);
template<> ::keyboard::cdc::CdcFrame* Arena::CreateMaybeMessage<::keyboard::cdc::CdcFrame>(Arena*);
template<> ::keyboard::cdc::CdcPacketBody* Arena::CreateMaybeMessage<::keyboard::cdc::CdcPacketBody>(Arena*);
template<> ::keyboard::cdc::Error* Arena::CreateMaybeMessage<::keyboard::cdc::Error>(Arena*);
template<> ::keyboard::cdc::FunctionKeyEvent* Arena::CreateMaybeMessage<::keyboard::cdc::FunctionKeyEvent>(Arena*);
template<> ::keyboard::cdc::HelloReq* Arena::CreateMaybeMessage<::keyboard::cdc::HelloReq>(Arena*);
template<> ::keyboard::cdc::HelloRsp* Arena::CreateMaybeMessage<::keyboard::cdc::HelloRsp>(Arena*);
template<> ::keyboard::cdc::LedState* Arena::CreateMaybeMessage<::keyboard::cdc::LedState>(Arena*);
template<> ::keyboard::cdc::ThemeRgb* Arena::CreateMaybeMessage<::keyboard::cdc::ThemeRgb>(Arena*);
template<> ::keyboard::cdc::TimeSync* Arena::CreateMaybeMessage<::keyboard::cdc::TimeSync>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace keyboard {
namespace cdc {
enum CdcPacketType : int {
CDC_PACKET_TYPE_UNKNOWN = 0,
CDC_PACKET_TYPE_HELLO_REQ = 1,
CDC_PACKET_TYPE_HELLO_RSP = 2,
CDC_PACKET_TYPE_BITMAP = 16,
CDC_PACKET_TYPE_FUNCTION_KEY_EVENT = 32,
CDC_PACKET_TYPE_LED_STATE = 33,
CDC_PACKET_TYPE_TIME_SYNC = 48,
CDC_PACKET_TYPE_THEME_RGB = 49,
CDC_PACKET_TYPE_ACK = 126,
CDC_PACKET_TYPE_ERROR = 127,
CdcPacketType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
CdcPacketType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CdcPacketType_IsValid(int value);
constexpr CdcPacketType CdcPacketType_MIN = CDC_PACKET_TYPE_UNKNOWN;
constexpr CdcPacketType CdcPacketType_MAX = CDC_PACKET_TYPE_ERROR;
constexpr int CdcPacketType_ARRAYSIZE = CdcPacketType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CdcPacketType_descriptor();
template<typename T>
inline const std::string& CdcPacketType_Name(T enum_t_value) {
static_assert(::std::is_same<T, CdcPacketType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function CdcPacketType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
CdcPacketType_descriptor(), enum_t_value);
}
inline bool CdcPacketType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CdcPacketType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CdcPacketType>(
CdcPacketType_descriptor(), name, value);
}
enum KeyAction : int {
KEY_ACTION_RELEASE = 0,
KEY_ACTION_PRESS = 1,
KeyAction_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
KeyAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool KeyAction_IsValid(int value);
constexpr KeyAction KeyAction_MIN = KEY_ACTION_RELEASE;
constexpr KeyAction KeyAction_MAX = KEY_ACTION_PRESS;
constexpr int KeyAction_ARRAYSIZE = KeyAction_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeyAction_descriptor();
template<typename T>
inline const std::string& KeyAction_Name(T enum_t_value) {
static_assert(::std::is_same<T, KeyAction>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function KeyAction_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
KeyAction_descriptor(), enum_t_value);
}
inline bool KeyAction_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeyAction* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeyAction>(
KeyAction_descriptor(), name, value);
}
enum ErrorCode : int {
ERROR_CODE_NONE = 0,
ERROR_CODE_UNKNOWN_TYPE = 1,
ERROR_CODE_INVALID_LENGTH = 2,
ERROR_CODE_INVALID_PARAM = 3,
ERROR_CODE_NOT_READY = 4,
ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ErrorCode_IsValid(int value);
constexpr ErrorCode ErrorCode_MIN = ERROR_CODE_NONE;
constexpr ErrorCode ErrorCode_MAX = ERROR_CODE_NOT_READY;
constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
template<typename T>
inline const std::string& ErrorCode_Name(T enum_t_value) {
static_assert(::std::is_same<T, ErrorCode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ErrorCode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ErrorCode_descriptor(), enum_t_value);
}
inline bool ErrorCode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorCode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
ErrorCode_descriptor(), name, value);
}
// ===================================================================
class CdcFrame PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.CdcFrame) */ {
public:
inline CdcFrame() : CdcFrame(nullptr) {}
virtual ~CdcFrame();
CdcFrame(const CdcFrame& from);
CdcFrame(CdcFrame&& from) noexcept
: CdcFrame() {
*this = ::std::move(from);
}
inline CdcFrame& operator=(const CdcFrame& from) {
CopyFrom(from);
return *this;
}
inline CdcFrame& operator=(CdcFrame&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const CdcFrame& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const CdcFrame* internal_default_instance() {
return reinterpret_cast<const CdcFrame*>(
&_CdcFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(CdcFrame& a, CdcFrame& b) {
a.Swap(&b);
}
inline void Swap(CdcFrame* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(CdcFrame* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline CdcFrame* New() const final {
return CreateMaybeMessage<CdcFrame>(nullptr);
}
CdcFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<CdcFrame>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const CdcFrame& from);
void MergeFrom(const CdcFrame& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(CdcFrame* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.CdcFrame";
}
protected:
explicit CdcFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPayloadFieldNumber = 5,
kHead1FieldNumber = 1,
kHead2FieldNumber = 2,
kPayloadLengthFieldNumber = 3,
kTypeFieldNumber = 4,
kChecksumFieldNumber = 6,
};
// bytes payload = 5;
void clear_payload();
const std::string& payload() const;
void set_payload(const std::string& value);
void set_payload(std::string&& value);
void set_payload(const char* value);
void set_payload(const void* value, size_t size);
std::string* mutable_payload();
std::string* release_payload();
void set_allocated_payload(std::string* payload);
private:
const std::string& _internal_payload() const;
void _internal_set_payload(const std::string& value);
std::string* _internal_mutable_payload();
public:
// uint32 head1 = 1;
void clear_head1();
::PROTOBUF_NAMESPACE_ID::uint32 head1() const;
void set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_head1() const;
void _internal_set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 head2 = 2;
void clear_head2();
::PROTOBUF_NAMESPACE_ID::uint32 head2() const;
void set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_head2() const;
void _internal_set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 payload_length = 3;
void clear_payload_length();
::PROTOBUF_NAMESPACE_ID::uint32 payload_length() const;
void set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_payload_length() const;
void _internal_set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// .keyboard.cdc.CdcPacketType type = 4;
void clear_type();
::keyboard::cdc::CdcPacketType type() const;
void set_type(::keyboard::cdc::CdcPacketType value);
private:
::keyboard::cdc::CdcPacketType _internal_type() const;
void _internal_set_type(::keyboard::cdc::CdcPacketType value);
public:
// uint32 checksum = 6;
void clear_checksum();
::PROTOBUF_NAMESPACE_ID::uint32 checksum() const;
void set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_checksum() const;
void _internal_set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.CdcFrame)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
::PROTOBUF_NAMESPACE_ID::uint32 head1_;
::PROTOBUF_NAMESPACE_ID::uint32 head2_;
::PROTOBUF_NAMESPACE_ID::uint32 payload_length_;
int type_;
::PROTOBUF_NAMESPACE_ID::uint32 checksum_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class CdcPacketBody PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.CdcPacketBody) */ {
public:
inline CdcPacketBody() : CdcPacketBody(nullptr) {}
virtual ~CdcPacketBody();
CdcPacketBody(const CdcPacketBody& from);
CdcPacketBody(CdcPacketBody&& from) noexcept
: CdcPacketBody() {
*this = ::std::move(from);
}
inline CdcPacketBody& operator=(const CdcPacketBody& from) {
CopyFrom(from);
return *this;
}
inline CdcPacketBody& operator=(CdcPacketBody&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const CdcPacketBody& default_instance();
enum BodyCase {
kHelloReq = 1,
kHelloRsp = 2,
kBitmap = 3,
kFunctionKeyEvent = 4,
kLedState = 5,
kTimeSync = 6,
kThemeRgb = 7,
kAck = 8,
kError = 9,
BODY_NOT_SET = 0,
};
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const CdcPacketBody* internal_default_instance() {
return reinterpret_cast<const CdcPacketBody*>(
&_CdcPacketBody_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(CdcPacketBody& a, CdcPacketBody& b) {
a.Swap(&b);
}
inline void Swap(CdcPacketBody* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(CdcPacketBody* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline CdcPacketBody* New() const final {
return CreateMaybeMessage<CdcPacketBody>(nullptr);
}
CdcPacketBody* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<CdcPacketBody>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const CdcPacketBody& from);
void MergeFrom(const CdcPacketBody& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(CdcPacketBody* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.CdcPacketBody";
}
protected:
explicit CdcPacketBody(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHelloReqFieldNumber = 1,
kHelloRspFieldNumber = 2,
kBitmapFieldNumber = 3,
kFunctionKeyEventFieldNumber = 4,
kLedStateFieldNumber = 5,
kTimeSyncFieldNumber = 6,
kThemeRgbFieldNumber = 7,
kAckFieldNumber = 8,
kErrorFieldNumber = 9,
};
// .keyboard.cdc.HelloReq hello_req = 1;
bool has_hello_req() const;
private:
bool _internal_has_hello_req() const;
public:
void clear_hello_req();
const ::keyboard::cdc::HelloReq& hello_req() const;
::keyboard::cdc::HelloReq* release_hello_req();
::keyboard::cdc::HelloReq* mutable_hello_req();
void set_allocated_hello_req(::keyboard::cdc::HelloReq* hello_req);
private:
const ::keyboard::cdc::HelloReq& _internal_hello_req() const;
::keyboard::cdc::HelloReq* _internal_mutable_hello_req();
public:
void unsafe_arena_set_allocated_hello_req(
::keyboard::cdc::HelloReq* hello_req);
::keyboard::cdc::HelloReq* unsafe_arena_release_hello_req();
// .keyboard.cdc.HelloRsp hello_rsp = 2;
bool has_hello_rsp() const;
private:
bool _internal_has_hello_rsp() const;
public:
void clear_hello_rsp();
const ::keyboard::cdc::HelloRsp& hello_rsp() const;
::keyboard::cdc::HelloRsp* release_hello_rsp();
::keyboard::cdc::HelloRsp* mutable_hello_rsp();
void set_allocated_hello_rsp(::keyboard::cdc::HelloRsp* hello_rsp);
private:
const ::keyboard::cdc::HelloRsp& _internal_hello_rsp() const;
::keyboard::cdc::HelloRsp* _internal_mutable_hello_rsp();
public:
void unsafe_arena_set_allocated_hello_rsp(
::keyboard::cdc::HelloRsp* hello_rsp);
::keyboard::cdc::HelloRsp* unsafe_arena_release_hello_rsp();
// .keyboard.cdc.Bitmap bitmap = 3;
bool has_bitmap() const;
private:
bool _internal_has_bitmap() const;
public:
void clear_bitmap();
const ::keyboard::cdc::Bitmap& bitmap() const;
::keyboard::cdc::Bitmap* release_bitmap();
::keyboard::cdc::Bitmap* mutable_bitmap();
void set_allocated_bitmap(::keyboard::cdc::Bitmap* bitmap);
private:
const ::keyboard::cdc::Bitmap& _internal_bitmap() const;
::keyboard::cdc::Bitmap* _internal_mutable_bitmap();
public:
void unsafe_arena_set_allocated_bitmap(
::keyboard::cdc::Bitmap* bitmap);
::keyboard::cdc::Bitmap* unsafe_arena_release_bitmap();
// .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
bool has_function_key_event() const;
private:
bool _internal_has_function_key_event() const;
public:
void clear_function_key_event();
const ::keyboard::cdc::FunctionKeyEvent& function_key_event() const;
::keyboard::cdc::FunctionKeyEvent* release_function_key_event();
::keyboard::cdc::FunctionKeyEvent* mutable_function_key_event();
void set_allocated_function_key_event(::keyboard::cdc::FunctionKeyEvent* function_key_event);
private:
const ::keyboard::cdc::FunctionKeyEvent& _internal_function_key_event() const;
::keyboard::cdc::FunctionKeyEvent* _internal_mutable_function_key_event();
public:
void unsafe_arena_set_allocated_function_key_event(
::keyboard::cdc::FunctionKeyEvent* function_key_event);
::keyboard::cdc::FunctionKeyEvent* unsafe_arena_release_function_key_event();
// .keyboard.cdc.LedState led_state = 5;
bool has_led_state() const;
private:
bool _internal_has_led_state() const;
public:
void clear_led_state();
const ::keyboard::cdc::LedState& led_state() const;
::keyboard::cdc::LedState* release_led_state();
::keyboard::cdc::LedState* mutable_led_state();
void set_allocated_led_state(::keyboard::cdc::LedState* led_state);
private:
const ::keyboard::cdc::LedState& _internal_led_state() const;
::keyboard::cdc::LedState* _internal_mutable_led_state();
public:
void unsafe_arena_set_allocated_led_state(
::keyboard::cdc::LedState* led_state);
::keyboard::cdc::LedState* unsafe_arena_release_led_state();
// .keyboard.cdc.TimeSync time_sync = 6;
bool has_time_sync() const;
private:
bool _internal_has_time_sync() const;
public:
void clear_time_sync();
const ::keyboard::cdc::TimeSync& time_sync() const;
::keyboard::cdc::TimeSync* release_time_sync();
::keyboard::cdc::TimeSync* mutable_time_sync();
void set_allocated_time_sync(::keyboard::cdc::TimeSync* time_sync);
private:
const ::keyboard::cdc::TimeSync& _internal_time_sync() const;
::keyboard::cdc::TimeSync* _internal_mutable_time_sync();
public:
void unsafe_arena_set_allocated_time_sync(
::keyboard::cdc::TimeSync* time_sync);
::keyboard::cdc::TimeSync* unsafe_arena_release_time_sync();
// .keyboard.cdc.ThemeRgb theme_rgb = 7;
bool has_theme_rgb() const;
private:
bool _internal_has_theme_rgb() const;
public:
void clear_theme_rgb();
const ::keyboard::cdc::ThemeRgb& theme_rgb() const;
::keyboard::cdc::ThemeRgb* release_theme_rgb();
::keyboard::cdc::ThemeRgb* mutable_theme_rgb();
void set_allocated_theme_rgb(::keyboard::cdc::ThemeRgb* theme_rgb);
private:
const ::keyboard::cdc::ThemeRgb& _internal_theme_rgb() const;
::keyboard::cdc::ThemeRgb* _internal_mutable_theme_rgb();
public:
void unsafe_arena_set_allocated_theme_rgb(
::keyboard::cdc::ThemeRgb* theme_rgb);
::keyboard::cdc::ThemeRgb* unsafe_arena_release_theme_rgb();
// .keyboard.cdc.Ack ack = 8;
bool has_ack() const;
private:
bool _internal_has_ack() const;
public:
void clear_ack();
const ::keyboard::cdc::Ack& ack() const;
::keyboard::cdc::Ack* release_ack();
::keyboard::cdc::Ack* mutable_ack();
void set_allocated_ack(::keyboard::cdc::Ack* ack);
private:
const ::keyboard::cdc::Ack& _internal_ack() const;
::keyboard::cdc::Ack* _internal_mutable_ack();
public:
void unsafe_arena_set_allocated_ack(
::keyboard::cdc::Ack* ack);
::keyboard::cdc::Ack* unsafe_arena_release_ack();
// .keyboard.cdc.Error error = 9;
bool has_error() const;
private:
bool _internal_has_error() const;
public:
void clear_error();
const ::keyboard::cdc::Error& error() const;
::keyboard::cdc::Error* release_error();
::keyboard::cdc::Error* mutable_error();
void set_allocated_error(::keyboard::cdc::Error* error);
private:
const ::keyboard::cdc::Error& _internal_error() const;
::keyboard::cdc::Error* _internal_mutable_error();
public:
void unsafe_arena_set_allocated_error(
::keyboard::cdc::Error* error);
::keyboard::cdc::Error* unsafe_arena_release_error();
void clear_body();
BodyCase body_case() const;
// @@protoc_insertion_point(class_scope:keyboard.cdc.CdcPacketBody)
private:
class _Internal;
void set_has_hello_req();
void set_has_hello_rsp();
void set_has_bitmap();
void set_has_function_key_event();
void set_has_led_state();
void set_has_time_sync();
void set_has_theme_rgb();
void set_has_ack();
void set_has_error();
inline bool has_body() const;
inline void clear_has_body();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
union BodyUnion {
BodyUnion() {}
::keyboard::cdc::HelloReq* hello_req_;
::keyboard::cdc::HelloRsp* hello_rsp_;
::keyboard::cdc::Bitmap* bitmap_;
::keyboard::cdc::FunctionKeyEvent* function_key_event_;
::keyboard::cdc::LedState* led_state_;
::keyboard::cdc::TimeSync* time_sync_;
::keyboard::cdc::ThemeRgb* theme_rgb_;
::keyboard::cdc::Ack* ack_;
::keyboard::cdc::Error* error_;
} body_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class HelloReq PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.HelloReq) */ {
public:
inline HelloReq() : HelloReq(nullptr) {}
virtual ~HelloReq();
HelloReq(const HelloReq& from);
HelloReq(HelloReq&& from) noexcept
: HelloReq() {
*this = ::std::move(from);
}
inline HelloReq& operator=(const HelloReq& from) {
CopyFrom(from);
return *this;
}
inline HelloReq& operator=(HelloReq&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const HelloReq& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const HelloReq* internal_default_instance() {
return reinterpret_cast<const HelloReq*>(
&_HelloReq_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(HelloReq& a, HelloReq& b) {
a.Swap(&b);
}
inline void Swap(HelloReq* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HelloReq* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline HelloReq* New() const final {
return CreateMaybeMessage<HelloReq>(nullptr);
}
HelloReq* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<HelloReq>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const HelloReq& from);
void MergeFrom(const HelloReq& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(HelloReq* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.HelloReq";
}
protected:
explicit HelloReq(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kProtocolVersionFieldNumber = 1,
};
// uint32 protocol_version = 1;
void clear_protocol_version();
::PROTOBUF_NAMESPACE_ID::uint32 protocol_version() const;
void set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_protocol_version() const;
void _internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.HelloReq)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 protocol_version_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class HelloRsp PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.HelloRsp) */ {
public:
inline HelloRsp() : HelloRsp(nullptr) {}
virtual ~HelloRsp();
HelloRsp(const HelloRsp& from);
HelloRsp(HelloRsp&& from) noexcept
: HelloRsp() {
*this = ::std::move(from);
}
inline HelloRsp& operator=(const HelloRsp& from) {
CopyFrom(from);
return *this;
}
inline HelloRsp& operator=(HelloRsp&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const HelloRsp& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const HelloRsp* internal_default_instance() {
return reinterpret_cast<const HelloRsp*>(
&_HelloRsp_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(HelloRsp& a, HelloRsp& b) {
a.Swap(&b);
}
inline void Swap(HelloRsp* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HelloRsp* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline HelloRsp* New() const final {
return CreateMaybeMessage<HelloRsp>(nullptr);
}
HelloRsp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<HelloRsp>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const HelloRsp& from);
void MergeFrom(const HelloRsp& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(HelloRsp* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.HelloRsp";
}
protected:
explicit HelloRsp(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kProtocolVersionFieldNumber = 1,
kVendorIdFieldNumber = 2,
kProductIdFieldNumber = 3,
kFirmwareMajorFieldNumber = 4,
kFirmwareMinorFieldNumber = 5,
kCapabilityFlagsFieldNumber = 6,
};
// uint32 protocol_version = 1;
void clear_protocol_version();
::PROTOBUF_NAMESPACE_ID::uint32 protocol_version() const;
void set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_protocol_version() const;
void _internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 vendor_id = 2;
void clear_vendor_id();
::PROTOBUF_NAMESPACE_ID::uint32 vendor_id() const;
void set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_vendor_id() const;
void _internal_set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 product_id = 3;
void clear_product_id();
::PROTOBUF_NAMESPACE_ID::uint32 product_id() const;
void set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_product_id() const;
void _internal_set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 firmware_major = 4;
void clear_firmware_major();
::PROTOBUF_NAMESPACE_ID::uint32 firmware_major() const;
void set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_firmware_major() const;
void _internal_set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 firmware_minor = 5;
void clear_firmware_minor();
::PROTOBUF_NAMESPACE_ID::uint32 firmware_minor() const;
void set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_firmware_minor() const;
void _internal_set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 capability_flags = 6;
void clear_capability_flags();
::PROTOBUF_NAMESPACE_ID::uint32 capability_flags() const;
void set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_capability_flags() const;
void _internal_set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.HelloRsp)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 protocol_version_;
::PROTOBUF_NAMESPACE_ID::uint32 vendor_id_;
::PROTOBUF_NAMESPACE_ID::uint32 product_id_;
::PROTOBUF_NAMESPACE_ID::uint32 firmware_major_;
::PROTOBUF_NAMESPACE_ID::uint32 firmware_minor_;
::PROTOBUF_NAMESPACE_ID::uint32 capability_flags_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class Bitmap PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.Bitmap) */ {
public:
inline Bitmap() : Bitmap(nullptr) {}
virtual ~Bitmap();
Bitmap(const Bitmap& from);
Bitmap(Bitmap&& from) noexcept
: Bitmap() {
*this = ::std::move(from);
}
inline Bitmap& operator=(const Bitmap& from) {
CopyFrom(from);
return *this;
}
inline Bitmap& operator=(Bitmap&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const Bitmap& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const Bitmap* internal_default_instance() {
return reinterpret_cast<const Bitmap*>(
&_Bitmap_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(Bitmap& a, Bitmap& b) {
a.Swap(&b);
}
inline void Swap(Bitmap* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Bitmap* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline Bitmap* New() const final {
return CreateMaybeMessage<Bitmap>(nullptr);
}
Bitmap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<Bitmap>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const Bitmap& from);
void MergeFrom(const Bitmap& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Bitmap* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.Bitmap";
}
protected:
explicit Bitmap(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUsageBitmapFieldNumber = 1,
};
// bytes usage_bitmap = 1;
void clear_usage_bitmap();
const std::string& usage_bitmap() const;
void set_usage_bitmap(const std::string& value);
void set_usage_bitmap(std::string&& value);
void set_usage_bitmap(const char* value);
void set_usage_bitmap(const void* value, size_t size);
std::string* mutable_usage_bitmap();
std::string* release_usage_bitmap();
void set_allocated_usage_bitmap(std::string* usage_bitmap);
private:
const std::string& _internal_usage_bitmap() const;
void _internal_set_usage_bitmap(const std::string& value);
std::string* _internal_mutable_usage_bitmap();
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.Bitmap)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr usage_bitmap_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class FunctionKeyEvent PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.FunctionKeyEvent) */ {
public:
inline FunctionKeyEvent() : FunctionKeyEvent(nullptr) {}
virtual ~FunctionKeyEvent();
FunctionKeyEvent(const FunctionKeyEvent& from);
FunctionKeyEvent(FunctionKeyEvent&& from) noexcept
: FunctionKeyEvent() {
*this = ::std::move(from);
}
inline FunctionKeyEvent& operator=(const FunctionKeyEvent& from) {
CopyFrom(from);
return *this;
}
inline FunctionKeyEvent& operator=(FunctionKeyEvent&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const FunctionKeyEvent& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const FunctionKeyEvent* internal_default_instance() {
return reinterpret_cast<const FunctionKeyEvent*>(
&_FunctionKeyEvent_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(FunctionKeyEvent& a, FunctionKeyEvent& b) {
a.Swap(&b);
}
inline void Swap(FunctionKeyEvent* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FunctionKeyEvent* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline FunctionKeyEvent* New() const final {
return CreateMaybeMessage<FunctionKeyEvent>(nullptr);
}
FunctionKeyEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<FunctionKeyEvent>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const FunctionKeyEvent& from);
void MergeFrom(const FunctionKeyEvent& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FunctionKeyEvent* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.FunctionKeyEvent";
}
protected:
explicit FunctionKeyEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUsageFieldNumber = 1,
kActionFieldNumber = 2,
};
// uint32 usage = 1;
void clear_usage();
::PROTOBUF_NAMESPACE_ID::uint32 usage() const;
void set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_usage() const;
void _internal_set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// .keyboard.cdc.KeyAction action = 2;
void clear_action();
::keyboard::cdc::KeyAction action() const;
void set_action(::keyboard::cdc::KeyAction value);
private:
::keyboard::cdc::KeyAction _internal_action() const;
void _internal_set_action(::keyboard::cdc::KeyAction value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.FunctionKeyEvent)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 usage_;
int action_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class LedState PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.LedState) */ {
public:
inline LedState() : LedState(nullptr) {}
virtual ~LedState();
LedState(const LedState& from);
LedState(LedState&& from) noexcept
: LedState() {
*this = ::std::move(from);
}
inline LedState& operator=(const LedState& from) {
CopyFrom(from);
return *this;
}
inline LedState& operator=(LedState&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const LedState& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const LedState* internal_default_instance() {
return reinterpret_cast<const LedState*>(
&_LedState_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(LedState& a, LedState& b) {
a.Swap(&b);
}
inline void Swap(LedState* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LedState* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline LedState* New() const final {
return CreateMaybeMessage<LedState>(nullptr);
}
LedState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<LedState>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const LedState& from);
void MergeFrom(const LedState& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LedState* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.LedState";
}
protected:
explicit LedState(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kLedMaskFieldNumber = 1,
};
// uint32 led_mask = 1;
void clear_led_mask();
::PROTOBUF_NAMESPACE_ID::uint32 led_mask() const;
void set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_led_mask() const;
void _internal_set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.LedState)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 led_mask_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class TimeSync PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.TimeSync) */ {
public:
inline TimeSync() : TimeSync(nullptr) {}
virtual ~TimeSync();
TimeSync(const TimeSync& from);
TimeSync(TimeSync&& from) noexcept
: TimeSync() {
*this = ::std::move(from);
}
inline TimeSync& operator=(const TimeSync& from) {
CopyFrom(from);
return *this;
}
inline TimeSync& operator=(TimeSync&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const TimeSync& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const TimeSync* internal_default_instance() {
return reinterpret_cast<const TimeSync*>(
&_TimeSync_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(TimeSync& a, TimeSync& b) {
a.Swap(&b);
}
inline void Swap(TimeSync* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(TimeSync* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline TimeSync* New() const final {
return CreateMaybeMessage<TimeSync>(nullptr);
}
TimeSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<TimeSync>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const TimeSync& from);
void MergeFrom(const TimeSync& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(TimeSync* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.TimeSync";
}
protected:
explicit TimeSync(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kVersionFieldNumber = 1,
kFlagsFieldNumber = 2,
kUtcMsFieldNumber = 4,
kTimezoneMinFieldNumber = 3,
kAccuracyMsFieldNumber = 5,
};
// uint32 version = 1;
void clear_version();
::PROTOBUF_NAMESPACE_ID::uint32 version() const;
void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_version() const;
void _internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 flags = 2;
void clear_flags();
::PROTOBUF_NAMESPACE_ID::uint32 flags() const;
void set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_flags() const;
void _internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// fixed64 utc_ms = 4;
void clear_utc_ms();
::PROTOBUF_NAMESPACE_ID::uint64 utc_ms() const;
void set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value);
private:
::PROTOBUF_NAMESPACE_ID::uint64 _internal_utc_ms() const;
void _internal_set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value);
public:
// sint32 timezone_min = 3;
void clear_timezone_min();
::PROTOBUF_NAMESPACE_ID::int32 timezone_min() const;
void set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_timezone_min() const;
void _internal_set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// fixed32 accuracy_ms = 5;
void clear_accuracy_ms();
::PROTOBUF_NAMESPACE_ID::uint32 accuracy_ms() const;
void set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_accuracy_ms() const;
void _internal_set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.TimeSync)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 version_;
::PROTOBUF_NAMESPACE_ID::uint32 flags_;
::PROTOBUF_NAMESPACE_ID::uint64 utc_ms_;
::PROTOBUF_NAMESPACE_ID::int32 timezone_min_;
::PROTOBUF_NAMESPACE_ID::uint32 accuracy_ms_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class ThemeRgb PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.ThemeRgb) */ {
public:
inline ThemeRgb() : ThemeRgb(nullptr) {}
virtual ~ThemeRgb();
ThemeRgb(const ThemeRgb& from);
ThemeRgb(ThemeRgb&& from) noexcept
: ThemeRgb() {
*this = ::std::move(from);
}
inline ThemeRgb& operator=(const ThemeRgb& from) {
CopyFrom(from);
return *this;
}
inline ThemeRgb& operator=(ThemeRgb&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const ThemeRgb& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const ThemeRgb* internal_default_instance() {
return reinterpret_cast<const ThemeRgb*>(
&_ThemeRgb_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(ThemeRgb& a, ThemeRgb& b) {
a.Swap(&b);
}
inline void Swap(ThemeRgb* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ThemeRgb* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline ThemeRgb* New() const final {
return CreateMaybeMessage<ThemeRgb>(nullptr);
}
ThemeRgb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<ThemeRgb>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const ThemeRgb& from);
void MergeFrom(const ThemeRgb& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ThemeRgb* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.ThemeRgb";
}
protected:
explicit ThemeRgb(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kRedFieldNumber = 1,
kGreenFieldNumber = 2,
kBlueFieldNumber = 3,
};
// uint32 red = 1;
void clear_red();
::PROTOBUF_NAMESPACE_ID::uint32 red() const;
void set_red(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_red() const;
void _internal_set_red(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 green = 2;
void clear_green();
::PROTOBUF_NAMESPACE_ID::uint32 green() const;
void set_green(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_green() const;
void _internal_set_green(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// uint32 blue = 3;
void clear_blue();
::PROTOBUF_NAMESPACE_ID::uint32 blue() const;
void set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_blue() const;
void _internal_set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.ThemeRgb)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 red_;
::PROTOBUF_NAMESPACE_ID::uint32 green_;
::PROTOBUF_NAMESPACE_ID::uint32 blue_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class Ack PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.Ack) */ {
public:
inline Ack() : Ack(nullptr) {}
virtual ~Ack();
Ack(const Ack& from);
Ack(Ack&& from) noexcept
: Ack() {
*this = ::std::move(from);
}
inline Ack& operator=(const Ack& from) {
CopyFrom(from);
return *this;
}
inline Ack& operator=(Ack&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const Ack& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const Ack* internal_default_instance() {
return reinterpret_cast<const Ack*>(
&_Ack_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
friend void swap(Ack& a, Ack& b) {
a.Swap(&b);
}
inline void Swap(Ack* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Ack* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline Ack* New() const final {
return CreateMaybeMessage<Ack>(nullptr);
}
Ack* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<Ack>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const Ack& from);
void MergeFrom(const Ack& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Ack* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.Ack";
}
protected:
explicit Ack(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAckedTypeFieldNumber = 1,
};
// uint32 acked_type = 1;
void clear_acked_type();
::PROTOBUF_NAMESPACE_ID::uint32 acked_type() const;
void set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_acked_type() const;
void _internal_set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.Ack)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 acked_type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------
class Error PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.Error) */ {
public:
inline Error() : Error(nullptr) {}
virtual ~Error();
Error(const Error& from);
Error(Error&& from) noexcept
: Error() {
*this = ::std::move(from);
}
inline Error& operator=(const Error& from) {
CopyFrom(from);
return *this;
}
inline Error& operator=(Error&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const Error& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const Error* internal_default_instance() {
return reinterpret_cast<const Error*>(
&_Error_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
friend void swap(Error& a, Error& b) {
a.Swap(&b);
}
inline void Swap(Error* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Error* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline Error* New() const final {
return CreateMaybeMessage<Error>(nullptr);
}
Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<Error>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const Error& from);
void MergeFrom(const Error& from);
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:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Error* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "keyboard.cdc.Error";
}
protected:
explicit Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kErrorTypeFieldNumber = 1,
kErrorCodeFieldNumber = 2,
};
// uint32 error_type = 1;
void clear_error_type();
::PROTOBUF_NAMESPACE_ID::uint32 error_type() const;
void set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
private:
::PROTOBUF_NAMESPACE_ID::uint32 _internal_error_type() const;
void _internal_set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
public:
// .keyboard.cdc.ErrorCode error_code = 2;
void clear_error_code();
::keyboard::cdc::ErrorCode error_code() const;
void set_error_code(::keyboard::cdc::ErrorCode value);
private:
::keyboard::cdc::ErrorCode _internal_error_code() const;
void _internal_set_error_code(::keyboard::cdc::ErrorCode value);
public:
// @@protoc_insertion_point(class_scope:keyboard.cdc.Error)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::uint32 error_type_;
int error_code_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_keyboard_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// CdcFrame
// uint32 head1 = 1;
inline void CdcFrame::clear_head1() {
head1_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_head1() const {
return head1_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::head1() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.head1)
return _internal_head1();
}
inline void CdcFrame::_internal_set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value) {
head1_ = value;
}
inline void CdcFrame::set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_head1(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.head1)
}
// uint32 head2 = 2;
inline void CdcFrame::clear_head2() {
head2_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_head2() const {
return head2_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::head2() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.head2)
return _internal_head2();
}
inline void CdcFrame::_internal_set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value) {
head2_ = value;
}
inline void CdcFrame::set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_head2(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.head2)
}
// uint32 payload_length = 3;
inline void CdcFrame::clear_payload_length() {
payload_length_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_payload_length() const {
return payload_length_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::payload_length() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.payload_length)
return _internal_payload_length();
}
inline void CdcFrame::_internal_set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value) {
payload_length_ = value;
}
inline void CdcFrame::set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_payload_length(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.payload_length)
}
// .keyboard.cdc.CdcPacketType type = 4;
inline void CdcFrame::clear_type() {
type_ = 0;
}
inline ::keyboard::cdc::CdcPacketType CdcFrame::_internal_type() const {
return static_cast< ::keyboard::cdc::CdcPacketType >(type_);
}
inline ::keyboard::cdc::CdcPacketType CdcFrame::type() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.type)
return _internal_type();
}
inline void CdcFrame::_internal_set_type(::keyboard::cdc::CdcPacketType value) {
type_ = value;
}
inline void CdcFrame::set_type(::keyboard::cdc::CdcPacketType value) {
_internal_set_type(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.type)
}
// bytes payload = 5;
inline void CdcFrame::clear_payload() {
payload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& CdcFrame::payload() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.payload)
return _internal_payload();
}
inline void CdcFrame::set_payload(const std::string& value) {
_internal_set_payload(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.payload)
}
inline std::string* CdcFrame::mutable_payload() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcFrame.payload)
return _internal_mutable_payload();
}
inline const std::string& CdcFrame::_internal_payload() const {
return payload_.Get();
}
inline void CdcFrame::_internal_set_payload(const std::string& value) {
payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void CdcFrame::set_payload(std::string&& value) {
payload_.Set(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:keyboard.cdc.CdcFrame.payload)
}
inline void CdcFrame::set_payload(const char* value) {
GOOGLE_DCHECK(value != nullptr);
payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
GetArena());
// @@protoc_insertion_point(field_set_char:keyboard.cdc.CdcFrame.payload)
}
inline void CdcFrame::set_payload(const void* value,
size_t size) {
payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:keyboard.cdc.CdcFrame.payload)
}
inline std::string* CdcFrame::_internal_mutable_payload() {
return payload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* CdcFrame::release_payload() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcFrame.payload)
return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CdcFrame::set_allocated_payload(std::string* payload) {
if (payload != nullptr) {
} else {
}
payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
GetArena());
// @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcFrame.payload)
}
// uint32 checksum = 6;
inline void CdcFrame::clear_checksum() {
checksum_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_checksum() const {
return checksum_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::checksum() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.checksum)
return _internal_checksum();
}
inline void CdcFrame::_internal_set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value) {
checksum_ = value;
}
inline void CdcFrame::set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_checksum(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.checksum)
}
// -------------------------------------------------------------------
// CdcPacketBody
// .keyboard.cdc.HelloReq hello_req = 1;
inline bool CdcPacketBody::_internal_has_hello_req() const {
return body_case() == kHelloReq;
}
inline bool CdcPacketBody::has_hello_req() const {
return _internal_has_hello_req();
}
inline void CdcPacketBody::set_has_hello_req() {
_oneof_case_[0] = kHelloReq;
}
inline void CdcPacketBody::clear_hello_req() {
if (_internal_has_hello_req()) {
if (GetArena() == nullptr) {
delete body_.hello_req_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::release_hello_req() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.hello_req)
if (_internal_has_hello_req()) {
clear_has_body();
::keyboard::cdc::HelloReq* temp = body_.hello_req_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.hello_req_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::HelloReq& CdcPacketBody::_internal_hello_req() const {
return _internal_has_hello_req()
? *body_.hello_req_
: *reinterpret_cast< ::keyboard::cdc::HelloReq*>(&::keyboard::cdc::_HelloReq_default_instance_);
}
inline const ::keyboard::cdc::HelloReq& CdcPacketBody::hello_req() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.hello_req)
return _internal_hello_req();
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::unsafe_arena_release_hello_req() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.hello_req)
if (_internal_has_hello_req()) {
clear_has_body();
::keyboard::cdc::HelloReq* temp = body_.hello_req_;
body_.hello_req_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_hello_req(::keyboard::cdc::HelloReq* hello_req) {
clear_body();
if (hello_req) {
set_has_hello_req();
body_.hello_req_ = hello_req;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.hello_req)
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::_internal_mutable_hello_req() {
if (!_internal_has_hello_req()) {
clear_body();
set_has_hello_req();
body_.hello_req_ = CreateMaybeMessage< ::keyboard::cdc::HelloReq >(GetArena());
}
return body_.hello_req_;
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::mutable_hello_req() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.hello_req)
return _internal_mutable_hello_req();
}
// .keyboard.cdc.HelloRsp hello_rsp = 2;
inline bool CdcPacketBody::_internal_has_hello_rsp() const {
return body_case() == kHelloRsp;
}
inline bool CdcPacketBody::has_hello_rsp() const {
return _internal_has_hello_rsp();
}
inline void CdcPacketBody::set_has_hello_rsp() {
_oneof_case_[0] = kHelloRsp;
}
inline void CdcPacketBody::clear_hello_rsp() {
if (_internal_has_hello_rsp()) {
if (GetArena() == nullptr) {
delete body_.hello_rsp_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::release_hello_rsp() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.hello_rsp)
if (_internal_has_hello_rsp()) {
clear_has_body();
::keyboard::cdc::HelloRsp* temp = body_.hello_rsp_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.hello_rsp_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::HelloRsp& CdcPacketBody::_internal_hello_rsp() const {
return _internal_has_hello_rsp()
? *body_.hello_rsp_
: *reinterpret_cast< ::keyboard::cdc::HelloRsp*>(&::keyboard::cdc::_HelloRsp_default_instance_);
}
inline const ::keyboard::cdc::HelloRsp& CdcPacketBody::hello_rsp() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.hello_rsp)
return _internal_hello_rsp();
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::unsafe_arena_release_hello_rsp() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.hello_rsp)
if (_internal_has_hello_rsp()) {
clear_has_body();
::keyboard::cdc::HelloRsp* temp = body_.hello_rsp_;
body_.hello_rsp_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_hello_rsp(::keyboard::cdc::HelloRsp* hello_rsp) {
clear_body();
if (hello_rsp) {
set_has_hello_rsp();
body_.hello_rsp_ = hello_rsp;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.hello_rsp)
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::_internal_mutable_hello_rsp() {
if (!_internal_has_hello_rsp()) {
clear_body();
set_has_hello_rsp();
body_.hello_rsp_ = CreateMaybeMessage< ::keyboard::cdc::HelloRsp >(GetArena());
}
return body_.hello_rsp_;
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::mutable_hello_rsp() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.hello_rsp)
return _internal_mutable_hello_rsp();
}
// .keyboard.cdc.Bitmap bitmap = 3;
inline bool CdcPacketBody::_internal_has_bitmap() const {
return body_case() == kBitmap;
}
inline bool CdcPacketBody::has_bitmap() const {
return _internal_has_bitmap();
}
inline void CdcPacketBody::set_has_bitmap() {
_oneof_case_[0] = kBitmap;
}
inline void CdcPacketBody::clear_bitmap() {
if (_internal_has_bitmap()) {
if (GetArena() == nullptr) {
delete body_.bitmap_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::release_bitmap() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.bitmap)
if (_internal_has_bitmap()) {
clear_has_body();
::keyboard::cdc::Bitmap* temp = body_.bitmap_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.bitmap_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::Bitmap& CdcPacketBody::_internal_bitmap() const {
return _internal_has_bitmap()
? *body_.bitmap_
: *reinterpret_cast< ::keyboard::cdc::Bitmap*>(&::keyboard::cdc::_Bitmap_default_instance_);
}
inline const ::keyboard::cdc::Bitmap& CdcPacketBody::bitmap() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.bitmap)
return _internal_bitmap();
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::unsafe_arena_release_bitmap() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.bitmap)
if (_internal_has_bitmap()) {
clear_has_body();
::keyboard::cdc::Bitmap* temp = body_.bitmap_;
body_.bitmap_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_bitmap(::keyboard::cdc::Bitmap* bitmap) {
clear_body();
if (bitmap) {
set_has_bitmap();
body_.bitmap_ = bitmap;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.bitmap)
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::_internal_mutable_bitmap() {
if (!_internal_has_bitmap()) {
clear_body();
set_has_bitmap();
body_.bitmap_ = CreateMaybeMessage< ::keyboard::cdc::Bitmap >(GetArena());
}
return body_.bitmap_;
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::mutable_bitmap() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.bitmap)
return _internal_mutable_bitmap();
}
// .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
inline bool CdcPacketBody::_internal_has_function_key_event() const {
return body_case() == kFunctionKeyEvent;
}
inline bool CdcPacketBody::has_function_key_event() const {
return _internal_has_function_key_event();
}
inline void CdcPacketBody::set_has_function_key_event() {
_oneof_case_[0] = kFunctionKeyEvent;
}
inline void CdcPacketBody::clear_function_key_event() {
if (_internal_has_function_key_event()) {
if (GetArena() == nullptr) {
delete body_.function_key_event_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::release_function_key_event() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.function_key_event)
if (_internal_has_function_key_event()) {
clear_has_body();
::keyboard::cdc::FunctionKeyEvent* temp = body_.function_key_event_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.function_key_event_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::FunctionKeyEvent& CdcPacketBody::_internal_function_key_event() const {
return _internal_has_function_key_event()
? *body_.function_key_event_
: *reinterpret_cast< ::keyboard::cdc::FunctionKeyEvent*>(&::keyboard::cdc::_FunctionKeyEvent_default_instance_);
}
inline const ::keyboard::cdc::FunctionKeyEvent& CdcPacketBody::function_key_event() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.function_key_event)
return _internal_function_key_event();
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::unsafe_arena_release_function_key_event() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.function_key_event)
if (_internal_has_function_key_event()) {
clear_has_body();
::keyboard::cdc::FunctionKeyEvent* temp = body_.function_key_event_;
body_.function_key_event_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_function_key_event(::keyboard::cdc::FunctionKeyEvent* function_key_event) {
clear_body();
if (function_key_event) {
set_has_function_key_event();
body_.function_key_event_ = function_key_event;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.function_key_event)
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::_internal_mutable_function_key_event() {
if (!_internal_has_function_key_event()) {
clear_body();
set_has_function_key_event();
body_.function_key_event_ = CreateMaybeMessage< ::keyboard::cdc::FunctionKeyEvent >(GetArena());
}
return body_.function_key_event_;
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::mutable_function_key_event() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.function_key_event)
return _internal_mutable_function_key_event();
}
// .keyboard.cdc.LedState led_state = 5;
inline bool CdcPacketBody::_internal_has_led_state() const {
return body_case() == kLedState;
}
inline bool CdcPacketBody::has_led_state() const {
return _internal_has_led_state();
}
inline void CdcPacketBody::set_has_led_state() {
_oneof_case_[0] = kLedState;
}
inline void CdcPacketBody::clear_led_state() {
if (_internal_has_led_state()) {
if (GetArena() == nullptr) {
delete body_.led_state_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::LedState* CdcPacketBody::release_led_state() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.led_state)
if (_internal_has_led_state()) {
clear_has_body();
::keyboard::cdc::LedState* temp = body_.led_state_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.led_state_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::LedState& CdcPacketBody::_internal_led_state() const {
return _internal_has_led_state()
? *body_.led_state_
: *reinterpret_cast< ::keyboard::cdc::LedState*>(&::keyboard::cdc::_LedState_default_instance_);
}
inline const ::keyboard::cdc::LedState& CdcPacketBody::led_state() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.led_state)
return _internal_led_state();
}
inline ::keyboard::cdc::LedState* CdcPacketBody::unsafe_arena_release_led_state() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.led_state)
if (_internal_has_led_state()) {
clear_has_body();
::keyboard::cdc::LedState* temp = body_.led_state_;
body_.led_state_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_led_state(::keyboard::cdc::LedState* led_state) {
clear_body();
if (led_state) {
set_has_led_state();
body_.led_state_ = led_state;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.led_state)
}
inline ::keyboard::cdc::LedState* CdcPacketBody::_internal_mutable_led_state() {
if (!_internal_has_led_state()) {
clear_body();
set_has_led_state();
body_.led_state_ = CreateMaybeMessage< ::keyboard::cdc::LedState >(GetArena());
}
return body_.led_state_;
}
inline ::keyboard::cdc::LedState* CdcPacketBody::mutable_led_state() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.led_state)
return _internal_mutable_led_state();
}
// .keyboard.cdc.TimeSync time_sync = 6;
inline bool CdcPacketBody::_internal_has_time_sync() const {
return body_case() == kTimeSync;
}
inline bool CdcPacketBody::has_time_sync() const {
return _internal_has_time_sync();
}
inline void CdcPacketBody::set_has_time_sync() {
_oneof_case_[0] = kTimeSync;
}
inline void CdcPacketBody::clear_time_sync() {
if (_internal_has_time_sync()) {
if (GetArena() == nullptr) {
delete body_.time_sync_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::release_time_sync() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.time_sync)
if (_internal_has_time_sync()) {
clear_has_body();
::keyboard::cdc::TimeSync* temp = body_.time_sync_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.time_sync_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::TimeSync& CdcPacketBody::_internal_time_sync() const {
return _internal_has_time_sync()
? *body_.time_sync_
: *reinterpret_cast< ::keyboard::cdc::TimeSync*>(&::keyboard::cdc::_TimeSync_default_instance_);
}
inline const ::keyboard::cdc::TimeSync& CdcPacketBody::time_sync() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.time_sync)
return _internal_time_sync();
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::unsafe_arena_release_time_sync() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.time_sync)
if (_internal_has_time_sync()) {
clear_has_body();
::keyboard::cdc::TimeSync* temp = body_.time_sync_;
body_.time_sync_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_time_sync(::keyboard::cdc::TimeSync* time_sync) {
clear_body();
if (time_sync) {
set_has_time_sync();
body_.time_sync_ = time_sync;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.time_sync)
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::_internal_mutable_time_sync() {
if (!_internal_has_time_sync()) {
clear_body();
set_has_time_sync();
body_.time_sync_ = CreateMaybeMessage< ::keyboard::cdc::TimeSync >(GetArena());
}
return body_.time_sync_;
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::mutable_time_sync() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.time_sync)
return _internal_mutable_time_sync();
}
// .keyboard.cdc.ThemeRgb theme_rgb = 7;
inline bool CdcPacketBody::_internal_has_theme_rgb() const {
return body_case() == kThemeRgb;
}
inline bool CdcPacketBody::has_theme_rgb() const {
return _internal_has_theme_rgb();
}
inline void CdcPacketBody::set_has_theme_rgb() {
_oneof_case_[0] = kThemeRgb;
}
inline void CdcPacketBody::clear_theme_rgb() {
if (_internal_has_theme_rgb()) {
if (GetArena() == nullptr) {
delete body_.theme_rgb_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::release_theme_rgb() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.theme_rgb)
if (_internal_has_theme_rgb()) {
clear_has_body();
::keyboard::cdc::ThemeRgb* temp = body_.theme_rgb_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.theme_rgb_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::ThemeRgb& CdcPacketBody::_internal_theme_rgb() const {
return _internal_has_theme_rgb()
? *body_.theme_rgb_
: *reinterpret_cast< ::keyboard::cdc::ThemeRgb*>(&::keyboard::cdc::_ThemeRgb_default_instance_);
}
inline const ::keyboard::cdc::ThemeRgb& CdcPacketBody::theme_rgb() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.theme_rgb)
return _internal_theme_rgb();
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::unsafe_arena_release_theme_rgb() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.theme_rgb)
if (_internal_has_theme_rgb()) {
clear_has_body();
::keyboard::cdc::ThemeRgb* temp = body_.theme_rgb_;
body_.theme_rgb_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_theme_rgb(::keyboard::cdc::ThemeRgb* theme_rgb) {
clear_body();
if (theme_rgb) {
set_has_theme_rgb();
body_.theme_rgb_ = theme_rgb;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.theme_rgb)
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::_internal_mutable_theme_rgb() {
if (!_internal_has_theme_rgb()) {
clear_body();
set_has_theme_rgb();
body_.theme_rgb_ = CreateMaybeMessage< ::keyboard::cdc::ThemeRgb >(GetArena());
}
return body_.theme_rgb_;
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::mutable_theme_rgb() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.theme_rgb)
return _internal_mutable_theme_rgb();
}
// .keyboard.cdc.Ack ack = 8;
inline bool CdcPacketBody::_internal_has_ack() const {
return body_case() == kAck;
}
inline bool CdcPacketBody::has_ack() const {
return _internal_has_ack();
}
inline void CdcPacketBody::set_has_ack() {
_oneof_case_[0] = kAck;
}
inline void CdcPacketBody::clear_ack() {
if (_internal_has_ack()) {
if (GetArena() == nullptr) {
delete body_.ack_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::Ack* CdcPacketBody::release_ack() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.ack)
if (_internal_has_ack()) {
clear_has_body();
::keyboard::cdc::Ack* temp = body_.ack_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.ack_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::Ack& CdcPacketBody::_internal_ack() const {
return _internal_has_ack()
? *body_.ack_
: *reinterpret_cast< ::keyboard::cdc::Ack*>(&::keyboard::cdc::_Ack_default_instance_);
}
inline const ::keyboard::cdc::Ack& CdcPacketBody::ack() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.ack)
return _internal_ack();
}
inline ::keyboard::cdc::Ack* CdcPacketBody::unsafe_arena_release_ack() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.ack)
if (_internal_has_ack()) {
clear_has_body();
::keyboard::cdc::Ack* temp = body_.ack_;
body_.ack_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_ack(::keyboard::cdc::Ack* ack) {
clear_body();
if (ack) {
set_has_ack();
body_.ack_ = ack;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.ack)
}
inline ::keyboard::cdc::Ack* CdcPacketBody::_internal_mutable_ack() {
if (!_internal_has_ack()) {
clear_body();
set_has_ack();
body_.ack_ = CreateMaybeMessage< ::keyboard::cdc::Ack >(GetArena());
}
return body_.ack_;
}
inline ::keyboard::cdc::Ack* CdcPacketBody::mutable_ack() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.ack)
return _internal_mutable_ack();
}
// .keyboard.cdc.Error error = 9;
inline bool CdcPacketBody::_internal_has_error() const {
return body_case() == kError;
}
inline bool CdcPacketBody::has_error() const {
return _internal_has_error();
}
inline void CdcPacketBody::set_has_error() {
_oneof_case_[0] = kError;
}
inline void CdcPacketBody::clear_error() {
if (_internal_has_error()) {
if (GetArena() == nullptr) {
delete body_.error_;
}
clear_has_body();
}
}
inline ::keyboard::cdc::Error* CdcPacketBody::release_error() {
// @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.error)
if (_internal_has_error()) {
clear_has_body();
::keyboard::cdc::Error* temp = body_.error_;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
body_.error_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::keyboard::cdc::Error& CdcPacketBody::_internal_error() const {
return _internal_has_error()
? *body_.error_
: *reinterpret_cast< ::keyboard::cdc::Error*>(&::keyboard::cdc::_Error_default_instance_);
}
inline const ::keyboard::cdc::Error& CdcPacketBody::error() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.error)
return _internal_error();
}
inline ::keyboard::cdc::Error* CdcPacketBody::unsafe_arena_release_error() {
// @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.error)
if (_internal_has_error()) {
clear_has_body();
::keyboard::cdc::Error* temp = body_.error_;
body_.error_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void CdcPacketBody::unsafe_arena_set_allocated_error(::keyboard::cdc::Error* error) {
clear_body();
if (error) {
set_has_error();
body_.error_ = error;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.error)
}
inline ::keyboard::cdc::Error* CdcPacketBody::_internal_mutable_error() {
if (!_internal_has_error()) {
clear_body();
set_has_error();
body_.error_ = CreateMaybeMessage< ::keyboard::cdc::Error >(GetArena());
}
return body_.error_;
}
inline ::keyboard::cdc::Error* CdcPacketBody::mutable_error() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.error)
return _internal_mutable_error();
}
inline bool CdcPacketBody::has_body() const {
return body_case() != BODY_NOT_SET;
}
inline void CdcPacketBody::clear_has_body() {
_oneof_case_[0] = BODY_NOT_SET;
}
inline CdcPacketBody::BodyCase CdcPacketBody::body_case() const {
return CdcPacketBody::BodyCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
// HelloReq
// uint32 protocol_version = 1;
inline void HelloReq::clear_protocol_version() {
protocol_version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloReq::_internal_protocol_version() const {
return protocol_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloReq::protocol_version() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloReq.protocol_version)
return _internal_protocol_version();
}
inline void HelloReq::_internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
protocol_version_ = value;
}
inline void HelloReq::set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_protocol_version(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloReq.protocol_version)
}
// -------------------------------------------------------------------
// HelloRsp
// uint32 protocol_version = 1;
inline void HelloRsp::clear_protocol_version() {
protocol_version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_protocol_version() const {
return protocol_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::protocol_version() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.protocol_version)
return _internal_protocol_version();
}
inline void HelloRsp::_internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
protocol_version_ = value;
}
inline void HelloRsp::set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_protocol_version(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.protocol_version)
}
// uint32 vendor_id = 2;
inline void HelloRsp::clear_vendor_id() {
vendor_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_vendor_id() const {
return vendor_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::vendor_id() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.vendor_id)
return _internal_vendor_id();
}
inline void HelloRsp::_internal_set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
vendor_id_ = value;
}
inline void HelloRsp::set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_vendor_id(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.vendor_id)
}
// uint32 product_id = 3;
inline void HelloRsp::clear_product_id() {
product_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_product_id() const {
return product_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::product_id() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.product_id)
return _internal_product_id();
}
inline void HelloRsp::_internal_set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
product_id_ = value;
}
inline void HelloRsp::set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_product_id(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.product_id)
}
// uint32 firmware_major = 4;
inline void HelloRsp::clear_firmware_major() {
firmware_major_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_firmware_major() const {
return firmware_major_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::firmware_major() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.firmware_major)
return _internal_firmware_major();
}
inline void HelloRsp::_internal_set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value) {
firmware_major_ = value;
}
inline void HelloRsp::set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_firmware_major(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.firmware_major)
}
// uint32 firmware_minor = 5;
inline void HelloRsp::clear_firmware_minor() {
firmware_minor_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_firmware_minor() const {
return firmware_minor_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::firmware_minor() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.firmware_minor)
return _internal_firmware_minor();
}
inline void HelloRsp::_internal_set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value) {
firmware_minor_ = value;
}
inline void HelloRsp::set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_firmware_minor(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.firmware_minor)
}
// uint32 capability_flags = 6;
inline void HelloRsp::clear_capability_flags() {
capability_flags_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_capability_flags() const {
return capability_flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::capability_flags() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.capability_flags)
return _internal_capability_flags();
}
inline void HelloRsp::_internal_set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
capability_flags_ = value;
}
inline void HelloRsp::set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_capability_flags(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.capability_flags)
}
// -------------------------------------------------------------------
// Bitmap
// bytes usage_bitmap = 1;
inline void Bitmap::clear_usage_bitmap() {
usage_bitmap_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& Bitmap::usage_bitmap() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.Bitmap.usage_bitmap)
return _internal_usage_bitmap();
}
inline void Bitmap::set_usage_bitmap(const std::string& value) {
_internal_set_usage_bitmap(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.Bitmap.usage_bitmap)
}
inline std::string* Bitmap::mutable_usage_bitmap() {
// @@protoc_insertion_point(field_mutable:keyboard.cdc.Bitmap.usage_bitmap)
return _internal_mutable_usage_bitmap();
}
inline const std::string& Bitmap::_internal_usage_bitmap() const {
return usage_bitmap_.Get();
}
inline void Bitmap::_internal_set_usage_bitmap(const std::string& value) {
usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Bitmap::set_usage_bitmap(std::string&& value) {
usage_bitmap_.Set(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:keyboard.cdc.Bitmap.usage_bitmap)
}
inline void Bitmap::set_usage_bitmap(const char* value) {
GOOGLE_DCHECK(value != nullptr);
usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
GetArena());
// @@protoc_insertion_point(field_set_char:keyboard.cdc.Bitmap.usage_bitmap)
}
inline void Bitmap::set_usage_bitmap(const void* value,
size_t size) {
usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:keyboard.cdc.Bitmap.usage_bitmap)
}
inline std::string* Bitmap::_internal_mutable_usage_bitmap() {
return usage_bitmap_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Bitmap::release_usage_bitmap() {
// @@protoc_insertion_point(field_release:keyboard.cdc.Bitmap.usage_bitmap)
return usage_bitmap_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Bitmap::set_allocated_usage_bitmap(std::string* usage_bitmap) {
if (usage_bitmap != nullptr) {
} else {
}
usage_bitmap_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), usage_bitmap,
GetArena());
// @@protoc_insertion_point(field_set_allocated:keyboard.cdc.Bitmap.usage_bitmap)
}
// -------------------------------------------------------------------
// FunctionKeyEvent
// uint32 usage = 1;
inline void FunctionKeyEvent::clear_usage() {
usage_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FunctionKeyEvent::_internal_usage() const {
return usage_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FunctionKeyEvent::usage() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.FunctionKeyEvent.usage)
return _internal_usage();
}
inline void FunctionKeyEvent::_internal_set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value) {
usage_ = value;
}
inline void FunctionKeyEvent::set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_usage(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.FunctionKeyEvent.usage)
}
// .keyboard.cdc.KeyAction action = 2;
inline void FunctionKeyEvent::clear_action() {
action_ = 0;
}
inline ::keyboard::cdc::KeyAction FunctionKeyEvent::_internal_action() const {
return static_cast< ::keyboard::cdc::KeyAction >(action_);
}
inline ::keyboard::cdc::KeyAction FunctionKeyEvent::action() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.FunctionKeyEvent.action)
return _internal_action();
}
inline void FunctionKeyEvent::_internal_set_action(::keyboard::cdc::KeyAction value) {
action_ = value;
}
inline void FunctionKeyEvent::set_action(::keyboard::cdc::KeyAction value) {
_internal_set_action(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.FunctionKeyEvent.action)
}
// -------------------------------------------------------------------
// LedState
// uint32 led_mask = 1;
inline void LedState::clear_led_mask() {
led_mask_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LedState::_internal_led_mask() const {
return led_mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LedState::led_mask() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.LedState.led_mask)
return _internal_led_mask();
}
inline void LedState::_internal_set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value) {
led_mask_ = value;
}
inline void LedState::set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_led_mask(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.LedState.led_mask)
}
// -------------------------------------------------------------------
// TimeSync
// uint32 version = 1;
inline void TimeSync::clear_version() {
version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::_internal_version() const {
return version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::version() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.version)
return _internal_version();
}
inline void TimeSync::_internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
version_ = value;
}
inline void TimeSync::set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_version(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.version)
}
// uint32 flags = 2;
inline void TimeSync::clear_flags() {
flags_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::_internal_flags() const {
return flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::flags() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.flags)
return _internal_flags();
}
inline void TimeSync::_internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
flags_ = value;
}
inline void TimeSync::set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_flags(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.flags)
}
// sint32 timezone_min = 3;
inline void TimeSync::clear_timezone_min() {
timezone_min_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TimeSync::_internal_timezone_min() const {
return timezone_min_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TimeSync::timezone_min() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.timezone_min)
return _internal_timezone_min();
}
inline void TimeSync::_internal_set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
timezone_min_ = value;
}
inline void TimeSync::set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_timezone_min(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.timezone_min)
}
// fixed64 utc_ms = 4;
inline void TimeSync::clear_utc_ms() {
utc_ms_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TimeSync::_internal_utc_ms() const {
return utc_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TimeSync::utc_ms() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.utc_ms)
return _internal_utc_ms();
}
inline void TimeSync::_internal_set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value) {
utc_ms_ = value;
}
inline void TimeSync::set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value) {
_internal_set_utc_ms(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.utc_ms)
}
// fixed32 accuracy_ms = 5;
inline void TimeSync::clear_accuracy_ms() {
accuracy_ms_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::_internal_accuracy_ms() const {
return accuracy_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::accuracy_ms() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.accuracy_ms)
return _internal_accuracy_ms();
}
inline void TimeSync::_internal_set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
accuracy_ms_ = value;
}
inline void TimeSync::set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_accuracy_ms(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.accuracy_ms)
}
// -------------------------------------------------------------------
// ThemeRgb
// uint32 red = 1;
inline void ThemeRgb::clear_red() {
red_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::_internal_red() const {
return red_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::red() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.ThemeRgb.red)
return _internal_red();
}
inline void ThemeRgb::_internal_set_red(::PROTOBUF_NAMESPACE_ID::uint32 value) {
red_ = value;
}
inline void ThemeRgb::set_red(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_red(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.ThemeRgb.red)
}
// uint32 green = 2;
inline void ThemeRgb::clear_green() {
green_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::_internal_green() const {
return green_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::green() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.ThemeRgb.green)
return _internal_green();
}
inline void ThemeRgb::_internal_set_green(::PROTOBUF_NAMESPACE_ID::uint32 value) {
green_ = value;
}
inline void ThemeRgb::set_green(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_green(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.ThemeRgb.green)
}
// uint32 blue = 3;
inline void ThemeRgb::clear_blue() {
blue_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::_internal_blue() const {
return blue_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::blue() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.ThemeRgb.blue)
return _internal_blue();
}
inline void ThemeRgb::_internal_set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value) {
blue_ = value;
}
inline void ThemeRgb::set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_blue(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.ThemeRgb.blue)
}
// -------------------------------------------------------------------
// Ack
// uint32 acked_type = 1;
inline void Ack::clear_acked_type() {
acked_type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Ack::_internal_acked_type() const {
return acked_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Ack::acked_type() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.Ack.acked_type)
return _internal_acked_type();
}
inline void Ack::_internal_set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
acked_type_ = value;
}
inline void Ack::set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_acked_type(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.Ack.acked_type)
}
// -------------------------------------------------------------------
// Error
// uint32 error_type = 1;
inline void Error::clear_error_type() {
error_type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Error::_internal_error_type() const {
return error_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Error::error_type() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.Error.error_type)
return _internal_error_type();
}
inline void Error::_internal_set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
error_type_ = value;
}
inline void Error::set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
_internal_set_error_type(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.Error.error_type)
}
// .keyboard.cdc.ErrorCode error_code = 2;
inline void Error::clear_error_code() {
error_code_ = 0;
}
inline ::keyboard::cdc::ErrorCode Error::_internal_error_code() const {
return static_cast< ::keyboard::cdc::ErrorCode >(error_code_);
}
inline ::keyboard::cdc::ErrorCode Error::error_code() const {
// @@protoc_insertion_point(field_get:keyboard.cdc.Error.error_code)
return _internal_error_code();
}
inline void Error::_internal_set_error_code(::keyboard::cdc::ErrorCode value) {
error_code_ = value;
}
inline void Error::set_error_code(::keyboard::cdc::ErrorCode value) {
_internal_set_error_code(value);
// @@protoc_insertion_point(field_set:keyboard.cdc.Error.error_code)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace cdc
} // namespace keyboard
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::keyboard::cdc::CdcPacketType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::keyboard::cdc::CdcPacketType>() {
return ::keyboard::cdc::CdcPacketType_descriptor();
}
template <> struct is_proto_enum< ::keyboard::cdc::KeyAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::keyboard::cdc::KeyAction>() {
return ::keyboard::cdc::KeyAction_descriptor();
}
template <> struct is_proto_enum< ::keyboard::cdc::ErrorCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::keyboard::cdc::ErrorCode>() {
return ::keyboard::cdc::ErrorCode_descriptor();
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_keyboard_2eproto
Reference in New Issue Copy Permalink