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

#ifndef GOOGLE_PROTOBUF_INCLUDED_printers_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_printers_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4024000
#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  // PROTOBUF_VERSION

#if 4024003 < 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  // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "common.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_printers_2eproto

namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_printers_2eproto {
  static const ::uint32_t offsets[];
};
extern const ::google::protobuf::internal::DescriptorTable
    descriptor_table_printers_2eproto;
namespace PrinterMsg {
class HMessage;
struct HMessageDefaultTypeInternal;
extern HMessageDefaultTypeInternal _HMessage_default_instance_;
class PrinterListMsg;
struct PrinterListMsgDefaultTypeInternal;
extern PrinterListMsgDefaultTypeInternal _PrinterListMsg_default_instance_;
class Request;
struct RequestDefaultTypeInternal;
extern RequestDefaultTypeInternal _Request_default_instance_;
class Response;
struct ResponseDefaultTypeInternal;
extern ResponseDefaultTypeInternal _Response_default_instance_;
}  // namespace PrinterMsg
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace PrinterMsg {
enum MSG : int {
  UNDEFINE = 0,
  LOGIN_REQUEST = 1001,
  LOGIN_RESPONSE = 1002,
  STATE_REQUEST = 2001,
  STATE_RESPONSE = 2002,
  CAMERA_DATA_REQUEST = 2003,
  CAMERA_DATA_RESPONSE = 2004,
  LAYER_DATA_REQUEST = 2005,
  LAYER_DATA_RESPONSE = 2006,
  VERSION_REQUEST = 2007,
  VERSION_RESPONSE = 2008,
  REMOTE_JOB_LIST_REQUEST = 2009,
  REMOTE_JOB_LIST_RESPONSE = 2010,
  CTRL_SYSTEM_PAUSE = 3001,
  CRTL_SYSTEM_STOP = 3002,
  STATE_CHANGE = 4001,
  STATE_CHANGE_RESPONSE = 4004,
  ALARM_NOTIFY_REQUEST = 4002,
  ALARM_NOTIFY_RESPONSE = 4003,
  JOB_INFO_REQUEST = 6001,
  JOB_INFO_RESPONSE = 6002,
  PRINTER_LIST_RESPONSE = 7001,
  LOG_REQUEST_RECORD_TASK = 8004,
  LOG_RESPONSE_RECORD_TASK = 8005,
  LOG_REQUEST_RECORD_TASK_LIST = 8006,
  LOG_RESPONSE_RECORD_TASK_LIST = 8007,
  MSG_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  MSG_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool MSG_IsValid(int value);
constexpr MSG MSG_MIN = static_cast<MSG>(0);
constexpr MSG MSG_MAX = static_cast<MSG>(8007);
constexpr int MSG_ARRAYSIZE = 8007 + 1;
const ::google::protobuf::EnumDescriptor*
MSG_descriptor();
template <typename T>
const std::string& MSG_Name(T value) {
  static_assert(std::is_same<T, MSG>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to MSG_Name().");
  return ::google::protobuf::internal::NameOfEnum(MSG_descriptor(), value);
}
inline bool MSG_Parse(absl::string_view name, MSG* value) {
  return ::google::protobuf::internal::ParseNamedEnum<MSG>(
      MSG_descriptor(), name, value);
}

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


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

class PrinterListMsg final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PrinterMsg.PrinterListMsg) */ {
 public:
  inline PrinterListMsg() : PrinterListMsg(nullptr) {}
  ~PrinterListMsg() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PrinterListMsg(::google::protobuf::internal::ConstantInitialized);

  PrinterListMsg(const PrinterListMsg& from);
  PrinterListMsg(PrinterListMsg&& from) noexcept
    : PrinterListMsg() {
    *this = ::std::move(from);
  }

  inline PrinterListMsg& operator=(const PrinterListMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrinterListMsg& operator=(PrinterListMsg&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PrinterListMsg& default_instance() {
    return *internal_default_instance();
  }
  static inline const PrinterListMsg* internal_default_instance() {
    return reinterpret_cast<const PrinterListMsg*>(
               &_PrinterListMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(PrinterListMsg& a, PrinterListMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(PrinterListMsg* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PrinterListMsg* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PrinterListMsg* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PrinterListMsg>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PrinterListMsg& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PrinterListMsg& from) {
    PrinterListMsg::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PrinterListMsg* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "PrinterMsg.PrinterListMsg";
  }
  protected:
  explicit PrinterListMsg(::google::protobuf::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPrintersFieldNumber = 1,
  };
  // repeated .MachineMsg printers = 1;
  int printers_size() const;
  private:
  int _internal_printers_size() const;

  public:
  void clear_printers() ;
  ::MachineMsg* mutable_printers(int index);
  ::google::protobuf::RepeatedPtrField< ::MachineMsg >*
      mutable_printers();
  private:
  const ::google::protobuf::RepeatedPtrField<::MachineMsg>& _internal_printers() const;
  ::google::protobuf::RepeatedPtrField<::MachineMsg>* _internal_mutable_printers();
  public:
  const ::MachineMsg& printers(int index) const;
  ::MachineMsg* add_printers();
  const ::google::protobuf::RepeatedPtrField< ::MachineMsg >&
      printers() const;
  // @@protoc_insertion_point(class_scope:PrinterMsg.PrinterListMsg)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 1, 1, 0, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::google::protobuf::RepeatedPtrField< ::MachineMsg > printers_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_printers_2eproto;
};// -------------------------------------------------------------------

class Response final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PrinterMsg.Response) */ {
 public:
  inline Response() : Response(nullptr) {}
  ~Response() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Response(::google::protobuf::internal::ConstantInitialized);

  Response(const Response& from);
  Response(Response&& from) noexcept
    : Response() {
    *this = ::std::move(from);
  }

  inline Response& operator=(const Response& from) {
    CopyFrom(from);
    return *this;
  }
  inline Response& operator=(Response&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Response& default_instance() {
    return *internal_default_instance();
  }
  enum RespsCase {
    kErrorMsg = 2,
    kStateMsg = 3,
    kJobMsg = 4,
    kPrinterList = 5,
    kLayerDataMsg = 6,
    kStateMsgs = 7,
    kCameraData = 8,
    kStateChangeMsg = 9,
    kRecordTasksMsg = 10,
    kRecordTaskListMsg = 11,
    kRemoteJobResMsg = 12,
    kVersionInfoResMsg = 13,
    RESPS_NOT_SET = 0,
  };

  static inline const Response* internal_default_instance() {
    return reinterpret_cast<const Response*>(
               &_Response_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Response& a, Response& b) {
    a.Swap(&b);
  }
  inline void Swap(Response* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Response* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Response* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Response>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Response& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Response& from) {
    Response::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Response* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "PrinterMsg.Response";
  }
  protected:
  explicit Response(::google::protobuf::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kResultFieldNumber = 1,
    kErrorMsgFieldNumber = 2,
    kStateMsgFieldNumber = 3,
    kJobMsgFieldNumber = 4,
    kPrinterListFieldNumber = 5,
    kLayerDataMsgFieldNumber = 6,
    kStateMsgsFieldNumber = 7,
    kCameraDataFieldNumber = 8,
    kStateChangeMsgFieldNumber = 9,
    kRecordTasksMsgFieldNumber = 10,
    kRecordTaskListMsgFieldNumber = 11,
    kRemoteJobResMsgFieldNumber = 12,
    kVersionInfoResMsgFieldNumber = 13,
  };
  // bool result = 1;
  void clear_result() ;
  bool result() const;
  void set_result(bool value);

  private:
  bool _internal_result() const;
  void _internal_set_result(bool value);

  public:
  // .ErrorMsg errorMsg = 2;
  bool has_errormsg() const;
  private:
  bool _internal_has_errormsg() const;

  public:
  void clear_errormsg() ;
  const ::ErrorMsg& errormsg() const;
  PROTOBUF_NODISCARD ::ErrorMsg* release_errormsg();
  ::ErrorMsg* mutable_errormsg();
  void set_allocated_errormsg(::ErrorMsg* value);
  void unsafe_arena_set_allocated_errormsg(::ErrorMsg* value);
  ::ErrorMsg* unsafe_arena_release_errormsg();

  private:
  const ::ErrorMsg& _internal_errormsg() const;
  ::ErrorMsg* _internal_mutable_errormsg();

  public:
  // .StateMsg stateMsg = 3;
  bool has_statemsg() const;
  private:
  bool _internal_has_statemsg() const;

  public:
  void clear_statemsg() ;
  const ::StateMsg& statemsg() const;
  PROTOBUF_NODISCARD ::StateMsg* release_statemsg();
  ::StateMsg* mutable_statemsg();
  void set_allocated_statemsg(::StateMsg* value);
  void unsafe_arena_set_allocated_statemsg(::StateMsg* value);
  ::StateMsg* unsafe_arena_release_statemsg();

  private:
  const ::StateMsg& _internal_statemsg() const;
  ::StateMsg* _internal_mutable_statemsg();

  public:
  // .JobMsg jobMsg = 4;
  bool has_jobmsg() const;
  private:
  bool _internal_has_jobmsg() const;

  public:
  void clear_jobmsg() ;
  const ::JobMsg& jobmsg() const;
  PROTOBUF_NODISCARD ::JobMsg* release_jobmsg();
  ::JobMsg* mutable_jobmsg();
  void set_allocated_jobmsg(::JobMsg* value);
  void unsafe_arena_set_allocated_jobmsg(::JobMsg* value);
  ::JobMsg* unsafe_arena_release_jobmsg();

  private:
  const ::JobMsg& _internal_jobmsg() const;
  ::JobMsg* _internal_mutable_jobmsg();

  public:
  // .PrinterMsg.PrinterListMsg printerList = 5;
  bool has_printerlist() const;
  private:
  bool _internal_has_printerlist() const;

  public:
  void clear_printerlist() ;
  const ::PrinterMsg::PrinterListMsg& printerlist() const;
  PROTOBUF_NODISCARD ::PrinterMsg::PrinterListMsg* release_printerlist();
  ::PrinterMsg::PrinterListMsg* mutable_printerlist();
  void set_allocated_printerlist(::PrinterMsg::PrinterListMsg* value);
  void unsafe_arena_set_allocated_printerlist(::PrinterMsg::PrinterListMsg* value);
  ::PrinterMsg::PrinterListMsg* unsafe_arena_release_printerlist();

  private:
  const ::PrinterMsg::PrinterListMsg& _internal_printerlist() const;
  ::PrinterMsg::PrinterListMsg* _internal_mutable_printerlist();

  public:
  // .LayerDataRespMsg layerDataMsg = 6;
  bool has_layerdatamsg() const;
  private:
  bool _internal_has_layerdatamsg() const;

  public:
  void clear_layerdatamsg() ;
  const ::LayerDataRespMsg& layerdatamsg() const;
  PROTOBUF_NODISCARD ::LayerDataRespMsg* release_layerdatamsg();
  ::LayerDataRespMsg* mutable_layerdatamsg();
  void set_allocated_layerdatamsg(::LayerDataRespMsg* value);
  void unsafe_arena_set_allocated_layerdatamsg(::LayerDataRespMsg* value);
  ::LayerDataRespMsg* unsafe_arena_release_layerdatamsg();

  private:
  const ::LayerDataRespMsg& _internal_layerdatamsg() const;
  ::LayerDataRespMsg* _internal_mutable_layerdatamsg();

  public:
  // .ResponseState stateMsgs = 7;
  bool has_statemsgs() const;
  private:
  bool _internal_has_statemsgs() const;

  public:
  void clear_statemsgs() ;
  const ::ResponseState& statemsgs() const;
  PROTOBUF_NODISCARD ::ResponseState* release_statemsgs();
  ::ResponseState* mutable_statemsgs();
  void set_allocated_statemsgs(::ResponseState* value);
  void unsafe_arena_set_allocated_statemsgs(::ResponseState* value);
  ::ResponseState* unsafe_arena_release_statemsgs();

  private:
  const ::ResponseState& _internal_statemsgs() const;
  ::ResponseState* _internal_mutable_statemsgs();

  public:
  // .CameraDataMsg cameraData = 8;
  bool has_cameradata() const;
  private:
  bool _internal_has_cameradata() const;

  public:
  void clear_cameradata() ;
  const ::CameraDataMsg& cameradata() const;
  PROTOBUF_NODISCARD ::CameraDataMsg* release_cameradata();
  ::CameraDataMsg* mutable_cameradata();
  void set_allocated_cameradata(::CameraDataMsg* value);
  void unsafe_arena_set_allocated_cameradata(::CameraDataMsg* value);
  ::CameraDataMsg* unsafe_arena_release_cameradata();

  private:
  const ::CameraDataMsg& _internal_cameradata() const;
  ::CameraDataMsg* _internal_mutable_cameradata();

  public:
  // .StateChangeMsg stateChangeMsg = 9;
  bool has_statechangemsg() const;
  private:
  bool _internal_has_statechangemsg() const;

  public:
  void clear_statechangemsg() ;
  const ::StateChangeMsg& statechangemsg() const;
  PROTOBUF_NODISCARD ::StateChangeMsg* release_statechangemsg();
  ::StateChangeMsg* mutable_statechangemsg();
  void set_allocated_statechangemsg(::StateChangeMsg* value);
  void unsafe_arena_set_allocated_statechangemsg(::StateChangeMsg* value);
  ::StateChangeMsg* unsafe_arena_release_statechangemsg();

  private:
  const ::StateChangeMsg& _internal_statechangemsg() const;
  ::StateChangeMsg* _internal_mutable_statechangemsg();

  public:
  // .RecordTasksMsg recordTasksMsg = 10;
  bool has_recordtasksmsg() const;
  private:
  bool _internal_has_recordtasksmsg() const;

  public:
  void clear_recordtasksmsg() ;
  const ::RecordTasksMsg& recordtasksmsg() const;
  PROTOBUF_NODISCARD ::RecordTasksMsg* release_recordtasksmsg();
  ::RecordTasksMsg* mutable_recordtasksmsg();
  void set_allocated_recordtasksmsg(::RecordTasksMsg* value);
  void unsafe_arena_set_allocated_recordtasksmsg(::RecordTasksMsg* value);
  ::RecordTasksMsg* unsafe_arena_release_recordtasksmsg();

  private:
  const ::RecordTasksMsg& _internal_recordtasksmsg() const;
  ::RecordTasksMsg* _internal_mutable_recordtasksmsg();

  public:
  // .RecordTasksListMsg recordTaskListMsg = 11;
  bool has_recordtasklistmsg() const;
  private:
  bool _internal_has_recordtasklistmsg() const;

  public:
  void clear_recordtasklistmsg() ;
  const ::RecordTasksListMsg& recordtasklistmsg() const;
  PROTOBUF_NODISCARD ::RecordTasksListMsg* release_recordtasklistmsg();
  ::RecordTasksListMsg* mutable_recordtasklistmsg();
  void set_allocated_recordtasklistmsg(::RecordTasksListMsg* value);
  void unsafe_arena_set_allocated_recordtasklistmsg(::RecordTasksListMsg* value);
  ::RecordTasksListMsg* unsafe_arena_release_recordtasklistmsg();

  private:
  const ::RecordTasksListMsg& _internal_recordtasklistmsg() const;
  ::RecordTasksListMsg* _internal_mutable_recordtasklistmsg();

  public:
  // .RemoteJobResMsg remoteJobResMsg = 12;
  bool has_remotejobresmsg() const;
  private:
  bool _internal_has_remotejobresmsg() const;

  public:
  void clear_remotejobresmsg() ;
  const ::RemoteJobResMsg& remotejobresmsg() const;
  PROTOBUF_NODISCARD ::RemoteJobResMsg* release_remotejobresmsg();
  ::RemoteJobResMsg* mutable_remotejobresmsg();
  void set_allocated_remotejobresmsg(::RemoteJobResMsg* value);
  void unsafe_arena_set_allocated_remotejobresmsg(::RemoteJobResMsg* value);
  ::RemoteJobResMsg* unsafe_arena_release_remotejobresmsg();

  private:
  const ::RemoteJobResMsg& _internal_remotejobresmsg() const;
  ::RemoteJobResMsg* _internal_mutable_remotejobresmsg();

  public:
  // .VersionInfoResMsg versionInfoResMsg = 13;
  bool has_versioninforesmsg() const;
  private:
  bool _internal_has_versioninforesmsg() const;

  public:
  void clear_versioninforesmsg() ;
  const ::VersionInfoResMsg& versioninforesmsg() const;
  PROTOBUF_NODISCARD ::VersionInfoResMsg* release_versioninforesmsg();
  ::VersionInfoResMsg* mutable_versioninforesmsg();
  void set_allocated_versioninforesmsg(::VersionInfoResMsg* value);
  void unsafe_arena_set_allocated_versioninforesmsg(::VersionInfoResMsg* value);
  ::VersionInfoResMsg* unsafe_arena_release_versioninforesmsg();

  private:
  const ::VersionInfoResMsg& _internal_versioninforesmsg() const;
  ::VersionInfoResMsg* _internal_mutable_versioninforesmsg();

  public:
  void clear_resps();
  RespsCase resps_case() const;
  // @@protoc_insertion_point(class_scope:PrinterMsg.Response)
 private:
  class _Internal;
  void set_has_errormsg();
  void set_has_statemsg();
  void set_has_jobmsg();
  void set_has_printerlist();
  void set_has_layerdatamsg();
  void set_has_statemsgs();
  void set_has_cameradata();
  void set_has_statechangemsg();
  void set_has_recordtasksmsg();
  void set_has_recordtasklistmsg();
  void set_has_remotejobresmsg();
  void set_has_versioninforesmsg();

  inline bool has_resps() const;
  inline void clear_has_resps();

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 13, 12, 0, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    bool result_;
    union RespsUnion {
      constexpr RespsUnion() : _constinit_{} {}
        ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::ErrorMsg* errormsg_;
      ::StateMsg* statemsg_;
      ::JobMsg* jobmsg_;
      ::PrinterMsg::PrinterListMsg* printerlist_;
      ::LayerDataRespMsg* layerdatamsg_;
      ::ResponseState* statemsgs_;
      ::CameraDataMsg* cameradata_;
      ::StateChangeMsg* statechangemsg_;
      ::RecordTasksMsg* recordtasksmsg_;
      ::RecordTasksListMsg* recordtasklistmsg_;
      ::RemoteJobResMsg* remotejobresmsg_;
      ::VersionInfoResMsg* versioninforesmsg_;
    } resps_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_printers_2eproto;
};// -------------------------------------------------------------------

class Request final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PrinterMsg.Request) */ {
 public:
  inline Request() : Request(nullptr) {}
  ~Request() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Request(::google::protobuf::internal::ConstantInitialized);

  Request(const Request& from);
  Request(Request&& from) noexcept
    : Request() {
    *this = ::std::move(from);
  }

  inline Request& operator=(const Request& from) {
    CopyFrom(from);
    return *this;
  }
  inline Request& operator=(Request&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Request& default_instance() {
    return *internal_default_instance();
  }
  enum OneofReqCase {
    kMachineMsg = 1,
    kLayerDataMsg = 2,
    kAlarmNotifyMsg = 3,
    kReqRecordTaskMsg = 4,
    kReqRecordTaskListMsg = 5,
    ONEOF_REQ_NOT_SET = 0,
  };

  static inline const Request* internal_default_instance() {
    return reinterpret_cast<const Request*>(
               &_Request_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Request& a, Request& b) {
    a.Swap(&b);
  }
  inline void Swap(Request* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Request* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Request* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Request>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Request& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Request& from) {
    Request::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Request* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "PrinterMsg.Request";
  }
  protected:
  explicit Request(::google::protobuf::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMachineMsgFieldNumber = 1,
    kLayerDataMsgFieldNumber = 2,
    kAlarmNotifyMsgFieldNumber = 3,
    kReqRecordTaskMsgFieldNumber = 4,
    kReqRecordTaskListMsgFieldNumber = 5,
  };
  // .MachineMsg machineMsg = 1;
  bool has_machinemsg() const;
  private:
  bool _internal_has_machinemsg() const;

  public:
  void clear_machinemsg() ;
  const ::MachineMsg& machinemsg() const;
  PROTOBUF_NODISCARD ::MachineMsg* release_machinemsg();
  ::MachineMsg* mutable_machinemsg();
  void set_allocated_machinemsg(::MachineMsg* value);
  void unsafe_arena_set_allocated_machinemsg(::MachineMsg* value);
  ::MachineMsg* unsafe_arena_release_machinemsg();

  private:
  const ::MachineMsg& _internal_machinemsg() const;
  ::MachineMsg* _internal_mutable_machinemsg();

  public:
  // .LayerDataReqMsg layerDataMsg = 2;
  bool has_layerdatamsg() const;
  private:
  bool _internal_has_layerdatamsg() const;

  public:
  void clear_layerdatamsg() ;
  const ::LayerDataReqMsg& layerdatamsg() const;
  PROTOBUF_NODISCARD ::LayerDataReqMsg* release_layerdatamsg();
  ::LayerDataReqMsg* mutable_layerdatamsg();
  void set_allocated_layerdatamsg(::LayerDataReqMsg* value);
  void unsafe_arena_set_allocated_layerdatamsg(::LayerDataReqMsg* value);
  ::LayerDataReqMsg* unsafe_arena_release_layerdatamsg();

  private:
  const ::LayerDataReqMsg& _internal_layerdatamsg() const;
  ::LayerDataReqMsg* _internal_mutable_layerdatamsg();

  public:
  // .AlarmNotifyMsg alarmNotifyMsg = 3;
  bool has_alarmnotifymsg() const;
  private:
  bool _internal_has_alarmnotifymsg() const;

  public:
  void clear_alarmnotifymsg() ;
  const ::AlarmNotifyMsg& alarmnotifymsg() const;
  PROTOBUF_NODISCARD ::AlarmNotifyMsg* release_alarmnotifymsg();
  ::AlarmNotifyMsg* mutable_alarmnotifymsg();
  void set_allocated_alarmnotifymsg(::AlarmNotifyMsg* value);
  void unsafe_arena_set_allocated_alarmnotifymsg(::AlarmNotifyMsg* value);
  ::AlarmNotifyMsg* unsafe_arena_release_alarmnotifymsg();

  private:
  const ::AlarmNotifyMsg& _internal_alarmnotifymsg() const;
  ::AlarmNotifyMsg* _internal_mutable_alarmnotifymsg();

  public:
  // .ReqRecordTaskMsg reqRecordTaskMsg = 4;
  bool has_reqrecordtaskmsg() const;
  private:
  bool _internal_has_reqrecordtaskmsg() const;

  public:
  void clear_reqrecordtaskmsg() ;
  const ::ReqRecordTaskMsg& reqrecordtaskmsg() const;
  PROTOBUF_NODISCARD ::ReqRecordTaskMsg* release_reqrecordtaskmsg();
  ::ReqRecordTaskMsg* mutable_reqrecordtaskmsg();
  void set_allocated_reqrecordtaskmsg(::ReqRecordTaskMsg* value);
  void unsafe_arena_set_allocated_reqrecordtaskmsg(::ReqRecordTaskMsg* value);
  ::ReqRecordTaskMsg* unsafe_arena_release_reqrecordtaskmsg();

  private:
  const ::ReqRecordTaskMsg& _internal_reqrecordtaskmsg() const;
  ::ReqRecordTaskMsg* _internal_mutable_reqrecordtaskmsg();

  public:
  // .ReqRecordTaskListMsg reqRecordTaskListMsg = 5;
  bool has_reqrecordtasklistmsg() const;
  private:
  bool _internal_has_reqrecordtasklistmsg() const;

  public:
  void clear_reqrecordtasklistmsg() ;
  const ::ReqRecordTaskListMsg& reqrecordtasklistmsg() const;
  PROTOBUF_NODISCARD ::ReqRecordTaskListMsg* release_reqrecordtasklistmsg();
  ::ReqRecordTaskListMsg* mutable_reqrecordtasklistmsg();
  void set_allocated_reqrecordtasklistmsg(::ReqRecordTaskListMsg* value);
  void unsafe_arena_set_allocated_reqrecordtasklistmsg(::ReqRecordTaskListMsg* value);
  ::ReqRecordTaskListMsg* unsafe_arena_release_reqrecordtasklistmsg();

  private:
  const ::ReqRecordTaskListMsg& _internal_reqrecordtasklistmsg() const;
  ::ReqRecordTaskListMsg* _internal_mutable_reqrecordtasklistmsg();

  public:
  void clear_oneof_req();
  OneofReqCase oneof_req_case() const;
  // @@protoc_insertion_point(class_scope:PrinterMsg.Request)
 private:
  class _Internal;
  void set_has_machinemsg();
  void set_has_layerdatamsg();
  void set_has_alarmnotifymsg();
  void set_has_reqrecordtaskmsg();
  void set_has_reqrecordtasklistmsg();

  inline bool has_oneof_req() const;
  inline void clear_has_oneof_req();

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 5, 5, 0, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union OneofReqUnion {
      constexpr OneofReqUnion() : _constinit_{} {}
        ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::MachineMsg* machinemsg_;
      ::LayerDataReqMsg* layerdatamsg_;
      ::AlarmNotifyMsg* alarmnotifymsg_;
      ::ReqRecordTaskMsg* reqrecordtaskmsg_;
      ::ReqRecordTaskListMsg* reqrecordtasklistmsg_;
    } oneof_req_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_printers_2eproto;
};// -------------------------------------------------------------------

class HMessage final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PrinterMsg.HMessage) */ {
 public:
  inline HMessage() : HMessage(nullptr) {}
  ~HMessage() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR HMessage(::google::protobuf::internal::ConstantInitialized);

  HMessage(const HMessage& from);
  HMessage(HMessage&& from) noexcept
    : HMessage() {
    *this = ::std::move(from);
  }

  inline HMessage& operator=(const HMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline HMessage& operator=(HMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const HMessage* internal_default_instance() {
    return reinterpret_cast<const HMessage*>(
               &_HMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(HMessage& a, HMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(HMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HMessage* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  HMessage* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HMessage>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const HMessage& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const HMessage& from) {
    HMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HMessage* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "PrinterMsg.HMessage";
  }
  protected:
  explicit HMessage(::google::protobuf::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIdFieldNumber = 2,
    kMcodeFieldNumber = 3,
    kRequestFieldNumber = 4,
    kResponseFieldNumber = 5,
    kSendTimeFieldNumber = 6,
    kTypeFieldNumber = 1,
  };
  // string id = 2;
  void clear_id() ;
  const std::string& id() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_id(Arg_&& arg, Args_... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* ptr);

  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(
      const std::string& value);
  std::string* _internal_mutable_id();

  public:
  // string mcode = 3;
  void clear_mcode() ;
  const std::string& mcode() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_mcode(Arg_&& arg, Args_... args);
  std::string* mutable_mcode();
  PROTOBUF_NODISCARD std::string* release_mcode();
  void set_allocated_mcode(std::string* ptr);

  private:
  const std::string& _internal_mcode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mcode(
      const std::string& value);
  std::string* _internal_mutable_mcode();

  public:
  // .PrinterMsg.Request request = 4;
  bool has_request() const;
  void clear_request() ;
  const ::PrinterMsg::Request& request() const;
  PROTOBUF_NODISCARD ::PrinterMsg::Request* release_request();
  ::PrinterMsg::Request* mutable_request();
  void set_allocated_request(::PrinterMsg::Request* value);
  void unsafe_arena_set_allocated_request(::PrinterMsg::Request* value);
  ::PrinterMsg::Request* unsafe_arena_release_request();

  private:
  const ::PrinterMsg::Request& _internal_request() const;
  ::PrinterMsg::Request* _internal_mutable_request();

  public:
  // .PrinterMsg.Response response = 5;
  bool has_response() const;
  void clear_response() ;
  const ::PrinterMsg::Response& response() const;
  PROTOBUF_NODISCARD ::PrinterMsg::Response* release_response();
  ::PrinterMsg::Response* mutable_response();
  void set_allocated_response(::PrinterMsg::Response* value);
  void unsafe_arena_set_allocated_response(::PrinterMsg::Response* value);
  ::PrinterMsg::Response* unsafe_arena_release_response();

  private:
  const ::PrinterMsg::Response& _internal_response() const;
  ::PrinterMsg::Response* _internal_mutable_response();

  public:
  // uint64 sendTime = 6;
  void clear_sendtime() ;
  ::uint64_t sendtime() const;
  void set_sendtime(::uint64_t value);

  private:
  ::uint64_t _internal_sendtime() const;
  void _internal_set_sendtime(::uint64_t value);

  public:
  // .PrinterMsg.MSG type = 1;
  void clear_type() ;
  ::PrinterMsg::MSG type() const;
  void set_type(::PrinterMsg::MSG value);

  private:
  ::PrinterMsg::MSG _internal_type() const;
  void _internal_set_type(::PrinterMsg::MSG value);

  public:
  // @@protoc_insertion_point(class_scope:PrinterMsg.HMessage)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 6, 2, 35, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr id_;
    ::google::protobuf::internal::ArenaStringPtr mcode_;
    ::PrinterMsg::Request* request_;
    ::PrinterMsg::Response* response_;
    ::uint64_t sendtime_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_printers_2eproto;
};

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




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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// PrinterListMsg

// repeated .MachineMsg printers = 1;
inline int PrinterListMsg::_internal_printers_size() const {
  return _internal_printers().size();
}
inline int PrinterListMsg::printers_size() const {
  return _internal_printers_size();
}
inline ::MachineMsg* PrinterListMsg::mutable_printers(int index) {
  // @@protoc_insertion_point(field_mutable:PrinterMsg.PrinterListMsg.printers)
  return _internal_mutable_printers()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::MachineMsg >*
PrinterListMsg::mutable_printers() {
  // @@protoc_insertion_point(field_mutable_list:PrinterMsg.PrinterListMsg.printers)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_printers();
}
inline const ::MachineMsg& PrinterListMsg::printers(int index) const {
  // @@protoc_insertion_point(field_get:PrinterMsg.PrinterListMsg.printers)
    return _internal_printers().Get(index);
}
inline ::MachineMsg* PrinterListMsg::add_printers() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::MachineMsg* _add = _internal_mutable_printers()->Add();
  // @@protoc_insertion_point(field_add:PrinterMsg.PrinterListMsg.printers)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField< ::MachineMsg >&
PrinterListMsg::printers() const {
  // @@protoc_insertion_point(field_list:PrinterMsg.PrinterListMsg.printers)
  return _internal_printers();
}
inline const ::google::protobuf::RepeatedPtrField<::MachineMsg>&
PrinterListMsg::_internal_printers() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.printers_;
}
inline ::google::protobuf::RepeatedPtrField<::MachineMsg>*
PrinterListMsg::_internal_mutable_printers() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.printers_;
}

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

// Response

// bool result = 1;
inline void Response::clear_result() {
  _impl_.result_ = false;
}
inline bool Response::result() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.result)
  return _internal_result();
}
inline void Response::set_result(bool value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:PrinterMsg.Response.result)
}
inline bool Response::_internal_result() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.result_;
}
inline void Response::_internal_set_result(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.result_ = value;
}

// .ErrorMsg errorMsg = 2;
inline bool Response::has_errormsg() const {
  return resps_case() == kErrorMsg;
}
inline bool Response::_internal_has_errormsg() const {
  return resps_case() == kErrorMsg;
}
inline void Response::set_has_errormsg() {
  _impl_._oneof_case_[0] = kErrorMsg;
}
inline ::ErrorMsg* Response::release_errormsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.errorMsg)
  if (resps_case() == kErrorMsg) {
    clear_has_resps();
    ::ErrorMsg* temp = _impl_.resps_.errormsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.errormsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ErrorMsg& Response::_internal_errormsg() const {
  return resps_case() == kErrorMsg
      ? *_impl_.resps_.errormsg_
      : reinterpret_cast<::ErrorMsg&>(::_ErrorMsg_default_instance_);
}
inline const ::ErrorMsg& Response::errormsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.errorMsg)
  return _internal_errormsg();
}
inline ::ErrorMsg* Response::unsafe_arena_release_errormsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.errorMsg)
  if (resps_case() == kErrorMsg) {
    clear_has_resps();
    ::ErrorMsg* temp = _impl_.resps_.errormsg_;
    _impl_.resps_.errormsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_errormsg(::ErrorMsg* errormsg) {
  clear_resps();
  if (errormsg) {
    set_has_errormsg();
    _impl_.resps_.errormsg_ = errormsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.errorMsg)
}
inline ::ErrorMsg* Response::_internal_mutable_errormsg() {
  if (resps_case() != kErrorMsg) {
    clear_resps();
    set_has_errormsg();
    _impl_.resps_.errormsg_ = CreateMaybeMessage< ::ErrorMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.errormsg_;
}
inline ::ErrorMsg* Response::mutable_errormsg() {
  ::ErrorMsg* _msg = _internal_mutable_errormsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.errorMsg)
  return _msg;
}

// .StateMsg stateMsg = 3;
inline bool Response::has_statemsg() const {
  return resps_case() == kStateMsg;
}
inline bool Response::_internal_has_statemsg() const {
  return resps_case() == kStateMsg;
}
inline void Response::set_has_statemsg() {
  _impl_._oneof_case_[0] = kStateMsg;
}
inline ::StateMsg* Response::release_statemsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.stateMsg)
  if (resps_case() == kStateMsg) {
    clear_has_resps();
    ::StateMsg* temp = _impl_.resps_.statemsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.statemsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::StateMsg& Response::_internal_statemsg() const {
  return resps_case() == kStateMsg
      ? *_impl_.resps_.statemsg_
      : reinterpret_cast<::StateMsg&>(::_StateMsg_default_instance_);
}
inline const ::StateMsg& Response::statemsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.stateMsg)
  return _internal_statemsg();
}
inline ::StateMsg* Response::unsafe_arena_release_statemsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.stateMsg)
  if (resps_case() == kStateMsg) {
    clear_has_resps();
    ::StateMsg* temp = _impl_.resps_.statemsg_;
    _impl_.resps_.statemsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_statemsg(::StateMsg* statemsg) {
  clear_resps();
  if (statemsg) {
    set_has_statemsg();
    _impl_.resps_.statemsg_ = statemsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.stateMsg)
}
inline ::StateMsg* Response::_internal_mutable_statemsg() {
  if (resps_case() != kStateMsg) {
    clear_resps();
    set_has_statemsg();
    _impl_.resps_.statemsg_ = CreateMaybeMessage< ::StateMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.statemsg_;
}
inline ::StateMsg* Response::mutable_statemsg() {
  ::StateMsg* _msg = _internal_mutable_statemsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.stateMsg)
  return _msg;
}

// .JobMsg jobMsg = 4;
inline bool Response::has_jobmsg() const {
  return resps_case() == kJobMsg;
}
inline bool Response::_internal_has_jobmsg() const {
  return resps_case() == kJobMsg;
}
inline void Response::set_has_jobmsg() {
  _impl_._oneof_case_[0] = kJobMsg;
}
inline ::JobMsg* Response::release_jobmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.jobMsg)
  if (resps_case() == kJobMsg) {
    clear_has_resps();
    ::JobMsg* temp = _impl_.resps_.jobmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.jobmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::JobMsg& Response::_internal_jobmsg() const {
  return resps_case() == kJobMsg
      ? *_impl_.resps_.jobmsg_
      : reinterpret_cast<::JobMsg&>(::_JobMsg_default_instance_);
}
inline const ::JobMsg& Response::jobmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.jobMsg)
  return _internal_jobmsg();
}
inline ::JobMsg* Response::unsafe_arena_release_jobmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.jobMsg)
  if (resps_case() == kJobMsg) {
    clear_has_resps();
    ::JobMsg* temp = _impl_.resps_.jobmsg_;
    _impl_.resps_.jobmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_jobmsg(::JobMsg* jobmsg) {
  clear_resps();
  if (jobmsg) {
    set_has_jobmsg();
    _impl_.resps_.jobmsg_ = jobmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.jobMsg)
}
inline ::JobMsg* Response::_internal_mutable_jobmsg() {
  if (resps_case() != kJobMsg) {
    clear_resps();
    set_has_jobmsg();
    _impl_.resps_.jobmsg_ = CreateMaybeMessage< ::JobMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.jobmsg_;
}
inline ::JobMsg* Response::mutable_jobmsg() {
  ::JobMsg* _msg = _internal_mutable_jobmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.jobMsg)
  return _msg;
}

// .PrinterMsg.PrinterListMsg printerList = 5;
inline bool Response::has_printerlist() const {
  return resps_case() == kPrinterList;
}
inline bool Response::_internal_has_printerlist() const {
  return resps_case() == kPrinterList;
}
inline void Response::set_has_printerlist() {
  _impl_._oneof_case_[0] = kPrinterList;
}
inline void Response::clear_printerlist() {
  if (resps_case() == kPrinterList) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.resps_.printerlist_;
    }
    clear_has_resps();
  }
}
inline ::PrinterMsg::PrinterListMsg* Response::release_printerlist() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.printerList)
  if (resps_case() == kPrinterList) {
    clear_has_resps();
    ::PrinterMsg::PrinterListMsg* temp = _impl_.resps_.printerlist_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.printerlist_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::PrinterMsg::PrinterListMsg& Response::_internal_printerlist() const {
  return resps_case() == kPrinterList
      ? *_impl_.resps_.printerlist_
      : reinterpret_cast<::PrinterMsg::PrinterListMsg&>(::PrinterMsg::_PrinterListMsg_default_instance_);
}
inline const ::PrinterMsg::PrinterListMsg& Response::printerlist() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.printerList)
  return _internal_printerlist();
}
inline ::PrinterMsg::PrinterListMsg* Response::unsafe_arena_release_printerlist() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.printerList)
  if (resps_case() == kPrinterList) {
    clear_has_resps();
    ::PrinterMsg::PrinterListMsg* temp = _impl_.resps_.printerlist_;
    _impl_.resps_.printerlist_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_printerlist(::PrinterMsg::PrinterListMsg* printerlist) {
  clear_resps();
  if (printerlist) {
    set_has_printerlist();
    _impl_.resps_.printerlist_ = printerlist;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.printerList)
}
inline ::PrinterMsg::PrinterListMsg* Response::_internal_mutable_printerlist() {
  if (resps_case() != kPrinterList) {
    clear_resps();
    set_has_printerlist();
    _impl_.resps_.printerlist_ = CreateMaybeMessage< ::PrinterMsg::PrinterListMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.printerlist_;
}
inline ::PrinterMsg::PrinterListMsg* Response::mutable_printerlist() {
  ::PrinterMsg::PrinterListMsg* _msg = _internal_mutable_printerlist();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.printerList)
  return _msg;
}

// .LayerDataRespMsg layerDataMsg = 6;
inline bool Response::has_layerdatamsg() const {
  return resps_case() == kLayerDataMsg;
}
inline bool Response::_internal_has_layerdatamsg() const {
  return resps_case() == kLayerDataMsg;
}
inline void Response::set_has_layerdatamsg() {
  _impl_._oneof_case_[0] = kLayerDataMsg;
}
inline ::LayerDataRespMsg* Response::release_layerdatamsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.layerDataMsg)
  if (resps_case() == kLayerDataMsg) {
    clear_has_resps();
    ::LayerDataRespMsg* temp = _impl_.resps_.layerdatamsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.layerdatamsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerDataRespMsg& Response::_internal_layerdatamsg() const {
  return resps_case() == kLayerDataMsg
      ? *_impl_.resps_.layerdatamsg_
      : reinterpret_cast<::LayerDataRespMsg&>(::_LayerDataRespMsg_default_instance_);
}
inline const ::LayerDataRespMsg& Response::layerdatamsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.layerDataMsg)
  return _internal_layerdatamsg();
}
inline ::LayerDataRespMsg* Response::unsafe_arena_release_layerdatamsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.layerDataMsg)
  if (resps_case() == kLayerDataMsg) {
    clear_has_resps();
    ::LayerDataRespMsg* temp = _impl_.resps_.layerdatamsg_;
    _impl_.resps_.layerdatamsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_layerdatamsg(::LayerDataRespMsg* layerdatamsg) {
  clear_resps();
  if (layerdatamsg) {
    set_has_layerdatamsg();
    _impl_.resps_.layerdatamsg_ = layerdatamsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.layerDataMsg)
}
inline ::LayerDataRespMsg* Response::_internal_mutable_layerdatamsg() {
  if (resps_case() != kLayerDataMsg) {
    clear_resps();
    set_has_layerdatamsg();
    _impl_.resps_.layerdatamsg_ = CreateMaybeMessage< ::LayerDataRespMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.layerdatamsg_;
}
inline ::LayerDataRespMsg* Response::mutable_layerdatamsg() {
  ::LayerDataRespMsg* _msg = _internal_mutable_layerdatamsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.layerDataMsg)
  return _msg;
}

// .ResponseState stateMsgs = 7;
inline bool Response::has_statemsgs() const {
  return resps_case() == kStateMsgs;
}
inline bool Response::_internal_has_statemsgs() const {
  return resps_case() == kStateMsgs;
}
inline void Response::set_has_statemsgs() {
  _impl_._oneof_case_[0] = kStateMsgs;
}
inline ::ResponseState* Response::release_statemsgs() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.stateMsgs)
  if (resps_case() == kStateMsgs) {
    clear_has_resps();
    ::ResponseState* temp = _impl_.resps_.statemsgs_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.statemsgs_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ResponseState& Response::_internal_statemsgs() const {
  return resps_case() == kStateMsgs
      ? *_impl_.resps_.statemsgs_
      : reinterpret_cast<::ResponseState&>(::_ResponseState_default_instance_);
}
inline const ::ResponseState& Response::statemsgs() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.stateMsgs)
  return _internal_statemsgs();
}
inline ::ResponseState* Response::unsafe_arena_release_statemsgs() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.stateMsgs)
  if (resps_case() == kStateMsgs) {
    clear_has_resps();
    ::ResponseState* temp = _impl_.resps_.statemsgs_;
    _impl_.resps_.statemsgs_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_statemsgs(::ResponseState* statemsgs) {
  clear_resps();
  if (statemsgs) {
    set_has_statemsgs();
    _impl_.resps_.statemsgs_ = statemsgs;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.stateMsgs)
}
inline ::ResponseState* Response::_internal_mutable_statemsgs() {
  if (resps_case() != kStateMsgs) {
    clear_resps();
    set_has_statemsgs();
    _impl_.resps_.statemsgs_ = CreateMaybeMessage< ::ResponseState >(GetArenaForAllocation());
  }
  return _impl_.resps_.statemsgs_;
}
inline ::ResponseState* Response::mutable_statemsgs() {
  ::ResponseState* _msg = _internal_mutable_statemsgs();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.stateMsgs)
  return _msg;
}

