cast_channel.pb.cc | Explore in Territory

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

#include "cast_channel.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace openscreen {
namespace cast {
namespace proto {
PROTOBUF_CONSTEXPR CastMessage::CastMessage(
    ::_pbi::ConstantInitialized): … { … }
struct CastMessageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CastMessageDefaultTypeInternal _CastMessage_default_instance_;
PROTOBUF_CONSTEXPR AuthChallenge::AuthChallenge(
    ::_pbi::ConstantInitialized): … { … }
struct AuthChallengeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AuthChallengeDefaultTypeInternal _AuthChallenge_default_instance_;
PROTOBUF_CONSTEXPR AuthResponse::AuthResponse(
    ::_pbi::ConstantInitialized): … { … }
struct AuthResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AuthResponseDefaultTypeInternal _AuthResponse_default_instance_;
PROTOBUF_CONSTEXPR AuthError::AuthError(
    ::_pbi::ConstantInitialized): … { … }
struct AuthErrorDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AuthErrorDefaultTypeInternal _AuthError_default_instance_;
PROTOBUF_CONSTEXPR DeviceAuthMessage::DeviceAuthMessage(
    ::_pbi::ConstantInitialized): … { … }
struct DeviceAuthMessageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceAuthMessageDefaultTypeInternal _DeviceAuthMessage_default_instance_;
}  // namespace proto
}  // namespace cast
}  // namespace openscreen
namespace openscreen {
namespace cast {
namespace proto {
bool CastMessage_ProtocolVersion_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CastMessage_ProtocolVersion_strings[4] = …;

static const char CastMessage_ProtocolVersion_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CastMessage_ProtocolVersion_entries[] = …;

static const int CastMessage_ProtocolVersion_entries_by_number[] = …;

const std::string& CastMessage_ProtocolVersion_Name(
    CastMessage_ProtocolVersion value) { … }
bool CastMessage_ProtocolVersion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastMessage_ProtocolVersion* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CastMessage_ProtocolVersion CastMessage::CASTV2_1_0;
constexpr CastMessage_ProtocolVersion CastMessage::CASTV2_1_1;
constexpr CastMessage_ProtocolVersion CastMessage::CASTV2_1_2;
constexpr CastMessage_ProtocolVersion CastMessage::CASTV2_1_3;
constexpr CastMessage_ProtocolVersion CastMessage::ProtocolVersion_MIN;
constexpr CastMessage_ProtocolVersion CastMessage::ProtocolVersion_MAX;
constexpr int CastMessage::ProtocolVersion_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CastMessage_PayloadType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CastMessage_PayloadType_strings[2] = …;

static const char CastMessage_PayloadType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CastMessage_PayloadType_entries[] = …;

static const int CastMessage_PayloadType_entries_by_number[] = …;

const std::string& CastMessage_PayloadType_Name(
    CastMessage_PayloadType value) { … }
bool CastMessage_PayloadType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastMessage_PayloadType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CastMessage_PayloadType CastMessage::STRING;
constexpr CastMessage_PayloadType CastMessage::BINARY;
constexpr CastMessage_PayloadType CastMessage::PayloadType_MIN;
constexpr CastMessage_PayloadType CastMessage::PayloadType_MAX;
constexpr int CastMessage::PayloadType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool AuthError_ErrorType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AuthError_ErrorType_strings[3] = …;

static const char AuthError_ErrorType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AuthError_ErrorType_entries[] = …;

static const int AuthError_ErrorType_entries_by_number[] = …;

const std::string& AuthError_ErrorType_Name(
    AuthError_ErrorType value) { … }
bool AuthError_ErrorType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AuthError_ErrorType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr AuthError_ErrorType AuthError::INTERNAL_ERROR;
constexpr AuthError_ErrorType AuthError::NO_TLS;
constexpr AuthError_ErrorType AuthError::SIGNATURE_ALGORITHM_UNAVAILABLE;
constexpr AuthError_ErrorType AuthError::ErrorType_MIN;
constexpr AuthError_ErrorType AuthError::ErrorType_MAX;
constexpr int AuthError::ErrorType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool SignatureAlgorithm_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SignatureAlgorithm_strings[3] = …;

static const char SignatureAlgorithm_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SignatureAlgorithm_entries[] = …;

static const int SignatureAlgorithm_entries_by_number[] = …;

const std::string& SignatureAlgorithm_Name(
    SignatureAlgorithm value) { … }
bool SignatureAlgorithm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignatureAlgorithm* value) { … }
bool HashAlgorithm_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> HashAlgorithm_strings[2] = …;

static const char HashAlgorithm_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry HashAlgorithm_entries[] = …;

static const int HashAlgorithm_entries_by_number[] = …;

const std::string& HashAlgorithm_Name(
    HashAlgorithm value) { … }
bool HashAlgorithm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HashAlgorithm* value) { … }

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

class CastMessage::_Internal { … };

CastMessage::CastMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CastMessage::CastMessage(const CastMessage& from)
  : … { … }

inline void CastMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CastMessage::~CastMessage() { … }

inline void CastMessage::SharedDtor() { … }

void CastMessage::SetCachedSize(int size) const { … }

void CastMessage::Clear() { … }

const char* CastMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CastMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CastMessage::RequiredFieldsByteSizeFallback() const { … }
size_t CastMessage::ByteSizeLong() const { … }

void CastMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CastMessage::MergeFrom(const CastMessage& from) { … }

void CastMessage::CopyFrom(const CastMessage& from) { … }

bool CastMessage::IsInitialized() const { … }

void CastMessage::InternalSwap(CastMessage* other) { … }

std::string CastMessage::GetTypeName() const { … }


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

class AuthChallenge::_Internal { … };

AuthChallenge::AuthChallenge(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AuthChallenge::AuthChallenge(const AuthChallenge& from)
  : … { … }

inline void AuthChallenge::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AuthChallenge::~AuthChallenge() { … }

inline void AuthChallenge::SharedDtor() { … }

void AuthChallenge::SetCachedSize(int size) const { … }

void AuthChallenge::Clear() { … }

const char* AuthChallenge::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AuthChallenge::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AuthChallenge::ByteSizeLong() const { … }

void AuthChallenge::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AuthChallenge::MergeFrom(const AuthChallenge& from) { … }

void AuthChallenge::CopyFrom(const AuthChallenge& from) { … }

bool AuthChallenge::IsInitialized() const { … }

void AuthChallenge::InternalSwap(AuthChallenge* other) { … }

std::string AuthChallenge::GetTypeName() const { … }


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

class AuthResponse::_Internal { … };

AuthResponse::AuthResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AuthResponse::AuthResponse(const AuthResponse& from)
  : … { … }

inline void AuthResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AuthResponse::~AuthResponse() { … }

inline void AuthResponse::SharedDtor() { … }

void AuthResponse::SetCachedSize(int size) const { … }

void AuthResponse::Clear() { … }

const char* AuthResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AuthResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AuthResponse::RequiredFieldsByteSizeFallback() const { … }
size_t AuthResponse::ByteSizeLong() const { … }

void AuthResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AuthResponse::MergeFrom(const AuthResponse& from) { … }

void AuthResponse::CopyFrom(const AuthResponse& from) { … }

bool AuthResponse::IsInitialized() const { … }

void AuthResponse::InternalSwap(AuthResponse* other) { … }

std::string AuthResponse::GetTypeName() const { … }


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

class AuthError::_Internal { … };

AuthError::AuthError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AuthError::AuthError(const AuthError& from)
  : … { … }

inline void AuthError::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AuthError::~AuthError() { … }

inline void AuthError::SharedDtor() { … }

void AuthError::SetCachedSize(int size) const { … }

void AuthError::Clear() { … }

const char* AuthError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AuthError::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AuthError::ByteSizeLong() const { … }

void AuthError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AuthError::MergeFrom(const AuthError& from) { … }

void AuthError::CopyFrom(const AuthError& from) { … }

bool AuthError::IsInitialized() const { … }

void AuthError::InternalSwap(AuthError* other) { … }

std::string AuthError::GetTypeName() const { … }


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

class DeviceAuthMessage::_Internal { … };

const ::openscreen::cast::proto::AuthChallenge&
DeviceAuthMessage::_Internal::challenge(const DeviceAuthMessage* msg) { … }
const ::openscreen::cast::proto::AuthResponse&
DeviceAuthMessage::_Internal::response(const DeviceAuthMessage* msg) { … }
const ::openscreen::cast::proto::AuthError&
DeviceAuthMessage::_Internal::error(const DeviceAuthMessage* msg) { … }
DeviceAuthMessage::DeviceAuthMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
DeviceAuthMessage::DeviceAuthMessage(const DeviceAuthMessage& from)
  : … { … }

inline void DeviceAuthMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

DeviceAuthMessage::~DeviceAuthMessage() { … }

inline void DeviceAuthMessage::SharedDtor() { … }

void DeviceAuthMessage::SetCachedSize(int size) const { … }

void DeviceAuthMessage::Clear() { … }

const char* DeviceAuthMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* DeviceAuthMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t DeviceAuthMessage::ByteSizeLong() const { … }

void DeviceAuthMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void DeviceAuthMessage::MergeFrom(const DeviceAuthMessage& from) { … }

void DeviceAuthMessage::CopyFrom(const DeviceAuthMessage& from) { … }

bool DeviceAuthMessage::IsInitialized() const { … }

void DeviceAuthMessage::InternalSwap(DeviceAuthMessage* other) { … }

std::string DeviceAuthMessage::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace cast
}  // namespace openscreen
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::openscreen::cast::proto::CastMessage*
Arena::CreateMaybeMessage< ::openscreen::cast::proto::CastMessage >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::openscreen::cast::proto::AuthChallenge*
Arena::CreateMaybeMessage< ::openscreen::cast::proto::AuthChallenge >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::openscreen::cast::proto::AuthResponse*
Arena::CreateMaybeMessage< ::openscreen::cast::proto::AuthResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::openscreen::cast::proto::AuthError*
Arena::CreateMaybeMessage< ::openscreen::cast::proto::AuthError >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::openscreen::cast::proto::DeviceAuthMessage*
Arena::CreateMaybeMessage< ::openscreen::cast::proto::DeviceAuthMessage >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
chromium/out/Default/gen/third_party/openscreen/src/cast/common/channel/proto/cast_channel.pb.cc
