// 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