// .CameraDataMsg cameraData = 8;
inline bool Response::has_cameradata() const {
  return resps_case() == kCameraData;
}
inline bool Response::_internal_has_cameradata() const {
  return resps_case() == kCameraData;
}
inline void Response::set_has_cameradata() {
  _impl_._oneof_case_[0] = kCameraData;
}
inline ::CameraDataMsg* Response::release_cameradata() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.cameraData)
  if (resps_case() == kCameraData) {
    clear_has_resps();
    ::CameraDataMsg* temp = _impl_.resps_.cameradata_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.cameradata_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CameraDataMsg& Response::_internal_cameradata() const {
  return resps_case() == kCameraData
      ? *_impl_.resps_.cameradata_
      : reinterpret_cast<::CameraDataMsg&>(::_CameraDataMsg_default_instance_);
}
inline const ::CameraDataMsg& Response::cameradata() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.cameraData)
  return _internal_cameradata();
}
inline ::CameraDataMsg* Response::unsafe_arena_release_cameradata() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.cameraData)
  if (resps_case() == kCameraData) {
    clear_has_resps();
    ::CameraDataMsg* temp = _impl_.resps_.cameradata_;
    _impl_.resps_.cameradata_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_cameradata(::CameraDataMsg* cameradata) {
  clear_resps();
  if (cameradata) {
    set_has_cameradata();
    _impl_.resps_.cameradata_ = cameradata;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.cameraData)
}
inline ::CameraDataMsg* Response::_internal_mutable_cameradata() {
  if (resps_case() != kCameraData) {
    clear_resps();
    set_has_cameradata();
    _impl_.resps_.cameradata_ = CreateMaybeMessage< ::CameraDataMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.cameradata_;
}
inline ::CameraDataMsg* Response::mutable_cameradata() {
  ::CameraDataMsg* _msg = _internal_mutable_cameradata();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.cameraData)
  return _msg;
}

// .StateChangeMsg stateChangeMsg = 9;
inline bool Response::has_statechangemsg() const {
  return resps_case() == kStateChangeMsg;
}
inline bool Response::_internal_has_statechangemsg() const {
  return resps_case() == kStateChangeMsg;
}
inline void Response::set_has_statechangemsg() {
  _impl_._oneof_case_[0] = kStateChangeMsg;
}
inline ::StateChangeMsg* Response::release_statechangemsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.stateChangeMsg)
  if (resps_case() == kStateChangeMsg) {
    clear_has_resps();
    ::StateChangeMsg* temp = _impl_.resps_.statechangemsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.statechangemsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::StateChangeMsg& Response::_internal_statechangemsg() const {
  return resps_case() == kStateChangeMsg
      ? *_impl_.resps_.statechangemsg_
      : reinterpret_cast<::StateChangeMsg&>(::_StateChangeMsg_default_instance_);
}
inline const ::StateChangeMsg& Response::statechangemsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.stateChangeMsg)
  return _internal_statechangemsg();
}
inline ::StateChangeMsg* Response::unsafe_arena_release_statechangemsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.stateChangeMsg)
  if (resps_case() == kStateChangeMsg) {
    clear_has_resps();
    ::StateChangeMsg* temp = _impl_.resps_.statechangemsg_;
    _impl_.resps_.statechangemsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_statechangemsg(::StateChangeMsg* statechangemsg) {
  clear_resps();
  if (statechangemsg) {
    set_has_statechangemsg();
    _impl_.resps_.statechangemsg_ = statechangemsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.stateChangeMsg)
}
inline ::StateChangeMsg* Response::_internal_mutable_statechangemsg() {
  if (resps_case() != kStateChangeMsg) {
    clear_resps();
    set_has_statechangemsg();
    _impl_.resps_.statechangemsg_ = CreateMaybeMessage< ::StateChangeMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.statechangemsg_;
}
inline ::StateChangeMsg* Response::mutable_statechangemsg() {
  ::StateChangeMsg* _msg = _internal_mutable_statechangemsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.stateChangeMsg)
  return _msg;
}

// .RecordTasksMsg recordTasksMsg = 10;
inline bool Response::has_recordtasksmsg() const {
  return resps_case() == kRecordTasksMsg;
}
inline bool Response::_internal_has_recordtasksmsg() const {
  return resps_case() == kRecordTasksMsg;
}
inline void Response::set_has_recordtasksmsg() {
  _impl_._oneof_case_[0] = kRecordTasksMsg;
}
inline ::RecordTasksMsg* Response::release_recordtasksmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.recordTasksMsg)
  if (resps_case() == kRecordTasksMsg) {
    clear_has_resps();
    ::RecordTasksMsg* temp = _impl_.resps_.recordtasksmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.recordtasksmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::RecordTasksMsg& Response::_internal_recordtasksmsg() const {
  return resps_case() == kRecordTasksMsg
      ? *_impl_.resps_.recordtasksmsg_
      : reinterpret_cast<::RecordTasksMsg&>(::_RecordTasksMsg_default_instance_);
}
inline const ::RecordTasksMsg& Response::recordtasksmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.recordTasksMsg)
  return _internal_recordtasksmsg();
}
inline ::RecordTasksMsg* Response::unsafe_arena_release_recordtasksmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.recordTasksMsg)
  if (resps_case() == kRecordTasksMsg) {
    clear_has_resps();
    ::RecordTasksMsg* temp = _impl_.resps_.recordtasksmsg_;
    _impl_.resps_.recordtasksmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_recordtasksmsg(::RecordTasksMsg* recordtasksmsg) {
  clear_resps();
  if (recordtasksmsg) {
    set_has_recordtasksmsg();
    _impl_.resps_.recordtasksmsg_ = recordtasksmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.recordTasksMsg)
}
inline ::RecordTasksMsg* Response::_internal_mutable_recordtasksmsg() {
  if (resps_case() != kRecordTasksMsg) {
    clear_resps();
    set_has_recordtasksmsg();
    _impl_.resps_.recordtasksmsg_ = CreateMaybeMessage< ::RecordTasksMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.recordtasksmsg_;
}
inline ::RecordTasksMsg* Response::mutable_recordtasksmsg() {
  ::RecordTasksMsg* _msg = _internal_mutable_recordtasksmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.recordTasksMsg)
  return _msg;
}

// .RecordTasksListMsg recordTaskListMsg = 11;
inline bool Response::has_recordtasklistmsg() const {
  return resps_case() == kRecordTaskListMsg;
}
inline bool Response::_internal_has_recordtasklistmsg() const {
  return resps_case() == kRecordTaskListMsg;
}
inline void Response::set_has_recordtasklistmsg() {
  _impl_._oneof_case_[0] = kRecordTaskListMsg;
}
inline ::RecordTasksListMsg* Response::release_recordtasklistmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.recordTaskListMsg)
  if (resps_case() == kRecordTaskListMsg) {
    clear_has_resps();
    ::RecordTasksListMsg* temp = _impl_.resps_.recordtasklistmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.recordtasklistmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::RecordTasksListMsg& Response::_internal_recordtasklistmsg() const {
  return resps_case() == kRecordTaskListMsg
      ? *_impl_.resps_.recordtasklistmsg_
      : reinterpret_cast<::RecordTasksListMsg&>(::_RecordTasksListMsg_default_instance_);
}
inline const ::RecordTasksListMsg& Response::recordtasklistmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.recordTaskListMsg)
  return _internal_recordtasklistmsg();
}
inline ::RecordTasksListMsg* Response::unsafe_arena_release_recordtasklistmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.recordTaskListMsg)
  if (resps_case() == kRecordTaskListMsg) {
    clear_has_resps();
    ::RecordTasksListMsg* temp = _impl_.resps_.recordtasklistmsg_;
    _impl_.resps_.recordtasklistmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_recordtasklistmsg(::RecordTasksListMsg* recordtasklistmsg) {
  clear_resps();
  if (recordtasklistmsg) {
    set_has_recordtasklistmsg();
    _impl_.resps_.recordtasklistmsg_ = recordtasklistmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.recordTaskListMsg)
}
inline ::RecordTasksListMsg* Response::_internal_mutable_recordtasklistmsg() {
  if (resps_case() != kRecordTaskListMsg) {
    clear_resps();
    set_has_recordtasklistmsg();
    _impl_.resps_.recordtasklistmsg_ = CreateMaybeMessage< ::RecordTasksListMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.recordtasklistmsg_;
}
inline ::RecordTasksListMsg* Response::mutable_recordtasklistmsg() {
  ::RecordTasksListMsg* _msg = _internal_mutable_recordtasklistmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.recordTaskListMsg)
  return _msg;
}

// .RemoteJobResMsg remoteJobResMsg = 12;
inline bool Response::has_remotejobresmsg() const {
  return resps_case() == kRemoteJobResMsg;
}
inline bool Response::_internal_has_remotejobresmsg() const {
  return resps_case() == kRemoteJobResMsg;
}
inline void Response::set_has_remotejobresmsg() {
  _impl_._oneof_case_[0] = kRemoteJobResMsg;
}
inline ::RemoteJobResMsg* Response::release_remotejobresmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.remoteJobResMsg)
  if (resps_case() == kRemoteJobResMsg) {
    clear_has_resps();
    ::RemoteJobResMsg* temp = _impl_.resps_.remotejobresmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.remotejobresmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::RemoteJobResMsg& Response::_internal_remotejobresmsg() const {
  return resps_case() == kRemoteJobResMsg
      ? *_impl_.resps_.remotejobresmsg_
      : reinterpret_cast<::RemoteJobResMsg&>(::_RemoteJobResMsg_default_instance_);
}
inline const ::RemoteJobResMsg& Response::remotejobresmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.remoteJobResMsg)
  return _internal_remotejobresmsg();
}
inline ::RemoteJobResMsg* Response::unsafe_arena_release_remotejobresmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.remoteJobResMsg)
  if (resps_case() == kRemoteJobResMsg) {
    clear_has_resps();
    ::RemoteJobResMsg* temp = _impl_.resps_.remotejobresmsg_;
    _impl_.resps_.remotejobresmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_remotejobresmsg(::RemoteJobResMsg* remotejobresmsg) {
  clear_resps();
  if (remotejobresmsg) {
    set_has_remotejobresmsg();
    _impl_.resps_.remotejobresmsg_ = remotejobresmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.remoteJobResMsg)
}
inline ::RemoteJobResMsg* Response::_internal_mutable_remotejobresmsg() {
  if (resps_case() != kRemoteJobResMsg) {
    clear_resps();
    set_has_remotejobresmsg();
    _impl_.resps_.remotejobresmsg_ = CreateMaybeMessage< ::RemoteJobResMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.remotejobresmsg_;
}
inline ::RemoteJobResMsg* Response::mutable_remotejobresmsg() {
  ::RemoteJobResMsg* _msg = _internal_mutable_remotejobresmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.remoteJobResMsg)
  return _msg;
}

// .VersionInfoResMsg versionInfoResMsg = 13;
inline bool Response::has_versioninforesmsg() const {
  return resps_case() == kVersionInfoResMsg;
}
inline bool Response::_internal_has_versioninforesmsg() const {
  return resps_case() == kVersionInfoResMsg;
}
inline void Response::set_has_versioninforesmsg() {
  _impl_._oneof_case_[0] = kVersionInfoResMsg;
}
inline ::VersionInfoResMsg* Response::release_versioninforesmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Response.versionInfoResMsg)
  if (resps_case() == kVersionInfoResMsg) {
    clear_has_resps();
    ::VersionInfoResMsg* temp = _impl_.resps_.versioninforesmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.resps_.versioninforesmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::VersionInfoResMsg& Response::_internal_versioninforesmsg() const {
  return resps_case() == kVersionInfoResMsg
      ? *_impl_.resps_.versioninforesmsg_
      : reinterpret_cast<::VersionInfoResMsg&>(::_VersionInfoResMsg_default_instance_);
}
inline const ::VersionInfoResMsg& Response::versioninforesmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Response.versionInfoResMsg)
  return _internal_versioninforesmsg();
}
inline ::VersionInfoResMsg* Response::unsafe_arena_release_versioninforesmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Response.versionInfoResMsg)
  if (resps_case() == kVersionInfoResMsg) {
    clear_has_resps();
    ::VersionInfoResMsg* temp = _impl_.resps_.versioninforesmsg_;
    _impl_.resps_.versioninforesmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Response::unsafe_arena_set_allocated_versioninforesmsg(::VersionInfoResMsg* versioninforesmsg) {
  clear_resps();
  if (versioninforesmsg) {
    set_has_versioninforesmsg();
    _impl_.resps_.versioninforesmsg_ = versioninforesmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Response.versionInfoResMsg)
}
inline ::VersionInfoResMsg* Response::_internal_mutable_versioninforesmsg() {
  if (resps_case() != kVersionInfoResMsg) {
    clear_resps();
    set_has_versioninforesmsg();
    _impl_.resps_.versioninforesmsg_ = CreateMaybeMessage< ::VersionInfoResMsg >(GetArenaForAllocation());
  }
  return _impl_.resps_.versioninforesmsg_;
}
inline ::VersionInfoResMsg* Response::mutable_versioninforesmsg() {
  ::VersionInfoResMsg* _msg = _internal_mutable_versioninforesmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Response.versionInfoResMsg)
  return _msg;
}

