mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-14 22:56:12 -04:00
2086 lines
81 KiB
C++
2086 lines
81 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: proto/ukey.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fukey_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fukey_2eproto
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include <google/protobuf/port_def.inc>
|
|
#if PROTOBUF_VERSION < 3019000
|
|
#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 3019004 < PROTOBUF_MIN_PROTOC_VERSION
|
|
#error This file was generated by an older version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please
|
|
#error regenerate this file with a newer version of protoc.
|
|
#endif
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/arena.h>
|
|
#include <google/protobuf/arenastring.h>
|
|
#include <google/protobuf/generated_message_table_driven.h>
|
|
#include <google/protobuf/generated_message_util.h>
|
|
#include <google/protobuf/metadata_lite.h>
|
|
#include <google/protobuf/message_lite.h>
|
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
|
#include <google/protobuf/generated_enum_util.h>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_proto_2fukey_2eproto
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
namespace internal {
|
|
class AnyMetadata;
|
|
} // namespace internal
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// Internal implementation detail -- do not use these members.
|
|
struct TableStruct_proto_2fukey_2eproto {
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
|
|
static const uint32_t offsets[];
|
|
};
|
|
namespace securegcm {
|
|
class Ukey2Alert;
|
|
struct Ukey2AlertDefaultTypeInternal;
|
|
extern Ukey2AlertDefaultTypeInternal _Ukey2Alert_default_instance_;
|
|
class Ukey2ClientFinished;
|
|
struct Ukey2ClientFinishedDefaultTypeInternal;
|
|
extern Ukey2ClientFinishedDefaultTypeInternal _Ukey2ClientFinished_default_instance_;
|
|
class Ukey2ClientInit;
|
|
struct Ukey2ClientInitDefaultTypeInternal;
|
|
extern Ukey2ClientInitDefaultTypeInternal _Ukey2ClientInit_default_instance_;
|
|
class Ukey2ClientInit_CipherCommitment;
|
|
struct Ukey2ClientInit_CipherCommitmentDefaultTypeInternal;
|
|
extern Ukey2ClientInit_CipherCommitmentDefaultTypeInternal _Ukey2ClientInit_CipherCommitment_default_instance_;
|
|
class Ukey2Message;
|
|
struct Ukey2MessageDefaultTypeInternal;
|
|
extern Ukey2MessageDefaultTypeInternal _Ukey2Message_default_instance_;
|
|
class Ukey2ServerInit;
|
|
struct Ukey2ServerInitDefaultTypeInternal;
|
|
extern Ukey2ServerInitDefaultTypeInternal _Ukey2ServerInit_default_instance_;
|
|
} // namespace securegcm
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::securegcm::Ukey2Alert* Arena::CreateMaybeMessage<::securegcm::Ukey2Alert>(Arena*);
|
|
template<> ::securegcm::Ukey2ClientFinished* Arena::CreateMaybeMessage<::securegcm::Ukey2ClientFinished>(Arena*);
|
|
template<> ::securegcm::Ukey2ClientInit* Arena::CreateMaybeMessage<::securegcm::Ukey2ClientInit>(Arena*);
|
|
template<> ::securegcm::Ukey2ClientInit_CipherCommitment* Arena::CreateMaybeMessage<::securegcm::Ukey2ClientInit_CipherCommitment>(Arena*);
|
|
template<> ::securegcm::Ukey2Message* Arena::CreateMaybeMessage<::securegcm::Ukey2Message>(Arena*);
|
|
template<> ::securegcm::Ukey2ServerInit* Arena::CreateMaybeMessage<::securegcm::Ukey2ServerInit>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace securegcm {
|
|
|
|
enum Ukey2Message_Type : int {
|
|
Ukey2Message_Type_UNKNOWN_DO_NOT_USE = 0,
|
|
Ukey2Message_Type_ALERT = 1,
|
|
Ukey2Message_Type_CLIENT_INIT = 2,
|
|
Ukey2Message_Type_SERVER_INIT = 3,
|
|
Ukey2Message_Type_CLIENT_FINISH = 4
|
|
};
|
|
bool Ukey2Message_Type_IsValid(int value);
|
|
constexpr Ukey2Message_Type Ukey2Message_Type_Type_MIN = Ukey2Message_Type_UNKNOWN_DO_NOT_USE;
|
|
constexpr Ukey2Message_Type Ukey2Message_Type_Type_MAX = Ukey2Message_Type_CLIENT_FINISH;
|
|
constexpr int Ukey2Message_Type_Type_ARRAYSIZE = Ukey2Message_Type_Type_MAX + 1;
|
|
|
|
const std::string& Ukey2Message_Type_Name(Ukey2Message_Type value);
|
|
template<typename T>
|
|
inline const std::string& Ukey2Message_Type_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, Ukey2Message_Type>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function Ukey2Message_Type_Name.");
|
|
return Ukey2Message_Type_Name(static_cast<Ukey2Message_Type>(enum_t_value));
|
|
}
|
|
bool Ukey2Message_Type_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ukey2Message_Type* value);
|
|
enum Ukey2Alert_AlertType : int {
|
|
Ukey2Alert_AlertType_BAD_MESSAGE = 1,
|
|
Ukey2Alert_AlertType_BAD_MESSAGE_TYPE = 2,
|
|
Ukey2Alert_AlertType_INCORRECT_MESSAGE = 3,
|
|
Ukey2Alert_AlertType_BAD_MESSAGE_DATA = 4,
|
|
Ukey2Alert_AlertType_BAD_VERSION = 100,
|
|
Ukey2Alert_AlertType_BAD_RANDOM = 101,
|
|
Ukey2Alert_AlertType_BAD_HANDSHAKE_CIPHER = 102,
|
|
Ukey2Alert_AlertType_BAD_NEXT_PROTOCOL = 103,
|
|
Ukey2Alert_AlertType_BAD_PUBLIC_KEY = 104,
|
|
Ukey2Alert_AlertType_INTERNAL_ERROR = 200
|
|
};
|
|
bool Ukey2Alert_AlertType_IsValid(int value);
|
|
constexpr Ukey2Alert_AlertType Ukey2Alert_AlertType_AlertType_MIN = Ukey2Alert_AlertType_BAD_MESSAGE;
|
|
constexpr Ukey2Alert_AlertType Ukey2Alert_AlertType_AlertType_MAX = Ukey2Alert_AlertType_INTERNAL_ERROR;
|
|
constexpr int Ukey2Alert_AlertType_AlertType_ARRAYSIZE = Ukey2Alert_AlertType_AlertType_MAX + 1;
|
|
|
|
const std::string& Ukey2Alert_AlertType_Name(Ukey2Alert_AlertType value);
|
|
template<typename T>
|
|
inline const std::string& Ukey2Alert_AlertType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, Ukey2Alert_AlertType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function Ukey2Alert_AlertType_Name.");
|
|
return Ukey2Alert_AlertType_Name(static_cast<Ukey2Alert_AlertType>(enum_t_value));
|
|
}
|
|
bool Ukey2Alert_AlertType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ukey2Alert_AlertType* value);
|
|
enum Ukey2HandshakeCipher : int {
|
|
RESERVED = 0,
|
|
P256_SHA512 = 100,
|
|
CURVE25519_SHA512 = 200
|
|
};
|
|
bool Ukey2HandshakeCipher_IsValid(int value);
|
|
constexpr Ukey2HandshakeCipher Ukey2HandshakeCipher_MIN = RESERVED;
|
|
constexpr Ukey2HandshakeCipher Ukey2HandshakeCipher_MAX = CURVE25519_SHA512;
|
|
constexpr int Ukey2HandshakeCipher_ARRAYSIZE = Ukey2HandshakeCipher_MAX + 1;
|
|
|
|
const std::string& Ukey2HandshakeCipher_Name(Ukey2HandshakeCipher value);
|
|
template<typename T>
|
|
inline const std::string& Ukey2HandshakeCipher_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, Ukey2HandshakeCipher>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function Ukey2HandshakeCipher_Name.");
|
|
return Ukey2HandshakeCipher_Name(static_cast<Ukey2HandshakeCipher>(enum_t_value));
|
|
}
|
|
bool Ukey2HandshakeCipher_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ukey2HandshakeCipher* value);
|
|
// ===================================================================
|
|
|
|
class Ukey2Message final :
|
|
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2Message) */ {
|
|
public:
|
|
inline Ukey2Message() : Ukey2Message(nullptr) {}
|
|
~Ukey2Message() override;
|
|
explicit constexpr Ukey2Message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Ukey2Message(const Ukey2Message& from);
|
|
Ukey2Message(Ukey2Message&& from) noexcept
|
|
: Ukey2Message() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Ukey2Message& operator=(const Ukey2Message& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Ukey2Message& operator=(Ukey2Message&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
|
|
}
|
|
inline std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<std::string>();
|
|
}
|
|
|
|
static const Ukey2Message& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Ukey2Message* internal_default_instance() {
|
|
return reinterpret_cast<const Ukey2Message*>(
|
|
&_Ukey2Message_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(Ukey2Message& a, Ukey2Message& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Ukey2Message* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Ukey2Message* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Ukey2Message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Ukey2Message>(arena);
|
|
}
|
|
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
|
|
void CopyFrom(const Ukey2Message& from);
|
|
void MergeFrom(const Ukey2Message& 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;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Ukey2Message* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "securegcm.Ukey2Message";
|
|
}
|
|
protected:
|
|
explicit Ukey2Message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
std::string GetTypeName() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef Ukey2Message_Type Type;
|
|
static constexpr Type UNKNOWN_DO_NOT_USE =
|
|
Ukey2Message_Type_UNKNOWN_DO_NOT_USE;
|
|
static constexpr Type ALERT =
|
|
Ukey2Message_Type_ALERT;
|
|
static constexpr Type CLIENT_INIT =
|
|
Ukey2Message_Type_CLIENT_INIT;
|
|
static constexpr Type SERVER_INIT =
|
|
Ukey2Message_Type_SERVER_INIT;
|
|
static constexpr Type CLIENT_FINISH =
|
|
Ukey2Message_Type_CLIENT_FINISH;
|
|
static inline bool Type_IsValid(int value) {
|
|
return Ukey2Message_Type_IsValid(value);
|
|
}
|
|
static constexpr Type Type_MIN =
|
|
Ukey2Message_Type_Type_MIN;
|
|
static constexpr Type Type_MAX =
|
|
Ukey2Message_Type_Type_MAX;
|
|
static constexpr int Type_ARRAYSIZE =
|
|
Ukey2Message_Type_Type_ARRAYSIZE;
|
|
template<typename T>
|
|
static inline const std::string& Type_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, Type>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function Type_Name.");
|
|
return Ukey2Message_Type_Name(enum_t_value);
|
|
}
|
|
static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
Type* value) {
|
|
return Ukey2Message_Type_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kMessageDataFieldNumber = 2,
|
|
kMessageTypeFieldNumber = 1,
|
|
};
|
|
// optional bytes message_data = 2;
|
|
bool has_message_data() const;
|
|
private:
|
|
bool _internal_has_message_data() const;
|
|
public:
|
|
void clear_message_data();
|
|
const std::string& message_data() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_message_data(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_message_data();
|
|
PROTOBUF_NODISCARD std::string* release_message_data();
|
|
void set_allocated_message_data(std::string* message_data);
|
|
private:
|
|
const std::string& _internal_message_data() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_message_data(const std::string& value);
|
|
std::string* _internal_mutable_message_data();
|
|
public:
|
|
|
|
// optional .securegcm.Ukey2Message.Type message_type = 1;
|
|
bool has_message_type() const;
|
|
private:
|
|
bool _internal_has_message_type() const;
|
|
public:
|
|
void clear_message_type();
|
|
::securegcm::Ukey2Message_Type message_type() const;
|
|
void set_message_type(::securegcm::Ukey2Message_Type value);
|
|
private:
|
|
::securegcm::Ukey2Message_Type _internal_message_type() const;
|
|
void _internal_set_message_type(::securegcm::Ukey2Message_Type value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:securegcm.Ukey2Message)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_data_;
|
|
int message_type_;
|
|
friend struct ::TableStruct_proto_2fukey_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Ukey2Alert final :
|
|
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2Alert) */ {
|
|
public:
|
|
inline Ukey2Alert() : Ukey2Alert(nullptr) {}
|
|
~Ukey2Alert() override;
|
|
explicit constexpr Ukey2Alert(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Ukey2Alert(const Ukey2Alert& from);
|
|
Ukey2Alert(Ukey2Alert&& from) noexcept
|
|
: Ukey2Alert() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Ukey2Alert& operator=(const Ukey2Alert& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Ukey2Alert& operator=(Ukey2Alert&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
|
|
}
|
|
inline std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<std::string>();
|
|
}
|
|
|
|
static const Ukey2Alert& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Ukey2Alert* internal_default_instance() {
|
|
return reinterpret_cast<const Ukey2Alert*>(
|
|
&_Ukey2Alert_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(Ukey2Alert& a, Ukey2Alert& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Ukey2Alert* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Ukey2Alert* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Ukey2Alert* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Ukey2Alert>(arena);
|
|
}
|
|
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
|
|
void CopyFrom(const Ukey2Alert& from);
|
|
void MergeFrom(const Ukey2Alert& 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;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Ukey2Alert* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "securegcm.Ukey2Alert";
|
|
}
|
|
protected:
|
|
explicit Ukey2Alert(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
std::string GetTypeName() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef Ukey2Alert_AlertType AlertType;
|
|
static constexpr AlertType BAD_MESSAGE =
|
|
Ukey2Alert_AlertType_BAD_MESSAGE;
|
|
static constexpr AlertType BAD_MESSAGE_TYPE =
|
|
Ukey2Alert_AlertType_BAD_MESSAGE_TYPE;
|
|
static constexpr AlertType INCORRECT_MESSAGE =
|
|
Ukey2Alert_AlertType_INCORRECT_MESSAGE;
|
|
static constexpr AlertType BAD_MESSAGE_DATA =
|
|
Ukey2Alert_AlertType_BAD_MESSAGE_DATA;
|
|
static constexpr AlertType BAD_VERSION =
|
|
Ukey2Alert_AlertType_BAD_VERSION;
|
|
static constexpr AlertType BAD_RANDOM =
|
|
Ukey2Alert_AlertType_BAD_RANDOM;
|
|
static constexpr AlertType BAD_HANDSHAKE_CIPHER =
|
|
Ukey2Alert_AlertType_BAD_HANDSHAKE_CIPHER;
|
|
static constexpr AlertType BAD_NEXT_PROTOCOL =
|
|
Ukey2Alert_AlertType_BAD_NEXT_PROTOCOL;
|
|
static constexpr AlertType BAD_PUBLIC_KEY =
|
|
Ukey2Alert_AlertType_BAD_PUBLIC_KEY;
|
|
static constexpr AlertType INTERNAL_ERROR =
|
|
Ukey2Alert_AlertType_INTERNAL_ERROR;
|
|
static inline bool AlertType_IsValid(int value) {
|
|
return Ukey2Alert_AlertType_IsValid(value);
|
|
}
|
|
static constexpr AlertType AlertType_MIN =
|
|
Ukey2Alert_AlertType_AlertType_MIN;
|
|
static constexpr AlertType AlertType_MAX =
|
|
Ukey2Alert_AlertType_AlertType_MAX;
|
|
static constexpr int AlertType_ARRAYSIZE =
|
|
Ukey2Alert_AlertType_AlertType_ARRAYSIZE;
|
|
template<typename T>
|
|
static inline const std::string& AlertType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, AlertType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function AlertType_Name.");
|
|
return Ukey2Alert_AlertType_Name(enum_t_value);
|
|
}
|
|
static inline bool AlertType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
AlertType* value) {
|
|
return Ukey2Alert_AlertType_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kErrorMessageFieldNumber = 2,
|
|
kTypeFieldNumber = 1,
|
|
};
|
|
// optional string error_message = 2;
|
|
bool has_error_message() const;
|
|
private:
|
|
bool _internal_has_error_message() const;
|
|
public:
|
|
void clear_error_message();
|
|
const std::string& error_message() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_error_message(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_error_message();
|
|
PROTOBUF_NODISCARD std::string* release_error_message();
|
|
void set_allocated_error_message(std::string* error_message);
|
|
private:
|
|
const std::string& _internal_error_message() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_message(const std::string& value);
|
|
std::string* _internal_mutable_error_message();
|
|
public:
|
|
|
|
// optional .securegcm.Ukey2Alert.AlertType type = 1;
|
|
bool has_type() const;
|
|
private:
|
|
bool _internal_has_type() const;
|
|
public:
|
|
void clear_type();
|
|
::securegcm::Ukey2Alert_AlertType type() const;
|
|
void set_type(::securegcm::Ukey2Alert_AlertType value);
|
|
private:
|
|
::securegcm::Ukey2Alert_AlertType _internal_type() const;
|
|
void _internal_set_type(::securegcm::Ukey2Alert_AlertType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:securegcm.Ukey2Alert)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
|
|
int type_;
|
|
friend struct ::TableStruct_proto_2fukey_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Ukey2ClientInit_CipherCommitment final :
|
|
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ClientInit.CipherCommitment) */ {
|
|
public:
|
|
inline Ukey2ClientInit_CipherCommitment() : Ukey2ClientInit_CipherCommitment(nullptr) {}
|
|
~Ukey2ClientInit_CipherCommitment() override;
|
|
explicit constexpr Ukey2ClientInit_CipherCommitment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Ukey2ClientInit_CipherCommitment(const Ukey2ClientInit_CipherCommitment& from);
|
|
Ukey2ClientInit_CipherCommitment(Ukey2ClientInit_CipherCommitment&& from) noexcept
|
|
: Ukey2ClientInit_CipherCommitment() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Ukey2ClientInit_CipherCommitment& operator=(const Ukey2ClientInit_CipherCommitment& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Ukey2ClientInit_CipherCommitment& operator=(Ukey2ClientInit_CipherCommitment&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
|
|
}
|
|
inline std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<std::string>();
|
|
}
|
|
|
|
static const Ukey2ClientInit_CipherCommitment& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Ukey2ClientInit_CipherCommitment* internal_default_instance() {
|
|
return reinterpret_cast<const Ukey2ClientInit_CipherCommitment*>(
|
|
&_Ukey2ClientInit_CipherCommitment_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(Ukey2ClientInit_CipherCommitment& a, Ukey2ClientInit_CipherCommitment& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Ukey2ClientInit_CipherCommitment* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Ukey2ClientInit_CipherCommitment* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Ukey2ClientInit_CipherCommitment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Ukey2ClientInit_CipherCommitment>(arena);
|
|
}
|
|
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
|
|
void CopyFrom(const Ukey2ClientInit_CipherCommitment& from);
|
|
void MergeFrom(const Ukey2ClientInit_CipherCommitment& 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;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Ukey2ClientInit_CipherCommitment* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "securegcm.Ukey2ClientInit.CipherCommitment";
|
|
}
|
|
protected:
|
|
explicit Ukey2ClientInit_CipherCommitment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
std::string GetTypeName() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCommitmentFieldNumber = 2,
|
|
kHandshakeCipherFieldNumber = 1,
|
|
};
|
|
// optional bytes commitment = 2;
|
|
bool has_commitment() const;
|
|
private:
|
|
bool _internal_has_commitment() const;
|
|
public:
|
|
void clear_commitment();
|
|
const std::string& commitment() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_commitment(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_commitment();
|
|
PROTOBUF_NODISCARD std::string* release_commitment();
|
|
void set_allocated_commitment(std::string* commitment);
|
|
private:
|
|
const std::string& _internal_commitment() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_commitment(const std::string& value);
|
|
std::string* _internal_mutable_commitment();
|
|
public:
|
|
|
|
// optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 1;
|
|
bool has_handshake_cipher() const;
|
|
private:
|
|
bool _internal_has_handshake_cipher() const;
|
|
public:
|
|
void clear_handshake_cipher();
|
|
::securegcm::Ukey2HandshakeCipher handshake_cipher() const;
|
|
void set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
|
|
private:
|
|
::securegcm::Ukey2HandshakeCipher _internal_handshake_cipher() const;
|
|
void _internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:securegcm.Ukey2ClientInit.CipherCommitment)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr commitment_;
|
|
int handshake_cipher_;
|
|
friend struct ::TableStruct_proto_2fukey_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Ukey2ClientInit final :
|
|
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ClientInit) */ {
|
|
public:
|
|
inline Ukey2ClientInit() : Ukey2ClientInit(nullptr) {}
|
|
~Ukey2ClientInit() override;
|
|
explicit constexpr Ukey2ClientInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Ukey2ClientInit(const Ukey2ClientInit& from);
|
|
Ukey2ClientInit(Ukey2ClientInit&& from) noexcept
|
|
: Ukey2ClientInit() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Ukey2ClientInit& operator=(const Ukey2ClientInit& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Ukey2ClientInit& operator=(Ukey2ClientInit&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
|
|
}
|
|
inline std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<std::string>();
|
|
}
|
|
|
|
static const Ukey2ClientInit& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Ukey2ClientInit* internal_default_instance() {
|
|
return reinterpret_cast<const Ukey2ClientInit*>(
|
|
&_Ukey2ClientInit_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(Ukey2ClientInit& a, Ukey2ClientInit& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Ukey2ClientInit* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Ukey2ClientInit* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Ukey2ClientInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Ukey2ClientInit>(arena);
|
|
}
|
|
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
|
|
void CopyFrom(const Ukey2ClientInit& from);
|
|
void MergeFrom(const Ukey2ClientInit& 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;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Ukey2ClientInit* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "securegcm.Ukey2ClientInit";
|
|
}
|
|
protected:
|
|
explicit Ukey2ClientInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
std::string GetTypeName() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef Ukey2ClientInit_CipherCommitment CipherCommitment;
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCipherCommitmentsFieldNumber = 3,
|
|
kRandomFieldNumber = 2,
|
|
kNextProtocolFieldNumber = 4,
|
|
kVersionFieldNumber = 1,
|
|
};
|
|
// repeated .securegcm.Ukey2ClientInit.CipherCommitment cipher_commitments = 3;
|
|
int cipher_commitments_size() const;
|
|
private:
|
|
int _internal_cipher_commitments_size() const;
|
|
public:
|
|
void clear_cipher_commitments();
|
|
::securegcm::Ukey2ClientInit_CipherCommitment* mutable_cipher_commitments(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >*
|
|
mutable_cipher_commitments();
|
|
private:
|
|
const ::securegcm::Ukey2ClientInit_CipherCommitment& _internal_cipher_commitments(int index) const;
|
|
::securegcm::Ukey2ClientInit_CipherCommitment* _internal_add_cipher_commitments();
|
|
public:
|
|
const ::securegcm::Ukey2ClientInit_CipherCommitment& cipher_commitments(int index) const;
|
|
::securegcm::Ukey2ClientInit_CipherCommitment* add_cipher_commitments();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >&
|
|
cipher_commitments() const;
|
|
|
|
// optional bytes random = 2;
|
|
bool has_random() const;
|
|
private:
|
|
bool _internal_has_random() const;
|
|
public:
|
|
void clear_random();
|
|
const std::string& random() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_random(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_random();
|
|
PROTOBUF_NODISCARD std::string* release_random();
|
|
void set_allocated_random(std::string* random);
|
|
private:
|
|
const std::string& _internal_random() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_random(const std::string& value);
|
|
std::string* _internal_mutable_random();
|
|
public:
|
|
|
|
// optional string next_protocol = 4;
|
|
bool has_next_protocol() const;
|
|
private:
|
|
bool _internal_has_next_protocol() const;
|
|
public:
|
|
void clear_next_protocol();
|
|
const std::string& next_protocol() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_next_protocol(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_next_protocol();
|
|
PROTOBUF_NODISCARD std::string* release_next_protocol();
|
|
void set_allocated_next_protocol(std::string* next_protocol);
|
|
private:
|
|
const std::string& _internal_next_protocol() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_protocol(const std::string& value);
|
|
std::string* _internal_mutable_next_protocol();
|
|
public:
|
|
|
|
// optional int32 version = 1;
|
|
bool has_version() const;
|
|
private:
|
|
bool _internal_has_version() const;
|
|
public:
|
|
void clear_version();
|
|
int32_t version() const;
|
|
void set_version(int32_t value);
|
|
private:
|
|
int32_t _internal_version() const;
|
|
void _internal_set_version(int32_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:securegcm.Ukey2ClientInit)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment > cipher_commitments_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr random_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr next_protocol_;
|
|
int32_t version_;
|
|
friend struct ::TableStruct_proto_2fukey_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Ukey2ServerInit final :
|
|
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ServerInit) */ {
|
|
public:
|
|
inline Ukey2ServerInit() : Ukey2ServerInit(nullptr) {}
|
|
~Ukey2ServerInit() override;
|
|
explicit constexpr Ukey2ServerInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Ukey2ServerInit(const Ukey2ServerInit& from);
|
|
Ukey2ServerInit(Ukey2ServerInit&& from) noexcept
|
|
: Ukey2ServerInit() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Ukey2ServerInit& operator=(const Ukey2ServerInit& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Ukey2ServerInit& operator=(Ukey2ServerInit&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
|
|
}
|
|
inline std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<std::string>();
|
|
}
|
|
|
|
static const Ukey2ServerInit& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Ukey2ServerInit* internal_default_instance() {
|
|
return reinterpret_cast<const Ukey2ServerInit*>(
|
|
&_Ukey2ServerInit_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(Ukey2ServerInit& a, Ukey2ServerInit& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Ukey2ServerInit* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Ukey2ServerInit* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Ukey2ServerInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Ukey2ServerInit>(arena);
|
|
}
|
|
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
|
|
void CopyFrom(const Ukey2ServerInit& from);
|
|
void MergeFrom(const Ukey2ServerInit& 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;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Ukey2ServerInit* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "securegcm.Ukey2ServerInit";
|
|
}
|
|
protected:
|
|
explicit Ukey2ServerInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
std::string GetTypeName() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kRandomFieldNumber = 2,
|
|
kPublicKeyFieldNumber = 4,
|
|
kVersionFieldNumber = 1,
|
|
kHandshakeCipherFieldNumber = 3,
|
|
};
|
|
// optional bytes random = 2;
|
|
bool has_random() const;
|
|
private:
|
|
bool _internal_has_random() const;
|
|
public:
|
|
void clear_random();
|
|
const std::string& random() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_random(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_random();
|
|
PROTOBUF_NODISCARD std::string* release_random();
|
|
void set_allocated_random(std::string* random);
|
|
private:
|
|
const std::string& _internal_random() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_random(const std::string& value);
|
|
std::string* _internal_mutable_random();
|
|
public:
|
|
|
|
// optional bytes public_key = 4;
|
|
bool has_public_key() const;
|
|
private:
|
|
bool _internal_has_public_key() const;
|
|
public:
|
|
void clear_public_key();
|
|
const std::string& public_key() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_public_key(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_public_key();
|
|
PROTOBUF_NODISCARD std::string* release_public_key();
|
|
void set_allocated_public_key(std::string* public_key);
|
|
private:
|
|
const std::string& _internal_public_key() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
|
|
std::string* _internal_mutable_public_key();
|
|
public:
|
|
|
|
// optional int32 version = 1;
|
|
bool has_version() const;
|
|
private:
|
|
bool _internal_has_version() const;
|
|
public:
|
|
void clear_version();
|
|
int32_t version() const;
|
|
void set_version(int32_t value);
|
|
private:
|
|
int32_t _internal_version() const;
|
|
void _internal_set_version(int32_t value);
|
|
public:
|
|
|
|
// optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 3;
|
|
bool has_handshake_cipher() const;
|
|
private:
|
|
bool _internal_has_handshake_cipher() const;
|
|
public:
|
|
void clear_handshake_cipher();
|
|
::securegcm::Ukey2HandshakeCipher handshake_cipher() const;
|
|
void set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
|
|
private:
|
|
::securegcm::Ukey2HandshakeCipher _internal_handshake_cipher() const;
|
|
void _internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:securegcm.Ukey2ServerInit)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr random_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
|
|
int32_t version_;
|
|
int handshake_cipher_;
|
|
friend struct ::TableStruct_proto_2fukey_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Ukey2ClientFinished final :
|
|
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ClientFinished) */ {
|
|
public:
|
|
inline Ukey2ClientFinished() : Ukey2ClientFinished(nullptr) {}
|
|
~Ukey2ClientFinished() override;
|
|
explicit constexpr Ukey2ClientFinished(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Ukey2ClientFinished(const Ukey2ClientFinished& from);
|
|
Ukey2ClientFinished(Ukey2ClientFinished&& from) noexcept
|
|
: Ukey2ClientFinished() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Ukey2ClientFinished& operator=(const Ukey2ClientFinished& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Ukey2ClientFinished& operator=(Ukey2ClientFinished&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
|
|
}
|
|
inline std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<std::string>();
|
|
}
|
|
|
|
static const Ukey2ClientFinished& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Ukey2ClientFinished* internal_default_instance() {
|
|
return reinterpret_cast<const Ukey2ClientFinished*>(
|
|
&_Ukey2ClientFinished_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
5;
|
|
|
|
friend void swap(Ukey2ClientFinished& a, Ukey2ClientFinished& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Ukey2ClientFinished* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Ukey2ClientFinished* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Ukey2ClientFinished* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Ukey2ClientFinished>(arena);
|
|
}
|
|
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
|
|
void CopyFrom(const Ukey2ClientFinished& from);
|
|
void MergeFrom(const Ukey2ClientFinished& 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;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Ukey2ClientFinished* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "securegcm.Ukey2ClientFinished";
|
|
}
|
|
protected:
|
|
explicit Ukey2ClientFinished(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
std::string GetTypeName() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kPublicKeyFieldNumber = 1,
|
|
};
|
|
// optional bytes public_key = 1;
|
|
bool has_public_key() const;
|
|
private:
|
|
bool _internal_has_public_key() const;
|
|
public:
|
|
void clear_public_key();
|
|
const std::string& public_key() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_public_key(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_public_key();
|
|
PROTOBUF_NODISCARD std::string* release_public_key();
|
|
void set_allocated_public_key(std::string* public_key);
|
|
private:
|
|
const std::string& _internal_public_key() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
|
|
std::string* _internal_mutable_public_key();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:securegcm.Ukey2ClientFinished)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
|
|
friend struct ::TableStruct_proto_2fukey_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// Ukey2Message
|
|
|
|
// optional .securegcm.Ukey2Message.Type message_type = 1;
|
|
inline bool Ukey2Message::_internal_has_message_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2Message::has_message_type() const {
|
|
return _internal_has_message_type();
|
|
}
|
|
inline void Ukey2Message::clear_message_type() {
|
|
message_type_ = 0;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::securegcm::Ukey2Message_Type Ukey2Message::_internal_message_type() const {
|
|
return static_cast< ::securegcm::Ukey2Message_Type >(message_type_);
|
|
}
|
|
inline ::securegcm::Ukey2Message_Type Ukey2Message::message_type() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2Message.message_type)
|
|
return _internal_message_type();
|
|
}
|
|
inline void Ukey2Message::_internal_set_message_type(::securegcm::Ukey2Message_Type value) {
|
|
assert(::securegcm::Ukey2Message_Type_IsValid(value));
|
|
_has_bits_[0] |= 0x00000002u;
|
|
message_type_ = value;
|
|
}
|
|
inline void Ukey2Message::set_message_type(::securegcm::Ukey2Message_Type value) {
|
|
_internal_set_message_type(value);
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2Message.message_type)
|
|
}
|
|
|
|
// optional bytes message_data = 2;
|
|
inline bool Ukey2Message::_internal_has_message_data() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2Message::has_message_data() const {
|
|
return _internal_has_message_data();
|
|
}
|
|
inline void Ukey2Message::clear_message_data() {
|
|
message_data_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Ukey2Message::message_data() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2Message.message_data)
|
|
return _internal_message_data();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2Message::set_message_data(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
message_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2Message.message_data)
|
|
}
|
|
inline std::string* Ukey2Message::mutable_message_data() {
|
|
std::string* _s = _internal_mutable_message_data();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2Message.message_data)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2Message::_internal_message_data() const {
|
|
return message_data_.Get();
|
|
}
|
|
inline void Ukey2Message::_internal_set_message_data(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
message_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2Message::_internal_mutable_message_data() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return message_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2Message::release_message_data() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2Message.message_data)
|
|
if (!_internal_has_message_data()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = message_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (message_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
message_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2Message::set_allocated_message_data(std::string* message_data) {
|
|
if (message_data != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
message_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message_data,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (message_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
message_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2Message.message_data)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Ukey2Alert
|
|
|
|
// optional .securegcm.Ukey2Alert.AlertType type = 1;
|
|
inline bool Ukey2Alert::_internal_has_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2Alert::has_type() const {
|
|
return _internal_has_type();
|
|
}
|
|
inline void Ukey2Alert::clear_type() {
|
|
type_ = 1;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::securegcm::Ukey2Alert_AlertType Ukey2Alert::_internal_type() const {
|
|
return static_cast< ::securegcm::Ukey2Alert_AlertType >(type_);
|
|
}
|
|
inline ::securegcm::Ukey2Alert_AlertType Ukey2Alert::type() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2Alert.type)
|
|
return _internal_type();
|
|
}
|
|
inline void Ukey2Alert::_internal_set_type(::securegcm::Ukey2Alert_AlertType value) {
|
|
assert(::securegcm::Ukey2Alert_AlertType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000002u;
|
|
type_ = value;
|
|
}
|
|
inline void Ukey2Alert::set_type(::securegcm::Ukey2Alert_AlertType value) {
|
|
_internal_set_type(value);
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2Alert.type)
|
|
}
|
|
|
|
// optional string error_message = 2;
|
|
inline bool Ukey2Alert::_internal_has_error_message() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2Alert::has_error_message() const {
|
|
return _internal_has_error_message();
|
|
}
|
|
inline void Ukey2Alert::clear_error_message() {
|
|
error_message_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Ukey2Alert::error_message() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2Alert.error_message)
|
|
return _internal_error_message();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2Alert::set_error_message(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
error_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2Alert.error_message)
|
|
}
|
|
inline std::string* Ukey2Alert::mutable_error_message() {
|
|
std::string* _s = _internal_mutable_error_message();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2Alert.error_message)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2Alert::_internal_error_message() const {
|
|
return error_message_.Get();
|
|
}
|
|
inline void Ukey2Alert::_internal_set_error_message(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
error_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2Alert::_internal_mutable_error_message() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return error_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2Alert::release_error_message() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2Alert.error_message)
|
|
if (!_internal_has_error_message()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = error_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (error_message_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
error_message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2Alert::set_allocated_error_message(std::string* error_message) {
|
|
if (error_message != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
error_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), error_message,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (error_message_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
error_message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2Alert.error_message)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Ukey2ClientInit_CipherCommitment
|
|
|
|
// optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 1;
|
|
inline bool Ukey2ClientInit_CipherCommitment::_internal_has_handshake_cipher() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ClientInit_CipherCommitment::has_handshake_cipher() const {
|
|
return _internal_has_handshake_cipher();
|
|
}
|
|
inline void Ukey2ClientInit_CipherCommitment::clear_handshake_cipher() {
|
|
handshake_cipher_ = 0;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::securegcm::Ukey2HandshakeCipher Ukey2ClientInit_CipherCommitment::_internal_handshake_cipher() const {
|
|
return static_cast< ::securegcm::Ukey2HandshakeCipher >(handshake_cipher_);
|
|
}
|
|
inline ::securegcm::Ukey2HandshakeCipher Ukey2ClientInit_CipherCommitment::handshake_cipher() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.CipherCommitment.handshake_cipher)
|
|
return _internal_handshake_cipher();
|
|
}
|
|
inline void Ukey2ClientInit_CipherCommitment::_internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
|
|
assert(::securegcm::Ukey2HandshakeCipher_IsValid(value));
|
|
_has_bits_[0] |= 0x00000002u;
|
|
handshake_cipher_ = value;
|
|
}
|
|
inline void Ukey2ClientInit_CipherCommitment::set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
|
|
_internal_set_handshake_cipher(value);
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.CipherCommitment.handshake_cipher)
|
|
}
|
|
|
|
// optional bytes commitment = 2;
|
|
inline bool Ukey2ClientInit_CipherCommitment::_internal_has_commitment() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ClientInit_CipherCommitment::has_commitment() const {
|
|
return _internal_has_commitment();
|
|
}
|
|
inline void Ukey2ClientInit_CipherCommitment::clear_commitment() {
|
|
commitment_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Ukey2ClientInit_CipherCommitment::commitment() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
|
|
return _internal_commitment();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2ClientInit_CipherCommitment::set_commitment(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
commitment_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
|
|
}
|
|
inline std::string* Ukey2ClientInit_CipherCommitment::mutable_commitment() {
|
|
std::string* _s = _internal_mutable_commitment();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2ClientInit_CipherCommitment::_internal_commitment() const {
|
|
return commitment_.Get();
|
|
}
|
|
inline void Ukey2ClientInit_CipherCommitment::_internal_set_commitment(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
commitment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientInit_CipherCommitment::_internal_mutable_commitment() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return commitment_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientInit_CipherCommitment::release_commitment() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
|
|
if (!_internal_has_commitment()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = commitment_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (commitment_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
commitment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2ClientInit_CipherCommitment::set_allocated_commitment(std::string* commitment) {
|
|
if (commitment != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
commitment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), commitment,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (commitment_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
commitment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Ukey2ClientInit
|
|
|
|
// optional int32 version = 1;
|
|
inline bool Ukey2ClientInit::_internal_has_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ClientInit::has_version() const {
|
|
return _internal_has_version();
|
|
}
|
|
inline void Ukey2ClientInit::clear_version() {
|
|
version_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline int32_t Ukey2ClientInit::_internal_version() const {
|
|
return version_;
|
|
}
|
|
inline int32_t Ukey2ClientInit::version() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.version)
|
|
return _internal_version();
|
|
}
|
|
inline void Ukey2ClientInit::_internal_set_version(int32_t value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
version_ = value;
|
|
}
|
|
inline void Ukey2ClientInit::set_version(int32_t value) {
|
|
_internal_set_version(value);
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.version)
|
|
}
|
|
|
|
// optional bytes random = 2;
|
|
inline bool Ukey2ClientInit::_internal_has_random() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ClientInit::has_random() const {
|
|
return _internal_has_random();
|
|
}
|
|
inline void Ukey2ClientInit::clear_random() {
|
|
random_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Ukey2ClientInit::random() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.random)
|
|
return _internal_random();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2ClientInit::set_random(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
random_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.random)
|
|
}
|
|
inline std::string* Ukey2ClientInit::mutable_random() {
|
|
std::string* _s = _internal_mutable_random();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.random)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2ClientInit::_internal_random() const {
|
|
return random_.Get();
|
|
}
|
|
inline void Ukey2ClientInit::_internal_set_random(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
random_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientInit::_internal_mutable_random() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return random_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientInit::release_random() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2ClientInit.random)
|
|
if (!_internal_has_random()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = random_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2ClientInit::set_allocated_random(std::string* random) {
|
|
if (random != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
random_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), random,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientInit.random)
|
|
}
|
|
|
|
// repeated .securegcm.Ukey2ClientInit.CipherCommitment cipher_commitments = 3;
|
|
inline int Ukey2ClientInit::_internal_cipher_commitments_size() const {
|
|
return cipher_commitments_.size();
|
|
}
|
|
inline int Ukey2ClientInit::cipher_commitments_size() const {
|
|
return _internal_cipher_commitments_size();
|
|
}
|
|
inline void Ukey2ClientInit::clear_cipher_commitments() {
|
|
cipher_commitments_.Clear();
|
|
}
|
|
inline ::securegcm::Ukey2ClientInit_CipherCommitment* Ukey2ClientInit::mutable_cipher_commitments(int index) {
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.cipher_commitments)
|
|
return cipher_commitments_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >*
|
|
Ukey2ClientInit::mutable_cipher_commitments() {
|
|
// @@protoc_insertion_point(field_mutable_list:securegcm.Ukey2ClientInit.cipher_commitments)
|
|
return &cipher_commitments_;
|
|
}
|
|
inline const ::securegcm::Ukey2ClientInit_CipherCommitment& Ukey2ClientInit::_internal_cipher_commitments(int index) const {
|
|
return cipher_commitments_.Get(index);
|
|
}
|
|
inline const ::securegcm::Ukey2ClientInit_CipherCommitment& Ukey2ClientInit::cipher_commitments(int index) const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.cipher_commitments)
|
|
return _internal_cipher_commitments(index);
|
|
}
|
|
inline ::securegcm::Ukey2ClientInit_CipherCommitment* Ukey2ClientInit::_internal_add_cipher_commitments() {
|
|
return cipher_commitments_.Add();
|
|
}
|
|
inline ::securegcm::Ukey2ClientInit_CipherCommitment* Ukey2ClientInit::add_cipher_commitments() {
|
|
::securegcm::Ukey2ClientInit_CipherCommitment* _add = _internal_add_cipher_commitments();
|
|
// @@protoc_insertion_point(field_add:securegcm.Ukey2ClientInit.cipher_commitments)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >&
|
|
Ukey2ClientInit::cipher_commitments() const {
|
|
// @@protoc_insertion_point(field_list:securegcm.Ukey2ClientInit.cipher_commitments)
|
|
return cipher_commitments_;
|
|
}
|
|
|
|
// optional string next_protocol = 4;
|
|
inline bool Ukey2ClientInit::_internal_has_next_protocol() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ClientInit::has_next_protocol() const {
|
|
return _internal_has_next_protocol();
|
|
}
|
|
inline void Ukey2ClientInit::clear_next_protocol() {
|
|
next_protocol_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& Ukey2ClientInit::next_protocol() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.next_protocol)
|
|
return _internal_next_protocol();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2ClientInit::set_next_protocol(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
next_protocol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.next_protocol)
|
|
}
|
|
inline std::string* Ukey2ClientInit::mutable_next_protocol() {
|
|
std::string* _s = _internal_mutable_next_protocol();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.next_protocol)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2ClientInit::_internal_next_protocol() const {
|
|
return next_protocol_.Get();
|
|
}
|
|
inline void Ukey2ClientInit::_internal_set_next_protocol(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
next_protocol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientInit::_internal_mutable_next_protocol() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return next_protocol_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientInit::release_next_protocol() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2ClientInit.next_protocol)
|
|
if (!_internal_has_next_protocol()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
auto* p = next_protocol_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (next_protocol_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
next_protocol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2ClientInit::set_allocated_next_protocol(std::string* next_protocol) {
|
|
if (next_protocol != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
next_protocol_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), next_protocol,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (next_protocol_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
next_protocol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientInit.next_protocol)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Ukey2ServerInit
|
|
|
|
// optional int32 version = 1;
|
|
inline bool Ukey2ServerInit::_internal_has_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ServerInit::has_version() const {
|
|
return _internal_has_version();
|
|
}
|
|
inline void Ukey2ServerInit::clear_version() {
|
|
version_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline int32_t Ukey2ServerInit::_internal_version() const {
|
|
return version_;
|
|
}
|
|
inline int32_t Ukey2ServerInit::version() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.version)
|
|
return _internal_version();
|
|
}
|
|
inline void Ukey2ServerInit::_internal_set_version(int32_t value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
version_ = value;
|
|
}
|
|
inline void Ukey2ServerInit::set_version(int32_t value) {
|
|
_internal_set_version(value);
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.version)
|
|
}
|
|
|
|
// optional bytes random = 2;
|
|
inline bool Ukey2ServerInit::_internal_has_random() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ServerInit::has_random() const {
|
|
return _internal_has_random();
|
|
}
|
|
inline void Ukey2ServerInit::clear_random() {
|
|
random_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Ukey2ServerInit::random() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.random)
|
|
return _internal_random();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2ServerInit::set_random(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
random_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.random)
|
|
}
|
|
inline std::string* Ukey2ServerInit::mutable_random() {
|
|
std::string* _s = _internal_mutable_random();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ServerInit.random)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2ServerInit::_internal_random() const {
|
|
return random_.Get();
|
|
}
|
|
inline void Ukey2ServerInit::_internal_set_random(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
random_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ServerInit::_internal_mutable_random() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return random_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ServerInit::release_random() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2ServerInit.random)
|
|
if (!_internal_has_random()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = random_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2ServerInit::set_allocated_random(std::string* random) {
|
|
if (random != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
random_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), random,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ServerInit.random)
|
|
}
|
|
|
|
// optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 3;
|
|
inline bool Ukey2ServerInit::_internal_has_handshake_cipher() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ServerInit::has_handshake_cipher() const {
|
|
return _internal_has_handshake_cipher();
|
|
}
|
|
inline void Ukey2ServerInit::clear_handshake_cipher() {
|
|
handshake_cipher_ = 0;
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline ::securegcm::Ukey2HandshakeCipher Ukey2ServerInit::_internal_handshake_cipher() const {
|
|
return static_cast< ::securegcm::Ukey2HandshakeCipher >(handshake_cipher_);
|
|
}
|
|
inline ::securegcm::Ukey2HandshakeCipher Ukey2ServerInit::handshake_cipher() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.handshake_cipher)
|
|
return _internal_handshake_cipher();
|
|
}
|
|
inline void Ukey2ServerInit::_internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
|
|
assert(::securegcm::Ukey2HandshakeCipher_IsValid(value));
|
|
_has_bits_[0] |= 0x00000008u;
|
|
handshake_cipher_ = value;
|
|
}
|
|
inline void Ukey2ServerInit::set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
|
|
_internal_set_handshake_cipher(value);
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.handshake_cipher)
|
|
}
|
|
|
|
// optional bytes public_key = 4;
|
|
inline bool Ukey2ServerInit::_internal_has_public_key() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ServerInit::has_public_key() const {
|
|
return _internal_has_public_key();
|
|
}
|
|
inline void Ukey2ServerInit::clear_public_key() {
|
|
public_key_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& Ukey2ServerInit::public_key() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.public_key)
|
|
return _internal_public_key();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2ServerInit::set_public_key(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.public_key)
|
|
}
|
|
inline std::string* Ukey2ServerInit::mutable_public_key() {
|
|
std::string* _s = _internal_mutable_public_key();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ServerInit.public_key)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2ServerInit::_internal_public_key() const {
|
|
return public_key_.Get();
|
|
}
|
|
inline void Ukey2ServerInit::_internal_set_public_key(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ServerInit::_internal_mutable_public_key() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ServerInit::release_public_key() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2ServerInit.public_key)
|
|
if (!_internal_has_public_key()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
auto* p = public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2ServerInit::set_allocated_public_key(std::string* public_key) {
|
|
if (public_key != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ServerInit.public_key)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Ukey2ClientFinished
|
|
|
|
// optional bytes public_key = 1;
|
|
inline bool Ukey2ClientFinished::_internal_has_public_key() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Ukey2ClientFinished::has_public_key() const {
|
|
return _internal_has_public_key();
|
|
}
|
|
inline void Ukey2ClientFinished::clear_public_key() {
|
|
public_key_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Ukey2ClientFinished::public_key() const {
|
|
// @@protoc_insertion_point(field_get:securegcm.Ukey2ClientFinished.public_key)
|
|
return _internal_public_key();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Ukey2ClientFinished::set_public_key(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:securegcm.Ukey2ClientFinished.public_key)
|
|
}
|
|
inline std::string* Ukey2ClientFinished::mutable_public_key() {
|
|
std::string* _s = _internal_mutable_public_key();
|
|
// @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientFinished.public_key)
|
|
return _s;
|
|
}
|
|
inline const std::string& Ukey2ClientFinished::_internal_public_key() const {
|
|
return public_key_.Get();
|
|
}
|
|
inline void Ukey2ClientFinished::_internal_set_public_key(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientFinished::_internal_mutable_public_key() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Ukey2ClientFinished::release_public_key() {
|
|
// @@protoc_insertion_point(field_release:securegcm.Ukey2ClientFinished.public_key)
|
|
if (!_internal_has_public_key()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Ukey2ClientFinished::set_allocated_public_key(std::string* public_key) {
|
|
if (public_key != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientFinished.public_key)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace securegcm
|
|
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
|
|
template <> struct is_proto_enum< ::securegcm::Ukey2Message_Type> : ::std::true_type {};
|
|
template <> struct is_proto_enum< ::securegcm::Ukey2Alert_AlertType> : ::std::true_type {};
|
|
template <> struct is_proto_enum< ::securegcm::Ukey2HandshakeCipher> : ::std::true_type {};
|
|
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fukey_2eproto
|