676 lines
23 KiB
C++
676 lines
23 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)
|
|
|
|
// 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_CollectionRequest = 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_CollectionResponse = 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 CollectionRequest = ClientMessage_Type_CollectionRequest;
|
|
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 .ClientMessage.Type type = 1;
|
|
inline bool has_type() const;
|
|
inline void clear_type();
|
|
static const int kTypeFieldNumber = 1;
|
|
inline ::ClientMessage_Type type() const;
|
|
inline void set_type(::ClientMessage_Type value);
|
|
|
|
// optional .AuthRequest auth_request = 2;
|
|
inline bool has_auth_request() const;
|
|
inline void clear_auth_request();
|
|
static const int kAuthRequestFieldNumber = 2;
|
|
inline const ::AuthRequest& auth_request() const;
|
|
inline ::AuthRequest* mutable_auth_request();
|
|
inline ::AuthRequest* release_auth_request();
|
|
inline void set_allocated_auth_request(::AuthRequest* auth_request);
|
|
|
|
// optional .CollectionRequest collection_request = 3;
|
|
inline bool has_collection_request() const;
|
|
inline void clear_collection_request();
|
|
static const int kCollectionRequestFieldNumber = 3;
|
|
inline const ::CollectionRequest& collection_request() const;
|
|
inline ::CollectionRequest* mutable_collection_request();
|
|
inline ::CollectionRequest* release_collection_request();
|
|
inline void set_allocated_collection_request(::CollectionRequest* collection_request);
|
|
|
|
// optional .MediaRequest media_request = 4;
|
|
inline bool has_media_request() const;
|
|
inline void clear_media_request();
|
|
static const int kMediaRequestFieldNumber = 4;
|
|
inline const ::MediaRequest& media_request() const;
|
|
inline ::MediaRequest* mutable_media_request();
|
|
inline ::MediaRequest* release_media_request();
|
|
inline void set_allocated_media_request(::MediaRequest* media_request);
|
|
|
|
// @@protoc_insertion_point(class_scope: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_collection_request();
|
|
inline void clear_has_collection_request();
|
|
inline void set_has_media_request();
|
|
inline void clear_has_media_request();
|
|
|
|
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
|
|
|
::AuthRequest* auth_request_;
|
|
::CollectionRequest* collection_request_;
|
|
::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 CollectionResponse = ServerMessage_Type_CollectionResponse;
|
|
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 .ServerMessage.Type type = 1;
|
|
inline bool has_type() const;
|
|
inline void clear_type();
|
|
static const int kTypeFieldNumber = 1;
|
|
inline ::ServerMessage_Type type() const;
|
|
inline void set_type(::ServerMessage_Type value);
|
|
|
|
// optional .AuthResponse auth_response = 2;
|
|
inline bool has_auth_response() const;
|
|
inline void clear_auth_response();
|
|
static const int kAuthResponseFieldNumber = 2;
|
|
inline const ::AuthResponse& auth_response() const;
|
|
inline ::AuthResponse* mutable_auth_response();
|
|
inline ::AuthResponse* release_auth_response();
|
|
inline void set_allocated_auth_response(::AuthResponse* auth_response);
|
|
|
|
// optional .CollectionResponse collection_response = 3;
|
|
inline bool has_collection_response() const;
|
|
inline void clear_collection_response();
|
|
static const int kCollectionResponseFieldNumber = 3;
|
|
inline const ::CollectionResponse& collection_response() const;
|
|
inline ::CollectionResponse* mutable_collection_response();
|
|
inline ::CollectionResponse* release_collection_response();
|
|
inline void set_allocated_collection_response(::CollectionResponse* collection_response);
|
|
|
|
// optional .MediaResponse media_response = 4;
|
|
inline bool has_media_response() const;
|
|
inline void clear_media_response();
|
|
static const int kMediaResponseFieldNumber = 4;
|
|
inline const ::MediaResponse& media_response() const;
|
|
inline ::MediaResponse* mutable_media_response();
|
|
inline ::MediaResponse* release_media_response();
|
|
inline void set_allocated_media_response(::MediaResponse* media_response);
|
|
|
|
// @@protoc_insertion_point(class_scope: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_collection_response();
|
|
inline void clear_has_collection_response();
|
|
inline void set_has_media_response();
|
|
inline void clear_has_media_response();
|
|
|
|
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
|
|
|
::AuthResponse* auth_response_;
|
|
::CollectionResponse* collection_response_;
|
|
::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 .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 ::ClientMessage_Type ClientMessage::type() const {
|
|
return static_cast< ::ClientMessage_Type >(type_);
|
|
}
|
|
inline void ClientMessage::set_type(::ClientMessage_Type value) {
|
|
assert(::ClientMessage_Type_IsValid(value));
|
|
set_has_type();
|
|
type_ = value;
|
|
}
|
|
|
|
// optional .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_->::AuthRequest::Clear();
|
|
clear_has_auth_request();
|
|
}
|
|
inline const ::AuthRequest& ClientMessage::auth_request() const {
|
|
return auth_request_ != NULL ? *auth_request_ : *default_instance_->auth_request_;
|
|
}
|
|
inline ::AuthRequest* ClientMessage::mutable_auth_request() {
|
|
set_has_auth_request();
|
|
if (auth_request_ == NULL) auth_request_ = new ::AuthRequest;
|
|
return auth_request_;
|
|
}
|
|
inline ::AuthRequest* ClientMessage::release_auth_request() {
|
|
clear_has_auth_request();
|
|
::AuthRequest* temp = auth_request_;
|
|
auth_request_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ClientMessage::set_allocated_auth_request(::AuthRequest* auth_request) {
|
|
delete auth_request_;
|
|
auth_request_ = auth_request;
|
|
if (auth_request) {
|
|
set_has_auth_request();
|
|
} else {
|
|
clear_has_auth_request();
|
|
}
|
|
}
|
|
|
|
// optional .CollectionRequest collection_request = 3;
|
|
inline bool ClientMessage::has_collection_request() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void ClientMessage::set_has_collection_request() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void ClientMessage::clear_has_collection_request() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void ClientMessage::clear_collection_request() {
|
|
if (collection_request_ != NULL) collection_request_->::CollectionRequest::Clear();
|
|
clear_has_collection_request();
|
|
}
|
|
inline const ::CollectionRequest& ClientMessage::collection_request() const {
|
|
return collection_request_ != NULL ? *collection_request_ : *default_instance_->collection_request_;
|
|
}
|
|
inline ::CollectionRequest* ClientMessage::mutable_collection_request() {
|
|
set_has_collection_request();
|
|
if (collection_request_ == NULL) collection_request_ = new ::CollectionRequest;
|
|
return collection_request_;
|
|
}
|
|
inline ::CollectionRequest* ClientMessage::release_collection_request() {
|
|
clear_has_collection_request();
|
|
::CollectionRequest* temp = collection_request_;
|
|
collection_request_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ClientMessage::set_allocated_collection_request(::CollectionRequest* collection_request) {
|
|
delete collection_request_;
|
|
collection_request_ = collection_request;
|
|
if (collection_request) {
|
|
set_has_collection_request();
|
|
} else {
|
|
clear_has_collection_request();
|
|
}
|
|
}
|
|
|
|
// optional .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_->::MediaRequest::Clear();
|
|
clear_has_media_request();
|
|
}
|
|
inline const ::MediaRequest& ClientMessage::media_request() const {
|
|
return media_request_ != NULL ? *media_request_ : *default_instance_->media_request_;
|
|
}
|
|
inline ::MediaRequest* ClientMessage::mutable_media_request() {
|
|
set_has_media_request();
|
|
if (media_request_ == NULL) media_request_ = new ::MediaRequest;
|
|
return media_request_;
|
|
}
|
|
inline ::MediaRequest* ClientMessage::release_media_request() {
|
|
clear_has_media_request();
|
|
::MediaRequest* temp = media_request_;
|
|
media_request_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ClientMessage::set_allocated_media_request(::MediaRequest* media_request) {
|
|
delete media_request_;
|
|
media_request_ = media_request;
|
|
if (media_request) {
|
|
set_has_media_request();
|
|
} else {
|
|
clear_has_media_request();
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ServerMessage
|
|
|
|
// required .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 ::ServerMessage_Type ServerMessage::type() const {
|
|
return static_cast< ::ServerMessage_Type >(type_);
|
|
}
|
|
inline void ServerMessage::set_type(::ServerMessage_Type value) {
|
|
assert(::ServerMessage_Type_IsValid(value));
|
|
set_has_type();
|
|
type_ = value;
|
|
}
|
|
|
|
// optional .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_->::AuthResponse::Clear();
|
|
clear_has_auth_response();
|
|
}
|
|
inline const ::AuthResponse& ServerMessage::auth_response() const {
|
|
return auth_response_ != NULL ? *auth_response_ : *default_instance_->auth_response_;
|
|
}
|
|
inline ::AuthResponse* ServerMessage::mutable_auth_response() {
|
|
set_has_auth_response();
|
|
if (auth_response_ == NULL) auth_response_ = new ::AuthResponse;
|
|
return auth_response_;
|
|
}
|
|
inline ::AuthResponse* ServerMessage::release_auth_response() {
|
|
clear_has_auth_response();
|
|
::AuthResponse* temp = auth_response_;
|
|
auth_response_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ServerMessage::set_allocated_auth_response(::AuthResponse* auth_response) {
|
|
delete auth_response_;
|
|
auth_response_ = auth_response;
|
|
if (auth_response) {
|
|
set_has_auth_response();
|
|
} else {
|
|
clear_has_auth_response();
|
|
}
|
|
}
|
|
|
|
// optional .CollectionResponse collection_response = 3;
|
|
inline bool ServerMessage::has_collection_response() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void ServerMessage::set_has_collection_response() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void ServerMessage::clear_has_collection_response() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void ServerMessage::clear_collection_response() {
|
|
if (collection_response_ != NULL) collection_response_->::CollectionResponse::Clear();
|
|
clear_has_collection_response();
|
|
}
|
|
inline const ::CollectionResponse& ServerMessage::collection_response() const {
|
|
return collection_response_ != NULL ? *collection_response_ : *default_instance_->collection_response_;
|
|
}
|
|
inline ::CollectionResponse* ServerMessage::mutable_collection_response() {
|
|
set_has_collection_response();
|
|
if (collection_response_ == NULL) collection_response_ = new ::CollectionResponse;
|
|
return collection_response_;
|
|
}
|
|
inline ::CollectionResponse* ServerMessage::release_collection_response() {
|
|
clear_has_collection_response();
|
|
::CollectionResponse* temp = collection_response_;
|
|
collection_response_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ServerMessage::set_allocated_collection_response(::CollectionResponse* collection_response) {
|
|
delete collection_response_;
|
|
collection_response_ = collection_response;
|
|
if (collection_response) {
|
|
set_has_collection_response();
|
|
} else {
|
|
clear_has_collection_response();
|
|
}
|
|
}
|
|
|
|
// optional .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_->::MediaResponse::Clear();
|
|
clear_has_media_response();
|
|
}
|
|
inline const ::MediaResponse& ServerMessage::media_response() const {
|
|
return media_response_ != NULL ? *media_response_ : *default_instance_->media_response_;
|
|
}
|
|
inline ::MediaResponse* ServerMessage::mutable_media_response() {
|
|
set_has_media_response();
|
|
if (media_response_ == NULL) media_response_ = new ::MediaResponse;
|
|
return media_response_;
|
|
}
|
|
inline ::MediaResponse* ServerMessage::release_media_response() {
|
|
clear_has_media_response();
|
|
::MediaResponse* temp = media_response_;
|
|
media_response_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void ServerMessage::set_allocated_media_response(::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)
|
|
|
|
#ifndef SWIG
|
|
namespace google {
|
|
namespace protobuf {
|
|
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::ClientMessage_Type>() {
|
|
return ::ClientMessage_Type_descriptor();
|
|
}
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::ServerMessage_Type>() {
|
|
return ::ServerMessage_Type_descriptor();
|
|
}
|
|
|
|
} // namespace google
|
|
} // namespace protobuf
|
|
#endif // SWIG
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#endif // PROTOBUF_messages_2eproto__INCLUDED
|