inline bool Response::has_resps() const {
  return resps_case() != RESPS_NOT_SET;
}
inline void Response::clear_has_resps() {
  _impl_._oneof_case_[0] = RESPS_NOT_SET;
}
inline Response::RespsCase Response::resps_case() const {
  return Response::RespsCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Request

// .MachineMsg machineMsg = 1;
inline bool Request::has_machinemsg() const {
  return oneof_req_case() == kMachineMsg;
}
inline bool Request::_internal_has_machinemsg() const {
  return oneof_req_case() == kMachineMsg;
}
inline void Request::set_has_machinemsg() {
  _impl_._oneof_case_[0] = kMachineMsg;
}
inline ::MachineMsg* Request::release_machinemsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Request.machineMsg)
  if (oneof_req_case() == kMachineMsg) {
    clear_has_oneof_req();
    ::MachineMsg* temp = _impl_.oneof_req_.machinemsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.oneof_req_.machinemsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::MachineMsg& Request::_internal_machinemsg() const {
  return oneof_req_case() == kMachineMsg
      ? *_impl_.oneof_req_.machinemsg_
      : reinterpret_cast<::MachineMsg&>(::_MachineMsg_default_instance_);
}
inline const ::MachineMsg& Request::machinemsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Request.machineMsg)
  return _internal_machinemsg();
}
inline ::MachineMsg* Request::unsafe_arena_release_machinemsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Request.machineMsg)
  if (oneof_req_case() == kMachineMsg) {
    clear_has_oneof_req();
    ::MachineMsg* temp = _impl_.oneof_req_.machinemsg_;
    _impl_.oneof_req_.machinemsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Request::unsafe_arena_set_allocated_machinemsg(::MachineMsg* machinemsg) {
  clear_oneof_req();
  if (machinemsg) {
    set_has_machinemsg();
    _impl_.oneof_req_.machinemsg_ = machinemsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Request.machineMsg)
}
inline ::MachineMsg* Request::_internal_mutable_machinemsg() {
  if (oneof_req_case() != kMachineMsg) {
    clear_oneof_req();
    set_has_machinemsg();
    _impl_.oneof_req_.machinemsg_ = CreateMaybeMessage< ::MachineMsg >(GetArenaForAllocation());
  }
  return _impl_.oneof_req_.machinemsg_;
}
inline ::MachineMsg* Request::mutable_machinemsg() {
  ::MachineMsg* _msg = _internal_mutable_machinemsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Request.machineMsg)
  return _msg;
}

