wiselib.testing/external_interface/iphone/proto/MarcusProtocol.pb.h

Go to the documentation of this file.

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

#ifndef PROTOBUF_MarcusProtocol_2eproto__INCLUDED
#define PROTOBUF_MarcusProtocol_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2003000
#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 2003000 < 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/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
// @@protoc_insertion_point(includes)

namespace marcusiphone {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_MarcusProtocol_2eproto();
void protobuf_AssignDesc_MarcusProtocol_2eproto();
void protobuf_ShutdownFile_MarcusProtocol_2eproto();

class Envelope;
class LoginMessage;
class StatusMessage;
class RequestMessage;
class DebugMessage;
class ErrorMessage;
class FloorSetup;
class FloorCommand;
class LedColor;
class LedTemperature;

enum Envelope_MessageType {
  Envelope_MessageType_LOGIN = 1,
  Envelope_MessageType_STATUS = 2,
  Envelope_MessageType_REQUEST = 3,
  Envelope_MessageType_COMMAND = 4,
  Envelope_MessageType_DEBUG = 5,
  Envelope_MessageType_ERROR = 6
};
bool Envelope_MessageType_IsValid(int value);
const Envelope_MessageType Envelope_MessageType_MessageType_MIN = Envelope_MessageType_LOGIN;
const Envelope_MessageType Envelope_MessageType_MessageType_MAX = Envelope_MessageType_ERROR;
const int Envelope_MessageType_MessageType_ARRAYSIZE = Envelope_MessageType_MessageType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Envelope_MessageType_descriptor();
inline const ::std::string& Envelope_MessageType_Name(Envelope_MessageType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Envelope_MessageType_descriptor(), value);
}
inline bool Envelope_MessageType_Parse(
    const ::std::string& name, Envelope_MessageType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Envelope_MessageType>(
    Envelope_MessageType_descriptor(), name, value);
}
enum StatusMessage_StatusType {
  StatusMessage_StatusType_LED = 1,
  StatusMessage_StatusType_LEDTEMP = 2,
  StatusMessage_StatusType_FLOORSETUP = 3
};
bool StatusMessage_StatusType_IsValid(int value);
const StatusMessage_StatusType StatusMessage_StatusType_StatusType_MIN = StatusMessage_StatusType_LED;
const StatusMessage_StatusType StatusMessage_StatusType_StatusType_MAX = StatusMessage_StatusType_FLOORSETUP;
const int StatusMessage_StatusType_StatusType_ARRAYSIZE = StatusMessage_StatusType_StatusType_MAX + 1;

const ::google::protobuf::EnumDescriptor* StatusMessage_StatusType_descriptor();
inline const ::std::string& StatusMessage_StatusType_Name(StatusMessage_StatusType value) {
  return ::google::protobuf::internal::NameOfEnum(
    StatusMessage_StatusType_descriptor(), value);
}
inline bool StatusMessage_StatusType_Parse(
    const ::std::string& name, StatusMessage_StatusType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<StatusMessage_StatusType>(
    StatusMessage_StatusType_descriptor(), name, value);
}
enum RequestMessage_RequestType {
  RequestMessage_RequestType_FLOORSETUP = 1
};
bool RequestMessage_RequestType_IsValid(int value);
const RequestMessage_RequestType RequestMessage_RequestType_RequestType_MIN = RequestMessage_RequestType_FLOORSETUP;
const RequestMessage_RequestType RequestMessage_RequestType_RequestType_MAX = RequestMessage_RequestType_FLOORSETUP;
const int RequestMessage_RequestType_RequestType_ARRAYSIZE = RequestMessage_RequestType_RequestType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RequestMessage_RequestType_descriptor();
inline const ::std::string& RequestMessage_RequestType_Name(RequestMessage_RequestType value) {
  return ::google::protobuf::internal::NameOfEnum(
    RequestMessage_RequestType_descriptor(), value);
}
inline bool RequestMessage_RequestType_Parse(
    const ::std::string& name, RequestMessage_RequestType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RequestMessage_RequestType>(
    RequestMessage_RequestType_descriptor(), name, value);
}
enum FloorCommand_CommandType {
  FloorCommand_CommandType_REBOOT = 1,
  FloorCommand_CommandType_LED = 2
};
bool FloorCommand_CommandType_IsValid(int value);
const FloorCommand_CommandType FloorCommand_CommandType_CommandType_MIN = FloorCommand_CommandType_REBOOT;
const FloorCommand_CommandType FloorCommand_CommandType_CommandType_MAX = FloorCommand_CommandType_LED;
const int FloorCommand_CommandType_CommandType_ARRAYSIZE = FloorCommand_CommandType_CommandType_MAX + 1;

const ::google::protobuf::EnumDescriptor* FloorCommand_CommandType_descriptor();
inline const ::std::string& FloorCommand_CommandType_Name(FloorCommand_CommandType value) {
  return ::google::protobuf::internal::NameOfEnum(
    FloorCommand_CommandType_descriptor(), value);
}
inline bool FloorCommand_CommandType_Parse(
    const ::std::string& name, FloorCommand_CommandType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<FloorCommand_CommandType>(
    FloorCommand_CommandType_descriptor(), name, value);
}
// ===================================================================

class Envelope : public ::google::protobuf::Message {
 public:
  Envelope();
  virtual ~Envelope();
  
  Envelope(const Envelope& from);
  
