680 lines
24 KiB
C++
680 lines
24 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: messages.proto
|
|
|
|
#ifndef PROTOBUF_messages_2eproto__INCLUDED
|
|
#define PROTOBUF_messages_2eproto__INCLUDED
|
|
|
|
#include <string>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
|
|
#if GOOGLE_PROTOBUF_VERSION < 2005000
|
|
#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 2005000 < GOOGLE_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/generated_message_util.h>
|
|
#include <google/protobuf/message.h>
|
|
#include <google/protobuf/repeated_field.h>
|
|
#include <google/protobuf/extension_set.h>
|
|
#include <google/protobuf/generated_enum_reflection.h>
|
|
#include <google/protobuf/unknown_field_set.h>
|
|
#include "common.pb.h"
|
|
#include "auth.pb.h"
|
|
#include "collection.pb.h"
|
|
#include "media.pb.h"
|
|
// @@protoc_insertion_point(includes)
|
|
|
|
namespace Remote {
|
|
|
|
// Internal implementation detail -- do not call these.
|
|
void protobuf_AddDesc_messages_2eproto();
|
|
void protobuf_AssignDesc_messages_2eproto();
|
|
void protobuf_ShutdownFile_messages_2eproto();
|
|
|
|
class ClientMessage;
|
|
class ServerMessage;
|
|
|
|
enum ClientMessage_Type {
|
|
ClientMessage_Type_AuthRequest = 1,
|
|
ClientMessage_Type_AudioCollectionRequest = 2,
|
|
ClientMessage_Type_MediaRequest = 3
|
|
};
|
|
bool ClientMessage_Type_IsValid(int value);
|
|
const ClientMessage_Type ClientMessage_Type_Type_MIN = ClientMessage_Type_AuthRequest;
|
|
const ClientMessage_Type ClientMessage_Type_Type_MAX = ClientMessage_Type_MediaRequest;
|
|
const int ClientMessage_Type_Type_ARRAYSIZE = ClientMessage_Type_Type_MAX + 1;
|
|
|
|
const ::google::protobuf::EnumDescriptor* ClientMessage_Type_descriptor();
|
|
inline const ::std::string& ClientMessage_Type_Name(ClientMessage_Type value) {
|
|
return ::google::protobuf::internal::NameOfEnum(
|
|
ClientMessage_Type_descriptor(), value);
|
|
}
|
|
inline bool ClientMessage_Type_Parse(
|
|
const ::std::string& name, ClientMessage_Type* value) {
|
|
return ::google::protobuf::internal::ParseNamedEnum<ClientMessage_Type>(
|
|
ClientMessage_Type_descriptor(), name, value);
|
|
}
|
|
enum ServerMessage_Type {
|
|
ServerMessage_Type_AuthResponse = 1,
|
|
ServerMessage_Type_AudioCollectionResponse = 2,
|
|
ServerMessage_Type_MediaResponse = 3
|
|
};
|
|
bool ServerMessage_Type_IsValid(int value);
|
|
const ServerMessage_Type ServerMessage_Type_Type_MIN = ServerMessage_Type_AuthResponse;
|
|
const ServerMessage_Type ServerMessage_Type_Type_MAX = ServerMessage_Type_MediaResponse;
|
|
const int ServerMessage_Type_Type_ARRAYSIZE = ServerMessage_Type_Type_MAX + 1;
|
|
|
|
const ::google::protobuf::EnumDescriptor* ServerMessage_Type_descriptor();
|
|
inline const ::std::string& ServerMessage_Type_Name(ServerMessage_Type value) {
|
|
return ::google::protobuf::internal::NameOfEnum(
|
|
ServerMessage_Type_descriptor(), value);
|
|
}
|
|
inline bool ServerMessage_Type_Parse(
|
|
const ::std::string& name, ServerMessage_Type* value) {
|
|
return ::google::protobuf::internal::ParseNamedEnum<ServerMessage_Type>(
|
|
ServerMessage_Type_descriptor(), name, value);
|
|
}
|
|
// ===================================================================
|
|
|
|
class ClientMessage : public ::google::protobuf::Message {
|
|
public:
|
|
ClientMessage();
|
|
virtual ~ClientMessage();
|
|
|
|
ClientMessage(const ClientMessage& from);
|
|
|
|
inline ClientMessage& operator=(const ClientMessage& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
|
return _unknown_fields_;
|
|
}
|
|
|
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
|
return &_unknown_fields_;
|
|
}
|
|
|
|
static const ::google::protobuf::Descriptor* descriptor();
|
|
static const ClientMessage& default_instance();
|
|
|
|
void Swap(ClientMessage* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
ClientMessage* New() const;
|
|
void CopyFrom(const ::google::protobuf::Message& from);
|
|
void MergeFrom(const ::google::protobuf::Message& from);
|
|
void CopyFrom(const ClientMessage& from);
|
|
void MergeFrom(const ClientMessage& from);
|
|
void Clear();
|
|
bool IsInitialized() const;
|
|
|
|
int ByteSize() const;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input);
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const;
|
|
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
|
|
int GetCachedSize() const { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
public:
|
|
|
|
::google::protobuf::Metadata GetMetadata() const;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef ClientMessage_Type Type;
|
|
static const Type AuthRequest = ClientMessage_Type_AuthRequest;
|
|
static const Type AudioCollectionRequest = ClientMessage_Type_AudioCollectionRequest;
|
|
static const Type MediaRequest = ClientMessage_Type_MediaRequest;
|
|
static inline bool Type_IsValid(int value) {
|
|
return ClientMessage_Type_IsValid(value);
|
|
}
|
|
static const Type Type_MIN =
|
|
ClientMessage_Type_Type_MIN;
|
|
static const Type Type_MAX =
|
|
ClientMessage_Type_Type_MAX;
|
|
static const int Type_ARRAYSIZE =
|
|
ClientMessage_Type_Type_ARRAYSIZE;
|
|
static inline const ::google::protobuf::EnumDescriptor*
|
|
Type_descriptor() {
|
|
return ClientMessage_Type_descriptor();
|
|
}
|
|
static inline const ::std::string& Type_Name(Type value) {
|
|
return ClientMessage_Type_Name(value);
|
|
}
|
|
static inline bool Type_Parse(const ::std::string& name,
|
|
Type* value) {
|
|
return ClientMessage_Type_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// required .Remote.ClientMessage.Type type = 1;
|
|
inline bool has_type() const;
|
|
inline void clear_type();
|
|
static const int kTypeFieldNumber = 1;
|
|
inline ::Remote::ClientMessage_Type type() const;
|
|
inline void set_type(::Remote::ClientMessage_Type value);
|
|
|
|
// optional .Remote.AuthRequest auth_request = 2;
|
|
inline bool has_auth_request() const;
|
|
inline void clear_auth_request();
|
|
static const int kAuthRequestFieldNumber = 2;
|
|
inline const ::Remote::AuthRequest& auth_request() const;
|
|
inline ::Remote::AuthRequest* mutable_auth_request();
|
|
inline ::Remote::AuthRequest* release_auth_request();
|
|
inline void set_allocated_auth_request(::Remote::AuthRequest* auth_request);
|
|
|
|
// optional .Remote.AudioCollectionRequest audio_collection_request = 3;
|
|
inline bool has_audio_collection_request() const;
|
|
inline void clear_audio_collection_request();
|
|
static const int kAudioCollectionRequestFieldNumber = 3;
|
|
inline const ::Remote::AudioCollectionRequest& audio_collection_request() const;
|
|
inline ::Remote::AudioCollectionRequest* mutable_audio_collection_request();
|
|
inline ::Remote::AudioCollectionRequest* release_audio_collection_request();
|
|
inline void set_allocated_audio_collection_request(::Remote::AudioCollectionRequest* audio_collection_request);
|
|
|
|
// optional .Remote.MediaRequest media_request = 4;
|
|
inline bool has_media_request() const;
|
|
inline void clear_media_request();
|
|
static const int kMediaRequestFieldNumber = 4;
|
|
inline const ::Remote::MediaRequest& media_request() const;
|
|
inline ::Remote::MediaRequest* mutable_media_request();
|
|
inline ::Remote::MediaRequest* release_media_request();
|
|
inline void set_allocated_media_request(::Remote::MediaRequest* media_request);
|
|
|
|
// @@protoc_insertion_point(class_scope:Remote.ClientMessage)
|
|
private:
|
|
inline void set_has_type();
|
|
inline void clear_has_type();
|
|
inline void set_has_auth_request();
|
|
inline void clear_has_auth_request();
|
|
inline void set_has_audio_collection_request();
|
|
inline void clear_has_audio_collection_request();
|
|
inline void set_has_media_request();
|
|
inline void clear_has_media_request();
|
|
|
|
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
|
|
|
::Remote::AuthRequest* auth_request_;
|
|
::Remote::AudioCollectionRequest* audio_collection_request_;
|
|
::Remote::MediaRequest* media_request_;
|
|
int type_;
|
|
|
|
mutable int _cached_size_;
|
|
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
|
|
|
|
friend void protobuf_AddDesc_messages_2eproto();
|
|
friend void protobuf_AssignDesc_messages_2eproto();
|
|
friend void protobuf_ShutdownFile_messages_2eproto();
|
|
|
|
void InitAsDefaultInstance();
|
|
static ClientMessage* default_instance_;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ServerMessage : public ::google::protobuf::Message {
|
|
public:
|
|
ServerMessage();
|
|
virtual ~ServerMessage();
|
|
|
|
ServerMessage(const ServerMessage& from);
|
|
|
|
inline ServerMessage& operator=(const ServerMessage& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
|
return _unknown_fields_;
|
|
}
|
|
|
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
|
return &_unknown_fields_;
|
|
}
|
|
|
|
static const ::google::protobuf::Descriptor* descriptor();
|
|
static const ServerMessage& default_instance();
|
|
|
|
void Swap(ServerMessage* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
ServerMessage* New() const;
|
|
void CopyFrom(const ::google::protobuf::Message& from);
|
|
void MergeFrom(const ::google::protobuf::Message& from);
|
|
void CopyFrom(const ServerMessage& from);
|
|
void MergeFrom(const ServerMessage& from);
|
|
void Clear();
|
|
bool IsInitialized() const;
|
|
|
|
int ByteSize() const;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input);
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const;
|
|
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
|
|
int GetCachedSize() const { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
public:
|
|
|
|
::google::protobuf::Metadata GetMetadata() const;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef ServerMessage_Type Type;
|
|
static const Type AuthResponse = ServerMessage_Type_AuthResponse;
|
|
static const Type AudioCollectionResponse = ServerMessage_Type_AudioCollectionResponse;
|
|
static const Type MediaResponse = ServerMessage_Type_MediaResponse;
|
|
static inline bool Type_IsValid(int value) {
|
|
return ServerMessage_Type_IsValid(value);
|
|
}
|
|
static const Type Type_MIN =
|
|
ServerMessage_Type_Type_MIN;
|
|
static const Type Type_MAX =
|
|
ServerMessage_Type_Type_MAX;
|
|
static const int Type_ARRAYSIZE =
|
|
ServerMessage_Type_Type_ARRAYSIZE;
|
|
static inline const ::google::protobuf::EnumDescriptor*
|
|
Type_descriptor() {
|
|
return ServerMessage_Type_descriptor();
|
|
}
|
|
static inline const ::std::string& Type_Name(Type value) {
|
|
return ServerMessage_Type_Name(value);
|
|
}
|
|
static inline bool Type_Parse(const ::std::string& name,
|
|
Type* value) {
|
|
return ServerMessage_Type_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// required .Remote.ServerMessage.Type type = 1;
|
|
inline bool has_type() const;
|
|
inline void clear_type();
|
|
static const int kTypeFieldNumber = 1;
|
|
inline ::Remote::ServerMessage_Type type() const;
|
|
inline void set_type(::Remote::ServerMessage_Type value);
|
|
|
|
// optional .Remote.AuthResponse auth_response = 2;
|
|
inline bool has_auth_response() const;
|
|
inline void clear_auth_response();
|
|
static const int kAuthResponseFieldNumber = 2;
|
|
inline const ::Remote::AuthResponse& auth_response() const;
|
|
inline ::Remote::AuthResponse* mutable_auth_response();
|
|
inline ::Remote::AuthResponse* release_auth_response();
|
|
inline void set_allocated_auth_response(::Remote::AuthResponse* auth_response);
|
|
|
|
// optional .Remote.AudioCollectionResponse audio_collection_response = 3;
|
|
inline bool has_audio_collection_response() const;
|
|
inline void clear_audio_collection_response();
|
|
static const int kAudioCollectionResponseFieldNumber = 3;
|
|
inline const ::Remote::AudioCollectionResponse& audio_collection_response() const;
|
|
inline ::Remote::AudioCollectionResponse* mutable_audio_collection_response();
|
|
inline ::Remote::AudioCollectionResponse* release_audio_collection_response();
|
|
inline void set_allocated_audio_collection_response(::Remote::AudioCollectionResponse* audio_collection_response);
|
|
|
|
// optional .Remote.MediaResponse media_response = 4;
|
|
inline bool has_media_response() const;
|
|
inline void clear_media_response();
|
|
static const int kMediaResponseFieldNumber = 4;
|
|
inline const ::Remote::MediaResponse& media_response() const;
|
|
inline ::Remote::MediaResponse* mutable_media_response();
|
|
inline ::Remote::MediaResponse* release_media_response();
|
|
inline void set_allocated_media_response(::Remote::MediaResponse* media_response);
|
|
|
|
// @@protoc_insertion_point(class_scope:Remote.ServerMessage)
|
|
private:
|
|
inline void set_has_type();
|
|
inline void clear_has_type();
|
|
inline void set_has_auth_response();
|
|
inline void clear_has_auth_response();
|
|
inline void set_has_audio_collection_response();
|
|
inline void clear_has_audio_collection_response();
|
|
inline void set_has_media_response();
|
|
inline void clear_has_media_response();
|
|
|
|
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
|
|
|
::Remote::AuthResponse* auth_response_;
|
|
::Remote::AudioCollectionResponse* audio_collection_response_;
|
|
::Remote::MediaResponse* media_response_;
|
|
int type_;
|
|
|
|
mutable int _cached_size_;
|
|
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
|
|
|
|
friend void protobuf_AddDesc_messages_2eproto();
|
|
friend void protobuf_AssignDesc_messages_2eproto();
|
|
friend void protobuf_ShutdownFile_messages_2eproto();
|
|
|
|
void InitAsDefaultInstance();
|
|
static ServerMessage* default_instance_;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
// ClientMessage
|
|
|
|
// required .Remote.ClientMessage.Type type = 1;
|
|
inline bool ClientMessage::has_type() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void ClientMessage::set_has_type() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void ClientMessage::clear_has_type() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void ClientMessage::clear_type() {
|
|
type_ = 1;
|
|
clear_has_type();
|
|
}
|
|
inline ::Remote::ClientMessage_Type ClientMessage::type() const {
|
|
return static_cast< ::Remote::ClientMessage_Type >(type_);
|
|
}
|
|
inline void ClientMessage::set_type(::Remote::ClientMessage_Type value) {
|
|
assert(::Remote::ClientMessage_Type_IsValid(value));
|
|
set_has_type();
|
|
type_ = value;
|
|
}
|
|
|
|
// optional .Remote.AuthRequest auth_request = 2;
|
|
inline bool ClientMessage::has_auth_request() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void ClientMessage::set_has_auth_request() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void ClientMessage::clear_has_auth_request() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void ClientMessage::clear_auth_request() {
|
|
if (auth_request_ != NULL) auth_request_->::Remote::AuthRequest::Clear();
|
|
clear_has_auth_request();
|
|
}
|
|
inline const ::Remote::AuthRequest& ClientMessage::auth_request() const {
|
|
return auth_request_ != NULL ? *auth_request_ : *default_instance_->auth_request_;
|
|
}
|
|
inline ::Remote::AuthRequest* ClientMessage::mutable_auth_request() {
|
|
set_has_auth_request();
|
|
if (auth_request_ == NULL) auth_request_ = new ::Remote::AuthRequest;
|
|
return auth_request_;
|
|
}
|
|
inline ::Remote::AuthRequest* ClientMessage::release_auth_request() {
|
|
clear_has_auth_request();
|
|
::Remote::AuthRequest* temp = auth_request_;
|
|
auth_request_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ClientMessage::set_allocated_auth_request(::Remote::AuthRequest* auth_request) {
|
|
delete auth_request_;
|
|
auth_request_ = auth_request;
|
|
if (auth_request) {
|
|
set_has_auth_request();
|
|
} else {
|
|
clear_has_auth_request();
|
|
}
|
|
}
|
|
|
|
// optional .Remote.AudioCollectionRequest audio_collection_request = 3;
|
|
inline bool ClientMessage::has_audio_collection_request() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void ClientMessage::set_has_audio_collection_request() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void ClientMessage::clear_has_audio_collection_request() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void ClientMessage::clear_audio_collection_request() {
|
|
if (audio_collection_request_ != NULL) audio_collection_request_->::Remote::AudioCollectionRequest::Clear();
|
|
clear_has_audio_collection_request();
|
|
}
|
|
inline const ::Remote::AudioCollectionRequest& ClientMessage::audio_collection_request() const {
|
|
return audio_collection_request_ != NULL ? *audio_collection_request_ : *default_instance_->audio_collection_request_;
|
|
}
|
|
inline ::Remote::AudioCollectionRequest* ClientMessage::mutable_audio_collection_request() {
|
|
set_has_audio_collection_request();
|
|
if (audio_collection_request_ == NULL) audio_collection_request_ = new ::Remote::AudioCollectionRequest;
|
|
return audio_collection_request_;
|
|
}
|
|
inline ::Remote::AudioCollectionRequest* ClientMessage::release_audio_collection_request() {
|
|
clear_has_audio_collection_request();
|
|
::Remote::AudioCollectionRequest* temp = audio_collection_request_;
|
|
audio_collection_request_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ClientMessage::set_allocated_audio_collection_request(::Remote::AudioCollectionRequest* audio_collection_request) {
|
|
delete audio_collection_request_;
|
|
audio_collection_request_ = audio_collection_request;
|
|
if (audio_collection_request) {
|
|
set_has_audio_collection_request();
|
|
} else {
|
|
clear_has_audio_collection_request();
|
|
}
|
|
}
|
|
|
|
// optional .Remote.MediaRequest media_request = 4;
|
|
inline bool ClientMessage::has_media_request() const {
|
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
|
}
|
|
inline void ClientMessage::set_has_media_request() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
}
|
|
inline void ClientMessage::clear_has_media_request() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline void ClientMessage::clear_media_request() {
|
|
if (media_request_ != NULL) media_request_->::Remote::MediaRequest::Clear();
|
|
clear_has_media_request();
|
|
}
|
|
inline const ::Remote::MediaRequest& ClientMessage::media_request() const {
|
|
return media_request_ != NULL ? *media_request_ : *default_instance_->media_request_;
|
|
}
|
|
inline ::Remote::MediaRequest* ClientMessage::mutable_media_request() {
|
|
set_has_media_request();
|
|
if (media_request_ == NULL) media_request_ = new ::Remote::MediaRequest;
|
|
return media_request_;
|
|
}
|
|
inline ::Remote::MediaRequest* ClientMessage::release_media_request() {
|
|
clear_has_media_request();
|
|
::Remote::MediaRequest* temp = media_request_;
|
|
media_request_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ClientMessage::set_allocated_media_request(::Remote::MediaRequest* media_request) {
|
|
delete media_request_;
|
|
media_request_ = media_request;
|
|
if (media_request) {
|
|
set_has_media_request();
|
|
} else {
|
|
clear_has_media_request();
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ServerMessage
|
|
|
|
// required .Remote.ServerMessage.Type type = 1;
|
|
inline bool ServerMessage::has_type() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void ServerMessage::set_has_type() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void ServerMessage::clear_has_type() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void ServerMessage::clear_type() {
|
|
type_ = 1;
|
|
clear_has_type();
|
|
}
|
|
inline ::Remote::ServerMessage_Type ServerMessage::type() const {
|
|
return static_cast< ::Remote::ServerMessage_Type >(type_);
|
|
}
|
|
inline void ServerMessage::set_type(::Remote::ServerMessage_Type value) {
|
|
assert(::Remote::ServerMessage_Type_IsValid(value));
|
|
set_has_type();
|
|
type_ = value;
|
|
}
|
|
|
|
// optional .Remote.AuthResponse auth_response = 2;
|
|
inline bool ServerMessage::has_auth_response() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void ServerMessage::set_has_auth_response() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void ServerMessage::clear_has_auth_response() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void ServerMessage::clear_auth_response() {
|
|
if (auth_response_ != NULL) auth_response_->::Remote::AuthResponse::Clear();
|
|
clear_has_auth_response();
|
|
}
|
|
inline const ::Remote::AuthResponse& ServerMessage::auth_response() const {
|
|
return auth_response_ != NULL ? *auth_response_ : *default_instance_->auth_response_;
|
|
}
|
|
inline ::Remote::AuthResponse* ServerMessage::mutable_auth_response() {
|
|
set_has_auth_response();
|
|
if (auth_response_ == NULL) auth_response_ = new ::Remote::AuthResponse;
|
|
return auth_response_;
|
|
}
|
|
inline ::Remote::AuthResponse* ServerMessage::release_auth_response() {
|
|
clear_has_auth_response();
|
|
::Remote::AuthResponse* temp = auth_response_;
|
|
auth_response_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ServerMessage::set_allocated_auth_response(::Remote::AuthResponse* auth_response) {
|
|
delete auth_response_;
|
|
auth_response_ = auth_response;
|
|
if (auth_response) {
|
|
set_has_auth_response();
|
|
} else {
|
|
clear_has_auth_response();
|
|
}
|
|
}
|
|
|
|
// optional .Remote.AudioCollectionResponse audio_collection_response = 3;
|
|
inline bool ServerMessage::has_audio_collection_response() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void ServerMessage::set_has_audio_collection_response() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void ServerMessage::clear_has_audio_collection_response() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void ServerMessage::clear_audio_collection_response() {
|
|
if (audio_collection_response_ != NULL) audio_collection_response_->::Remote::AudioCollectionResponse::Clear();
|
|
clear_has_audio_collection_response();
|
|
}
|
|
inline const ::Remote::AudioCollectionResponse& ServerMessage::audio_collection_response() const {
|
|
return audio_collection_response_ != NULL ? *audio_collection_response_ : *default_instance_->audio_collection_response_;
|
|
}
|
|
inline ::Remote::AudioCollectionResponse* ServerMessage::mutable_audio_collection_response() {
|
|
set_has_audio_collection_response();
|
|
if (audio_collection_response_ == NULL) audio_collection_response_ = new ::Remote::AudioCollectionResponse;
|
|
return audio_collection_response_;
|
|
}
|
|
inline ::Remote::AudioCollectionResponse* ServerMessage::release_audio_collection_response() {
|
|
clear_has_audio_collection_response();
|
|
::Remote::AudioCollectionResponse* temp = audio_collection_response_;
|
|
audio_collection_response_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ServerMessage::set_allocated_audio_collection_response(::Remote::AudioCollectionResponse* audio_collection_response) {
|
|
delete audio_collection_response_;
|
|
audio_collection_response_ = audio_collection_response;
|
|
if (audio_collection_response) {
|
|
set_has_audio_collection_response();
|
|
} else {
|
|
clear_has_audio_collection_response();
|
|
}
|
|
}
|
|
|
|
// optional .Remote.MediaResponse media_response = 4;
|
|
inline bool ServerMessage::has_media_response() const {
|
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
|
}
|
|
inline void ServerMessage::set_has_media_response() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
}
|
|
inline void ServerMessage::clear_has_media_response() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline void ServerMessage::clear_media_response() {
|
|
if (media_response_ != NULL) media_response_->::Remote::MediaResponse::Clear();
|
|
clear_has_media_response();
|
|
}
|
|
inline const ::Remote::MediaResponse& ServerMessage::media_response() const {
|
|
return media_response_ != NULL ? *media_response_ : *default_instance_->media_response_;
|
|
}
|
|
inline ::Remote::MediaResponse* ServerMessage::mutable_media_response() {
|
|
set_has_media_response();
|
|
if (media_response_ == NULL) media_response_ = new ::Remote::MediaResponse;
|
|
return media_response_;
|
|
}
|
|
inline ::Remote::MediaResponse* ServerMessage::release_media_response() {
|
|
clear_has_media_response();
|
|
::Remote::MediaResponse* temp = media_response_;
|
|
media_response_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ServerMessage::set_allocated_media_response(::Remote::MediaResponse* media_response) {
|
|
delete media_response_;
|
|
media_response_ = media_response;
|
|
if (media_response) {
|
|
set_has_media_response();
|
|
} else {
|
|
clear_has_media_response();
|
|
}
|
|
}
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace Remote
|
|
|
|
#ifndef SWIG
|
|
namespace google {
|
|
namespace protobuf {
|
|
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::Remote::ClientMessage_Type>() {
|
|
return ::Remote::ClientMessage_Type_descriptor();
|
|
}
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::Remote::ServerMessage_Type>() {
|
|
return ::Remote::ServerMessage_Type_descriptor();
|
|
}
|
|
|
|
} // namespace google
|
|
} // namespace protobuf
|
|
#endif // SWIG
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#endif // PROTOBUF_messages_2eproto__INCLUDED
|