// .LayerDataReqMsg layerDataMsg = 2;
inline bool Request::has_layerdatamsg() const {
  return oneof_req_case() == kLayerDataMsg;
}
inline bool Request::_internal_has_layerdatamsg() const {
  return oneof_req_case() == kLayerDataMsg;
}
inline void Request::set_has_layerdatamsg() {
  _impl_._oneof_case_[0] = kLayerDataMsg;
}
inline ::LayerDataReqMsg* Request::release_layerdatamsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Request.layerDataMsg)
  if (oneof_req_case() == kLayerDataMsg) {
    clear_has_oneof_req();
    ::LayerDataReqMsg* temp = _impl_.oneof_req_.layerdatamsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.oneof_req_.layerdatamsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerDataReqMsg& Request::_internal_layerdatamsg() const {
  return oneof_req_case() == kLayerDataMsg
      ? *_impl_.oneof_req_.layerdatamsg_
      : reinterpret_cast<::LayerDataReqMsg&>(::_LayerDataReqMsg_default_instance_);
}
inline const ::LayerDataReqMsg& Request::layerdatamsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Request.layerDataMsg)
  return _internal_layerdatamsg();
}
inline ::LayerDataReqMsg* Request::unsafe_arena_release_layerdatamsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Request.layerDataMsg)
  if (oneof_req_case() == kLayerDataMsg) {
    clear_has_oneof_req();
    ::LayerDataReqMsg* temp = _impl_.oneof_req_.layerdatamsg_;
    _impl_.oneof_req_.layerdatamsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Request::unsafe_arena_set_allocated_layerdatamsg(::LayerDataReqMsg* layerdatamsg) {
  clear_oneof_req();
  if (layerdatamsg) {
    set_has_layerdatamsg();
    _impl_.oneof_req_.layerdatamsg_ = layerdatamsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Request.layerDataMsg)
}
inline ::LayerDataReqMsg* Request::_internal_mutable_layerdatamsg() {
  if (oneof_req_case() != kLayerDataMsg) {
    clear_oneof_req();
    set_has_layerdatamsg();
    _impl_.oneof_req_.layerdatamsg_ = CreateMaybeMessage< ::LayerDataReqMsg >(GetArenaForAllocation());
  }
  return _impl_.oneof_req_.layerdatamsg_;
}
inline ::LayerDataReqMsg* Request::mutable_layerdatamsg() {
  ::LayerDataReqMsg* _msg = _internal_mutable_layerdatamsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Request.layerDataMsg)
  return _msg;
}