  inline Envelope& operator=(const Envelope& 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 Envelope& default_instance();
  
  void Swap(Envelope* other);
  
  // implements Message ----------------------------------------------
  
  Envelope* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Envelope& from);
  void MergeFrom(const Envelope& 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 Envelope_MessageType MessageType;
  static const MessageType LOGIN = Envelope_MessageType_LOGIN;
  static const MessageType STATUS = Envelope_MessageType_STATUS;
  static const MessageType REQUEST = Envelope_MessageType_REQUEST;
  static const MessageType COMMAND = Envelope_MessageType_COMMAND;
  static const MessageType DEBUG = Envelope_MessageType_DEBUG;
  static const MessageType ERROR = Envelope_MessageType_ERROR;
  static inline bool MessageType_IsValid(int value) {
    return Envelope_MessageType_IsValid(value);
  }
  static const MessageType MessageType_MIN =
    Envelope_MessageType_MessageType_MIN;
  static const MessageType MessageType_MAX =
    Envelope_MessageType_MessageType_MAX;
  static const int MessageType_ARRAYSIZE =
    Envelope_MessageType_MessageType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  MessageType_descriptor() {
    return Envelope_MessageType_descriptor();
  }
  static inline const ::std::string& MessageType_Name(MessageType value) {
    return Envelope_MessageType_Name(value);
  }
  static inline bool MessageType_Parse(const ::std::string& name,
      MessageType* value) {
    return Envelope_MessageType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .marcusiphone.Envelope.MessageType messageType = 1;
  inline bool has_messagetype() const;
  inline void clear_messagetype();
  static const int kMessageTypeFieldNumber = 1;
  inline ::marcusiphone::Envelope_MessageType messagetype() const;
  inline void set_messagetype(::marcusiphone::Envelope_MessageType value);
  
  // optional string source = 2;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 2;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  
  // optional string destination = 3;
  inline bool has_destination() const;
  inline void clear_destination();
  static const int kDestinationFieldNumber = 3;
  inline const ::std::string& destination() const;
  inline void set_destination(const ::std::string& value);
  inline void set_destination(const char* value);
  inline void set_destination(const char* value, size_t size);
  inline ::std::string* mutable_destination();
  
  // optional .marcusiphone.LoginMessage loginMessage = 4;
  inline bool has_loginmessage() const;
  inline void clear_loginmessage();
  static const int kLoginMessageFieldNumber = 4;
  inline const ::marcusiphone::LoginMessage& loginmessage() const;
  inline ::marcusiphone::LoginMessage* mutable_loginmessage();
  
  // optional .marcusiphone.StatusMessage statusMessage = 5;
  inline bool has_statusmessage() const;
  inline void clear_statusmessage();
  static const int kStatusMessageFieldNumber = 5;
  inline const ::marcusiphone::StatusMessage& statusmessage() const;
  inline ::marcusiphone::StatusMessage* mutable_statusmessage();
  
  // optional .marcusiphone.ErrorMessage errorMessage = 6;
  inline bool has_errormessage() const;
  inline void clear_errormessage();
  static const int kErrorMessageFieldNumber = 6;
  inline const ::marcusiphone::ErrorMessage& errormessage() const;
  inline ::marcusiphone::ErrorMessage* mutable_errormessage();
  
  // optional .marcusiphone.DebugMessage debugMessage = 7;
  inline bool has_debugmessage() const;
  inline void clear_debugmessage();
  static const int kDebugMessageFieldNumber = 7;
  inline const ::marcusiphone::DebugMessage& debugmessage() const;
  inline ::marcusiphone::DebugMessage* mutable_debugmessage();
  
  // optional .marcusiphone.FloorCommand floorCommand = 8;
  inline bool has_floorcommand() const;
  inline void clear_floorcommand();
  static const int kFloorCommandFieldNumber = 8;
  inline const ::marcusiphone::FloorCommand& floorcommand() const;
  inline ::marcusiphone::FloorCommand* mutable_floorcommand();
  
  // optional .marcusiphone.RequestMessage requestMessage = 9;
  inline bool has_requestmessage() const;
  inline void clear_requestmessage();
  static const int kRequestMessageFieldNumber = 9;
  inline const ::marcusiphone::RequestMessage& requestmessage() const;
  inline ::marcusiphone::RequestMessage* mutable_requestmessage();
  
  // @@protoc_insertion_point(class_scope:marcusiphone.Envelope)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int messagetype_;
  ::std::string* source_;
  static const ::std::string _default_source_;
  ::std::string* destination_;
  static const ::std::string _default_destination_;
  ::marcusiphone::LoginMessage* loginmessage_;
  ::marcusiphone::StatusMessage* statusmessage_;
  ::marcusiphone::ErrorMessage* errormessage_;
  ::marcusiphone::DebugMessage* debugmessage_;
  ::marcusiphone::FloorCommand* floorcommand_;
  ::marcusiphone::RequestMessage* requestmessage_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Envelope* default_instance_;
};
// -------------------------------------------------------------------

class LoginMessage : public ::google::protobuf::Message {
 public:
  LoginMessage();
  virtual ~LoginMessage();
  
  LoginMessage(const LoginMessage& from);
  
  inline LoginMessage& operator=(const LoginMessage& 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 LoginMessage& default_instance();
  
  void Swap(LoginMessage* other);
  
  // implements Message ----------------------------------------------
  
  LoginMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LoginMessage& from);
  void MergeFrom(const LoginMessage& 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 ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool login = 1;
  inline bool has_login() const;
  inline void clear_login();
  static const int kLoginFieldNumber = 1;
  inline bool login() const;
  inline void set_login(bool value);
  
  // optional string user = 2;
  inline bool has_user() const;
  inline void clear_user();
  static const int kUserFieldNumber = 2;
  inline const ::std::string& user() const;
  inline void set_user(const ::std::string& value);
  inline void set_user(const char* value);
  inline void set_user(const char* value, size_t size);
  inline ::std::string* mutable_user();
  
  // optional string pwd = 3;
  inline bool has_pwd() const;
  inline void clear_pwd();
  static const int kPwdFieldNumber = 3;
  inline const ::std::string& pwd() const;
  inline void set_pwd(const ::std::string& value);
  inline void set_pwd(const char* value);
  inline void set_pwd(const char* value, size_t size);
  inline ::std::string* mutable_pwd();
  
  // @@protoc_insertion_point(class_scope:marcusiphone.LoginMessage)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool login_;
  ::std::string* user_;
  static const ::std::string _default_user_;
  ::std::string* pwd_;
  static const ::std::string _default_pwd_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static LoginMessage* default_instance_;
};
// -------------------------------------------------------------------

class StatusMessage : public ::google::protobuf::Message {
 public:
  StatusMessage();
  virtual ~StatusMessage();
  
  StatusMessage(const StatusMessage& from);
  
  inline StatusMessage& operator=(const StatusMessage& 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 StatusMessage& default_instance();
  
  void Swap(StatusMessage* other);
  
  // implements Message ----------------------------------------------
  
  StatusMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StatusMessage& from);
  void MergeFrom(const StatusMessage& 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 StatusMessage_StatusType StatusType;
  static const StatusType LED = StatusMessage_StatusType_LED;
  static const StatusType LEDTEMP = StatusMessage_StatusType_LEDTEMP;
  static const StatusType FLOORSETUP = StatusMessage_StatusType_FLOORSETUP;
  static inline bool StatusType_IsValid(int value) {
    return StatusMessage_StatusType_IsValid(value);
  }
  static const StatusType StatusType_MIN =
    StatusMessage_StatusType_StatusType_MIN;
  static const StatusType StatusType_MAX =
    StatusMessage_StatusType_StatusType_MAX;
  static const int StatusType_ARRAYSIZE =
    StatusMessage_StatusType_StatusType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  StatusType_descriptor() {
    return StatusMessage_StatusType_descriptor();
  }
  static inline const ::std::string& StatusType_Name(StatusType value) {
    return StatusMessage_StatusType_Name(value);
  }
  static inline bool StatusType_Parse(const ::std::string& name,
      StatusType* value) {
    return StatusMessage_StatusType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .marcusiphone.StatusMessage.StatusType statusType = 1;
  inline bool has_statustype() const;
  inline void clear_statustype();
  static const int kStatusTypeFieldNumber = 1;
  inline ::marcusiphone::StatusMessage_StatusType statustype() const;
  inline void set_statustype(::marcusiphone::StatusMessage_StatusType value);
  
  // repeated .marcusiphone.LedColor ledColors = 2;
  inline int ledcolors_size() const;
  inline void clear_ledcolors();
  static const int kLedColorsFieldNumber = 2;
  inline const ::marcusiphone::LedColor& ledcolors(int index) const;
  inline ::marcusiphone::LedColor* mutable_ledcolors(int index);
  inline ::marcusiphone::LedColor* add_ledcolors();
  inline const ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >&
      ledcolors() const;
  inline ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >*
      mutable_ledcolors();
  
  // repeated .marcusiphone.LedTemperature ledTemps = 3;
  inline int ledtemps_size() const;
  inline void clear_ledtemps();
  static const int kLedTempsFieldNumber = 3;
  inline const ::marcusiphone::LedTemperature& ledtemps(int index) const;
  inline ::marcusiphone::LedTemperature* mutable_ledtemps(int index);
  inline ::marcusiphone::LedTemperature* add_ledtemps();
  inline const ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedTemperature >&
      ledtemps() const;
  inline ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedTemperature >*
      mutable_ledtemps();
  
  // optional .marcusiphone.FloorSetup floorSetup = 4;
  inline bool has_floorsetup() const;
  inline void clear_floorsetup();
  static const int kFloorSetupFieldNumber = 4;
  inline const ::marcusiphone::FloorSetup& floorsetup() const;
  inline ::marcusiphone::FloorSetup* mutable_floorsetup();
  
  // @@protoc_insertion_point(class_scope:marcusiphone.StatusMessage)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int statustype_;
  ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor > ledcolors_;
  ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedTemperature > ledtemps_;
  ::marcusiphone::FloorSetup* floorsetup_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static StatusMessage* default_instance_;
};
// -------------------------------------------------------------------

class RequestMessage : public ::google::protobuf::Message {
 public:
  RequestMessage();
  virtual ~RequestMessage();
  
  RequestMessage(const RequestMessage& from);
  
  inline RequestMessage& operator=(const RequestMessage& 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 RequestMessage& default_instance();
  
  void Swap(RequestMessage* other);
  
  // implements Message ----------------------------------------------
  
  RequestMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestMessage& from);
  void MergeFrom(const RequestMessage& 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 RequestMessage_RequestType RequestType;
  static const RequestType FLOORSETUP = RequestMessage_RequestType_FLOORSETUP;
  static inline bool RequestType_IsValid(int value) {
    return RequestMessage_RequestType_IsValid(value);
  }
  static const RequestType RequestType_MIN =
    RequestMessage_RequestType_RequestType_MIN;
  static const RequestType RequestType_MAX =
    RequestMessage_RequestType_RequestType_MAX;
  static const int RequestType_ARRAYSIZE =
    RequestMessage_RequestType_RequestType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  RequestType_descriptor() {
    return RequestMessage_RequestType_descriptor();
  }
  static inline const ::std::string& RequestType_Name(RequestType value) {
    return RequestMessage_RequestType_Name(value);
  }
  static inline bool RequestType_Parse(const ::std::string& name,
      RequestType* value) {
    return RequestMessage_RequestType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .marcusiphone.RequestMessage.RequestType requestType = 1;
  inline bool has_requesttype() const;
  inline void clear_requesttype();
  static const int kRequestTypeFieldNumber = 1;
  inline ::marcusiphone::RequestMessage_RequestType requesttype() const;
  inline void set_requesttype(::marcusiphone::RequestMessage_RequestType value);
  
  // @@protoc_insertion_point(class_scope:marcusiphone.RequestMessage)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int requesttype_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RequestMessage* default_instance_;
};
// -------------------------------------------------------------------

class DebugMessage : public ::google::protobuf::Message {
 public:
  DebugMessage();
  virtual ~DebugMessage();
  
  DebugMessage(const DebugMessage& from);
  
  inline DebugMessage& operator=(const DebugMessage& 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 DebugMessage& default_instance();
  
  void Swap(DebugMessage* other);
  
  // implements Message ----------------------------------------------
  
  DebugMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DebugMessage& from);
  void MergeFrom(const DebugMessage& 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 ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string debugMsg = 1;
  inline bool has_debugmsg() const;
  inline void clear_debugmsg();
  static const int kDebugMsgFieldNumber = 1;
  inline const ::std::string& debugmsg() const;
  inline void set_debugmsg(const ::std::string& value);
  inline void set_debugmsg(const char* value);
  inline void set_debugmsg(const char* value, size_t size);
  inline ::std::string* mutable_debugmsg();
  
  // @@protoc_insertion_point(class_scope:marcusiphone.DebugMessage)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* debugmsg_;
  static const ::std::string _default_debugmsg_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DebugMessage* default_instance_;
};
// -------------------------------------------------------------------

class ErrorMessage : public ::google::protobuf::Message {
 public:
  ErrorMessage();
  virtual ~ErrorMessage();
  
  ErrorMessage(const ErrorMessage& from);
  
  inline ErrorMessage& operator=(const ErrorMessage& 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 ErrorMessage& default_instance();
  
  void Swap(ErrorMessage* other);
  
  // implements Message ----------------------------------------------
  
  ErrorMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ErrorMessage& from);
  void MergeFrom(const ErrorMessage& 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 ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 errorId = 1;
  inline bool has_errorid() const;
  inline void clear_errorid();
  static const int kErrorIdFieldNumber = 1;
  inline ::google::protobuf::uint32 errorid() const;
  inline void set_errorid(::google::protobuf::uint32 value);
  
  // required string errorMsg = 2;
  inline bool has_errormsg() const;
  inline void clear_errormsg();
  static const int kErrorMsgFieldNumber = 2;
  inline const ::std::string& errormsg() const;
  inline void set_errormsg(const ::std::string& value);
  inline void set_errormsg(const char* value);
  inline void set_errormsg(const char* value, size_t size);
  inline ::std::string* mutable_errormsg();
  
  // @@protoc_insertion_point(class_scope:marcusiphone.ErrorMessage)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 errorid_;
  ::std::string* errormsg_;
  static const ::std::string _default_errormsg_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static ErrorMessage* default_instance_;
};
// -------------------------------------------------------------------

class FloorSetup : public ::google::protobuf::Message {
 public:
  FloorSetup();
  virtual ~FloorSetup();
  
  FloorSetup(const FloorSetup& from);
  
  inline FloorSetup& operator=(const FloorSetup& 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 FloorSetup& default_instance();
  
  void Swap(FloorSetup* other);
  
  // implements Message ----------------------------------------------
  
  FloorSetup* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FloorSetup& from);
  void MergeFrom(const FloorSetup& 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 ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 floorWidth = 1;
  inline bool has_floorwidth() const;
  inline void clear_floorwidth();
  static const int kFloorWidthFieldNumber = 1;
  inline ::google::protobuf::uint32 floorwidth() const;
  inline void set_floorwidth(::google::protobuf::uint32 value);
  
  // optional uint32 floorHeight = 2;
  inline bool has_floorheight() const;
  inline void clear_floorheight();
  static const int kFloorHeightFieldNumber = 2;
  inline ::google::protobuf::uint32 floorheight() const;
  inline void set_floorheight(::google::protobuf::uint32 value);
  
  // optional uint32 dmsCount = 3;
  inline bool has_dmscount() const;
  inline void clear_dmscount();
  static const int kDmsCountFieldNumber = 3;
  inline ::google::protobuf::uint32 dmscount() const;
  inline void set_dmscount(::google::protobuf::uint32 value);
  
  // optional uint32 ledCount = 4;
  inline bool has_ledcount() const;
  inline void clear_ledcount();
  static const int kLedCountFieldNumber = 4;
  inline ::google::protobuf::uint32 ledcount() const;
  inline void set_ledcount(::google::protobuf::uint32 value);
  
  // optional uint32 pirCount = 5;
  inline bool has_pircount() const;
  inline void clear_pircount();
  static const int kPirCountFieldNumber = 5;
  inline ::google::protobuf::uint32 pircount() const;
  inline void set_pircount(::google::protobuf::uint32 value);
  
  // optional uint32 speakerCount = 6;
  inline bool has_speakercount() const;
  inline void clear_speakercount();
  static const int kSpeakerCountFieldNumber = 6;
  inline ::google::protobuf::uint32 speakercount() const;
  inline void set_speakercount(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:marcusiphone.FloorSetup)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 floorwidth_;
  ::google::protobuf::uint32 floorheight_;
  ::google::protobuf::uint32 dmscount_;
  ::google::protobuf::uint32 ledcount_;
  ::google::protobuf::uint32 pircount_;
  ::google::protobuf::uint32 speakercount_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static FloorSetup* default_instance_;
};
// -------------------------------------------------------------------

class FloorCommand : public ::google::protobuf::Message {
 public:
  FloorCommand();
  virtual ~FloorCommand();
  
  FloorCommand(const FloorCommand& from);
  
  inline FloorCommand& operator=(const FloorCommand& 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 FloorCommand& default_instance();
  
  void Swap(FloorCommand* other);
  
  // implements Message ----------------------------------------------
  
  FloorCommand* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FloorCommand& from);
  void MergeFrom(const FloorCommand& 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 FloorCommand_CommandType CommandType;
  static const CommandType REBOOT = FloorCommand_CommandType_REBOOT;
  static const CommandType LED = FloorCommand_CommandType_LED;
  static inline bool CommandType_IsValid(int value) {
    return FloorCommand_CommandType_IsValid(value);
  }
  static const CommandType CommandType_MIN =
    FloorCommand_CommandType_CommandType_MIN;
  static const CommandType CommandType_MAX =
    FloorCommand_CommandType_CommandType_MAX;
  static const int CommandType_ARRAYSIZE =
    FloorCommand_CommandType_CommandType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  CommandType_descriptor() {
    return FloorCommand_CommandType_descriptor();
  }
  static inline const ::std::string& CommandType_Name(CommandType value) {
    return FloorCommand_CommandType_Name(value);
  }
  static inline bool CommandType_Parse(const ::std::string& name,
      CommandType* value) {
    return FloorCommand_CommandType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .marcusiphone.FloorCommand.CommandType commandType = 1;
  inline bool has_commandtype() const;
  inline void clear_commandtype();
  static const int kCommandTypeFieldNumber = 1;
  inline ::marcusiphone::FloorCommand_CommandType commandtype() const;
  inline void set_commandtype(::marcusiphone::FloorCommand_CommandType value);
  
  // repeated .marcusiphone.LedColor ledColors = 2;
  inline int ledcolors_size() const;
  inline void clear_ledcolors();
  static const int kLedColorsFieldNumber = 2;
  inline const ::marcusiphone::LedColor& ledcolors(int index) const;
  inline ::marcusiphone::LedColor* mutable_ledcolors(int index);
  inline ::marcusiphone::LedColor* add_ledcolors();
  inline const ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >&
      ledcolors() const;
  inline ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >*
      mutable_ledcolors();
  
  // @@protoc_insertion_point(class_scope:marcusiphone.FloorCommand)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int commandtype_;
  ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor > ledcolors_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static FloorCommand* default_instance_;
};
// -------------------------------------------------------------------

class LedColor : public ::google::protobuf::Message {
 public:
  LedColor();
  virtual ~LedColor();
  
  LedColor(const LedColor& from);
  
  inline LedColor& operator=(const LedColor& 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 LedColor& default_instance();
  
  void Swap(LedColor* other);
  
  // implements Message ----------------------------------------------
  
  LedColor* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LedColor& from);
  void MergeFrom(const LedColor& 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 ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline ::google::protobuf::uint32 id() const;
  inline void set_id(::google::protobuf::uint32 value);
  
  // required uint32 red = 2;
  inline bool has_red() const;
  inline void clear_red();
  static const int kRedFieldNumber = 2;
  inline ::google::protobuf::uint32 red() const;
  inline void set_red(::google::protobuf::uint32 value);
  
  // required uint32 green = 3;
  inline bool has_green() const;
  inline void clear_green();
  static const int kGreenFieldNumber = 3;
  inline ::google::protobuf::uint32 green() const;
  inline void set_green(::google::protobuf::uint32 value);
  
  // required uint32 blue = 4;
  inline bool has_blue() const;
  inline void clear_blue();
  static const int kBlueFieldNumber = 4;
  inline ::google::protobuf::uint32 blue() const;
  inline void set_blue(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:marcusiphone.LedColor)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 id_;
  ::google::protobuf::uint32 red_;
  ::google::protobuf::uint32 green_;
  ::google::protobuf::uint32 blue_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static LedColor* default_instance_;
};
// -------------------------------------------------------------------

class LedTemperature : public ::google::protobuf::Message {
 public:
  LedTemperature();
  virtual ~LedTemperature();
  
  LedTemperature(const LedTemperature& from);
  
  inline LedTemperature& operator=(const LedTemperature& 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 LedTemperature& default_instance();
  
  void Swap(LedTemperature* other);
  
  // implements Message ----------------------------------------------
  
  LedTemperature* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LedTemperature& from);
  void MergeFrom(const LedTemperature& 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 ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline ::google::protobuf::uint32 id() const;
  inline void set_id(::google::protobuf::uint32 value);
  
  // required uint32 temperature = 2;
  inline bool has_temperature() const;
  inline void clear_temperature();
  static const int kTemperatureFieldNumber = 2;
  inline ::google::protobuf::uint32 temperature() const;
  inline void set_temperature(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:marcusiphone.LedTemperature)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 id_;
  ::google::protobuf::uint32 temperature_;
  friend void  protobuf_AddDesc_MarcusProtocol_2eproto();
  friend void protobuf_AssignDesc_MarcusProtocol_2eproto();
  friend void protobuf_ShutdownFile_MarcusProtocol_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static LedTemperature* default_instance_;
};
// ===================================================================


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

// Envelope

// required .marcusiphone.Envelope.MessageType messageType = 1;
inline bool Envelope::has_messagetype() const {
  return _has_bit(0);
}
inline void Envelope::clear_messagetype() {
  messagetype_ = 1;
  _clear_bit(0);
}
inline ::marcusiphone::Envelope_MessageType Envelope::messagetype() const {
  return static_cast< ::marcusiphone::Envelope_MessageType >(messagetype_);
}
inline void Envelope::set_messagetype(::marcusiphone::Envelope_MessageType value) {
  GOOGLE_DCHECK(::marcusiphone::Envelope_MessageType_IsValid(value));
  _set_bit(0);
  messagetype_ = value;
}

// optional string source = 2;
inline bool Envelope::has_source() const {
  return _has_bit(1);
}
inline void Envelope::clear_source() {
  if (source_ != &_default_source_) {
    source_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Envelope::source() const {
  return *source_;
}
inline void Envelope::set_source(const ::std::string& value) {
  _set_bit(1);
  if (source_ == &_default_source_) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void Envelope::set_source(const char* value) {
  _set_bit(1);
  if (source_ == &_default_source_) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void Envelope::set_source(const char* value, size_t size) {
  _set_bit(1);
  if (source_ == &_default_source_) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Envelope::mutable_source() {
  _set_bit(1);
  if (source_ == &_default_source_) {
    source_ = new ::std::string;
  }
  return source_;
}

// optional string destination = 3;
inline bool Envelope::has_destination() const {
  return _has_bit(2);
}
inline void Envelope::clear_destination() {
  if (destination_ != &_default_destination_) {
    destination_->clear();
  }
  _clear_bit(2);
}
inline const ::std::string& Envelope::destination() const {
  return *destination_;
}
inline void Envelope::set_destination(const ::std::string& value) {
  _set_bit(2);
  if (destination_ == &_default_destination_) {
    destination_ = new ::std::string;
  }
  destination_->assign(value);
}
inline void Envelope::set_destination(const char* value) {
  _set_bit(2);
  if (destination_ == &_default_destination_) {
    destination_ = new ::std::string;
  }
  destination_->assign(value);
}
inline void Envelope::set_destination(const char* value, size_t size) {
  _set_bit(2);
  if (destination_ == &_default_destination_) {
    destination_ = new ::std::string;
  }
  destination_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Envelope::mutable_destination() {
  _set_bit(2);
  if (destination_ == &_default_destination_) {
    destination_ = new ::std::string;
  }
  return destination_;
}

// optional .marcusiphone.LoginMessage loginMessage = 4;
inline bool Envelope::has_loginmessage() const {
  return _has_bit(3);
}
inline void Envelope::clear_loginmessage() {
  if (loginmessage_ != NULL) loginmessage_->::marcusiphone::LoginMessage::Clear();
  _clear_bit(3);
}
inline const ::marcusiphone::LoginMessage& Envelope::loginmessage() const {
  return loginmessage_ != NULL ? *loginmessage_ : *default_instance_->loginmessage_;
}
inline ::marcusiphone::LoginMessage* Envelope::mutable_loginmessage() {
  _set_bit(3);
  if (loginmessage_ == NULL) loginmessage_ = new ::marcusiphone::LoginMessage;
  return loginmessage_;
}

// optional .marcusiphone.StatusMessage statusMessage = 5;
inline bool Envelope::has_statusmessage() const {
  return _has_bit(4);
}
inline void Envelope::clear_statusmessage() {
  if (statusmessage_ != NULL) statusmessage_->::marcusiphone::StatusMessage::Clear();
  _clear_bit(4);
}
inline const ::marcusiphone::StatusMessage& Envelope::statusmessage() const {
  return statusmessage_ != NULL ? *statusmessage_ : *default_instance_->statusmessage_;
}
inline ::marcusiphone::StatusMessage* Envelope::mutable_statusmessage() {
  _set_bit(4);
  if (statusmessage_ == NULL) statusmessage_ = new ::marcusiphone::StatusMessage;
  return statusmessage_;
}

// optional .marcusiphone.ErrorMessage errorMessage = 6;
inline bool Envelope::has_errormessage() const {
  return _has_bit(5);
}
inline void Envelope::clear_errormessage() {
  if (errormessage_ != NULL) errormessage_->::marcusiphone::ErrorMessage::Clear();
  _clear_bit(5);
}
inline const ::marcusiphone::ErrorMessage& Envelope::errormessage() const {
  return errormessage_ != NULL ? *errormessage_ : *default_instance_->errormessage_;
}
inline ::marcusiphone::ErrorMessage* Envelope::mutable_errormessage() {
  _set_bit(5);
  if (errormessage_ == NULL) errormessage_ = new ::marcusiphone::ErrorMessage;
  return errormessage_;
}

// optional .marcusiphone.DebugMessage debugMessage = 7;
inline bool Envelope::has_debugmessage() const {
  return _has_bit(6);
}
inline void Envelope::clear_debugmessage() {
  if (debugmessage_ != NULL) debugmessage_->::marcusiphone::DebugMessage::Clear();
  _clear_bit(6);
}
inline const ::marcusiphone::DebugMessage& Envelope::debugmessage() const {
  return debugmessage_ != NULL ? *debugmessage_ : *default_instance_->debugmessage_;
}
inline ::marcusiphone::DebugMessage* Envelope::mutable_debugmessage() {
  _set_bit(6);
  if (debugmessage_ == NULL) debugmessage_ = new ::marcusiphone::DebugMessage;
  return debugmessage_;
}

// optional .marcusiphone.FloorCommand floorCommand = 8;
inline bool Envelope::has_floorcommand() const {
  return _has_bit(7);
}
inline void Envelope::clear_floorcommand() {
  if (floorcommand_ != NULL) floorcommand_->::marcusiphone::FloorCommand::Clear();
  _clear_bit(7);
}
inline const ::marcusiphone::FloorCommand& Envelope::floorcommand() const {
  return floorcommand_ != NULL ? *floorcommand_ : *default_instance_->floorcommand_;
}
inline ::marcusiphone::FloorCommand* Envelope::mutable_floorcommand() {
  _set_bit(7);
  if (floorcommand_ == NULL) floorcommand_ = new ::marcusiphone::FloorCommand;
  return floorcommand_;
}

// optional .marcusiphone.RequestMessage requestMessage = 9;
inline bool Envelope::has_requestmessage() const {
  return _has_bit(8);
}
inline void Envelope::clear_requestmessage() {
  if (requestmessage_ != NULL) requestmessage_->::marcusiphone::RequestMessage::Clear();
  _clear_bit(8);
}
inline const ::marcusiphone::RequestMessage& Envelope::requestmessage() const {
  return requestmessage_ != NULL ? *requestmessage_ : *default_instance_->requestmessage_;
}
inline ::marcusiphone::RequestMessage* Envelope::mutable_requestmessage() {
  _set_bit(8);
  if (requestmessage_ == NULL) requestmessage_ = new ::marcusiphone::RequestMessage;
  return requestmessage_;
}

// -------------------------------------------------------------------

// LoginMessage

// optional bool login = 1;
inline bool LoginMessage::has_login() const {
  return _has_bit(0);
}
inline void LoginMessage::clear_login() {
  login_ = false;
  _clear_bit(0);
}
inline bool LoginMessage::login() const {
  return login_;
}
inline void LoginMessage::set_login(bool value) {
  _set_bit(0);
  login_ = value;
}

// optional string user = 2;
inline bool LoginMessage::has_user() const {
  return _has_bit(1);
}
inline void LoginMessage::clear_user() {
  if (user_ != &_default_user_) {
    user_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& LoginMessage::user() const {
  return *user_;
}
inline void LoginMessage::set_user(const ::std::string& value) {
  _set_bit(1);
  if (user_ == &_default_user_) {
    user_ = new ::std::string;
  }
  user_->assign(value);
}
inline void LoginMessage::set_user(const char* value) {
  _set_bit(1);
  if (user_ == &_default_user_) {
    user_ = new ::std::string;
  }
  user_->assign(value);
}
inline void LoginMessage::set_user(const char* value, size_t size) {
  _set_bit(1);
  if (user_ == &_default_user_) {
    user_ = new ::std::string;
  }
  user_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LoginMessage::mutable_user() {
  _set_bit(1);
  if (user_ == &_default_user_) {
    user_ = new ::std::string;
  }
  return user_;
}

// optional string pwd = 3;
inline bool LoginMessage::has_pwd() const {
  return _has_bit(2);
}
inline void LoginMessage::clear_pwd() {
  if (pwd_ != &_default_pwd_) {
    pwd_->clear();
  }
  _clear_bit(2);
}
inline const ::std::string& LoginMessage::pwd() const {
  return *pwd_;
}
inline void LoginMessage::set_pwd(const ::std::string& value) {
  _set_bit(2);
  if (pwd_ == &_default_pwd_) {
    pwd_ = new ::std::string;
  }
  pwd_->assign(value);
}
inline void LoginMessage::set_pwd(const char* value) {
  _set_bit(2);
  if (pwd_ == &_default_pwd_) {
    pwd_ = new ::std::string;
  }
  pwd_->assign(value);
}
inline void LoginMessage::set_pwd(const char* value, size_t size) {
  _set_bit(2);
  if (pwd_ == &_default_pwd_) {
    pwd_ = new ::std::string;
  }
  pwd_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LoginMessage::mutable_pwd() {
  _set_bit(2);
  if (pwd_ == &_default_pwd_) {
    pwd_ = new ::std::string;
  }
  return pwd_;
}

// -------------------------------------------------------------------

// StatusMessage

// required .marcusiphone.StatusMessage.StatusType statusType = 1;
inline bool StatusMessage::has_statustype() const {
  return _has_bit(0);
}
inline void StatusMessage::clear_statustype() {
  statustype_ = 1;
  _clear_bit(0);
}
inline ::marcusiphone::StatusMessage_StatusType StatusMessage::statustype() const {
  return static_cast< ::marcusiphone::StatusMessage_StatusType >(statustype_);
}
inline void StatusMessage::set_statustype(::marcusiphone::StatusMessage_StatusType value) {
  GOOGLE_DCHECK(::marcusiphone::StatusMessage_StatusType_IsValid(value));
  _set_bit(0);
  statustype_ = value;
}

// repeated .marcusiphone.LedColor ledColors = 2;
inline int StatusMessage::ledcolors_size() const {
  return ledcolors_.size();
}
inline void StatusMessage::clear_ledcolors() {
  ledcolors_.Clear();
}
inline const ::marcusiphone::LedColor& StatusMessage::ledcolors(int index) const {
  return ledcolors_.Get(index);
}
inline ::marcusiphone::LedColor* StatusMessage::mutable_ledcolors(int index) {
  return ledcolors_.Mutable(index);
}
inline ::marcusiphone::LedColor* StatusMessage::add_ledcolors() {
  return ledcolors_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >&
StatusMessage::ledcolors() const {
  return ledcolors_;
}
inline ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >*
StatusMessage::mutable_ledcolors() {
  return &ledcolors_;
}

// repeated .marcusiphone.LedTemperature ledTemps = 3;
inline int StatusMessage::ledtemps_size() const {
  return ledtemps_.size();
}
inline void StatusMessage::clear_ledtemps() {
  ledtemps_.Clear();
}
inline const ::marcusiphone::LedTemperature& StatusMessage::ledtemps(int index) const {
  return ledtemps_.Get(index);
}
inline ::marcusiphone::LedTemperature* StatusMessage::mutable_ledtemps(int index) {
  return ledtemps_.Mutable(index);
}
inline ::marcusiphone::LedTemperature* StatusMessage::add_ledtemps() {
  return ledtemps_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedTemperature >&
StatusMessage::ledtemps() const {
  return ledtemps_;
}
inline ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedTemperature >*
StatusMessage::mutable_ledtemps() {
  return &ledtemps_;
}

// optional .marcusiphone.FloorSetup floorSetup = 4;
inline bool StatusMessage::has_floorsetup() const {
  return _has_bit(3);
}
inline void StatusMessage::clear_floorsetup() {
  if (floorsetup_ != NULL) floorsetup_->::marcusiphone::FloorSetup::Clear();
  _clear_bit(3);
}
inline const ::marcusiphone::FloorSetup& StatusMessage::floorsetup() const {
  return floorsetup_ != NULL ? *floorsetup_ : *default_instance_->floorsetup_;
}
inline ::marcusiphone::FloorSetup* StatusMessage::mutable_floorsetup() {
  _set_bit(3);
  if (floorsetup_ == NULL) floorsetup_ = new ::marcusiphone::FloorSetup;
  return floorsetup_;
}

// -------------------------------------------------------------------

// RequestMessage

// required .marcusiphone.RequestMessage.RequestType requestType = 1;
inline bool RequestMessage::has_requesttype() const {
  return _has_bit(0);
}
inline void RequestMessage::clear_requesttype() {
  requesttype_ = 1;
  _clear_bit(0);
}
inline ::marcusiphone::RequestMessage_RequestType RequestMessage::requesttype() const {
  return static_cast< ::marcusiphone::RequestMessage_RequestType >(requesttype_);
}
inline void RequestMessage::set_requesttype(::marcusiphone::RequestMessage_RequestType value) {
  GOOGLE_DCHECK(::marcusiphone::RequestMessage_RequestType_IsValid(value));
  _set_bit(0);
  requesttype_ = value;
}

// -------------------------------------------------------------------

// DebugMessage

// required string debugMsg = 1;
inline bool DebugMessage::has_debugmsg() const {
  return _has_bit(0);
}
inline void DebugMessage::clear_debugmsg() {
  if (debugmsg_ != &_default_debugmsg_) {
    debugmsg_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& DebugMessage::debugmsg() const {
  return *debugmsg_;
}
inline void DebugMessage::set_debugmsg(const ::std::string& value) {
  _set_bit(0);
  if (debugmsg_ == &_default_debugmsg_) {
    debugmsg_ = new ::std::string;
  }
  debugmsg_->assign(value);
}
inline void DebugMessage::set_debugmsg(const char* value) {
  _set_bit(0);
  if (debugmsg_ == &_default_debugmsg_) {
    debugmsg_ = new ::std::string;
  }
  debugmsg_->assign(value);
}
inline void DebugMessage::set_debugmsg(const char* value, size_t size) {
  _set_bit(0);
  if (debugmsg_ == &_default_debugmsg_) {
    debugmsg_ = new ::std::string;
  }
  debugmsg_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DebugMessage::mutable_debugmsg() {
  _set_bit(0);
  if (debugmsg_ == &_default_debugmsg_) {
    debugmsg_ = new ::std::string;
  }
  return debugmsg_;
}

// -------------------------------------------------------------------

// ErrorMessage

// required uint32 errorId = 1;
inline bool ErrorMessage::has_errorid() const {
  return _has_bit(0);
}
inline void ErrorMessage::clear_errorid() {
  errorid_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 ErrorMessage::errorid() const {
  return errorid_;
}
inline void ErrorMessage::set_errorid(::google::protobuf::uint32 value) {
  _set_bit(0);
  errorid_ = value;
}

// required string errorMsg = 2;
inline bool ErrorMessage::has_errormsg() const {
  return _has_bit(1);
}
inline void ErrorMessage::clear_errormsg() {
  if (errormsg_ != &_default_errormsg_) {
    errormsg_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& ErrorMessage::errormsg() const {
  return *errormsg_;
}
inline void ErrorMessage::set_errormsg(const ::std::string& value) {
  _set_bit(1);
  if (errormsg_ == &_default_errormsg_) {
    errormsg_ = new ::std::string;
  }
  errormsg_->assign(value);
}
inline void ErrorMessage::set_errormsg(const char* value) {
  _set_bit(1);
  if (errormsg_ == &_default_errormsg_) {
    errormsg_ = new ::std::string;
  }
  errormsg_->assign(value);
}
inline void ErrorMessage::set_errormsg(const char* value, size_t size) {
  _set_bit(1);
  if (errormsg_ == &_default_errormsg_) {
    errormsg_ = new ::std::string;
  }
  errormsg_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ErrorMessage::mutable_errormsg() {
  _set_bit(1);
  if (errormsg_ == &_default_errormsg_) {
    errormsg_ = new ::std::string;
  }
  return errormsg_;
}

// -------------------------------------------------------------------

// FloorSetup

// optional uint32 floorWidth = 1;
inline bool FloorSetup::has_floorwidth() const {
  return _has_bit(0);
}
inline void FloorSetup::clear_floorwidth() {
  floorwidth_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 FloorSetup::floorwidth() const {
  return floorwidth_;
}
inline void FloorSetup::set_floorwidth(::google::protobuf::uint32 value) {
  _set_bit(0);
  floorwidth_ = value;
}

// optional uint32 floorHeight = 2;
inline bool FloorSetup::has_floorheight() const {
  return _has_bit(1);
}
inline void FloorSetup::clear_floorheight() {
  floorheight_ = 0u;
  _clear_bit(1);
}
inline ::google::protobuf::uint32 FloorSetup::floorheight() const {
  return floorheight_;
}
inline void FloorSetup::set_floorheight(::google::protobuf::uint32 value) {
  _set_bit(1);
  floorheight_ = value;
}

// optional uint32 dmsCount = 3;
inline bool FloorSetup::has_dmscount() const {
  return _has_bit(2);
}
inline void FloorSetup::clear_dmscount() {
  dmscount_ = 0u;
  _clear_bit(2);
}
inline ::google::protobuf::uint32 FloorSetup::dmscount() const {
  return dmscount_;
}
inline void FloorSetup::set_dmscount(::google::protobuf::uint32 value) {
  _set_bit(2);
  dmscount_ = value;
}

// optional uint32 ledCount = 4;
inline bool FloorSetup::has_ledcount() const {
  return _has_bit(3);
}
inline void FloorSetup::clear_ledcount() {
  ledcount_ = 0u;
  _clear_bit(3);
}
inline ::google::protobuf::uint32 FloorSetup::ledcount() const {
  return ledcount_;
}
inline void FloorSetup::set_ledcount(::google::protobuf::uint32 value) {
  _set_bit(3);
  ledcount_ = value;
}

// optional uint32 pirCount = 5;
inline bool FloorSetup::has_pircount() const {
  return _has_bit(4);
}
inline void FloorSetup::clear_pircount() {
  pircount_ = 0u;
  _clear_bit(4);
}
inline ::google::protobuf::uint32 FloorSetup::pircount() const {
  return pircount_;
}
inline void FloorSetup::set_pircount(::google::protobuf::uint32 value) {
  _set_bit(4);
  pircount_ = value;
}

// optional uint32 speakerCount = 6;
inline bool FloorSetup::has_speakercount() const {
  return _has_bit(5);
}
inline void FloorSetup::clear_speakercount() {
  speakercount_ = 0u;
  _clear_bit(5);
}
inline ::google::protobuf::uint32 FloorSetup::speakercount() const {
  return speakercount_;
}
inline void FloorSetup::set_speakercount(::google::protobuf::uint32 value) {
  _set_bit(5);
  speakercount_ = value;
}

// -------------------------------------------------------------------

// FloorCommand

// required .marcusiphone.FloorCommand.CommandType commandType = 1;
inline bool FloorCommand::has_commandtype() const {
  return _has_bit(0);
}
inline void FloorCommand::clear_commandtype() {
  commandtype_ = 1;
  _clear_bit(0);
}
inline ::marcusiphone::FloorCommand_CommandType FloorCommand::commandtype() const {
  return static_cast< ::marcusiphone::FloorCommand_CommandType >(commandtype_);
}
inline void FloorCommand::set_commandtype(::marcusiphone::FloorCommand_CommandType value) {
  GOOGLE_DCHECK(::marcusiphone::FloorCommand_CommandType_IsValid(value));
  _set_bit(0);
  commandtype_ = value;
}

// repeated .marcusiphone.LedColor ledColors = 2;
inline int FloorCommand::ledcolors_size() const {
  return ledcolors_.size();
}
inline void FloorCommand::clear_ledcolors() {
  ledcolors_.Clear();
}
inline const ::marcusiphone::LedColor& FloorCommand::ledcolors(int index) const {
  return ledcolors_.Get(index);
}
inline ::marcusiphone::LedColor* FloorCommand::mutable_ledcolors(int index) {
  return ledcolors_.Mutable(index);
}
inline ::marcusiphone::LedColor* FloorCommand::add_ledcolors() {
  return ledcolors_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >&
FloorCommand::ledcolors() const {
  return ledcolors_;
}
inline ::google::protobuf::RepeatedPtrField< ::marcusiphone::LedColor >*
FloorCommand::mutable_ledcolors() {
  return &ledcolors_;
}

// -------------------------------------------------------------------

// LedColor

// required uint32 id = 1;
inline bool LedColor::has_id() const {
  return _has_bit(0);
}
inline void LedColor::clear_id() {
  id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 LedColor::id() const {
  return id_;
}
inline void LedColor::set_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  id_ = value;
}

// required uint32 red = 2;
inline bool LedColor::has_red() const {
  return _has_bit(1);
}
inline void LedColor::clear_red() {
  red_ = 0u;
  _clear_bit(1);
}
inline ::google::protobuf::uint32 LedColor::red() const {
  return red_;
}
inline void LedColor::set_red(::google::protobuf::uint32 value) {
  _set_bit(1);
  red_ = value;
}

// required uint32 green = 3;
inline bool LedColor::has_green() const {
  return _has_bit(2);
}
inline void LedColor::clear_green() {
  green_ = 0u;
  _clear_bit(2);
}
inline ::google::protobuf::uint32 LedColor::green() const {
  return green_;
}
inline void LedColor::set_green(::google::protobuf::uint32 value) {
  _set_bit(2);
  green_ = value;
}

// required uint32 blue = 4;
inline bool LedColor::has_blue() const {
  return _has_bit(3);
}
inline void LedColor::clear_blue() {
  blue_ = 0u;
  _clear_bit(3);
}
inline ::google::protobuf::uint32 LedColor::blue() const {
  return blue_;
}
inline void LedColor::set_blue(::google::protobuf::uint32 value) {
  _set_bit(3);
  blue_ = value;
}

// -------------------------------------------------------------------

// LedTemperature

// required uint32 id = 1;
inline bool LedTemperature::has_id() const {
  return _has_bit(0);
}
inline void LedTemperature::clear_id() {
  id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 LedTemperature::id() const {
  return id_;
}
inline void LedTemperature::set_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  id_ = value;
}

// required uint32 temperature = 2;
inline bool LedTemperature::has_temperature() const {
  return _has_bit(1);
}
inline void LedTemperature::clear_temperature() {
  temperature_ = 0u;
  _clear_bit(1);
}
inline ::google::protobuf::uint32 LedTemperature::temperature() const {
  return temperature_;
}
inline void LedTemperature::set_temperature(::google::protobuf::uint32 value) {
  _set_bit(1);
  temperature_ = value;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace marcusiphone

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::marcusiphone::Envelope_MessageType>() {
  return ::marcusiphone::Envelope_MessageType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::marcusiphone::StatusMessage_StatusType>() {
  return ::marcusiphone::StatusMessage_StatusType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::marcusiphone::RequestMessage_RequestType>() {
  return ::marcusiphone::RequestMessage_RequestType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::marcusiphone::FloorCommand_CommandType>() {
  return ::marcusiphone::FloorCommand_CommandType_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_MarcusProtocol_2eproto__INCLUDED