// .AlarmNotifyMsg alarmNotifyMsg = 3;
inline bool Request::has_alarmnotifymsg() const {
  return oneof_req_case() == kAlarmNotifyMsg;
}
inline bool Request::_internal_has_alarmnotifymsg() const {
  return oneof_req_case() == kAlarmNotifyMsg;
}
inline void Request::set_has_alarmnotifymsg() {
  _impl_._oneof_case_[0] = kAlarmNotifyMsg;
}
inline ::AlarmNotifyMsg* Request::release_alarmnotifymsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Request.alarmNotifyMsg)
  if (oneof_req_case() == kAlarmNotifyMsg) {
    clear_has_oneof_req();
    ::AlarmNotifyMsg* temp = _impl_.oneof_req_.alarmnotifymsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.oneof_req_.alarmnotifymsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::AlarmNotifyMsg& Request::_internal_alarmnotifymsg() const {
  return oneof_req_case() == kAlarmNotifyMsg
      ? *_impl_.oneof_req_.alarmnotifymsg_
      : reinterpret_cast<::AlarmNotifyMsg&>(::_AlarmNotifyMsg_default_instance_);
}
inline const ::AlarmNotifyMsg& Request::alarmnotifymsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Request.alarmNotifyMsg)
  return _internal_alarmnotifymsg();
}
inline ::AlarmNotifyMsg* Request::unsafe_arena_release_alarmnotifymsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Request.alarmNotifyMsg)
  if (oneof_req_case() == kAlarmNotifyMsg) {
    clear_has_oneof_req();
    ::AlarmNotifyMsg* temp = _impl_.oneof_req_.alarmnotifymsg_;
    _impl_.oneof_req_.alarmnotifymsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Request::unsafe_arena_set_allocated_alarmnotifymsg(::AlarmNotifyMsg* alarmnotifymsg) {
  clear_oneof_req();
  if (alarmnotifymsg) {
    set_has_alarmnotifymsg();
    _impl_.oneof_req_.alarmnotifymsg_ = alarmnotifymsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Request.alarmNotifyMsg)
}
inline ::AlarmNotifyMsg* Request::_internal_mutable_alarmnotifymsg() {
  if (oneof_req_case() != kAlarmNotifyMsg) {
    clear_oneof_req();
    set_has_alarmnotifymsg();
    _impl_.oneof_req_.alarmnotifymsg_ = CreateMaybeMessage< ::AlarmNotifyMsg >(GetArenaForAllocation());
  }
  return _impl_.oneof_req_.alarmnotifymsg_;
}
inline ::AlarmNotifyMsg* Request::mutable_alarmnotifymsg() {
  ::AlarmNotifyMsg* _msg = _internal_mutable_alarmnotifymsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Request.alarmNotifyMsg)
  return _msg;
}

// .ReqRecordTaskMsg reqRecordTaskMsg = 4;
inline bool Request::has_reqrecordtaskmsg() const {
  return oneof_req_case() == kReqRecordTaskMsg;
}
inline bool Request::_internal_has_reqrecordtaskmsg() const {
  return oneof_req_case() == kReqRecordTaskMsg;
}
inline void Request::set_has_reqrecordtaskmsg() {
  _impl_._oneof_case_[0] = kReqRecordTaskMsg;
}
inline ::ReqRecordTaskMsg* Request::release_reqrecordtaskmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Request.reqRecordTaskMsg)
  if (oneof_req_case() == kReqRecordTaskMsg) {
    clear_has_oneof_req();
    ::ReqRecordTaskMsg* temp = _impl_.oneof_req_.reqrecordtaskmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.oneof_req_.reqrecordtaskmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ReqRecordTaskMsg& Request::_internal_reqrecordtaskmsg() const {
  return oneof_req_case() == kReqRecordTaskMsg
      ? *_impl_.oneof_req_.reqrecordtaskmsg_
      : reinterpret_cast<::ReqRecordTaskMsg&>(::_ReqRecordTaskMsg_default_instance_);
}
inline const ::ReqRecordTaskMsg& Request::reqrecordtaskmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Request.reqRecordTaskMsg)
  return _internal_reqrecordtaskmsg();
}
inline ::ReqRecordTaskMsg* Request::unsafe_arena_release_reqrecordtaskmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Request.reqRecordTaskMsg)
  if (oneof_req_case() == kReqRecordTaskMsg) {
    clear_has_oneof_req();
    ::ReqRecordTaskMsg* temp = _impl_.oneof_req_.reqrecordtaskmsg_;
    _impl_.oneof_req_.reqrecordtaskmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Request::unsafe_arena_set_allocated_reqrecordtaskmsg(::ReqRecordTaskMsg* reqrecordtaskmsg) {
  clear_oneof_req();
  if (reqrecordtaskmsg) {
    set_has_reqrecordtaskmsg();
    _impl_.oneof_req_.reqrecordtaskmsg_ = reqrecordtaskmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Request.reqRecordTaskMsg)
}
inline ::ReqRecordTaskMsg* Request::_internal_mutable_reqrecordtaskmsg() {
  if (oneof_req_case() != kReqRecordTaskMsg) {
    clear_oneof_req();
    set_has_reqrecordtaskmsg();
    _impl_.oneof_req_.reqrecordtaskmsg_ = CreateMaybeMessage< ::ReqRecordTaskMsg >(GetArenaForAllocation());
  }
  return _impl_.oneof_req_.reqrecordtaskmsg_;
}
inline ::ReqRecordTaskMsg* Request::mutable_reqrecordtaskmsg() {
  ::ReqRecordTaskMsg* _msg = _internal_mutable_reqrecordtaskmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Request.reqRecordTaskMsg)
  return _msg;
}

// .ReqRecordTaskListMsg reqRecordTaskListMsg = 5;
inline bool Request::has_reqrecordtasklistmsg() const {
  return oneof_req_case() == kReqRecordTaskListMsg;
}
inline bool Request::_internal_has_reqrecordtasklistmsg() const {
  return oneof_req_case() == kReqRecordTaskListMsg;
}
inline void Request::set_has_reqrecordtasklistmsg() {
  _impl_._oneof_case_[0] = kReqRecordTaskListMsg;
}
inline ::ReqRecordTaskListMsg* Request::release_reqrecordtasklistmsg() {
  // @@protoc_insertion_point(field_release:PrinterMsg.Request.reqRecordTaskListMsg)
  if (oneof_req_case() == kReqRecordTaskListMsg) {
    clear_has_oneof_req();
    ::ReqRecordTaskListMsg* temp = _impl_.oneof_req_.reqrecordtasklistmsg_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.oneof_req_.reqrecordtasklistmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ReqRecordTaskListMsg& Request::_internal_reqrecordtasklistmsg() const {
  return oneof_req_case() == kReqRecordTaskListMsg
      ? *_impl_.oneof_req_.reqrecordtasklistmsg_
      : reinterpret_cast<::ReqRecordTaskListMsg&>(::_ReqRecordTaskListMsg_default_instance_);
}
inline const ::ReqRecordTaskListMsg& Request::reqrecordtasklistmsg() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.Request.reqRecordTaskListMsg)
  return _internal_reqrecordtasklistmsg();
}
inline ::ReqRecordTaskListMsg* Request::unsafe_arena_release_reqrecordtasklistmsg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PrinterMsg.Request.reqRecordTaskListMsg)
  if (oneof_req_case() == kReqRecordTaskListMsg) {
    clear_has_oneof_req();
    ::ReqRecordTaskListMsg* temp = _impl_.oneof_req_.reqrecordtasklistmsg_;
    _impl_.oneof_req_.reqrecordtasklistmsg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Request::unsafe_arena_set_allocated_reqrecordtasklistmsg(::ReqRecordTaskListMsg* reqrecordtasklistmsg) {
  clear_oneof_req();
  if (reqrecordtasklistmsg) {
    set_has_reqrecordtasklistmsg();
    _impl_.oneof_req_.reqrecordtasklistmsg_ = reqrecordtasklistmsg;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.Request.reqRecordTaskListMsg)
}
inline ::ReqRecordTaskListMsg* Request::_internal_mutable_reqrecordtasklistmsg() {
  if (oneof_req_case() != kReqRecordTaskListMsg) {
    clear_oneof_req();
    set_has_reqrecordtasklistmsg();
    _impl_.oneof_req_.reqrecordtasklistmsg_ = CreateMaybeMessage< ::ReqRecordTaskListMsg >(GetArenaForAllocation());
  }
  return _impl_.oneof_req_.reqrecordtasklistmsg_;
}
inline ::ReqRecordTaskListMsg* Request::mutable_reqrecordtasklistmsg() {
  ::ReqRecordTaskListMsg* _msg = _internal_mutable_reqrecordtasklistmsg();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.Request.reqRecordTaskListMsg)
  return _msg;
}

inline bool Request::has_oneof_req() const {
  return oneof_req_case() != ONEOF_REQ_NOT_SET;
}
inline void Request::clear_has_oneof_req() {
  _impl_._oneof_case_[0] = ONEOF_REQ_NOT_SET;
}
inline Request::OneofReqCase Request::oneof_req_case() const {
  return Request::OneofReqCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// HMessage

// .PrinterMsg.MSG type = 1;
inline void HMessage::clear_type() {
  _impl_.type_ = 0;
}
inline ::PrinterMsg::MSG HMessage::type() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.HMessage.type)
  return _internal_type();
}
inline void HMessage::set_type(::PrinterMsg::MSG value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:PrinterMsg.HMessage.type)
}
inline ::PrinterMsg::MSG HMessage::_internal_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::PrinterMsg::MSG>(_impl_.type_);
}
inline void HMessage::_internal_set_type(::PrinterMsg::MSG value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_ = value;
}

// string id = 2;
inline void HMessage::clear_id() {
  _impl_.id_.ClearToEmpty();
}
inline const std::string& HMessage::id() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.HMessage.id)
  return _internal_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void HMessage::set_id(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PrinterMsg.HMessage.id)
}
inline std::string* HMessage::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.HMessage.id)
  return _s;
}
inline const std::string& HMessage::_internal_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.id_.Get();
}
inline void HMessage::_internal_set_id(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* HMessage::_internal_mutable_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.id_.Mutable( GetArenaForAllocation());
}
inline std::string* HMessage::release_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:PrinterMsg.HMessage.id)
  return _impl_.id_.Release();
}
inline void HMessage::set_allocated_id(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.id_.IsDefault()) {
          _impl_.id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PrinterMsg.HMessage.id)
}

// string mcode = 3;
inline void HMessage::clear_mcode() {
  _impl_.mcode_.ClearToEmpty();
}
inline const std::string& HMessage::mcode() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.HMessage.mcode)
  return _internal_mcode();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void HMessage::set_mcode(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.mcode_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PrinterMsg.HMessage.mcode)
}
inline std::string* HMessage::mutable_mcode() {
  std::string* _s = _internal_mutable_mcode();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.HMessage.mcode)
  return _s;
}
inline const std::string& HMessage::_internal_mcode() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.mcode_.Get();
}
inline void HMessage::_internal_set_mcode(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.mcode_.Set(value, GetArenaForAllocation());
}
inline std::string* HMessage::_internal_mutable_mcode() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.mcode_.Mutable( GetArenaForAllocation());
}
inline std::string* HMessage::release_mcode() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:PrinterMsg.HMessage.mcode)
  return _impl_.mcode_.Release();
}
inline void HMessage::set_allocated_mcode(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.mcode_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.mcode_.IsDefault()) {
          _impl_.mcode_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PrinterMsg.HMessage.mcode)
}

// .PrinterMsg.Request request = 4;
inline bool HMessage::has_request() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void HMessage::clear_request() {
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::PrinterMsg::Request& HMessage::_internal_request() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::PrinterMsg::Request* p = _impl_.request_;
  return p != nullptr ? *p : reinterpret_cast<const ::PrinterMsg::Request&>(::PrinterMsg::_Request_default_instance_);
}
inline const ::PrinterMsg::Request& HMessage::request() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.HMessage.request)
  return _internal_request();
}
inline void HMessage::unsafe_arena_set_allocated_request(::PrinterMsg::Request* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.request_);
  }
  _impl_.request_ = reinterpret_cast<::PrinterMsg::Request*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.HMessage.request)
}
inline ::PrinterMsg::Request* HMessage::release_request() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::PrinterMsg::Request* released = _impl_.request_;
  _impl_.request_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArenaForAllocation() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::PrinterMsg::Request* HMessage::unsafe_arena_release_request() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:PrinterMsg.HMessage.request)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::PrinterMsg::Request* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::PrinterMsg::Request* HMessage::_internal_mutable_request() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.request_ == nullptr) {
    auto* p = CreateMaybeMessage<::PrinterMsg::Request>(GetArenaForAllocation());
    _impl_.request_ = reinterpret_cast<::PrinterMsg::Request*>(p);
  }
  return _impl_.request_;
}
inline ::PrinterMsg::Request* HMessage::mutable_request() {
  ::PrinterMsg::Request* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.HMessage.request)
  return _msg;
}
inline void HMessage::set_allocated_request(::PrinterMsg::Request* value) {
  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::PrinterMsg::Request*>(_impl_.request_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena =
        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::PrinterMsg::Request*>(value));
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.request_ = reinterpret_cast<::PrinterMsg::Request*>(value);
  // @@protoc_insertion_point(field_set_allocated:PrinterMsg.HMessage.request)
}

// .PrinterMsg.Response response = 5;
inline bool HMessage::has_response() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void HMessage::clear_response() {
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::PrinterMsg::Response& HMessage::_internal_response() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::PrinterMsg::Response* p = _impl_.response_;
  return p != nullptr ? *p : reinterpret_cast<const ::PrinterMsg::Response&>(::PrinterMsg::_Response_default_instance_);
}
inline const ::PrinterMsg::Response& HMessage::response() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.HMessage.response)
  return _internal_response();
}
inline void HMessage::unsafe_arena_set_allocated_response(::PrinterMsg::Response* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }
  _impl_.response_ = reinterpret_cast<::PrinterMsg::Response*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PrinterMsg.HMessage.response)
}
inline ::PrinterMsg::Response* HMessage::release_response() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PrinterMsg::Response* released = _impl_.response_;
  _impl_.response_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArenaForAllocation() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::PrinterMsg::Response* HMessage::unsafe_arena_release_response() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:PrinterMsg.HMessage.response)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PrinterMsg::Response* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::PrinterMsg::Response* HMessage::_internal_mutable_response() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.response_ == nullptr) {
    auto* p = CreateMaybeMessage<::PrinterMsg::Response>(GetArenaForAllocation());
    _impl_.response_ = reinterpret_cast<::PrinterMsg::Response*>(p);
  }
  return _impl_.response_;
}
inline ::PrinterMsg::Response* HMessage::mutable_response() {
  ::PrinterMsg::Response* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:PrinterMsg.HMessage.response)
  return _msg;
}
inline void HMessage::set_allocated_response(::PrinterMsg::Response* value) {
  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::PrinterMsg::Response*>(_impl_.response_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena =
        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::PrinterMsg::Response*>(value));
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.response_ = reinterpret_cast<::PrinterMsg::Response*>(value);
  // @@protoc_insertion_point(field_set_allocated:PrinterMsg.HMessage.response)
}

// uint64 sendTime = 6;
inline void HMessage::clear_sendtime() {
  _impl_.sendtime_ = ::uint64_t{0u};
}
inline ::uint64_t HMessage::sendtime() const {
  // @@protoc_insertion_point(field_get:PrinterMsg.HMessage.sendTime)
  return _internal_sendtime();
}
inline void HMessage::set_sendtime(::uint64_t value) {
  _internal_set_sendtime(value);
  // @@protoc_insertion_point(field_set:PrinterMsg.HMessage.sendTime)
}
inline ::uint64_t HMessage::_internal_sendtime() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sendtime_;
}
inline void HMessage::_internal_set_sendtime(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sendtime_ = value;
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace PrinterMsg


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::PrinterMsg::MSG> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::PrinterMsg::MSG>() {
  return ::PrinterMsg::MSG_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_printers_2eproto_2epb_2eh